EVEngine/PlacementSystem_8h_source.html

#pragma once

#include "common/Export.h"


// 放置操作静态入口 + 可插拔校验 / 吸附 / 变更钩子。

//

// C++ 侧通过 register* 扩展；脚本侧通过定义/世界上的策略名字符串选用已注册规则。


#include "building/BuildingTypes.h"

#include "common/Result.h"


#include <functional>

#include <limits>

#include <memory>

#include <string>

#include <unordered_map>

#include <utility>

#include <vector>


namespace eve::building {


class PlacementWorld;

class Ghost;

class HeightfieldSurface;

class StaticMeshSurface;


enum class PlacementRestoreStatus { Restored, Rejected };


class EVENGINE_API_WORLD PlacementSystem {

public:

    using ValidateFn = std::function<bool(const PlacementWorld &world, const PlacementQuery &q,

                                          std::string *reason)>;

    using SnapFn =

        std::function<SnapResult(const PlacementWorld &world, float worldX, float worldY)>;

    using ChangeHook = std::function<void(const BuildingChangeEvent &ev)>;


    struct PlacementHit {

        float worldX = 0.f;

        float worldY = 0.f;

        float worldZ = 0.f;

        float normalX = 0.f;

        float normalY = 1.f;

        float normalZ = 0.f;

        float tangentX = 1.f;

        float tangentY = 0.f;

        float tangentZ = 0.f;

        float bitangentX = 0.f;

        float bitangentY = 0.f;

        float bitangentZ = 1.f;

        std::string surfaceId;

        uint64_t surfaceRevision = 0;

        uint64_t primitiveId = 0;

        std::vector<std::string> tags;

    };


    struct SurfacePatchSample {

        int cellX = 0;

        int cellY = 0;

        PlacementHit hit;

    };


    struct SurfacePatch {

        PlacementHit anchor;

        std::vector<SurfacePatchSample> samples;

        float maxSlopeDegrees = 0.f;

        float heightDelta = 0.f;

    };


    struct EdgeLinePlacement {

        std::vector<int> instanceIds;

    };


    struct EdgePathPlacement {

        std::vector<int> instanceIds;

    };


    struct EdgePathPreview {

        std::string buildingId;

        int level = 0;

        std::vector<EdgeAddress> edges;

    };


    using EdgeCurvePoint = EdgeCurveControlPoint;


    struct EdgeCurveSurface {

        std::string providerName;

        std::string surfaceId;

        uint64_t surfaceRevision = 0;

        std::vector<EdgeCurveSurfaceSample> samples;

    };


    struct AreaCellPreview {

        int cellX = 0;

        int cellY = 0;

        bool accepted = false;

        std::string reason;

    };


    struct AreaPreview {

        std::string buildingId;

        int level = 0;

        float rotationDeg = 0.f;

        std::vector<AreaCellPreview> cells;

        int acceptedCount = 0;

        int rejectedCount = 0;

    };


    struct AreaPlacement {

        AreaPreview preview;

        std::vector<int> instanceIds;

    };


    enum class PatternKind {

        EdgeLine,

        EdgePath,

        EdgeCubicBezier,

        RectangleFill,

        RectangleOutline,

        CircleBrush

    };


    struct PatternRequest {

        PatternKind kind = PatternKind::RectangleFill;

        std::vector<EdgeCurvePoint> points;

        int radius = 0;

        int subdivisions = 16;

        float rotationDeg = 0.f;

        std::string surfaceName;

    };


    struct PatternPreview {

        PatternRequest request;

        EdgePathPreview edge;

        AreaPreview area;


        int anchorCount() const {

            return request.kind == PatternKind::EdgeLine ||

                           request.kind == PatternKind::EdgePath ||

                           request.kind == PatternKind::EdgeCubicBezier

                       ? static_cast<int>(edge.edges.size())

                       : static_cast<int>(area.cells.size());

        }


    };


    struct PatternPlacement {

        PatternPreview preview;

        std::vector<int> instanceIds;

    };


    using SurfaceFn = std::function<bool(const PlacementWorld &world, float x, float y,

                                         PlacementHit *hit)>;

    using SurfaceProviderFn =

        std::function<eve::Result<PlacementHit>(const PlacementWorld &world, float x, float y)>;


    static PlacementSystem &inst();


    static void registerValidateRule(const std::string &name, ValidateFn fn);

    static void unregisterValidateRule(const std::string &name);

    static bool hasValidateRule(const std::string &name);


    static void registerSnapRule(const std::string &name, SnapFn fn);

    static void unregisterSnapRule(const std::string &name);

    static bool hasSnapRule(const std::string &name);


    static void registerChangeHook(const std::string &name, ChangeHook fn);

    static void unregisterChangeHook(const std::string &name);

    static bool hasChangeHook(const std::string &name);


    static void registerSurface(const std::string &name, SurfaceFn fn);

    static void registerSurfaceProvider(const std::string &name, SurfaceProviderFn fn);

    [[nodiscard]] static eve::Result<void>

    registerHeightfieldSurface(const std::string &name,

                               std::shared_ptr<const HeightfieldSurface> surface);

    [[nodiscard]] static eve::Result<void>

    registerStaticMeshSurface(const std::string &name,

                              std::shared_ptr<const StaticMeshSurface> surface);

    static void unregisterSurface(const std::string &name);

    static bool hasSurface(const std::string &name);

    static bool surfaceHit(const PlacementWorld &world, const std::string &name, float x,

                           float y, PlacementHit *hit);

    [[nodiscard]] static eve::Result<PlacementHit>

    sampleSurface(const PlacementWorld &world, const std::string &name, float x, float y);

    [[nodiscard]] static eve::Result<SurfacePatch>

    sampleSurfacePatch(const PlacementWorld &world, const std::string &buildingId,

                       const std::string &surfaceName, float x, float y,

                       float rotationDegrees = 0.f);

    static std::vector<std::string> surfaceNames();

    static void setPlaneSurfaceHeight(float h);

    static float getPlaneSurfaceHeight();


    static void ensureBuiltins();


    static SnapResult snap(const PlacementWorld &world, const std::string &buildingId, float worldX,

                           float worldY);

    static SnapResult snap3D(const PlacementWorld &world, const std::string &buildingId,

                             float worldX, float worldY, float worldZ);

    static SnapResult snapWithMode(const PlacementWorld &world, const std::string &mode,

                                   float worldX, float worldY);


    static float normalizeRotation(const std::string &buildingId, float rotationDeg);


    static void effectiveFootprint(const BuildingDefinition &def, float rotationDeg, int *outW,

                                   int *outH);


    static bool foreachFootprintCell(const BuildingDefinition &def, int originCellX,

                                     int originCellY, float rotationDeg,

                                     const std::function<bool(int cx, int cy)> &fn);


    [[nodiscard]] static eve::Result<EdgeAddress> canonicalEdge(int cellX, int cellY,

                                                                 const std::string &direction);

    static bool canPlaceEdge(PlacementWorld *world, const std::string &buildingId, int cellX,

                             int cellY, const std::string &direction,

                             int excludeInstanceId = 0, std::string *reason = nullptr,

                             int level = std::numeric_limits<int>::min());

    static int placeEdge(PlacementWorld *world, const std::string &buildingId, int cellX,

                         int cellY, const std::string &direction);

    static bool canPlaceCorner(PlacementWorld *world, const std::string &buildingId, int vertexX,

                               int vertexY, int excludeInstanceId = 0,

                               std::string *reason = nullptr,

                               int level = std::numeric_limits<int>::min());

    [[nodiscard]] static eve::Result<PlacedBuilding>

    placeCornerResult(PlacementWorld *world, const std::string &buildingId, int vertexX,

                      int vertexY);

    static int placeCorner(PlacementWorld *world, const std::string &buildingId, int vertexX,

                           int vertexY);

    static bool canPlaceFree(PlacementWorld *world, const std::string &buildingId, float worldX,

                             float worldY, int excludeInstanceId = 0,

                             std::string *reason = nullptr,

                             int level = std::numeric_limits<int>::min(),

                             float rotationDeg = 0.f);

    static bool containsFreePoint(const PlacedBuilding &placed, float worldX, float worldY);

    [[nodiscard]] static eve::Result<PlacedBuilding>

    placeFreeResult(PlacementWorld *world, const std::string &buildingId, float worldX,

                    float worldY, float elevation = 0.f, float rotationDeg = 0.f);

    [[nodiscard]] static eve::Result<PlacedBuilding>

    placeFreeSurfaceResult(PlacementWorld *world, const std::string &buildingId,

                           const SurfacePatch &patch, float rotationDeg = 0.f);

    static int placeFree(PlacementWorld *world, const std::string &buildingId, float worldX,

                         float worldY, float elevation = 0.f, float rotationDeg = 0.f);

    static uint8_t edgeConnectionMask(const PlacementWorld &world, int instanceId);

    static std::string edgeVariant(const PlacementWorld &world, int instanceId);

    [[nodiscard]] static eve::Result<EdgeLinePlacement>

    placeEdgeLine(PlacementWorld *world, const std::string &buildingId, int startVertexX,

                  int startVertexY, int endVertexX, int endVertexY);

    [[nodiscard]] static eve::Result<EdgePathPlacement>

    placeEdgePath(PlacementWorld *world, const std::string &buildingId,

                  const std::vector<CornerAddress> &vertices);

    [[nodiscard]] static eve::Result<EdgePathPreview>

    previewEdgePath(PlacementWorld *world, const std::string &buildingId,

                    const std::vector<CornerAddress> &vertices);

    [[nodiscard]] static eve::Result<std::vector<CornerAddress>>

    sampleEdgeCubicBezier(const std::vector<EdgeCurvePoint> &controlPoints, int subdivisions);

    [[nodiscard]] static eve::Result<EdgePathPreview>

    previewEdgeCubicBezier(PlacementWorld *world, const std::string &buildingId,

                           const std::vector<EdgeCurvePoint> &controlPoints, int subdivisions);

    [[nodiscard]] static eve::Result<EdgePathPlacement>

    placeEdgeCubicBezier(PlacementWorld *world, const std::string &buildingId,

                         const std::vector<EdgeCurvePoint> &controlPoints, int subdivisions);

    [[nodiscard]] static eve::Result<EdgeCurveSurface>

    sampleEdgeCurveSurface(const PlacementWorld &world, const std::string &surfaceName,

                           const std::vector<EdgeCurvePoint> &controlPoints, int subdivisions);

    [[nodiscard]] static eve::Result<EdgePathPlacement>

    placeEdgeCubicBezierOnSurface(PlacementWorld *world, const std::string &buildingId,

                                  const std::vector<EdgeCurvePoint> &controlPoints,

                                  int subdivisions, const std::string &surfaceName);

    [[nodiscard]] static eve::Result<AreaPreview>

    previewRectangle(PlacementWorld *world, const std::string &buildingId, int minCellX,

                     int minCellY, int maxCellX, int maxCellY, float rotationDeg = 0.f);

    [[nodiscard]] static eve::Result<AreaPreview>

    previewBrush(PlacementWorld *world, const std::string &buildingId, int centerCellX,

                 int centerCellY, int radius, float rotationDeg = 0.f);

    [[nodiscard]] static eve::Result<AreaPreview>

    previewRectangleOutline(PlacementWorld *world, const std::string &buildingId,

                            int minCellX, int minCellY, int maxCellX, int maxCellY,

                            float rotationDeg = 0.f);

    [[nodiscard]] static eve::Result<AreaPlacement>

    placeRectangle(PlacementWorld *world, const std::string &buildingId, int minCellX,

                   int minCellY, int maxCellX, int maxCellY, float rotationDeg = 0.f);

    [[nodiscard]] static eve::Result<AreaPlacement>

    placeBrush(PlacementWorld *world, const std::string &buildingId, int centerCellX,

               int centerCellY, int radius, float rotationDeg = 0.f);

    [[nodiscard]] static eve::Result<AreaPlacement>

    placeRectangleOutline(PlacementWorld *world, const std::string &buildingId,

                          int minCellX, int minCellY, int maxCellX, int maxCellY,

                          float rotationDeg = 0.f);

    [[nodiscard]] static eve::Result<PatternPreview>

    previewPattern(PlacementWorld *world, const std::string &buildingId,

                   const PatternRequest &request);

    [[nodiscard]] static eve::Result<PatternPlacement>

    placePattern(PlacementWorld *world, const std::string &buildingId,

                 const PatternRequest &request);


    static bool canPlace(PlacementWorld *world, const std::string &buildingId, int cellX, int cellY,

                         float rotationDeg = 0.f, int excludeInstanceId = 0,

                         std::string *reason = nullptr);

    static bool canPlaceElev(PlacementWorld *world, const std::string &buildingId, int cellX,

                             int cellY, float elevation, float rotationDeg = 0.f,

                             int excludeInstanceId = 0, std::string *reason = nullptr,

                             int level = std::numeric_limits<int>::min());


    static int placeAt(PlacementWorld *world, const std::string &buildingId, int cellX, int cellY,

                       float rotationDeg = 0.f);

    static int placeAtWorld(PlacementWorld *world, const std::string &buildingId, float worldX,

                            float worldY, float rotationDeg = 0.f);

    static int placeAtWorld3D(PlacementWorld *world, const std::string &buildingId, float worldX,

                              float worldY, float worldZ, float rotationDeg = 0.f);

    static int placeGhost(PlacementWorld *world, Ghost *ghost);


    static PlacementRestoreStatus restoreExact(PlacementWorld *world, const PlacedBuilding &placed,

                                                std::string *reason = nullptr);


    [[nodiscard]] static eve::Result<EdgeCurveGroup>

    restoreEdgeCurveGroupExact(PlacementWorld *world, const EdgeCurveGroup &group,

                               const std::vector<PlacedBuilding> &members);


    static bool removeBuilding(PlacementWorld *world, int instanceId);

    [[nodiscard]] static eve::Result<StructuralRemovalReceipt>

    removeBuildingCascadeResult(PlacementWorld *world, int instanceId);

    static int removeBuildingCascade(PlacementWorld *world, int instanceId);

    [[nodiscard]] static eve::Result<StructuralLinkRebuildReceipt>

    rebuildStructuralLinksResult(PlacementWorld *world);

    [[nodiscard]] static eve::Result<PlacementEditReceipt>

    moveBuildingResult(PlacementWorld *world, int instanceId, int cellX, int cellY,

                       float rotationDeg = -1.f);

    [[nodiscard]] static eve::Result<PlacementEditReceipt>

    moveEdgeResult(PlacementWorld *world, int instanceId, int cellX, int cellY,

                   const std::string &direction);

    [[nodiscard]] static eve::Result<PlacementEditReceipt>

    moveCornerResult(PlacementWorld *world, int instanceId, int vertexX, int vertexY);

    [[nodiscard]] static eve::Result<PlacementEditReceipt>

    moveFreeResult(PlacementWorld *world, int instanceId, float worldX, float worldY,

                   float elevation, float rotationDeg);

    [[nodiscard]] static eve::Result<PlacementEditReceipt>

    moveFreeSurfaceResult(PlacementWorld *world, int instanceId, const SurfacePatch &patch,

                          float rotationDeg);

    [[nodiscard]] static eve::Result<PlacementEditReceipt>

    replaceBuildingResult(PlacementWorld *world, int instanceId,

                          const std::string &replacementBuildingId);

    static bool moveBuilding(PlacementWorld *world, int instanceId, int cellX, int cellY,

                             float rotationDeg = -1.f);

    static void clearBuildings(PlacementWorld *world);


    static void pushEvent(BuildingChangeEvent ev);

    static void pollEvents(std::vector<BuildingChangeEvent> &out);

    static void clearEvents();

    static const std::vector<BuildingChangeEvent> &events();


    static int nextInstanceId();


private:

    [[nodiscard]] static eve::Result<EdgePathPlacement>

    commitEdgePath(PlacementWorld *world, EdgePathPreview preview,

                   const std::vector<EdgeCurvePoint> *curveControls = nullptr,

                   int curveSubdivisions = 0,

                   const EdgeCurveSurface *curveSurface = nullptr);

    static void dissolveEdgeCurveGroup(PlacementWorld *world, EdgeCurveGroupId groupId);

    friend class Ghost;


    static bool canPlaceQuery(PlacementWorld *world, const PlacementQuery &q,

                              std::string *reason);

    static bool runValidate(const PlacementWorld &world, const BuildingDefinition &def,

                            const PlacementQuery &q, std::string *reason);

    static bool checkBoundsAndOccupancy(const PlacementWorld &world, const BuildingDefinition &def,

                                        const PlacementQuery &q, bool checkOccupancy,

                                        std::string *reason);

    static bool checkTerrain(const PlacementWorld &world, const BuildingDefinition &def,

                             const PlacementQuery &q, std::string *reason);

    static bool checkAdjacency(const PlacementWorld &world, const BuildingDefinition &def,

                               const PlacementQuery &q, std::string *reason);

    static bool checkSurfacePatch(const BuildingDefinition &def, const PlacementQuery &q,

                                  std::string *reason);

    static bool checkStructuralSupport(const PlacementWorld &world,

                                       const BuildingDefinition &def,

                                       const PlacementQuery &q, std::string *reason);

    static std::vector<int> collectStructuralSupports(const PlacementWorld &world,

                                                      const BuildingDefinition &def,

                                                      const PlacementQuery &q);

    static bool hasStructuralDependents(const PlacementWorld &world, int instanceId);

    static bool replacementPreservesStructuralDependents(

        const PlacementWorld &world, int instanceId, const BuildingDefinition &replacement);

    static bool removeBuildingUnchecked(PlacementWorld *world, int instanceId);

    static void writeOccupancy(PlacementWorld &world, const BuildingDefinition &def,

                               const PlacedBuilding &placed, int instanceId);

    static void clearOccupancy(PlacementWorld &world, int instanceId);

    static void emit(BuildingChangeEvent ev);

    static eve::Result<AreaPreview>

    previewArea(PlacementWorld *world, const std::string &buildingId,

                const std::vector<std::pair<int, int>> &anchors, float rotationDeg);

    static eve::Result<AreaPlacement> commitArea(PlacementWorld *world, AreaPreview preview);


    static std::unordered_map<std::string, ValidateFn> &validateRules();

    static std::unordered_map<std::string, SnapFn> &snapRules();

    static std::unordered_map<std::string, ChangeHook> &changeHooks();

    static std::unordered_map<std::string, SurfaceFn> &surfaces();

    static std::unordered_map<std::string, SurfaceProviderFn> &surfaceProviders();

    static float &planeSurfaceHeight();

    static std::vector<BuildingChangeEvent> &eventQueue();

    static int &instanceCounter();

    static bool &builtinsReady();


    PlacementSystem() = default;

    ~PlacementSystem() = default;

    PlacementSystem(const PlacementSystem &) = delete;

    PlacementSystem &operator=(const PlacementSystem &) = delete;


    std::unordered_map<std::string, ValidateFn> validateRules_;

    std::unordered_map<std::string, SnapFn> snapRules_;

    std::unordered_map<std::string, ChangeHook> changeHooks_;

    std::unordered_map<std::string, SurfaceFn> surfaces_;

    std::unordered_map<std::string, SurfaceProviderFn> surfaceProviders_;

    std::vector<BuildingChangeEvent> eventQueue_;

    int instanceCounter_ = 0;

    bool builtinsReady_ = false;

    float planeSurfaceHeight_ = 0.f;

};


}  // namespace eve::building

y
float y
Definition AnimClip.cpp:738

x
float x
Definition AnimClip.cpp:738

rotationDegrees
float rotationDegrees
Definition BuildingFx.cpp:65

group
building::EdgeCurveGroup group
Definition BuildingTarget.cpp:248

BuildingTypes.h

cx
float cx
Definition CardTypes.cpp:33

cy
float cy
Definition CardTypes.cpp:34

Export.h

EVENGINE_API_WORLD
#define EVENGINE_API_WORLD
Definition Export.h:109

request
const GltfImportRequest & request
Definition GltfMaterials.cpp:31

area
float area
Definition Grass.cpp:62

q
std::array< double, 10 > q
Definition GtsMeshSimplifier.cpp:14

elevation
float elevation
Definition HexTerrain.cpp:30

h
int h
Definition ImageData.cpp:690

kind
TokenKind kind
Definition LanguageIndex.cpp:17

name
std::string name
Definition McpScriptTools.cpp:40

level
int level
Definition ModuleAssembly.cpp:22

world
World3D * world
Definition PhysicsCapabilities.cpp:116

vertices
std::vector< Point > vertices
Definition PlacementSystem.cpp:46

radius
float radius
Definition PlacementSystem.cpp:42

hit
bool hit
Definition PrimitiveDrawList.cpp:77

Result.h
Move-only, checked operation results for the common layer.

direction
RoadLaneDirection direction
Definition RoadTraffic.cpp:20

edge
const RoadEdge * edge
Definition RoadTraffic.cpp:14

placed
bool placed
Definition TacticsPersistence.cpp:148

events
Battle::Events events
Definition TacticsPersistence.cpp:172

members
std::map< std::string, std::span< const std::uint8_t > > members
Definition UnityPackage.cpp:81

eve::Result
Move-only operation result carrying either a value or Status.
Definition Result.h:155

eve::building::Ghost
EVENGINE_API_WORLD public API.
Definition Ghost.h:16

eve::building::PlacementSystem
EVENGINE_API_WORLD public API.
Definition PlacementSystem.h:31

eve::building::PlacementSystem::ValidateFn
std::function< bool(const PlacementWorld &world, const PlacementQuery &q, std::string *reason)> ValidateFn
Definition PlacementSystem.h:34

eve::building::PlacementSystem::SurfaceFn
std::function< bool(const PlacementWorld &world, float x, float y, PlacementHit *hit)> SurfaceFn
Definition PlacementSystem.h:160

eve::building::PlacementSystem::SnapFn
std::function< SnapResult(const PlacementWorld &world, float worldX, float worldY)> SnapFn
Definition PlacementSystem.h:37

eve::building::PlacementSystem::SurfaceProviderFn
std::function< eve::Result< PlacementHit >(const PlacementWorld &world, float x, float y)> SurfaceProviderFn
Canonical surface provider contract.
Definition PlacementSystem.h:167

eve::building::PlacementSystem::ChangeHook
std::function< void(const BuildingChangeEvent &ev)> ChangeHook
Definition PlacementSystem.h:38

eve::building::PlacementSystem::PatternKind
PatternKind
Built-in geometry families accepted by the unified placement-pattern protocol.
Definition PlacementSystem.h:117

eve::building::PlacementWorld
格子型建筑放置世界（脚本可直接操作）。
Definition PlacementWorld.h:32

eve::building
建筑放置模块入口：定义 / 放置世界 / 鬼影 / 变更事件的脚本绑定点。 设计文档：docs/dev/建筑放置系统设计.md
Definition Building.cpp:7

eve::building::EdgeUpdateStatus::Rejected
@ Rejected

eve::building::PlacementRestoreStatus
PlacementRestoreStatus
Outcome of restoring an exact placement snapshot.
Definition PlacementSystem.h:28

eve::building::PlacementRestoreStatus::Restored
@ Restored

fn
SettlementPipeline::Stage fn
Definition Settlement.cpp:32

eve::building::BuildingChangeEvent
一次成功放置变更的事件（供脚本 poll / C++ hook）。
Definition BuildingTypes.h:246

eve::building::BuildingDefinition
建筑模板（进程级注册表中的定义）。
Definition BuildingTypes.h:100

eve::building::EdgeCurveControlPoint
One cubic Bezier control point in logical grid-vertex space.
Definition BuildingTypes.h:58

eve::building::EdgeCurveGroupId
Strong world-local identity of one authoritative edge-curve group.
Definition BuildingTypes.h:48

eve::building::EdgeCurveGroup
World-owned authoritative description and membership of one committed edge curve.
Definition BuildingTypes.h:80

eve::building::PlacedBuilding
已放置的建筑实例。
Definition BuildingTypes.h:184

eve::building::PlacementQuery
校验上下文：传给可插拔规则。
Definition BuildingTypes.h:267

eve::building::PlacementSystem::AreaCellPreview
One requested area anchor and its deterministic validation result.
Definition PlacementSystem.h:96

eve::building::PlacementSystem::AreaCellPreview::reason
std::string reason
Definition PlacementSystem.h:100

eve::building::PlacementSystem::AreaPlacement
Atomic receipt for a committed area placement.
Definition PlacementSystem.h:112

eve::building::PlacementSystem::AreaPlacement::instanceIds
std::vector< int > instanceIds
Definition PlacementSystem.h:114

eve::building::PlacementSystem::AreaPlacement::preview
AreaPreview preview
Definition PlacementSystem.h:113

eve::building::PlacementSystem::AreaPreview
Owning row-major preview for a rectangular or circular brush request.
Definition PlacementSystem.h:103

eve::building::PlacementSystem::AreaPreview::buildingId
std::string buildingId
Definition PlacementSystem.h:104

eve::building::PlacementSystem::AreaPreview::cells
std::vector< AreaCellPreview > cells
Definition PlacementSystem.h:107

eve::building::PlacementSystem::EdgeCurveSurface
Owning same-identity surface frames sampled along an analytic edge curve.
Definition PlacementSystem.h:89

eve::building::PlacementSystem::EdgeCurveSurface::samples
std::vector< EdgeCurveSurfaceSample > samples
Definition PlacementSystem.h:93

eve::building::PlacementSystem::EdgeCurveSurface::providerName
std::string providerName
Definition PlacementSystem.h:90

eve::building::PlacementSystem::EdgeCurveSurface::surfaceId
std::string surfaceId
Definition PlacementSystem.h:91

eve::building::PlacementSystem::EdgeLinePlacement
Atomic result of placing one axis-aligned continuous edge line.
Definition PlacementSystem.h:73

eve::building::PlacementSystem::EdgeLinePlacement::instanceIds
std::vector< int > instanceIds
Definition PlacementSystem.h:74

eve::building::PlacementSystem::EdgePathPlacement
Atomic result of placing one multi-segment edge path.
Definition PlacementSystem.h:77

eve::building::PlacementSystem::EdgePathPlacement::instanceIds
std::vector< int > instanceIds
Definition PlacementSystem.h:78

eve::building::PlacementSystem::EdgePathPreview
Owning validated edge addresses for one non-mutating path preview.
Definition PlacementSystem.h:81

eve::building::PlacementSystem::EdgePathPreview::edges
std::vector< EdgeAddress > edges
Definition PlacementSystem.h:84

eve::building::PlacementSystem::EdgePathPreview::buildingId
std::string buildingId
Definition PlacementSystem.h:82

eve::building::PlacementSystem::PatternPlacement
Atomic placement receipt shared by every built-in pattern kind.
Definition PlacementSystem.h:149

eve::building::PlacementSystem::PatternPlacement::instanceIds
std::vector< int > instanceIds
Definition PlacementSystem.h:151

eve::building::PlacementSystem::PatternPlacement::preview
PatternPreview preview
Definition PlacementSystem.h:150

eve::building::PlacementSystem::PatternPreview
Owning non-mutating expansion of an edge or area pattern.
Definition PlacementSystem.h:135

eve::building::PlacementSystem::PatternPreview::request
PatternRequest request
Definition PlacementSystem.h:136

eve::building::PlacementSystem::PatternPreview::anchorCount
int anchorCount() const
Number of concrete edge/cell anchors expanded by the pattern.
Definition PlacementSystem.h:140

eve::building::PlacementSystem::PatternPreview::area
AreaPreview area
Definition PlacementSystem.h:138

eve::building::PlacementSystem::PatternPreview::edge
EdgePathPreview edge
Definition PlacementSystem.h:137

eve::building::PlacementSystem::PatternRequest
Owning, renderer-neutral request for one atomic placement pattern.
Definition PlacementSystem.h:126

eve::building::PlacementSystem::PatternRequest::surfaceName
std::string surfaceName
Definition PlacementSystem.h:132

eve::building::PlacementSystem::PatternRequest::points
std::vector< EdgeCurvePoint > points
Definition PlacementSystem.h:128

eve::building::PlacementSystem::PlacementHit
One sampled point and orthonormal frame on a placement surface.
Definition PlacementSystem.h:41

eve::building::PlacementSystem::PlacementHit::surfaceId
std::string surfaceId
Definition PlacementSystem.h:54

eve::building::PlacementSystem::PlacementHit::tags
std::vector< std::string > tags
Definition PlacementSystem.h:57

eve::building::PlacementSystem::SurfacePatchSample
One footprint-relative surface sample.
Definition PlacementSystem.h:60

eve::building::PlacementSystem::SurfacePatchSample::hit
PlacementHit hit
Definition PlacementSystem.h:63

eve::building::PlacementSystem::SurfacePatch
Surface samples and continuity metrics for one rotated building footprint.
Definition PlacementSystem.h:66

eve::building::PlacementSystem::SurfacePatch::anchor
PlacementHit anchor
Definition PlacementSystem.h:67

eve::building::PlacementSystem::SurfacePatch::samples
std::vector< SurfacePatchSample > samples
Definition PlacementSystem.h:68

eve::building::SnapResult
吸附结果。
Definition BuildingTypes.h:290