ScenePhysicsPlacement.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "editing/EditingResult.h"
#include "editor/EditorSimulationPreview.h"
#include "scene/editing/SceneEditingCommands.h"
 
#include <cstdint>
#include <memory>
#include <string>
#include <vector>
 
namespace eve::scene_editor {
 
enum class PhysicsPlacementMode { Place, Rotate, Align, Fall, Point, Drag = Place, Drop = Fall };
 
enum class PhysicsPlacementShape { Box, Sphere, Capsule, ConvexHull, Auto };
 
enum class PhysicsPlacementColliderSource { Existing, Generated };
 
enum class PhysicsPlacementColliderPolicy { ExistingOnly, GeneratedWhenMissing, GeneratedOnly, ExistingAndGenerated };
 
struct PhysicsPlacementCollider {
    PhysicsPlacementShape          shape          = PhysicsPlacementShape::Box;
    PhysicsPlacementColliderSource source         = PhysicsPlacementColliderSource::Generated;
    double                         halfExtentX    = 0.5;
    double                         halfExtentY    = 0.5;
    double                         halfExtentZ    = 0.5;
    double                         localX         = 0.0;
    double                         localY         = 0.0;
    double                         localZ         = 0.0;
    double                         localRotationX = 0.0;
    double                         localRotationY = 0.0;
    double                         localRotationZ = 0.0;
    std::vector<float>             convexVertices;
    int                            convexMaxVertices = 64;
};
 
struct PhysicsPlacementObject {
    editing::ObjectId                     object;
    scene_editing::SceneTransformValue    transform;
    double                                halfExtentX = 0.5;
    double                                halfExtentY = 0.5;
    double                                halfExtentZ = 0.5;
    bool                                  selected    = false;
    PhysicsPlacementShape                 shape       = PhysicsPlacementShape::Box;
    std::vector<float>                    convexVertices;
    int                                   convexMaxVertices = 64;
    std::vector<PhysicsPlacementCollider> colliders;
    std::uint64_t                         layerBits = 1;
    std::vector<std::string>              tags;
    bool                                  enabled = true;
    bool                                  locked  = false;
    std::string                           colliderResourceKey;
};
 
struct PhysicsPlacementAdmissionPolicy {
    std::uint64_t            includedLayerBits = ~std::uint64_t{0};
    std::uint64_t            excludedLayerBits = 0;
    std::vector<std::string> requiredTags;
    bool                     excludeDisabled = true;
    bool                     excludeLocked   = true;
    bool                     useBounds       = false;
    double                   minimumX        = 0.0;
    double                   minimumY        = 0.0;
    double                   minimumZ        = 0.0;
    double                   maximumX        = 0.0;
    double                   maximumY        = 0.0;
    double                   maximumZ        = 0.0;
};
 
struct PhysicsPlacementSettings {
    PhysicsPlacementMode           mode                     = PhysicsPlacementMode::Drag;
    double                         gravityX                 = 0.0;
    double                         gravityY                 = -9.8;
    double                         gravityZ                 = 0.0;
    double                         maximumLinearSpeed       = 12.0;
    double                         linearDamping            = 0.0;
    double                         angularDamping           = 0.0;
    double                         contactHertz             = 30.0;
    double                         contactDampingRatio      = 10.0;
    double                         maximumPushOutSpeed      = 3.0;
    int                            subStepCount             = 4;
    bool                           preserveSelectionLayout  = true;
    PhysicsPlacementColliderPolicy colliderPolicy           = PhysicsPlacementColliderPolicy::GeneratedWhenMissing;
    bool                           freezePositionX          = false;
    bool                           freezePositionY          = false;
    bool                           freezePositionZ          = false;
    bool                           freezeRotationX          = false;
    bool                           freezeRotationY          = false;
    bool                           freezeRotationZ          = false;
    double                         maximumAngularSpeed      = 20.0;
    bool                           scaleSpeedByBounds       = true;
    double                         minimumBoundsSpeedFactor = 0.5;
    double                         maximumBoundsSpeedFactor = 2.0;
    double                         teleportDistance         = 0.0;
    bool                           softCollision            = true;
};
 
struct PhysicsPlacementRequest {
    editing::Revision                   sourceRevision = 0;
    editing::ObjectId                   primaryObject;
    std::vector<PhysicsPlacementObject> objects;
    PhysicsPlacementSettings            settings;
    PhysicsPlacementAdmissionPolicy     admission;
};
 
struct PhysicsPlacementFrame {
    std::uint64_t                       tick           = 0;
    bool                                colliding      = false;
    bool                                settled        = false;
    bool                                surfaceAligned = false;
    double                              surfaceNormalX = 0.0;
    double                              surfaceNormalY = 1.0;
    double                              surfaceNormalZ = 0.0;
    std::vector<PhysicsPlacementObject> objects;
};
 
class EVENGINE_API_EDITORS ScenePhysicsPlacementBackend final : public editor::IEditorSimulationBackend {
public:
    ~ScenePhysicsPlacementBackend() override;
    ScenePhysicsPlacementBackend(const ScenePhysicsPlacementBackend&)            = delete;
    ScenePhysicsPlacementBackend& operator=(const ScenePhysicsPlacementBackend&) = delete;
 
    [[nodiscard]] static editing::Result<std::unique_ptr<ScenePhysicsPlacementBackend>> create(
        PhysicsPlacementRequest request);
 
    [[nodiscard]] std::unique_ptr<editor::IEditorSimulationBackend> cloneForPreview() const override;
    [[nodiscard]] editing::Result<void> step(std::uint64_t tick, double fixedDelta) override;
    [[nodiscard]] editing::Result<std::vector<editor::SimulationObjectSample>> capture() const override;
 
    [[nodiscard]] editing::Result<void> setHandlePosition(double x, double y, double z);
    [[nodiscard]] editing::Result<void> setHandleRotation(double x, double y, double z);
    [[nodiscard]] editing::Result<void> setHandleScale(double x, double y, double z);
    [[nodiscard]] editing::Result<void> alignHandleToSurface(double fromX, double fromY, double fromZ, double toX,
                                                             double toY, double toZ, double offset = 0.0);
    [[nodiscard]] editing::Result<PhysicsPlacementFrame> placementFrame() const;
    [[nodiscard]] editing::Revision sourceRevision() const noexcept;
 
private:
    struct Impl;
    explicit ScenePhysicsPlacementBackend(std::unique_ptr<Impl> impl);
    std::unique_ptr<Impl> impl_;
};
 
}  // namespace eve::scene_editor