doc/api/_gx_shape_8h_source.html

//===========================================================================

//===========================================================================

#pragma once


GX_CORE_NAMESPACE_BEGIN()


class GxShapeSphere;            // 球

class GxShapeBox;               // 箱

class GxShapeAxisAlignedBox;    // 軸方向固定の箱

class GxShapeFrustum;           // 角錐台

class GxShapeCylinder;          // 円柱

class GxShapeCapsule;           // カプセル

class GxShapeMultisphere;       // マルチ球

class GxShapeTrimesh;           // 三角メッシュ

class GxShapePlane;             // 平面

class GxShapeRay;               // レイ

class GxShapeBeam;              // 太さのあるレイ


#define GX_USE_AAB_MIN_MAX 1    // AABをmin-max形式で記述するかどうか


//===========================================================================

//===========================================================================


enum class SHAPE_HIT_STATE

{

    OUTSIDE = 0,

    CROSS,

    INSIDE,

    MAX

};


//===========================================================================

//===========================================================================


class GxShape : public GxClassBase

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    GX_RTTI_ABSTRACT_CLASS(GxShape, GxClassBase)


    static const f32 HIT_DISTANCE;

    static const f32 NORMALIZED_JUDGE_MAX;


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxShape(void){}

    ~GxShape( void ) override {}


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    virtual const GxVector3 getNormal(const GxVector3& position) const = 0;


    virtual b32 isInclude(const GxVector3& /*point*/) const { GX_ERROR(false, "この形状に対するisInclude()は未対応です。"); return false; };


    // note:未テスト

    static b32 isHit(const GxShapeSphere& sphere0, const GxShapeSphere& sphere1, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);

    // note:未テスト

    static b32 isHit(const GxShapeSphere& sphere, const GxShapeBox& box, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);

    // note:未テスト

    static b32 isHit(const GxShapeSphere& sphere, const GxShapeCylinder& cylinder, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);

    // note:未テスト

    static b32 isHit(const GxShapeSphere& sphere, const GxShapeMultisphere& multisphere, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);

    // note:未テスト

    static b32 isHit(const GxShapeSphere& sphere, const GxShapePlane& plane, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);

    // note:未テスト

    static b32 isHit(const GxShapeSphere& sphere, const GxShapeTrimesh& trimesh, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);

    static b32 isHitSphereRay(const GxShapeSphere& sphere, const GxShapeRay& ray, f32* pParameter = nullptr, GxVector3* pHitNormal = nullptr);

    // note:未テスト

    static b32 isHit(const GxShapeSphere& sphere, const GxShapeBeam& beam, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);


    // note:未テスト

    static b32 isHit(const GxShapeBox& box0, const GxShapeBox& box1, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);

    // note:未テスト

    static b32 isHit(const GxShapeBox& box, const GxShapeCylinder& cylinder, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);

    // note:未テスト

    static b32 isHit(const GxShapeBox& box, const GxShapeMultisphere& multisphere, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);

    // note:未テスト

    static b32 isHit(const GxShapeBox& box, const GxShapePlane& plane, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);

    // note:未テスト

    static b32 isHit(const GxShapeBox& box, const GxVector3& n, const GxVector3& p, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);


    // note:未テスト

    static b32 isHit(const GxShapeBox& box, const GxShapeTrimesh& trimesh, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);

    static b32 isHitBoxRay(const GxShapeBox& box, const GxShapeRay& ray, f32* pParam = nullptr, GxVector3* pHitNormal = nullptr);

    // note:未テスト

    static b32 isHit(const GxShapeBox& box, const GxShapeBeam& beam, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);


    // note:未テスト

    static b32 isHit(const GxShapeCylinder& cylinder0, const GxShapeCylinder& cylinder1, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);

    // note:未テスト

    static b32 isHit(const GxShapeCylinder& cylinder, const GxShapeMultisphere& multisphere, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);

    // note:未テスト

    static b32 isHit(const GxShapeCylinder& cylinder, const GxShapePlane& plane, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);

    // note:未テスト

    static b32 isHit(const GxShapeCylinder& cylinder, const GxShapeTrimesh& trimesh, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);

    static b32 isHitCylinderRay(const GxShapeCylinder& cylinder, const GxShapeRay& ray, f32* pParameter = nullptr, GxVector3* pHitNormal = nullptr);

    // note:未テスト

    static b32 isHit(const GxShapeCylinder& cylinder, const GxShapeBeam& beam, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);


    // note:未テスト

    static b32 isHit(const GxShapeCapsule& multisphere0, const GxShapeCapsule& multisphere1, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);

    // note:未テスト

    static b32 isHit(const GxShapeCapsule& multisphere, const GxShapePlane& plane, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);

    // note:未テスト

    static b32 isHit(const GxShapeCapsule& multisphere, const GxShapeTrimesh& trimesh, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);

    // note:未テスト

    static b32 isHitCapsuleRay(const GxShapeCapsule& multisphere, const GxShapeRay& ray, f32* pParameter = nullptr, GxVector3* pHitNormal = nullptr);

    // note:未テスト

    static b32 isHit(const GxShapeCapsule& multisphere, const GxShapeBeam& beam, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);


    // note:未テスト

    static b32 isHit(const GxShapeMultisphere& multisphere0, const GxShapeMultisphere& multisphere1, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);

    // note:未テスト

    static b32 isHit(const GxShapeMultisphere& multisphere, const GxShapePlane& plane, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);

    // note:未テスト

    static b32 isHit(const GxShapeMultisphere& multisphere, const GxShapeTrimesh& trimesh, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);

    // note:未テスト

    static b32 isHitMultisphereRay(const GxShapeMultisphere& multisphere, const GxShapeRay& ray, f32* pParameter = nullptr, GxVector3* pHitNormal = nullptr);

    // note:未テスト

    static b32 isHit(const GxShapeMultisphere& multisphere, const GxShapeBeam& beam, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);


    // note:未テスト

    static b32 isHit(const GxShapeAxisAlignedBox& aab0, const GxShapeAxisAlignedBox& aab1, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);


    static b32 isHit(const GxShapeAxisAlignedBox& aabb, const GxShapePlane& plane, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);


    static b32 isHit(const GxShapeAxisAlignedBox& aabb, const GxVector3& n, const GxVector3& p, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);


    // note:未テスト

    static b32 isHit(const GxShapePlane& plane0, const GxShapePlane& plane1, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);

    // note:未テスト

    static b32 isHit(const GxShapePlane& plane, const GxShapeTrimesh& trimesh, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);

    // note:未テスト

    static b32 isHitPlaneRay(const GxShapePlane& plane, const GxShapeRay& ray, f32* pParameter = nullptr, GxVector3* pHitNormal = nullptr);

    // note:未テスト

    static b32 isHit(const GxShapePlane& plane, const GxShapeBeam& beam, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);


    // note:未テスト

    static b32 isHit(const GxShapeTrimesh& trimesh0, const GxShapeTrimesh& trimesh1, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);

    // note:未テスト

    static b32 isHit(const GxShapeTrimesh& trimesh, const GxShapeRay& ray, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);

    // note:未テスト

    static b32 isHit(const GxShapeTrimesh& trimesh, const GxShapeBeam& beam, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);


    // note:未テスト

    static b32 isHit(const GxShapeRay& ray0, const GxShapeRay& ray1, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);

    // note:未テスト

    static b32 isHit(const GxShapeRay& ray, const GxShapeBeam& beam, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);


    // note:未テスト

    static b32 isHit(const GxShapeBeam& beam0, const GxShapeBeam& beam1, GxVector3* pHitPosition = nullptr, GxVector3* pAdjustVector = nullptr);


    // note:未テスト

    static void getClosestPoint(const GxVector3& point, const GxShapeBox& box, GxVector3& closestPoint, GxVector3& surfacePoint);

    // note:未テスト

    static void getClosestPoint(const GxVector3& point, const GxShapeRay& ray, GxVector3& closestPoint);


};


//===========================================================================

//===========================================================================


class GxShapeSphere : public GxShape

{

    //-------------------------------------------------------------------

    //-------------------------------------------------------------------

public:

    GX_RTTI_CLASS(GxShapeSphere, GxShape)


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxShapeSphere(void) : _radius(0.f){}

    GxShapeSphere(f32 radius, const GxVector3& position) : _radius(radius), _position(position){}

    ~GxShapeSphere( void ) override {}


    //-----------------------------------------------------------

    //-----------------------------------------------------------


#if GX_DEVELOP

    static GxGuiBase* createGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index = 0);

#endif //GX_DEVELOP


    b32 createBounding(const GxVector3* pVertex, const u32 vertexCount);

    b32 createBounding(const void* pVertex, const u32 vertexCount, const u32 stride);


    b32 createMinSphereRough(const u32 vertexCount, const GxVector3* pVertex);


private:

    static void getSurfaceAverage(const GxVector3* pVertex, u32 vertexCount, const u8* pSurfaceFlag, GxVector3& average);


    static f32  getFarthestLength(const GxVector3* pVertex, u32 vertexCount, const GxVector3& basePosition);


    static u32 checkSurfaceVertex(const GxVector3* pVertex, u32 vertexCount, u8* pSurfaceFlag, f32 radius, const GxVector3& center);


    static b32  adjust(const GxVector3* pVertex, u32 vertexCount, const u8* pSurfaceFlag, f32& radius, GxVector3& center);


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    constexpr f32 getRadius(void) const { return _radius; }

    constexpr void setRadius(f32 radius){ _radius = radius; }

    GX_FORCE_INLINE const GxVector3& getPosition(void) const { return _position; }

    GX_FORCE_INLINE void setPosition(const GxVector3& position){ _position = position; }

    const GxVector3 getNormal(const GxVector3& position) const override;


    b32 isInclude(const GxVector3& point) const override;


    b32 isHitRay(const GxVector3& rayStart, const GxVector3& rayEnd, GxVector3* pHitPosition = nullptr, GxVector3* pNormal = nullptr ) const;


    //-----------------------------------------------------------

    //-----------------------------------------------------------

private:

    f32         _radius;

    GxVector3   _position;


};


//===========================================================================

//===========================================================================


class GxShapeBox : public GxShape

{

    //-------------------------------------------------------------------

    //-------------------------------------------------------------------

public:

    GX_RTTI_CLASS(GxShapeBox, GxShape)


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxShapeBox(void){}

    GxShapeBox(const GxVector3& extent, const GxMatrixAffine& matrix = GxMatrixAffine::IDENTITY) : _extent(extent), _matrix(matrix){}

    GxShapeBox(const GxShapeAxisAlignedBox& aab );

    ~GxShapeBox( void ) override {}


    //-----------------------------------------------------------

    //-----------------------------------------------------------

#if GX_DEVELOP

    // 書き込み

    b32 write(GxStreamWriter& writer);

#endif //GX_DEVELOP


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GX_FORCE_INLINE const GxVector3& getExtent(void) const { return _extent; }

    GX_FORCE_INLINE void setExtent(const GxVector3& extent){ _extent = extent; }

    constexpr void setExtent(const f32 x, const f32 y, const f32 z){ _extent._x = x; _extent._y = y; _extent._z = z; }

    GX_FORCE_INLINE const   GxMatrixAffine& getMatrix(void) const { return _matrix; }

    GX_FORCE_INLINE         GxMatrixAffine& getMatrix(void)       { return _matrix; }


    GX_FORCE_INLINE void setMatrix(const GxMatrixAffine& matrix)

    {

        // 本来の意味ではcolumnだがrowで代用

        // todo:スケールマトリクスをはじく処理

        _matrix = matrix;

    }


    GX_FORCE_INLINE void setPosition(const GxVector3& position){ _matrix.setPosition(position); }


    const GxVector3 getNormal(const GxVector3& position) const override;


    b32 isInclude(const GxVector3& point) const override;


    b32 isHitRay(const GxVector3& rayStart, const GxVector3& rayEnd, GxVector3* pHitPosition = nullptr, GxVector3* pNormal = nullptr ) const;


    //-----------------------------------------------------------

    //-----------------------------------------------------------

private:

    GxVector3       _extent;

    GxMatrixAffine  _matrix;


};


//===========================================================================

//===========================================================================


class GxShapeAxisAlignedBox : public GxShape

{

    //-------------------------------------------------------------------

    //-------------------------------------------------------------------

public:

    GX_RTTI_CLASS(GxShapeAxisAlignedBox, GxShape)


    //-----------------------------------------------------------

    //-----------------------------------------------------------


#if GX_USE_AAB_MIN_MAX

    GxShapeAxisAlignedBox(void) : _min(GxVector3::ZERO), _max(GxVector3::ZERO) {}

    GxShapeAxisAlignedBox( const GxVector3& min, const GxVector3& max ) : _min(min), _max(max){}

#else // GX_USE_AAB_MIN_MAX

    GxShapeAxisAlignedBox(void) : _extent(GxVector3::ZERO), _position(GxVector3::ZERO) {}

    GxShapeAxisAlignedBox( const GxVector3& extent, const GxVector3& position ) : _extent(extent), _position(position){}

#endif // !GX_USE_AAB_MIN_MAX

    ~GxShapeAxisAlignedBox( void ) override {}


    //-----------------------------------------------------------

    //-----------------------------------------------------------


#if GX_USE_AAB_MIN_MAX

    GX_FORCE_INLINE const GxVector3&    getMin( void ) const { return _min; }

    GX_FORCE_INLINE const GxVector3&    getMax( void ) const { return _max; }


    GX_FORCE_INLINE void    setMin( const GxVector3& position ) { _min = position; }

    GX_FORCE_INLINE void    setMax( const GxVector3& position) { _max = position; }


    GX_FORCE_INLINE GxVector3 getExtent(void) const { return GxVector3( 0.5f * (_max._x - _min._x), 0.5f * (_max._y - _min._y), 0.5f * (_max._z - _min._z) ); }

    GX_FORCE_INLINE GxVector3 getPosition(void) const { return GxVector3( 0.5f * (_max._x + _min._x), 0.5f * (_max._y + _min._y), 0.5f * (_max._z + _min._z) ); }

    GX_FORCE_INLINE void setPosition( const GxVector3& position) { GxVector3 extent(getExtent()); _max = position; _max += extent; _min = position; _min -= extent;}

#else // GX_USE_AAB_MIN_MAX

    GX_FORCE_INLINE const GxVector3& getExtent(void) const { return _extent; }

    GX_FORCE_INLINE void setExtent(const GxVector3& extent){ _extent = extent; }

    constexpr void setExtent(const f32 x, const f32 y, const f32 z){ _extent._x = x; _extent._y = y; _extent._z = z; }


    GX_FORCE_INLINE const GxVector3& getPosition(void) const { return _position; }


    GX_FORCE_INLINE GxVector3   getMin( void ) const { GxVector3 retval( _position ); retval -= _extent; return retval; }

    GX_FORCE_INLINE void        getMin( GxVector3& min ) const { min = _position; min -= _extent; }

    GX_FORCE_INLINE GxVector3   getMax( void ) const { GxVector3 retval( _position ); retval += _extent; return retval; }

    GX_FORCE_INLINE void        getMax( GxVector3& max ) const { max = _position; max += _extent; }

#endif // !GX_USE_AAB_MIN_MAX


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    b32 createBounding( const GxVector3* pVertex, const u32 count );

    b32 createBounding( const void* pVertex, const u32 count, const u32 stride );


    const GxVector3 getNormal(const GxVector3& position) const override;


    b32 isInclude(const GxVector3& point) const override;


    virtual b32 checkWithAABB(const GxShapeAxisAlignedBox& aabb) const;


    //-----------------------------------------------------------

    //-----------------------------------------------------------

private:

#if GX_USE_AAB_MIN_MAX

    GxVector3   _min;   //<! aab最小座標

    GxVector3   _max;   //<! aab最大座標

#else // GX_USE_AAB_MIN_MAX

    GxVector3   _position;

    GxVector3   _extent;

#endif // else GX_USE_AAB_MIN_MAX


};


//===========================================================================

//===========================================================================


class GxShapeFrustum : public GxShape

{

    //-------------------------------------------------------------------

    //-------------------------------------------------------------------

public:

    GX_RTTI_CLASS(GxShapeFrustum, GxShape)


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxShapeFrustum(void);

    GxShapeFrustum( const GxMatrixAffine& top, f32 nearZ, f32 farZ, f32 fov, f32 aspectRatio );

    ~GxShapeFrustum( void ) override {}


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GX_FORCE_INLINE const GxMatrixAffine& getTop( void ) const { return _top; }

    constexpr f32 getNearZ( void ) const { return _nearZ; }

    constexpr f32 getFarZ( void ) const { return _farZ; }

    constexpr f32 getFov( void ) const { return _fov; }

    constexpr f32 getAspectRatio( void ) const { return _aspectRatio; }


    void updateParameter( const GxMatrixAffine& top, f32 nearZ, f32 farZ, f32 fov, f32 aspectRatio );


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    b32 checkBounding( const GxShapeSphere& sphere ) const;

    b32 checkWithAABB( const GxShapeAxisAlignedBox& aabb , u32& intersect) const;


    b32 checkWithOBB( const GxShapeBox& obb ) const;

    b32 checkBounding( const GxShapeCylinder& cylinder ) const;


    const GxVector3 getNormal(const GxVector3& position) const override;


    b32 isInclude(const GxVector3& point) const override;


    void getVertex( GxVector3* pNearPlane, GxVector3* pFarPlane ) const;

    void getVertex( GxVector3* pVertex ) const;

    void getFarPlaneVertex( GxVector3* pFarPlane ) const;


private:

    void getPlaneVertex( GxVector3* pVertex, f32 tanFov, f32 z ) const;

    b32 checkCylinderVsPlane( const GxVector3& normalPlane, const f32 distPlane, const f32 radiusEff, const GxVector3& normalCylinder, GxVector3& diff0, GxVector3& diff1, b32 needsUpdate ) const;


    //-----------------------------------------------------------

    //-----------------------------------------------------------

private:

    GxMatrixAffine  _top;

    f32         _nearZ;

    f32         _farZ;


    f32         _fov;

    f32         _aspectRatio;


    GxVector3   _sideNormal[4];


};


//===========================================================================

//===========================================================================


class GxShapeCylinder : public GxShape

{

    //-------------------------------------------------------------------

    //-------------------------------------------------------------------

public:

    GX_RTTI_CLASS(GxShapeCylinder, GxShape)


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxShapeCylinder(void){}

    GxShapeCylinder(f32 radius, f32 heightHalf, const GxMatrixAffine& matrix = GxMatrixAffine::IDENTITY) : _extent(radius, heightHalf, radius), _matrix(matrix){}

    GxShapeCylinder(const f32 radius, const GxVector3& center0, const GxVector3& center1 );

    ~GxShapeCylinder( void ) override {}


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GX_FORCE_INLINE const GxVector3& getExtent(void) const { return _extent; }

    GX_FORCE_INLINE void setExtent(const GxVector3& extent){ _extent = extent; }

    GX_FORCE_INLINE const GxMatrixAffine& getMatrix(void) const { return _matrix; }


    GX_FORCE_INLINE void setMatrix(const GxMatrixAffine& matrix)

    {

        // 本来の意味ではcolumnだがrowで代用

        // todo:スケールマトリクスをはじく処理

        _matrix = matrix;

    }


    const GxVector3 getNormal(const GxVector3& position) const override;


    b32 isInclude(const GxVector3& point) const override;


    b32 isHitRay(const GxVector3& rayStart, const GxVector3& rayEnd, GxVector3* pHitPosition = nullptr, GxVector3* pNormal = nullptr ) const;


    //-----------------------------------------------------------

    //-----------------------------------------------------------

private:

    GxVector3   _extent;

    GxMatrixAffine  _matrix;


};


//===========================================================================

//===========================================================================


class GxShapeCapsule : public GxShape

{

    //-------------------------------------------------------------------

    //-------------------------------------------------------------------

public:

    GX_RTTI_CLASS(GxShapeCapsule, GxShape)


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxShapeCapsule( void ) : _radius(0.f), _height(0.f){}

    GxShapeCapsule( f32 radius, f32 height, const GxMatrixAffine& matrix = GxMatrixAffine::IDENTITY );

    ~GxShapeCapsule( void ) override {}


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    constexpr f32   getRadius(void) const { return _radius; }

    constexpr void  setRadius(f32 radius)   { _radius = radius; }


    constexpr f32   getHeight( void ) const { return _height; }

    constexpr void  setHeight( f32 height ) { _height = height;}


    GX_FORCE_INLINE const GxMatrixAffine& getMatrix(void) const { return _matrix; }


    GX_FORCE_INLINE void setMatrix(const GxMatrixAffine& matrix)

    {

        // 本来の意味ではcolumnだがrowで代用

        // todo:スケールマトリクスをはじく処理

        _matrix = matrix;

    }


    const GxVector3 getNormal(const GxVector3& position) const override;


    b32 isHitRay(const GxVector3& rayStart, const GxVector3& rayEnd, GxVector3* pHitPosition = nullptr, GxVector3* pNormal = nullptr, f32* pParameter = nullptr ) const;


    //-----------------------------------------------------------

    //-----------------------------------------------------------

private:

    f32             _radius;

    f32             _height;

    GxMatrixAffine  _matrix;


};


//===========================================================================

//===========================================================================


class GxShapeMultisphere : public GxShape

{

    //-------------------------------------------------------------------

    //-------------------------------------------------------------------

public:

    GX_RTTI_CLASS(GxShapeMultisphere, GxShape)


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxShapeMultisphere(void){}

    GxShapeMultisphere(f32 radius0, f32 radius1, const GxVector3& position0 = GxVector3::ZERO, const GxVector3& position1 = GxVector3::ZERO);

    ~GxShapeMultisphere( void ) override {}


    //-----------------------------------------------------------

    //-----------------------------------------------------------


#if GX_DEVELOP

    static GxGuiBase* createGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index = 0);

#endif //GX_DEVELOP


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    constexpr f32 getRadius0(void) const { return _radius[0]; }

    constexpr void setRadius0(f32 radius){ _radius[0] = radius; }

    constexpr f32 getRadius1(void) const { return _radius[1]; }

    constexpr void setRadius1(f32 radius){ _radius[1] = radius; }

    GX_FORCE_INLINE const GxVector3& getPosition0(void) const { return _position[0]; }

    GX_FORCE_INLINE void setPosition0(const GxVector3& position){ _position[0] = position; }

    GX_FORCE_INLINE const GxVector3& getPosition1(void) const { return _position[1]; }

    GX_FORCE_INLINE void setPosition1(const GxVector3& position){ _position[1] = position; }

    const GxVector3 getNormal(const GxVector3& position) const override;


    b32 isHitRay(const GxVector3& rayStart, const GxVector3& rayEnd, GxVector3* pHitPosition = nullptr, GxVector3* pNormal = nullptr, f32* pParameter = nullptr ) const;


    //-----------------------------------------------------------

    //-----------------------------------------------------------

private:

    f32         _radius[2];

    GxVector3   _position[2];


};


//===========================================================================

//===========================================================================


class GxShapeTriangle : public GxShape

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    static const u32 VERTEX_COUNT = 3;


    // RTTI定義

    GX_RTTI_CLASS(GxShapeTriangle, GxShape)


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxShapeTriangle(void);

    GxShapeTriangle(const GxVector3* pVertex0, const GxVector3* pVertex1, const GxVector3* pVertex2);


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    b32 operator == (const GxShapeTriangle& triangle) const;

    b32 operator < (const GxShapeTriangle& triangle) const;


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GX_FORCE_INLINE static b32 compareVertex(const GxVector3* pVertex0, const GxVector3* pVertex1) { return *pVertex0 < *pVertex1; }

    GX_FORCE_INLINE const GxVector3 getNormal(const GxVector3& /*position*/) const override { return GxVector3::ZERO; }


    //-----------------------------------------------------------

    //-----------------------------------------------------------

private:

    const GxVector3* _pVertex[VERTEX_COUNT];


};


//===========================================================================

// note:pVertex等のコピーは行っていないので、元を保持し続ける必要がある。

//===========================================================================


class GxShapeTrimesh : public GxShape

{

    //-------------------------------------------------------------------

    //-------------------------------------------------------------------

public:

    GX_RTTI_CLASS(GxShapeTrimesh, GxShape)

    //GX_PROHIBIT_CLASS_BASE(GxShapeTrimesh);


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxShapeTrimesh(void) : _pVertex(nullptr), _pIndex(nullptr), _pCheckFlag(nullptr), _pMaterial(nullptr){}


    GxShapeTrimesh(const GxMatrixAffine& matrix, const GxVector3* pVertex, u32 numVertex, const u32* pIndex, u32 numIndex, const u32* pCheckFlag, const s32* pMaterial) :

                _matrix(matrix), _pVertex(pVertex), _pIndex(pIndex), _pCheckFlag(pCheckFlag), _pMaterial(pMaterial), _numVertex(numVertex), _numIndex(numIndex) {}


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    static void getRingTriangleIndices(const GxVector3* pVertexList, u32 vertexCount, GxArray& triangleIndices, u32 vertexStartIndex = 0);

    static void getDelaunayTriangles(const GxVector3* pVertexList, u32 vertexCount, GxArray& triangleVertices);

    static void getDelaunayTriangleIndices(const GxVector3* pVertexList, u32 vertexCount, GxArray& triangleIndices, u32 vertexStartIndex = 0);

private:

    static b32 findTriangle(const GxArray& triangles, const GxShapeTriangle& triangle);


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:


    GX_FORCE_INLINE const GxVector3& getVertex(u32 number) const

    {

        GX_ASSERT(number < _numVertex, "vertex access error");

        return *(_pVertex + number);

    }


    GX_FORCE_INLINE const GxVector3* getVertexAddress( void ) const { return _pVertex; }

    GX_FORCE_INLINE const u32* getIndexAddress( void ) const { return _pIndex; }


    b32 getTriangleVertex(u32 triangleIndex, GxVector3& vertex0, GxVector3& vertex1, GxVector3& vertex2) const;


    const GxVector3 getNormal(const GxVector3& position) const override;


    GX_FORCE_INLINE const GxMatrixAffine& getMatrix(void) const { return _matrix; }


    GX_FORCE_INLINE void setMatrix(const GxMatrixAffine& matrix)

    {

        // 本来の意味ではcolumnだがrowで代用

        // todo:スケールマトリクスをはじく処理

        _matrix = matrix;

    }


    constexpr u32 getNumVertex(void) const { return _numVertex; }

    constexpr u32 getNumTriangle(void) const { return _numIndex / 3; }


    constexpr u32 getCheckFlag(u32 triangleIndex) const

    {

        GX_ASSERT(triangleIndex < _numIndex / 3, "checkFlag access error");

        return *(_pCheckFlag + triangleIndex);

    }


    // todo:_pCheckFlagのallocをGxShapeTrimesh内に入れられないか考察

    GX_FORCE_INLINE b32 isCheckFlagExist( void ) const { return _pCheckFlag ? true : false; }


    constexpr s32 getMaterial(u32 triangleIndex) const

    {

        GX_ASSERT(triangleIndex < _numIndex / 3, "material access error");

        return *(_pMaterial + triangleIndex);

    }


    // todo:_pMaterialのallocをGxShapeTrimesh内に入れられないか考察

    GX_FORCE_INLINE b32 isMaterialExist( void ) const { return _pMaterial ? true : false; }


    //-----------------------------------------------------------

    //-----------------------------------------------------------

private:

    GxMatrixAffine      _matrix;

    const GxVector3*    _pVertex;

    const u32*          _pIndex;

    const u32*          _pCheckFlag;

    const s32*          _pMaterial;

    u32                 _numVertex;

    u32                 _numIndex;


};


//===========================================================================

//===========================================================================


class GxShapeTetrahedron : public GxShape

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    const static size_t VERTEX_COUNT = 4;


    // RTTI定義

    GX_RTTI_CLASS(GxShapeTetrahedron, GxShape)


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    GxShapeTetrahedron(void);

    GxShapeTetrahedron(const GxVector3* pVertex0, const GxVector3* pVertex1, const GxVector3* pVertex2, const GxVector3* pVertex3);


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    b32 operator == (const GxShapeTetrahedron& tetrahedron) const;

    b32 operator < (const GxShapeTetrahedron& tetrahedron) const;


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GX_FORCE_INLINE static b32 compareVertex(const GxVector3* pVertex0, const GxVector3* pVertex1) { return *pVertex0 < *pVertex1; }

    GX_FORCE_INLINE const GxVector3 getNormal(const GxVector3& /*position*/) const override { return GxVector3::ZERO; }

    b32 hasCommonPoints(const GxShapeTetrahedron& tetrahedron) const;

    static f32 luDecomposition(f32 a[3][3], s32 ip[3]);

    static f32 gauss(f32 a[3][3], f32 b[3], f32 x[3]);

    void getCircumsphere(GxVector3& center, f32& radius) const;


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    const GxVector3* _pVertex[VERTEX_COUNT];


};


//===========================================================================

//===========================================================================


class GxShapePlane : public GxShape

{

    //-------------------------------------------------------------------

    //-------------------------------------------------------------------

public:

    GX_RTTI_CLASS(GxShapePlane, GxShape)


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxShapePlane(void){}

    GxShapePlane(const GxVector3& position, const GxVector3& normal);

    ~GxShapePlane( void ) override {}


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GX_FORCE_INLINE const GxVector3 getNormal(const GxVector3& /*position*/ = GxVector3::ZERO) const override { return GxVector3(_plane); }

    GX_FORCE_INLINE const GxVector4& getVector(void) const { return _plane; }

    GX_FORCE_INLINE f32 getDistance(const GxVector3& position) const { return (GxVector3::getDot(GxVector3(_plane), position) + _plane._w); }

    GX_FORCE_INLINE const GxVector3 getProjectivePosition(const GxVector3& position) const { return (position + (GxVector3(_plane) * -getDistance(position))); }


    b32 isHitRay( const GxVector3& position0, const GxVector3& position1, GxVector3* pHitPosition = nullptr, GxVector3* pNormal = nullptr  ) const;

    b32 isHitHalfLine( const GxVector3& start, const GxVector3& direction, GxVector3* pHitPosition = nullptr, GxVector3* pNormal = nullptr ) const;


    //-----------------------------------------------------------

    //-----------------------------------------------------------

private:

    GxVector4   _plane;


};


//===========================================================================

//===========================================================================


class GxShapeRay : public GxShape

{

    //-------------------------------------------------------------------

    //-------------------------------------------------------------------

public:

    GX_RTTI_CLASS(GxShapeRay, GxShape)


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxShapeRay(void){}

    GxShapeRay(const GxVector3& position0, const GxVector3& position1){ _position[0] = position0; _position[1] = position1; }

    ~GxShapeRay( void ) override {}


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GX_FORCE_INLINE const GxVector3& getPosition0(void) const { return _position[0]; }

    GX_FORCE_INLINE void setPosition0(const GxVector3& position){ _position[0] = position; }

    GX_FORCE_INLINE const GxVector3& getPosition1(void) const { return _position[1]; }

    GX_FORCE_INLINE void setPosition1(const GxVector3& position){ _position[1] = position; }

    GX_FORCE_INLINE const GxVector3 getNormal(const GxVector3& /*position*/) const override { return GxVector3::ZERO; }


    //-----------------------------------------------------------

    //-----------------------------------------------------------

private:

    GxVector3   _position[2];


};


//===========================================================================

//===========================================================================


class GxShapeBeam : public GxShapeRay

{

    //-------------------------------------------------------------------

    //-------------------------------------------------------------------

public:

    GX_RTTI_CLASS(GxShapeBeam, GxShapeRay)


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxShapeBeam(void) : _radius(0.f){}

    ~GxShapeBeam( void ) override {}


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    constexpr f32 getRadius(void) const { return _radius; }

    constexpr void setRadius(f32 radius){ _radius = radius; }


    //-----------------------------------------------------------

    //-----------------------------------------------------------

private:

    f32 _radius;


};


GX_CORE_NAMESPACE_END()

GxTypedObject
void GxTypedObject
その他
Definition GxDefine.h:213

INIT::ZERO
@ ZERO
全て 0 で初期化

SHAPE_HIT_STATE
SHAPE_HIT_STATE
形状同士の交差判定時
Definition GxShape.h:34

SHAPE_HIT_STATE::CROSS
@ CROSS
交差

SHAPE_HIT_STATE::MAX
@ MAX
定義数

SHAPE_HIT_STATE::INSIDE
@ INSIDE
内側

SHAPE_HIT_STATE::OUTSIDE
@ OUTSIDE
外側

GxArray
配列クラス
Definition GxArray.h:18

GxClassBase
オブジェクト基底クラス
Definition GxBase.h:88

GxProperty
プロパティクラス
Definition GxProperty.h:48

GxRtti
実行時型情報クラス
Definition GxRtti.h:154

GxShapeAxisAlignedBox
軸方向固定の箱形状クラス
Definition GxShape.h:418

GxShapeAxisAlignedBox::GxShapeAxisAlignedBox
GxShapeAxisAlignedBox(void)
デフォルトコンストラクタ
Definition GxShape.h:434

GxShapeAxisAlignedBox::getMax
GX_FORCE_INLINE const GxVector3 & getMax(void) const
最大取得
Definition GxShape.h:456

GxShapeAxisAlignedBox::isInclude
b32 isInclude(const GxVector3 &point) const override
指定点が含まれているか判定
Definition GxShape.cpp:2056

GxShapeAxisAlignedBox::getExtent
GX_FORCE_INLINE GxVector3 getExtent(void) const
大きさ取得
Definition GxShape.h:464

GxShapeAxisAlignedBox::getPosition
GX_FORCE_INLINE GxVector3 getPosition(void) const
位置取得
Definition GxShape.h:466

GxShapeAxisAlignedBox::getNormal
const GxVector3 getNormal(const GxVector3 &position) const override
指定位置への法線を求める
Definition GxShape.cpp:2028

GxShapeAxisAlignedBox::setMax
GX_FORCE_INLINE void setMax(const GxVector3 &position)
最大設定
Definition GxShape.h:461

GxShapeAxisAlignedBox::GxShapeAxisAlignedBox
GxShapeAxisAlignedBox(const GxVector3 &min, const GxVector3 &max)
コンストラクタ
Definition GxShape.h:436

GxShapeAxisAlignedBox::setMin
GX_FORCE_INLINE void setMin(const GxVector3 &position)
最小設定
Definition GxShape.h:459

GxShapeAxisAlignedBox::getMin
GX_FORCE_INLINE const GxVector3 & getMin(void) const
最小取得
Definition GxShape.h:454

GxShapeAxisAlignedBox::createBounding
b32 createBounding(const GxVector3 *pVertex, const u32 count)
境界作成(GxVector3指定)
Definition GxShape.cpp:1932

GxShapeAxisAlignedBox::setPosition
GX_FORCE_INLINE void setPosition(const GxVector3 &position)
位置設定
Definition GxShape.h:468

GxShapeAxisAlignedBox::checkWithAABB
virtual b32 checkWithAABB(const GxShapeAxisAlignedBox &aabb) const
指定点が含まれているか判定
Definition GxShape.cpp:2040

GxShapeBeam
光束形状クラス
Definition GxShape.h:1213

GxShapeBeam::~GxShapeBeam
~GxShapeBeam(void) override
デストラクタ
Definition GxShape.h:1230

GxShapeBeam::setRadius
constexpr void setRadius(f32 radius)
半径を設定
Definition GxShape.h:1241

GxShapeBeam::getRadius
constexpr f32 getRadius(void) const
半径を取得
Definition GxShape.h:1239

GxShapeBox
箱形状クラス
Definition GxShape.h:333

GxShapeBox::getExtent
GX_FORCE_INLINE const GxVector3 & getExtent(void) const
大きさ取得
Definition GxShape.h:373

GxShapeBox::getMatrix
GX_FORCE_INLINE const GxMatrixAffine & getMatrix(void) const
マトリクス取得
Definition GxShape.h:379

GxShapeBox::setExtent
constexpr void setExtent(const f32 x, const f32 y, const f32 z)
大きさ設定
Definition GxShape.h:377

GxShapeBox::setExtent
GX_FORCE_INLINE void setExtent(const GxVector3 &extent)
大きさ設定
Definition GxShape.h:375

GxShapeBox::GxShapeBox
GxShapeBox(const GxVector3 &extent, const GxMatrixAffine &matrix=GxMatrixAffine::IDENTITY)
コンストラクタ
Definition GxShape.h:350

GxShapeBox::GxShapeBox
GxShapeBox(void)
デフォルトコンストラクタ
Definition GxShape.h:348

GxShapeBox::~GxShapeBox
~GxShapeBox(void) override
デストラクタ
Definition GxShape.h:354

GxShapeBox::setPosition
GX_FORCE_INLINE void setPosition(const GxVector3 &position)
マトリクス設定(スケールは許可しない)
Definition GxShape.h:391

GxShapeBox::getMatrix
GX_FORCE_INLINE GxMatrixAffine & getMatrix(void)
マトリクス取得
Definition GxShape.h:381

GxShapeBox::setMatrix
GX_FORCE_INLINE void setMatrix(const GxMatrixAffine &matrix)
マトリクス設定(スケールは許可しない)
Definition GxShape.h:383

GxShapeBox::isInclude
b32 isInclude(const GxVector3 &point) const override
指定点が含まれているか判定
Definition GxShape.cpp:1868

GxShapeBox::isHitRay
b32 isHitRay(const GxVector3 &rayStart, const GxVector3 &rayEnd, GxVector3 *pHitPosition=nullptr, GxVector3 *pNormal=nullptr) const
線分の衝突判定
Definition GxShape.cpp:1893

GxShapeBox::getNormal
const GxVector3 getNormal(const GxVector3 &position) const override
表面位置から法線を求める
Definition GxShape.cpp:1855

GxShapeCapsule
カプセル形状クラス
Definition GxShape.h:707

GxShapeCapsule::getRadius
constexpr f32 getRadius(void) const
半径を取得
Definition GxShape.h:735

GxShapeCapsule::setMatrix
GX_FORCE_INLINE void setMatrix(const GxMatrixAffine &matrix)
マトリクス設定(スケールは許可しない)
Definition GxShape.h:747

GxShapeCapsule::getMatrix
GX_FORCE_INLINE const GxMatrixAffine & getMatrix(void) const
マトリクス取得
Definition GxShape.h:745

GxShapeCapsule::getHeight
constexpr f32 getHeight(void) const
高さを取得
Definition GxShape.h:740

GxShapeCapsule::setRadius
constexpr void setRadius(f32 radius)
半径を設定
Definition GxShape.h:737

GxShapeCapsule::GxShapeCapsule
GxShapeCapsule(void)
デフォルトコンストラクタ
Definition GxShape.h:722

GxShapeCapsule::isHitRay
b32 isHitRay(const GxVector3 &rayStart, const GxVector3 &rayEnd, GxVector3 *pHitPosition=nullptr, GxVector3 *pNormal=nullptr, f32 *pParameter=nullptr) const
線分の衝突判定
Definition GxShape.cpp:2780

GxShapeCapsule::getNormal
const GxVector3 getNormal(const GxVector3 &position) const override
指定位置への法線を取得
Definition GxShape.cpp:2764

GxShapeCapsule::setHeight
constexpr void setHeight(f32 height)
高さを設定
Definition GxShape.h:742

GxShapeCapsule::~GxShapeCapsule
~GxShapeCapsule(void) override
デストラクタ
Definition GxShape.h:726

GxShapeCylinder
円柱形状クラス
Definition GxShape.h:634

GxShapeCylinder::isHitRay
b32 isHitRay(const GxVector3 &rayStart, const GxVector3 &rayEnd, GxVector3 *pHitPosition=nullptr, GxVector3 *pNormal=nullptr) const
線分の衝突判定
Definition GxShape.cpp:2717

GxShapeCylinder::GxShapeCylinder
GxShapeCylinder(f32 radius, f32 heightHalf, const GxMatrixAffine &matrix=GxMatrixAffine::IDENTITY)
Definition GxShape.h:654

GxShapeCylinder::setExtent
GX_FORCE_INLINE void setExtent(const GxVector3 &extent)
大きさ設定
Definition GxShape.h:672

GxShapeCylinder::getNormal
const GxVector3 getNormal(const GxVector3 &position) const override
指定位置への法線を求める
Definition GxShape.cpp:2669

GxShapeCylinder::~GxShapeCylinder
~GxShapeCylinder(void) override
デストラクタ
Definition GxShape.h:661

GxShapeCylinder::getExtent
GX_FORCE_INLINE const GxVector3 & getExtent(void) const
大きさ取得
Definition GxShape.h:670

GxShapeCylinder::GxShapeCylinder
GxShapeCylinder(void)
デフォルトコンストラクタ
Definition GxShape.h:649

GxShapeCylinder::getMatrix
GX_FORCE_INLINE const GxMatrixAffine & getMatrix(void) const
マトリクス取得
Definition GxShape.h:674

GxShapeCylinder::isInclude
b32 isInclude(const GxVector3 &point) const override
指定点が含まれているか判定
Definition GxShape.cpp:2681

GxShapeCylinder::setMatrix
GX_FORCE_INLINE void setMatrix(const GxMatrixAffine &matrix)
マトリクス設定(スケールは許可しない)
Definition GxShape.h:676

GxShapeFrustum
角錐台
Definition GxShape.h:531

GxShapeFrustum::getFov
constexpr f32 getFov(void) const
Definition GxShape.h:569

GxShapeFrustum::getNormal
const GxVector3 getNormal(const GxVector3 &position) const override
指定位置への法線を求める
Definition GxShape.cpp:2551

GxShapeFrustum::getFarPlaneVertex
void getFarPlaneVertex(GxVector3 *pFarPlane) const
遠面の頂点を取得
Definition GxShape.cpp:2607

GxShapeFrustum::~GxShapeFrustum
~GxShapeFrustum(void) override
デストラクタ
Definition GxShape.h:550

GxShapeFrustum::GxShapeFrustum
GxShapeFrustum(void)
デフォルトコンストラクタ
Definition GxShape.cpp:2105

GxShapeFrustum::getVertex
void getVertex(GxVector3 *pNearPlane, GxVector3 *pFarPlane) const
頂点を取得(近面と遠面を別で取得)
Definition GxShape.cpp:2578

GxShapeFrustum::getFarZ
constexpr f32 getFarZ(void) const
Definition GxShape.h:566

GxShapeFrustum::updateParameter
void updateParameter(const GxMatrixAffine &top, f32 nearZ, f32 farZ, f32 fov, f32 aspectRatio)
パラメタ更新
Definition GxShape.cpp:2140

GxShapeFrustum::checkWithOBB
b32 checkWithOBB(const GxShapeBox &obb) const
境界形状との交差判定：OBB
Definition GxShape.cpp:2308

GxShapeFrustum::getAspectRatio
constexpr f32 getAspectRatio(void) const
Definition GxShape.h:572

GxShapeFrustum::getTop
GX_FORCE_INLINE const GxMatrixAffine & getTop(void) const
Definition GxShape.h:560

GxShapeFrustum::checkWithAABB
b32 checkWithAABB(const GxShapeAxisAlignedBox &aabb, u32 &intersect) const
境界形状との交差判定：AABB
Definition GxShape.cpp:2217

GxShapeFrustum::checkBounding
b32 checkBounding(const GxShapeSphere &sphere) const
境界形状との交差判定：球
Definition GxShape.cpp:2181

GxShapeFrustum::getNearZ
constexpr f32 getNearZ(void) const
Definition GxShape.h:563

GxShapeFrustum::isInclude
b32 isInclude(const GxVector3 &point) const override
指定点が含まれているか判定
Definition GxShape.cpp:2562

GxShape
形状基礎クラス
Definition GxShape.h:45

GxShape::isHit
static b32 isHit(const GxShapeSphere &sphere0, const GxShapeSphere &sphere1, GxVector3 *pHitPosition=nullptr, GxVector3 *pAdjustVector=nullptr)
球と球の衝突判定
Definition GxShape.cpp:38

GxShape::isHitSphereRay
static b32 isHitSphereRay(const GxShapeSphere &sphere, const GxShapeRay &ray, f32 *pParameter=nullptr, GxVector3 *pHitNormal=nullptr)
球と線分の衝突判定
Definition GxShape.cpp:192

GxShape::getClosestPoint
static void getClosestPoint(const GxVector3 &point, const GxShapeBox &box, GxVector3 &closestPoint, GxVector3 &surfacePoint)
点と箱の最近接点を求める
Definition GxShape.cpp:1359

GxShape::getNormal
virtual const GxVector3 getNormal(const GxVector3 &position) const =0
指定位置への法線を求める

GxShape::NORMALIZED_JUDGE_MAX
static const f32 NORMALIZED_JUDGE_MAX
fabs(lengthSquare - 1.f)がこの値未満なら正規化と判定
Definition GxShape.h:56

GxShape::isHitPlaneRay
static b32 isHitPlaneRay(const GxShapePlane &plane, const GxShapeRay &ray, f32 *pParameter=nullptr, GxVector3 *pHitNormal=nullptr)
平面と線分の衝突判定
Definition GxShape.cpp:1224

GxShape::isInclude
virtual b32 isInclude(const GxVector3 &) const
Definition GxShape.h:81

GxShape::isHitCylinderRay
static b32 isHitCylinderRay(const GxShapeCylinder &cylinder, const GxShapeRay &ray, f32 *pParameter=nullptr, GxVector3 *pHitNormal=nullptr)
円柱と線分の衝突判定
Definition GxShape.cpp:617

GxShape::isHitBoxRay
static b32 isHitBoxRay(const GxShapeBox &box, const GxShapeRay &ray, f32 *pParam=nullptr, GxVector3 *pHitNormal=nullptr)
箱と線分の衝突判定
Definition GxShape.cpp:448

GxShape::isHitMultisphereRay
static b32 isHitMultisphereRay(const GxShapeMultisphere &multisphere, const GxShapeRay &ray, f32 *pParameter=nullptr, GxVector3 *pHitNormal=nullptr)
マルチ球と線分の衝突判定
Definition GxShape.cpp:980

GxShape::HIT_DISTANCE
static const f32 HIT_DISTANCE
この距離未満なら衝突と判定
Definition GxShape.h:54

GxShape::~GxShape
~GxShape(void) override
デストラクタ
Definition GxShape.h:67

GxShape::isHitCapsuleRay
static b32 isHitCapsuleRay(const GxShapeCapsule &multisphere, const GxShapeRay &ray, f32 *pParameter=nullptr, GxVector3 *pHitNormal=nullptr)
カプセルと線分の衝突判定
Definition GxShape.cpp:855

GxShapeMultisphere
マルチ球形状クラス
Definition GxShape.h:776

GxShapeMultisphere::getRadius0
constexpr f32 getRadius0(void) const
半径0を取得
Definition GxShape.h:815

GxShapeMultisphere::setRadius1
constexpr void setRadius1(f32 radius)
半径1を設定
Definition GxShape.h:821

GxShapeMultisphere::getPosition0
GX_FORCE_INLINE const GxVector3 & getPosition0(void) const
位置0を取得
Definition GxShape.h:823

GxShapeMultisphere::GxShapeMultisphere
GxShapeMultisphere(void)
デフォルトコンストラクタ
Definition GxShape.h:791

GxShapeMultisphere::setPosition1
GX_FORCE_INLINE void setPosition1(const GxVector3 &position)
位置1を設定
Definition GxShape.h:829

GxShapeMultisphere::setPosition0
GX_FORCE_INLINE void setPosition0(const GxVector3 &position)
位置0を設定
Definition GxShape.h:825

GxShapeMultisphere::getPosition1
GX_FORCE_INLINE const GxVector3 & getPosition1(void) const
位置1を取得
Definition GxShape.h:827

GxShapeMultisphere::getRadius1
constexpr f32 getRadius1(void) const
半径1を取得
Definition GxShape.h:819

GxShapeMultisphere::isHitRay
b32 isHitRay(const GxVector3 &rayStart, const GxVector3 &rayEnd, GxVector3 *pHitPosition=nullptr, GxVector3 *pNormal=nullptr, f32 *pParameter=nullptr) const
線分の衝突判定
Definition GxShape.cpp:2849

GxShapeMultisphere::~GxShapeMultisphere
~GxShapeMultisphere(void) override
デストラクタ
Definition GxShape.h:795

GxShapeMultisphere::getNormal
const GxVector3 getNormal(const GxVector3 &position) const override
指定位置への法線を取得
Definition GxShape.cpp:2833

GxShapeMultisphere::setRadius0
constexpr void setRadius0(f32 radius)
半径0を設定
Definition GxShape.h:817

GxShapePlane
平面形状クラス
Definition GxShape.h:1102

GxShapePlane::getDistance
GX_FORCE_INLINE f32 getDistance(const GxVector3 &position) const
距離を取得
Definition GxShape.h:1134

GxShapePlane::getNormal
GX_FORCE_INLINE const GxVector3 getNormal(const GxVector3 &=GxVector3::ZERO) const override
指定位置への法線を取得
Definition GxShape.h:1130

GxShapePlane::GxShapePlane
GxShapePlane(void)
デフォルトコンストラクタ
Definition GxShape.h:1117

GxShapePlane::isHitHalfLine
b32 isHitHalfLine(const GxVector3 &start, const GxVector3 &direction, GxVector3 *pHitPosition=nullptr, GxVector3 *pNormal=nullptr) const
半直線との衝突判定
Definition GxShape.cpp:3555

GxShapePlane::~GxShapePlane
~GxShapePlane(void) override
デストラクタ
Definition GxShape.h:1121

GxShapePlane::isHitRay
b32 isHitRay(const GxVector3 &position0, const GxVector3 &position1, GxVector3 *pHitPosition=nullptr, GxVector3 *pNormal=nullptr) const
線分との衝突判定
Definition GxShape.cpp:3530

GxShapePlane::getProjectivePosition
GX_FORCE_INLINE const GxVector3 getProjectivePosition(const GxVector3 &position) const
射影した位置を取得
Definition GxShape.h:1136

GxShapePlane::getVector
GX_FORCE_INLINE const GxVector4 & getVector(void) const
ベクトルを取得
Definition GxShape.h:1132

GxShapeRay
線分形状クラス
Definition GxShape.h:1160

GxShapeRay::setPosition1
GX_FORCE_INLINE void setPosition1(const GxVector3 &position)
位置1を設定
Definition GxShape.h:1194

GxShapeRay::~GxShapeRay
~GxShapeRay(void) override
デストラクタ
Definition GxShape.h:1179

GxShapeRay::GxShapeRay
GxShapeRay(const GxVector3 &position0, const GxVector3 &position1)
コンストラクタ
Definition GxShape.h:1177

GxShapeRay::getNormal
GX_FORCE_INLINE const GxVector3 getNormal(const GxVector3 &) const override
指定位置への法線を取得
Definition GxShape.h:1196

GxShapeRay::getPosition1
GX_FORCE_INLINE const GxVector3 & getPosition1(void) const
位置1を取得
Definition GxShape.h:1192

GxShapeRay::getPosition0
GX_FORCE_INLINE const GxVector3 & getPosition0(void) const
位置0を取得
Definition GxShape.h:1188

GxShapeRay::setPosition0
GX_FORCE_INLINE void setPosition0(const GxVector3 &position)
位置0を設定
Definition GxShape.h:1190

GxShapeSphere
球形状クラス
Definition GxShape.h:240

GxShapeSphere::getPosition
GX_FORCE_INLINE const GxVector3 & getPosition(void) const
位置取得
Definition GxShape.h:305

GxShapeSphere::createBounding
b32 createBounding(const GxVector3 *pVertex, const u32 vertexCount)
境界作成(GxVector3指定)
Definition GxShape.cpp:1507

GxShapeSphere::setRadius
constexpr void setRadius(f32 radius)
半径設定
Definition GxShape.h:303

GxShapeSphere::getNormal
const GxVector3 getNormal(const GxVector3 &position) const override
指定位置への法線を求める
Definition GxShape.cpp:1457

GxShapeSphere::~GxShapeSphere
~GxShapeSphere(void) override
デストラクタ
Definition GxShape.h:259

GxShapeSphere::setPosition
GX_FORCE_INLINE void setPosition(const GxVector3 &position)
位置設定
Definition GxShape.h:307

GxShapeSphere::isInclude
b32 isInclude(const GxVector3 &point) const override
指定点が含まれているか判定
Definition GxShape.cpp:1469

GxShapeSphere::createMinSphereRough
b32 createMinSphereRough(const u32 vertexCount, const GxVector3 *pVertex)
Definition GxShape.cpp:1599

GxShapeSphere::GxShapeSphere
GxShapeSphere(f32 radius, const GxVector3 &position)
コンストラクタ
Definition GxShape.h:257

GxShapeSphere::isHitRay
b32 isHitRay(const GxVector3 &rayStart, const GxVector3 &rayEnd, GxVector3 *pHitPosition=nullptr, GxVector3 *pNormal=nullptr) const
線分の衝突判定
Definition GxShape.cpp:1484

GxShapeSphere::getRadius
constexpr f32 getRadius(void) const
半径取得
Definition GxShape.h:301

GxShapeTetrahedron
四面体形状クラス
Definition GxShape.h:1035

GxShapeTetrahedron::hasCommonPoints
b32 hasCommonPoints(const GxShapeTetrahedron &tetrahedron) const
同じ頂点を持つか判定
Definition GxShape.cpp:3342

GxShapeTetrahedron::gauss
static f32 gauss(f32 a[3][3], f32 b[3], f32 x[3])
ガウスの消去法
Definition GxShape.cpp:3430

GxShapeTetrahedron::getNormal
GX_FORCE_INLINE const GxVector3 getNormal(const GxVector3 &) const override
指定位置への法線を取得
Definition GxShape.h:1077

GxShapeTetrahedron::_pVertex
const GxVector3 * _pVertex[VERTEX_COUNT]
頂点
Definition GxShape.h:1093

GxShapeTetrahedron::getCircumsphere
void getCircumsphere(GxVector3 &center, f32 &radius) const
外接球を取得
Definition GxShape.cpp:3468

GxShapeTetrahedron::operator==
b32 operator==(const GxShapeTetrahedron &tetrahedron) const
一致
Definition GxShape.cpp:3289

GxShapeTetrahedron::compareVertex
static GX_FORCE_INLINE b32 compareVertex(const GxVector3 *pVertex0, const GxVector3 *pVertex1)
頂点ソート用比較関数
Definition GxShape.h:1075

GxShapeTetrahedron::luDecomposition
static f32 luDecomposition(f32 a[3][3], s32 ip[3])
LU分解
Definition GxShape.cpp:3363

GxShapeTetrahedron::GxShapeTetrahedron
GxShapeTetrahedron(void)
デフォルトコンストラクタ
Definition GxShape.cpp:3264

GxShapeTetrahedron::VERTEX_COUNT
static const size_t VERTEX_COUNT
頂点数
Definition GxShape.h:1041

GxShapeTetrahedron::operator<
b32 operator<(const GxShapeTetrahedron &tetrahedron) const
小なり
Definition GxShape.cpp:3315

GxShapeTriangle
三角形形状クラス
Definition GxShape.h:852

GxShapeTriangle::operator<
b32 operator<(const GxShapeTriangle &triangle) const
小なり
Definition GxShape.cpp:2957

GxShapeTriangle::compareVertex
static GX_FORCE_INLINE b32 compareVertex(const GxVector3 *pVertex0, const GxVector3 *pVertex1)
頂点ソート用比較関数
Definition GxShape.h:892

GxShapeTriangle::VERTEX_COUNT
static const u32 VERTEX_COUNT
頂点数
Definition GxShape.h:858

GxShapeTriangle::GxShapeTriangle
GxShapeTriangle(void)
デフォルトコンストラクタ
Definition GxShape.cpp:2907

GxShapeTriangle::operator==
b32 operator==(const GxShapeTriangle &triangle) const
一致
Definition GxShape.cpp:2930

GxShapeTriangle::getNormal
GX_FORCE_INLINE const GxVector3 getNormal(const GxVector3 &) const override
指定位置への法線を取得
Definition GxShape.h:894

GxShapeTrimesh
三角メッシュ形状クラス
Definition GxShape.h:912

GxShapeTrimesh::GxShapeTrimesh
GxShapeTrimesh(const GxMatrixAffine &matrix, const GxVector3 *pVertex, u32 numVertex, const u32 *pIndex, u32 numIndex, const u32 *pCheckFlag, const s32 *pMaterial)
Definition GxShape.h:937

GxShapeTrimesh::isMaterialExist
GX_FORCE_INLINE b32 isMaterialExist(void) const
マテリアルが存在するかチェック
Definition GxShape.h:1012

GxShapeTrimesh::getTriangleVertex
b32 getTriangleVertex(u32 triangleIndex, GxVector3 &vertex0, GxVector3 &vertex1, GxVector3 &vertex2) const
Indexから3頂点を取得
Definition GxShape.cpp:3229

GxShapeTrimesh::getNumTriangle
constexpr u32 getNumTriangle(void) const
三角メッシュの数を取得する
Definition GxShape.h:992

GxShapeTrimesh::getNumVertex
constexpr u32 getNumVertex(void) const
頂点数を取得
Definition GxShape.h:990

GxShapeTrimesh::getIndexAddress
GX_FORCE_INLINE const u32 * getIndexAddress(void) const
インデックスアドレスを取得
Definition GxShape.h:971

GxShapeTrimesh::isCheckFlagExist
GX_FORCE_INLINE b32 isCheckFlagExist(void) const
判定用フラグが存在するかチェック
Definition GxShape.h:1002

GxShapeTrimesh::getCheckFlag
constexpr u32 getCheckFlag(u32 triangleIndex) const
判定用フラグを取得
Definition GxShape.h:995

GxShapeTrimesh::getVertexAddress
GX_FORCE_INLINE const GxVector3 * getVertexAddress(void) const
頂点アドレスを取得
Definition GxShape.h:969

GxShapeTrimesh::getMaterial
constexpr s32 getMaterial(u32 triangleIndex) const
マテリアルを取得
Definition GxShape.h:1005

GxShapeTrimesh::setMatrix
GX_FORCE_INLINE void setMatrix(const GxMatrixAffine &matrix)
マトリクス設定(スケールは許可しない)
Definition GxShape.h:982

GxShapeTrimesh::getDelaunayTriangles
static void getDelaunayTriangles(const GxVector3 *pVertexList, u32 vertexCount, GxArray &triangleVertices)
ドロネー分割三角形を取得
Definition GxShape.cpp:3023

GxShapeTrimesh::getVertex
GX_FORCE_INLINE const GxVector3 & getVertex(u32 number) const
頂点を取得
Definition GxShape.h:963

GxShapeTrimesh::getNormal
const GxVector3 getNormal(const GxVector3 &position) const override
指定位置への法線を取得
Definition GxShape.cpp:3245

GxShapeTrimesh::getRingTriangleIndices
static void getRingTriangleIndices(const GxVector3 *pVertexList, u32 vertexCount, GxArray &triangleIndices, u32 vertexStartIndex=0)
リング状の頂点配列をそのままポリゴン化したインデックスを取得
Definition GxShape.cpp:2994

GxShapeTrimesh::getMatrix
GX_FORCE_INLINE const GxMatrixAffine & getMatrix(void) const
マトリクス取得
Definition GxShape.h:980

GxShapeTrimesh::getDelaunayTriangleIndices
static void getDelaunayTriangleIndices(const GxVector3 *pVertexList, u32 vertexCount, GxArray &triangleIndices, u32 vertexStartIndex=0)
ドロネー分割三角形をインデックスで取得
Definition GxShape.cpp:3185

GxStreamWriter
ストリーム書き込みクラス
Definition GxStreamWriter.h:19

GxMatrixAffine
アフィン変換行列(行優先)
Definition GxMatrix.h:330

GxMatrixAffine::IDENTITY
static const GxMatrixAffine IDENTITY
単位行列
Definition GxMatrix.h:341

GxMatrixAffine::setPosition
GX_FORCE_INLINE void setPosition(const GxVector3 &position)
平行移動量のみを設定
Definition GxMatrix.inl:2141

GxVector3
3次元ベクトル
Definition GxVector.h:245

GxVector3::_z
f32 _z
Z値
Definition GxVector.h:572

GxVector3::_y
f32 _y
Y値
Definition GxVector.h:571

GxVector3::ZERO
static const GxVector3 ZERO
(0, 0, 0)
Definition GxVector.h:256

GxVector3::getDot
static GX_FORCE_INLINE f32 getDot(const GxVector3 &vector0, const GxVector3 &vector1)
内積を取得
Definition GxVector.inl:2083

GxVector3::_x
f32 _x
X値
Definition GxVector.h:570

GxVector4
4次元ベクトル
Definition GxVector.h:582

GxVector4::_w
f32 _w
W値
Definition GxVector.h:796

b32
32bitブーリアン
Definition GxDefine.h:173