DistanceField3D.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include <algorithm>
#include <cstddef>
#include <vector>
 
namespace eve::physics {
 
class EVENGINE_API_WORLD DistanceField3D {
public:
    DistanceField3D(int width, int height, int depth, float cellSize, float originX,
                    float originY, float originZ, float outsideDistance);
 
    void setDistances(const std::vector<float> &distances);
    void fill(float distance);
    void setDistanceRegion(int x, int y, int z, int width, int height, int depth,
                           const std::vector<float> &distances);
    void fillRegion(int x, int y, int z, int width, int height, int depth, float distance);
    void setDistance(int x, int y, int z, float distance);
    float getDistance(int x, int y, int z) const;
    float sample(float x, float y, float z) const;
 
    int getWidth() const { return width_; }
    int getHeight() const { return height_; }
    int getDepth() const { return depth_; }
    int getSampleCount() const { return static_cast<int>(distances_.size()); }
    float getCellSize() const { return cellSize_; }
    float getOriginX() const { return originX_; }
    float getOriginY() const { return originY_; }
    float getOriginZ() const { return originZ_; }
    float getOutsideDistance() const { return outsideDistance_; }
    unsigned int getRevision() const { return revision_; }
 
    void sampleNormal(float x, float y, float z);
    float getNormalX() const { return normalX_; }
    float getNormalY() const { return normalY_; }
    float getNormalZ() const { return normalZ_; }
 
    bool checkSphere(float x, float y, float z, float radius);
    bool checkCapsule(float ax, float ay, float az, float bx, float by, float bz,
                      float radius);
    bool castSphere(float x, float y, float z, float radius, float deltaX, float deltaY,
                    float deltaZ);
    bool castCapsule(float ax, float ay, float az, float bx, float by, float bz, float radius,
                     float deltaX, float deltaY, float deltaZ);
    bool moveCapsule(float ax, float ay, float az, float bx, float by, float bz, float radius,
                     float deltaX, float deltaY, float deltaZ);
    void setMoverUp(float x, float y, float z);
    void setMoverSlopeLimit(float degrees);
    void setMoverSkinWidth(float width);
    float getMoverSkinWidth() const { return moverSkinWidth_; }
    void setMoverGroundSnap(float distance);
    float getMoverGroundSnap() const { return moverGroundSnap_; }
    void setMoverStepHeight(float height);
    float getMoverStepHeight() const { return moverStepHeight_; }
    float getCollisionDistance() const { return collisionDistance_; }
    float getCollisionX() const { return collisionX_; }
    float getCollisionY() const { return collisionY_; }
    float getCollisionZ() const { return collisionZ_; }
    float getSurfaceX() const { return surfaceX_; }
    float getSurfaceY() const { return surfaceY_; }
    float getSurfaceZ() const { return surfaceZ_; }
    float getShapeContactX() const { return shapeContactX_; }
    float getShapeContactY() const { return shapeContactY_; }
    float getShapeContactZ() const { return shapeContactZ_; }
    float getPenetrationDepth() const { return std::max(0.f, -collisionDistance_); }
    float getCastFraction() const { return castFraction_; }
    float getCastDistance() const { return castDistance_; }
    bool didCastStartInside() const { return castStartedInside_; }
    float getMoverDeltaX() const { return moverDeltaX_; }
    float getMoverDeltaY() const { return moverDeltaY_; }
    float getMoverDeltaZ() const { return moverDeltaZ_; }
    float getMoverNormalX() const { return moverNormalX_; }
    float getMoverNormalY() const { return moverNormalY_; }
    float getMoverNormalZ() const { return moverNormalZ_; }
    int getMoverIterations() const { return moverIterations_; }
    bool isMoverGrounded() const { return moverGrounded_; }
    float getMoverGroundDot() const { return moverGroundDot_; }
    bool didMoverHitWall() const { return moverHitWall_; }
 
private:
    bool validIndex(int x, int y, int z) const;
    bool validRegion(int x, int y, int z, int width, int height, int depth) const;
    size_t index(int x, int y, int z) const;
    void setCollisionResult(float x, float y, float z, float radius);
    float capsuleClearance(float ax, float ay, float az, float bx, float by, float bz,
                           float radius, float &closestX, float &closestY, float &closestZ) const;
    void updateContactPoints(float x, float y, float z, float radius);
    void setCastResult(float fraction, float travelLength, float x, float y, float z,
                       float clearance, float radius, bool startedInside);
 
    int width_, height_, depth_;
    float cellSize_, originX_, originY_, originZ_, outsideDistance_;
    std::vector<float> distances_;
    float normalX_ = 0.f, normalY_ = 1.f, normalZ_ = 0.f;
    float collisionDistance_ = 0.f, collisionX_ = 0.f, collisionY_ = 0.f,
          collisionZ_ = 0.f;
    float surfaceX_ = 0.f, surfaceY_ = 0.f, surfaceZ_ = 0.f;
    float shapeContactX_ = 0.f, shapeContactY_ = 0.f, shapeContactZ_ = 0.f;
    float castFraction_ = 1.f, castDistance_ = 0.f;
    bool castStartedInside_ = false;
    float moverDeltaX_ = 0.f, moverDeltaY_ = 0.f, moverDeltaZ_ = 0.f;
    float moverNormalX_ = 0.f, moverNormalY_ = 1.f, moverNormalZ_ = 0.f;
    int moverIterations_ = 0;
    float moverUpX_ = 0.f, moverUpY_ = 1.f, moverUpZ_ = 0.f;
    float moverSlopeCos_ = 0.6427876f;
    float moverSkinWidth_ = 0.f;
    float moverGroundSnap_ = 0.f;
    float moverStepHeight_ = 0.f;
    float moverGroundDot_ = -1.f;
    bool moverGrounded_ = false;
    bool moverHitWall_ = false;
    bool moverStepping_ = false;
    unsigned int revision_ = 0;
};
 
}  // namespace eve::physics