MeshDeformationSession.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Result.h"
#include "procgen/MeshBuild.h"
 
#include <cstdint>
#include <string_view>
#include <vector>
 
namespace eve::procgen {
 
struct MeshVertexSelectionCenter {
    float x = 0.f, y = 0.f, z = 0.f;
};
 
class EVENGINE_API_DOMAINS MeshDeformationSession {
public:
    [[nodiscard]] Result<void> initializeResult(const MeshBuild& mesh);
    [[nodiscard]] Result<void> applyBrushResult(std::string_view mode, float x, float y, float z, float radius,
                                                float strength, float falloff, float directionX = 0.f,
                                                float directionY = 1.f, float directionZ = 0.f);
    [[nodiscard]] Result<void> applyBrushGpuResult(std::string_view mode, float x, float y, float z, float radius,
                                                   float strength, float falloff, float directionX = 0.f,
                                                   float directionY = 1.f, float directionZ = 0.f);
    [[nodiscard]] Result<void> applyImpactResult(float x, float y, float z, float impulseX, float impulseY,
                                                 float impulseZ, float radius, float plasticity, float hardness,
                                                 float maxDisplacement);
    [[nodiscard]] Result<void> applyImpactGpuResult(float x, float y, float z, float impulseX, float impulseY,
                                                    float impulseZ, float radius, float plasticity, float hardness,
                                                    float maxDisplacement);
    [[nodiscard]] Result<void> prepareImpactVertexBlocksResult(int divisionsPerAxis);
    [[nodiscard]] int impactVertexBlockCount() const noexcept;
    [[nodiscard]] bool hasImpactVertexBlocks() const noexcept { return !impactVertexBlocks_.empty(); }
    [[nodiscard]] Result<void> applySurfaceContactResult(float x, float y, float z, float normalX, float normalY,
                                                         float normalZ, float velocityX, float velocityY,
                                                         float velocityZ, float radius, float depth, float drag,
                                                         float falloff, float plasticity = 0.f);
    [[nodiscard]] Result<void> recoverSurfaceResult(float dt, float recoveryRate);
    [[nodiscard]] Result<void> applySlimeImpulseResult(float x, float y, float z, float impulseX, float impulseY,
                                                       float impulseZ, float radius, float falloff);
    [[nodiscard]] Result<void> stepSlimeResult(float dt, float stiffness, float damping, float maxSpeed);
    [[nodiscard]] Result<void> configureColliderRefreshResult(std::string_view mode, float intervalSeconds,
                                                              float offsetX = 0.f, float offsetY = 0.f,
                                                              float offsetZ = 0.f);
    [[nodiscard]] Result<void> requestColliderRefreshResult();
    [[nodiscard]] Result<bool> updateColliderRefreshResult(float dt);
    [[nodiscard]] Result<MeshBuild> colliderMeshResult() const;
    [[nodiscard]] Result<int> selectVerticesSphereResult(float x, float y, float z, float radius, bool replace = true);
    [[nodiscard]] Result<int> selectVerticesBoxResult(float minX, float minY, float minZ, float maxX, float maxY,
                                                      float maxZ, bool replace = true);
    void clearVertexSelection() noexcept;
    [[nodiscard]] int selectedVertexCount() const noexcept;
    [[nodiscard]] Result<MeshVertexSelectionCenter> selectedVertexCenterResult() const;
    [[nodiscard]] Result<void> moveSelectedVerticesResult(float x, float y, float z);
    [[nodiscard]] Result<void> manipulateSelectedVerticesResult(std::string_view mode, float originX, float originY,
                                                                float originZ, float directionX, float directionY,
                                                                float directionZ, float distance);
    [[nodiscard]] Result<void> restoreResult();
    [[nodiscard]] Result<void> bakeResult();
    [[nodiscard]] Result<void> undoResult();
    [[nodiscard]] Result<MeshBuild> currentMeshResult() const;
    [[nodiscard]] std::uint64_t revision() const noexcept { return revision_; }
    [[nodiscard]] int undoCount() const noexcept { return static_cast<int>(undo_.size()); }
    [[nodiscard]] bool isInitialized() const noexcept { return initialized_; }
 
private:
    struct UndoState {
        MeshBuild          mesh;
        std::vector<float> equilibrium;
        std::vector<float> velocity;
    };
    void pushUndo();
    void invalidateImpactVertexBlocks() noexcept;
    [[nodiscard]] std::vector<std::uint32_t> impactCandidates(float x, float y, float z, float radius) const;
 
    MeshBuild                 original_;
    MeshBuild                 current_;
    std::vector<float>        surfaceEquilibrium_;
    std::vector<float>        surfaceVelocity_;
    std::vector<std::uint8_t> selectedVertices_;
    std::vector<std::vector<std::uint32_t>> impactVertexBlocks_;
    int                                     impactBlockDivisions_ = 0;
    float impactBlockMinX_ = 0.f, impactBlockMinY_ = 0.f, impactBlockMinZ_ = 0.f;
    float impactBlockMaxX_ = 0.f, impactBlockMaxY_ = 0.f, impactBlockMaxZ_ = 0.f;
    std::vector<UndoState>    undo_;
    std::string               colliderRefreshMode_        = "manual";
    float                     colliderRefreshInterval_    = 0.f;
    float                     colliderRefreshAccumulator_ = 0.f;
    float                     colliderOffsetX_ = 0.f, colliderOffsetY_ = 0.f, colliderOffsetZ_ = 0.f;
    bool                      colliderRefreshConfigured_ = false;
    bool                      colliderRefreshPending_    = false;
    std::uint64_t             revision_                  = 0;
    bool                      initialized_               = false;
};
 
}  // namespace eve::procgen