Shape3D.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "physics/PhysicsHandles.h"
 
#include <box3d/id.h>
#include <box3d/types.h>
 
#include <string>
#include <vector>
 
#include <cstdint>
 
namespace eve::physics {
 
class Body3D;
class World3D;
struct WorldSnapshotAccess;
 
class EVENGINE_API_WORLD Shape3D {
public:
    enum class Kind { Box, Sphere, Capsule, ConvexHull, TriangleMesh, HeightField };
 
    Shape3D(World3D *world, Body3D *body, b3ShapeId shapeId, PhysicsShapeHandle runtimeHandle, Kind kind, float a,
            float b, float c, std::vector<float> hullVertices = {}, int hullMaxVertices = 64,
            std::vector<float> meshVertices = {}, std::vector<int32_t> meshIndices = {}, b3MeshData *meshData = nullptr,
            bool meshWeldVertices = true, float meshWeldTolerance = 0.001f, bool meshIdentifyEdges = true,
            bool meshUseMedianSplit = false, std::vector<float> heightValues = {}, int heightCountX = 0,
            int heightCountZ = 0, float heightCellSizeX = 1.f, float heightCellSizeZ = 1.f, float heightGlobalMin = 0.f,
            float heightGlobalMax = 0.f, bool heightClockwise = false, b3HeightFieldData *heightData = nullptr);
    ~Shape3D();
 
    Shape3D(const Shape3D &)            = delete;
    Shape3D &operator=(const Shape3D &) = delete;
 
    int getId() const { return id_; }
    [[nodiscard]] PhysicsShapeHandle runtimeHandle() const noexcept { return runtimeHandle_; }
    void setTag(int tag);
    int getTag() const { return tag_; }
 
    void setHitEventsEnabled(bool enabled);
    bool areHitEventsEnabled() const;
 
    std::string getKind() const;
    void setBoxSize(float width, float height, float depth);
    void setSphereRadius(float radius);
    void setCapsuleSize(float height, float radius);
    void setConvexHullVertices(const std::vector<float> &vertices, int maxVertices = 64);
    int getConvexHullPointCount() const {
        return kind_ == Kind::ConvexHull ? static_cast<int>(hullVertices_.size() / 3) : 0;
    }
    int getConvexHullMaxVertices() const {
        return kind_ == Kind::ConvexHull ? hullMaxVertices_ : 0;
    }
    void setTriangleMeshData(const std::vector<float> &vertices,
                             const std::vector<int32_t> &indices, bool weldVertices = true,
                             float weldTolerance = 0.001f, bool identifyEdges = true,
                             bool useMedianSplit = false);
    int getTriangleMeshVertexCount() const {
        return kind_ == Kind::TriangleMesh ? static_cast<int>(meshVertices_.size() / 3) : 0;
    }
    int getTriangleMeshTriangleCount() const {
        return kind_ == Kind::TriangleMesh ? static_cast<int>(meshIndices_.size() / 3) : 0;
    }
    void setTriangleMeshMaterialIndices(const std::vector<int32_t> &materialIndices);
    int getTriangleMeshMaterialIndex(int triangleIndex) const;
    int getTriangleMeshMaterialCount() const;
    void setTriangleMeshMaterial(int slot, float friction, float restitution,
                                 float rollingResistance, float tangentX, float tangentY,
                                 float tangentZ, int materialId,
                                 const std::string &frictionMode,
                                 const std::string &restitutionMode);
    float getTriangleMeshMaterialFriction(int slot) const;
    float getTriangleMeshMaterialRestitution(int slot) const;
    float getTriangleMeshMaterialRollingResistance(int slot) const;
    int getTriangleMeshMaterialId(int slot) const;
    void setHeightFieldHeights(const std::vector<float> &heights);
    void setHeightFieldRegion(int x, int z, int width, int depth,
                              const std::vector<float> &heights);
    float getHeightFieldHeight(int x, int z) const;
    int getHeightFieldCountX() const { return kind_ == Kind::HeightField ? heightCountX_ : 0; }
    int getHeightFieldCountZ() const { return kind_ == Kind::HeightField ? heightCountZ_ : 0; }
    float getHeightFieldCellSizeX() const {
        return kind_ == Kind::HeightField ? heightCellSizeX_ : 0.f;
    }
    float getHeightFieldCellSizeZ() const {
        return kind_ == Kind::HeightField ? heightCellSizeZ_ : 0.f;
    }
    float getHeightFieldGlobalMin() const {
        return kind_ == Kind::HeightField ? heightGlobalMin_ : 0.f;
    }
    float getHeightFieldGlobalMax() const {
        return kind_ == Kind::HeightField ? heightGlobalMax_ : 0.f;
    }
    float getBoxWidth() const { return kind_ == Kind::Box ? 2.f * a_ : 0.f; }
    float getBoxHeight() const { return kind_ == Kind::Box ? 2.f * b_ : 0.f; }
    float getBoxDepth() const { return kind_ == Kind::Box ? 2.f * c_ : 0.f; }
    float getRadius() const {
        return kind_ == Kind::Sphere ? a_ : (kind_ == Kind::Capsule ? b_ : 0.f);
    }
    float getCapsuleHeight() const { return kind_ == Kind::Capsule ? 2.f * a_ : 0.f; }
 
    void setOneWay(float nx, float ny, float nz, float planeOffset, float margin,
                   float minNormalDot);
    void disableOneWay();
    bool isOneWay() const { return oneWayEnabled_; }
 
    void setLocalTransform(float px, float py, float pz, float qx, float qy, float qz, float qw);
    void setLocalPosition(float x, float y, float z);
    void setLocalRotation(float qx, float qy, float qz, float qw);
    float getLocalX() const { return localX_; }
    float getLocalY() const { return localY_; }
    float getLocalZ() const { return localZ_; }
    float getLocalRotX() const { return localQx_; }
    float getLocalRotY() const { return localQy_; }
    float getLocalRotZ() const { return localQz_; }
    float getLocalRotW() const { return localQw_; }
 
    void setSensor(bool sensor);
    bool isSensor() const;
 
    void  setFriction(float friction);
    float getFriction() const;
 
    void  setRestitution(float restitution);
    float getRestitution() const;
 
    void setRollingResistance(float resistance);
    float getRollingResistance() const;
    void setTangentVelocity(float x, float y, float z);
    float getTangentVelocityX() const;
    float getTangentVelocityY() const;
    float getTangentVelocityZ() const;
    void setMaterialId(int id);
    int getMaterialId() const;
    void setExplosionScale(float scale);
    float getExplosionScale() const { return explosionScale_; }
    void setFrictionCombineMode(const std::string &mode);
    std::string getFrictionCombineMode() const;
    void setRestitutionCombineMode(const std::string &mode);
    std::string getRestitutionCombineMode() const;
 
    void  setDensity(float density);
    float getDensity() const;
 
    void     setFilterBits(uint64_t categoryBits, uint64_t maskBits);
    uint64_t getCategoryBits() const;
    void setCategoryBits(uint64_t bits);
    void setMaskBits(uint64_t bits);
    uint64_t getMaskBits() const;
    void setGroupIndex(int index);
    int getGroupIndex() const;
 
    Body3D *getBody() { return body_; }
    const Body3D *getBody() const { return body_; }
 
    bool testPoint(float x, float y, float z) const;
 
    void destroy();
 
    b3ShapeId raw() const { return shapeId_; }
    bool      isValid() const;
 
    void invalidate();
 
private:
    friend class World3D;
    friend class Body3D;
    friend struct WorldSnapshotAccess;
 
    void recreate(bool sensor);
    void enableContactOverrideFiltering();
    void refreshOneWayWorldData();
    bool allowsOneWayContact(double pointX, double pointY, double pointZ, float normalX,
                             float normalY, float normalZ) const;
 
    World3D  *world_ = nullptr;
    Body3D   *body_  = nullptr;
    b3ShapeId shapeId_{};
    PhysicsShapeHandle             runtimeHandle_ = PhysicsShapeHandle::invalid();
    Kind      kind_ = Kind::Box;
    float     a_ = 0.f;  // box hx | sphere r | capsule half-height
    float     b_ = 0.f;  // box hy | unused   | capsule radius
    float     c_ = 0.f;  // box hz
    std::vector<float> hullVertices_;
    int       hullMaxVertices_ = 64;
    std::vector<float> meshVertices_;
    std::vector<int32_t> meshIndices_;
    b3MeshData *meshData_ = nullptr;
    bool meshWeldVertices_ = true;
    float meshWeldTolerance_ = 0.001f;
    bool meshIdentifyEdges_ = true;
    bool meshUseMedianSplit_ = false;
    std::vector<uint8_t> meshMaterialIndices_;
    std::vector<b3SurfaceMaterial> meshMaterials_;
    bool meshMaterialsDirty_ = false;
    bool contactOverrideFiltering_ = false;
    float explosionScale_ = 1.f;
    std::vector<float> heightValues_;
    int heightCountX_ = 0, heightCountZ_ = 0;
    float heightCellSizeX_ = 1.f, heightCellSizeZ_ = 1.f;
    float heightGlobalMin_ = 0.f, heightGlobalMax_ = 0.f;
    bool heightClockwise_ = false;
    b3HeightFieldData *heightData_ = nullptr;
    int       id_ = 0;
    int       tag_ = 0;
    bool      hitEventsEnabled_ = false;
    float     localX_ = 0.f, localY_ = 0.f, localZ_ = 0.f;
    float     localQx_ = 0.f, localQy_ = 0.f, localQz_ = 0.f, localQw_ = 1.f;
    bool      oneWayEnabled_ = false;
    float     oneWayLocalNormalX_ = 0.f, oneWayLocalNormalY_ = 1.f,
              oneWayLocalNormalZ_ = 0.f;
    float     oneWayPlaneOffset_ = 0.f;
    float     oneWayMargin_ = 0.05f;
    float     oneWayMinNormalDot_ = 0.1f;
    double    oneWayWorldPointX_ = 0.0, oneWayWorldPointY_ = 0.0, oneWayWorldPointZ_ = 0.0;
    float     oneWayWorldNormalX_ = 0.f, oneWayWorldNormalY_ = 1.f,
              oneWayWorldNormalZ_ = 0.f;
};
 
}  // namespace eve::physics