Body3D.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Result.h"
#include "physics/OwnedQuery3D.h"
#include "physics/PhysicsHandles.h"
 
#include <string>
#include <vector>
#include <cstdint>
 
#include <box3d/id.h>
 
namespace eve::physics {
 
class World3D;
class Shape3D;
 
class EVENGINE_API_WORLD Body3D {
public:
    Body3D(World3D *world, b3BodyId bodyId, int id, PhysicsBodyHandle runtimeHandle);
    ~Body3D();
 
    Body3D(const Body3D &)            = delete;
    Body3D &operator=(const Body3D &) = delete;
 
    int getId() const { return id_; }
 
    void  setPosition(float x, float y, float z);
    float getX() const;
    float getY() const;
    float getZ() const;
 
    void  setRotation(float qx, float qy, float qz, float qw);
    float getRotX() const;
    float getRotY() const;
    float getRotZ() const;
    float getRotW() const;
 
    void  setLinearVelocity(float vx, float vy, float vz);
    float getLinearVelocityX() const;
    float getLinearVelocityY() const;
    float getLinearVelocityZ() const;
 
    float getMass() const;
 
    void  setAngularVelocity(float wx, float wy, float wz);
    float getAngularVelocityX() const;
    float getAngularVelocityY() const;
    float getAngularVelocityZ() const;
 
    std::vector<float> localToWorldPoint(float x, float y, float z) const;
    [[nodiscard]] eve::Result<PhysicsVector3D> localToWorldPointOwned(float x, float y, float z) const;
    std::vector<float> worldToLocalPoint(float x, float y, float z) const;
    [[nodiscard]] eve::Result<PhysicsVector3D> worldToLocalPointOwned(float x, float y, float z) const;
    std::vector<float> localToWorldVector(float x, float y, float z) const;
    [[nodiscard]] eve::Result<PhysicsVector3D> localToWorldVectorOwned(float x, float y, float z) const;
    std::vector<float> worldToLocalVector(float x, float y, float z) const;
    std::vector<float> getLocalPointVelocity(float x, float y, float z) const;
    [[nodiscard]] eve::Result<PhysicsVector3D> getLocalPointVelocityOwned(float x, float y, float z) const;
    std::vector<float> getWorldPointVelocity(float x, float y, float z) const;
 
    void applyForce(float fx, float fy, float fz);
    void applyForceAt(float fx, float fy, float fz, float x, float y, float z);
    void applyTorque(float tx, float ty, float tz);
    void applyLinearImpulse(float ix, float iy, float iz);
    void applyLinearImpulseAt(float ix, float iy, float iz, float x, float y, float z);
    void applyAngularImpulse(float ix, float iy, float iz);
    void applyLocalForce(float fx, float fy, float fz, float x, float y, float z);
    void applyLocalForceToCenter(float fx, float fy, float fz);
    void applyLocalTorque(float tx, float ty, float tz);
    void applyLocalLinearImpulse(float ix, float iy, float iz, float x, float y, float z);
    void applyLocalLinearImpulseToCenter(float ix, float iy, float iz);
    void applyLocalAngularImpulse(float ix, float iy, float iz);
 
    void setTargetTransform(float x, float y, float z, float qx, float qy, float qz, float qw,
                            float timeStep);
 
    void  setLinearDamping(float damping);
    float getLinearDamping() const;
    void  setAngularDamping(float damping);
    float getAngularDamping() const;
    void  setGravityScale(float scale);
    float getGravityScale() const;
 
    void setSleepEnabled(bool enabled);
    bool isSleepEnabled() const;
    void  setSleepThreshold(float threshold);
    float getSleepThreshold() const;
 
    void setMotionLocks(bool linearX, bool linearY, bool linearZ, bool angularX, bool angularY,
                        bool angularZ);
    bool isLinearXLocked() const;
    bool isLinearYLocked() const;
    bool isLinearZLocked() const;
    bool isAngularXLocked() const;
    bool isAngularYLocked() const;
    bool isAngularZLocked() const;
 
    void setMassProperties(float mass, float centerX, float centerY, float centerZ,
                           float inertiaXX, float inertiaYY, float inertiaZZ,
                           float inertiaXY = 0.f, float inertiaXZ = 0.f,
                           float inertiaYZ = 0.f);
    void resetMassProperties();
    float getInertiaXX() const;
    float getInertiaYY() const;
    float getInertiaZZ() const;
    float getInertiaXY() const;
    float getInertiaXZ() const;
    float getInertiaYZ() const;
    float getLocalCenterX() const;
    float getLocalCenterY() const;
    float getLocalCenterZ() const;
    float getWorldCenterX() const;
    float getWorldCenterY() const;
    float getWorldCenterZ() const;
 
    void        setType(const std::string &bodyType);
    std::string getType() const;
 
    void setFixedRotation(bool fixed);
    bool isFixedRotation() const;
 
    void setActive(bool active);
    bool isActive() const;
 
    void setBullet(bool bullet);
    bool isBullet() const;
 
    void setAwake(bool awake);
    bool isAwake() const;
 
    Shape3D *newBoxShape(float width, float height, float depth, float density = 1.f,
                         float friction = 0.2f, float restitution = 0.f);
    Shape3D *newSphereShape(float radius, float density = 1.f, float friction = 0.2f,
                            float restitution = 0.f);
    Shape3D *newCapsuleShape(float height, float radius, float density = 1.f,
                             float friction = 0.2f, float restitution = 0.f);
    Shape3D *newConvexHullShape(const std::vector<float> &vertices, int maxVertices = 64,
                                float density = 1.f, float friction = 0.2f,
                                float restitution = 0.f);
    Shape3D *newTriangleMeshShape(const std::vector<float> &vertices,
                                  const std::vector<int32_t> &indices,
                                  bool weldVertices = true, float weldTolerance = 0.001f,
                                  bool identifyEdges = true, bool useMedianSplit = false);
    Shape3D *newHeightFieldShape(int countX, int countZ, float cellSizeX, float cellSizeZ,
                                 const std::vector<float> &heights, float globalMin,
                                 float globalMax, bool clockwiseWinding = false);
 
    void destroy();
 
    World3D  *getWorld() { return world_; }
    const World3D *getWorld() const { return world_; }
    b3BodyId  raw() const { return bodyId_; }
    bool      isValid() const;
 
    [[nodiscard]] PhysicsBodyHandle runtimeHandle() const noexcept { return runtimeHandle_; }
 
    void invalidate();
 
private:
    friend struct WorldSnapshotAccess;
    friend class World3D;
    friend class Shape3D;
 
    World3D *world_  = nullptr;
    b3BodyId bodyId_{};
    int      id_ = 0;
    PhysicsBodyHandle runtimeHandle_ = PhysicsBodyHandle::invalid();
};
 
}  // namespace eve::physics