Joint3D.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "physics/PhysicsHandles.h"
 
#include <box3d/id.h>
 
#include <string>
 
namespace eve::physics {
 
class Body3D;
class World3D;
 
class EVENGINE_API_WORLD Joint3D {
public:
    enum class Kind { Distance, Revolute, Prismatic, Spherical, Wheel, Weld, Motor, Parallel, Filter };
 
    Joint3D(World3D *world, Body3D *bodyA, Body3D *bodyB, b3JointId jointId, PhysicsJointHandle runtimeHandle,
            Kind kind, int id);
    ~Joint3D();
 
    Joint3D(const Joint3D &) = delete;
    Joint3D &operator=(const Joint3D &) = delete;
 
    int getId() const { return id_; }
    [[nodiscard]] PhysicsJointHandle runtimeHandle() const noexcept { return runtimeHandle_; }
    std::string getKind() const;
    int getBodyAId() const;
    int getBodyBId() const;
    [[nodiscard]] World3D *getWorld() const noexcept { return world_; }
    void setCollideConnected(bool collide);
    bool getCollideConnected() const;
    void setForceThreshold(float threshold);
    float getForceThreshold() const;
    void setTorqueThreshold(float threshold);
    float getTorqueThreshold() const;
 
    float getConstraintForceX() const;
    float getConstraintForceY() const;
    float getConstraintForceZ() const;
    float getConstraintTorqueX() const;
    float getConstraintTorqueY() const;
    float getConstraintTorqueZ() const;
    float getLinearSeparation() const;
    float getAngularSeparation() const;
 
    void setDistanceLength(float length);
    float getDistanceLength() const;
    float getDistanceCurrentLength() const;
    void setDistanceSpring(bool enabled, float hertz, float dampingRatio);
    void setDistanceLimits(bool enabled, float minimum, float maximum);
    void setDistanceMotor(bool enabled, float speed, float maxForce);
 
    void setRevoluteSpring(bool enabled, float targetAngle, float hertz, float dampingRatio);
    void setRevoluteLimits(bool enabled, float lower, float upper);
    void setRevoluteMotor(bool enabled, float speed, float maxTorque);
    float getRevoluteAngle() const;
    float getRevoluteMotorTorque() const;
 
    void setPrismaticSpring(bool enabled, float targetTranslation, float hertz,
                            float dampingRatio);
    void setPrismaticLimits(bool enabled, float lower, float upper);
    void setPrismaticMotor(bool enabled, float speed, float maxForce);
    float getPrismaticTranslation() const;
    float getPrismaticSpeed() const;
    float getPrismaticMotorForce() const;
 
    void setSphericalConeLimit(bool enabled, float angle);
    void setSphericalTwistLimits(bool enabled, float lower, float upper);
    void setSphericalMotor(bool enabled, float velocityX, float velocityY, float velocityZ,
                           float maxTorque);
    float getSphericalConeAngle() const;
    float getSphericalTwistAngle() const;
 
    void setWheelSuspension(bool enabled, float hertz, float dampingRatio);
    void setWheelSuspensionLimits(bool enabled, float lower, float upper);
    void setWheelSpinMotor(bool enabled, float speed, float maxTorque);
    void setWheelSteering(bool enabled, float targetAngle, float hertz, float dampingRatio,
                          float maxTorque);
    void setWheelSteeringLimits(bool enabled, float lower, float upper);
    float getWheelSpinSpeed() const;
    float getWheelSpinTorque() const;
    float getWheelSteeringAngle() const;
    float getWheelSteeringTorque() const;
 
    void setWeldLinearSpring(float hertz, float dampingRatio);
    void setWeldAngularSpring(float hertz, float dampingRatio);
    float getWeldLinearHertz() const;
    float getWeldLinearDampingRatio() const;
    float getWeldAngularHertz() const;
    float getWeldAngularDampingRatio() const;
 
    void setMotorLinearVelocity(float vx, float vy, float vz);
    void setMotorAngularVelocity(float wx, float wy, float wz);
    void setMotorVelocityLimits(float maxForce, float maxTorque);
    void setMotorLinearSpring(float hertz, float dampingRatio, float maxForce);
    void setMotorAngularSpring(float hertz, float dampingRatio, float maxTorque);
    float getMotorLinearVelocityX() const;
    float getMotorLinearVelocityY() const;
    float getMotorLinearVelocityZ() const;
    float getMotorAngularVelocityX() const;
    float getMotorAngularVelocityY() const;
    float getMotorAngularVelocityZ() const;
 
    void setParallelSpring(float hertz, float dampingRatio, float maxTorque);
    float getParallelHertz() const;
    float getParallelDampingRatio() const;
    float getParallelMaxTorque() const;
 
    void destroy();
    bool isValid() const;
    void invalidate();
    b3JointId raw() const { return jointId_; }
 
private:
    friend struct WorldSnapshotAccess;
    friend class Body3D;
    friend class World3D;
    void requireKind(Kind expected, const char *operation) const;
 
    World3D *world_ = nullptr;
    Body3D *bodyA_ = nullptr;
    Body3D *bodyB_ = nullptr;
    b3JointId jointId_{};
    PhysicsJointHandle runtimeHandle_ = PhysicsJointHandle::invalid();
    Kind kind_ = Kind::Distance;
    int id_ = 0;
};
 
}  // namespace eve::physics