GxPathSet.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_CHARACTER_NAMESPACE_BEGIN()
 
//===========================================================================
//===========================================================================
class GxPathNode : public GxClassBaseReference
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxPathNode, GxClassBaseReference)
    // GxClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxPathNode)
 
    class GxConnect;
 
    static constexpr u32 NUM_DATA = 4;
#if GX_DEVELOP
    static constexpr u32 RENDER_SPHERE_DIV = 4;
    static const f32 RENDER_SPHERE_RADIUS;
#endif //GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxPathNode(void) : _id(0), _connectList(GxAllocatorList::ALLOCATOR_TYPE::GLOBAL), _flag(0){ GX_MEMSET(_data, 0, sizeof(s32) * NUM_DATA); }
    GxPathNode(const GxVector3& position);
    void cleanup(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    void addConnect(GxPathNode* pNode, f32 staticWeight);
    void addConnect(GxConnect* pConnect);
    void eraseAllConnect(void);
    constexpr u32 getNumConnect(void) const { return _connectList.getCount(); }
    GxConnect* getConnect(u32 id);
    GX_FORCE_INLINE GxListClassBaseReference* getConnectList(void){ return &_connectList; }
    GX_FORCE_INLINE GxListClassBaseReference::GxNodeClassBaseReference* getConnectTopNode(void) const { return _connectList.getTop(); }
    constexpr u32 getId(void) const { return _id; }
    constexpr void setId(u32 id){ _id = id; }
    GX_FORCE_INLINE const GxVector3& getPosition(void) const { return _position; }
    GX_FORCE_INLINE void setPosition(const GxVector3& position){ _position = position; }
    constexpr s32 getData(u32 index) const { return _data[index]; }
    constexpr void setData(u32 index, s32 data){ _data[index] = data; }
    constexpr s32 getFlag(void) const { return _flag; }
    constexpr void setFlag(s32 flag){ _flag = flag; }
 
#if GX_DEVELOP
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    virtual void developRender(GxColor color = GxColor::BLUE, GxPathNode* pConnectNode = nullptr, b32 arrowFlag = false);
        
#endif //GX_DEVELOP
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    u32                         _id;                
    GxVector3                   _position;          
    GxListClassBaseReference    _connectList;       
    s32                         _data[NUM_DATA];    
    s32                         _flag;              
 
};
 
//===========================================================================
//===========================================================================
class GxPathNode::GxConnect : public GxClassBaseReference
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxPathNode::GxConnect, GxClassBaseReference)
    // GxClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxConnect)
 
    
    static constexpr u32 NUM_ADD_WEIGHT = 4;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxConnect(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    constexpr GxPathNode* getNode(void) const { return _pNode; }
    constexpr void setNode(GxPathNode* pNode){ _pNode = pNode; }
    constexpr f32 getStaticWeight(void) const { return _staticWeight; }
    constexpr void setStaticWeight(f32 staticWeight){ _staticWeight = staticWeight; }
    constexpr f32 getAddWeight(u32 index) const { return _addWeight[index]; }
    constexpr void setAddWeight(u32 index, f32 weight){ _addWeight[index] = weight; }
    constexpr f32 calculateDynamicWeight(GxClassBaseRoot* /*pObject*/) const { return 0.0f; }
    GX_FORCE_INLINE b32 isValid(void) const { return _valid; }
    GX_FORCE_INLINE void setValid(b32 flag){ _valid = flag; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    GxPathNode* _pNode;                     
    f32         _staticWeight;              
    f32         _addWeight[NUM_ADD_WEIGHT]; 
    b32         _valid;                     
 
};
 
//===========================================================================
//===========================================================================
class GxPath : public GxClassBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxPath, GxClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxPath)
 
    
    static const f32 GOAL_RANGE_DEFAULT;
    static const f32 TURN_RADIUS_DEFAULT;
    typedef void (GxClassBaseRoot::* ARRIVE_NODE_CALLBACK)(GxPathNode* pNode);
    enum class MOVE_TYPE
    {
        LINEAR, 
        SPLINE, 
        BEZIER, 
        TURN,   
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxPath(void);
    ~GxPath(void) override;
    void initialize(void);
#if GX_DEVELOP
    void developRender(void);
#endif //GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GX_FORCE_INLINE void addTopNode(GxPathNode* pNode){ _nodeList.addTop(pNode); }
    GX_FORCE_INLINE void addBottomNode(GxPathNode* pNode){ _nodeList.addBottom(pNode); }
    void addPath(GxPath* pPath);
    GX_FORCE_INLINE GxListClassBase* getNodeList(void){ return &_nodeList; }
    void eraseBottomNode(void);
    void eraseAllNode(void);
    constexpr void setOwner(GxUnitLocate* pOwner){ _pOwner = pOwner; }
    GX_FORCE_INLINE void setArriveNodeCallback(ARRIVE_NODE_CALLBACK pCallback){ _pArriveNodeCallback = pCallback; }
    GX_FORCE_INLINE GxPathNode* getTargetNode(void) const { return _pTargetNode ? static_cast<GxPathNode*>(_pTargetNode->getObject()) : nullptr; }
    void setTargetNode(GxPathNode* pNode);
    GX_FORCE_INLINE GxPathNode* getBeforeNode(void) const { return _pBeforeNode ? static_cast<GxPathNode*>(_pBeforeNode->getObject()) : nullptr; }
    GX_FORCE_INLINE GxPathNode* getNextNode(void) const { return (_pTargetNode && _pTargetNode->getNext()) ? static_cast<GxPathNode*>(_pTargetNode->getNext()->getObject()) : nullptr; }
    constexpr f32 getGoalRange(void) const { return _goalRange; }
    constexpr void setGoalRange(f32 range){ _goalRange = range; }
    GX_FORCE_INLINE b32 isGoal(void) const { return _goalFlag; }
    GX_FORCE_INLINE void setGoalFlag(b32 flag){ _goalFlag = flag; }
    GX_FORCE_INLINE b32 isLoop(void) const { return _loopFlag; }
    GX_FORCE_INLINE void setLoopFlag(b32 flag){ _loopFlag = flag; }
    constexpr MOVE_TYPE getMoveType(void) const { return _moveType; }
    constexpr void setMoveType(MOVE_TYPE type){ _moveType = type; }
    constexpr void setRadius(f32 radius){ _radius = radius; }
    virtual f32 calculateCost(GxClassBaseRoot* pObject);
    void getDirect(GxVector3& direct);
 
protected:
    virtual b32 isArrivedAtTargetNode( void );
 
private:
    void getDirectLinear(GxVector3& direct);
    void getDirectSpline(GxVector3& direct);
    void getDirectBezier(GxVector3& direct);
    void getDirectTurn(const GxVector3& directNow, GxVector3& directResult);
    void executeArriveNodeCallback(GxPathNode* pNode);
    GxListClassBaseReference::GxNodeClassBaseReference* getNextNode(GxListClassBaseReference::GxNodeClassBaseReference* pCurrentNode) const { return pCurrentNode->getNext() ? pCurrentNode->getNext() : pCurrentNode; }
    void calculateSplineControl(const GxVector3& position0, const GxVector3& position1, const GxVector3& position2, const GxVector3& position3);
    void calculateBezierControl(const GxVector3& position0, const GxVector3& position1, const GxVector3& position2, const GxVector3& position3);
    void setTurnPoint(const GxVector3& position0, const GxVector3& position1, const GxVector3& direct);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    GxListClassBaseReference    _nodeList;          
    GxUnitLocate*               _pOwner;            
    ARRIVE_NODE_CALLBACK        _pArriveNodeCallback;                   
    GxListClassBaseReference::GxNodeClassBaseReference* _pTargetNode;   
    GxListClassBaseReference::GxNodeClassBaseReference* _pBeforeNode;   
    f32                         _goalRange;         
    b32                         _goalFlag;          
    b32                         _loopFlag;          
    MOVE_TYPE                   _moveType;          
    f32                         _timer;             
    GxVector3                   _controlPoint[2];   
    GxVector3                   _turnPointCenter;   
    GxVector3                   _turnPointMiddle;   
    f32                         _radius;            
 
};
 
GX_CHARACTER_NAMESPACE_END()
#include "GxResPathSet.h"
GX_CHARACTER_NAMESPACE_BEGIN()
 
//===========================================================================
//===========================================================================
class GxPathSet : public GxClassBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxPathSet, GxClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxPathSet)
 
    class GxPathSetArea;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxPathSet(void);
    ~GxPathSet(void) override;
    void initialize(GxResPathSet* pResource);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    void update(void);
protected:
    virtual GxPathSetArea* allocateArea(void);
    GX_FORCE_INLINE virtual GxPathNode* allocateNode(void){ return GX_NEW GxPathNode; }
    GX_FORCE_INLINE virtual GxPathNode::GxConnect* allocateConnect(void){ return GX_NEW GxPathNode::GxConnect; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxPathSetArea* getArea(s32 id);
    GxPathSetArea* getArea(const GxVector3& position, const GxVector3* pTargetPosition = nullptr);
    void eraseAllArea(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    GxResPathSet*   _pResource;     
    GxListClassBase _areaList;      
 
};
 
//===========================================================================
//===========================================================================
class GxPathSet::GxPathSetArea : public GxClassBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxPathSet::GxPathSetArea, GxClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxPathSetArea)
    enum class SEARCH_LENGTH
    {
        SHORT = 0,  
        LONG,       
        MAX,        
    };
#if GX_DEVELOP
    GX_ENUM_TABLE_MAX(SEARCH_LENGTH)
#endif //GX_DEVELOP
    enum class SEARCH_TYPE
    {
        NEAR_ = 0,  
        FAR_,       
        MAX,        
    };
#if GX_DEVELOP
    GX_ENUM_TABLE_MAX(SEARCH_TYPE)
#endif //GX_DEVELOP
    enum ATTRIBUTE
    {
        ATTRIBUTE_COLLISION_INVALID = (1 << 0), 
        ATTRIBUTE_TARGET_NEAR       = (1 << 1), 
        ATTRIBUTE_TARGET_FAR        = (1 << 2), 
    };
 
    class GxAStarNode
    {
        //-------------------------------------------------------------
        //-------------------------------------------------------------
    public:
        GxAStarNode(void) : _costSum(0.0f), _costHeuristics(0.0f), _pNode(nullptr), _pParent(nullptr){}
        virtual ~GxAStarNode(void){}
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        f32 _costSum;               
        f32 _costHeuristics;        
        GxPathNode* _pNode;         
        GxAStarNode* _pParent;      
 
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxPathSetArea(void);
    ~GxPathSetArea(void) override;
    void createShape(GxResPathSet::GxAreaParam* pAreaParam);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
#if GX_DEVELOP
    void developRender(void);
#endif //GX_DEVELOP
    b32 isInclude(const GxVector3& position) const;
 
    b32 searchNoCost(GxPathNode* pStartNode, GxPathNode* pGoalNode, GxPath* pPath);
    b32 searchFast(GxPathNode* pStartNode, GxPathNode* pGoalNode, GxPath* pPath, GxClassBaseRoot* pObject, SEARCH_LENGTH length = SEARCH_LENGTH::SHORT);
    b32 searchAStar(GxPathNode* pStartNode, GxPathNode* pGoalNode, GxPath* pPath, GxClassBaseRoot* pObject, SEARCH_LENGTH length = SEARCH_LENGTH::SHORT);
    b32 getRoute(s32 id, GxPath* pPath) const;
protected:
    b32 checkCollision(const GxVector3& startPosition, const GxVector3& endPosition);
private:
    b32 searchNoCostLoop(GxPathNode* pCurrentNode, GxPathNode* pGoalNode, GxPath* pPath, GxListClassBaseReference* pCloseNodeList);
    b32 searchFastLoop(GxPathNode* pCurrentNode, GxPathNode* pGoalNode, GxPath* pPath, GxListClassBaseReference* pCloseNodeList, GxClassBaseRoot* pObject, SEARCH_LENGTH length);
    b32 searchAStarLoop(GxAStarNode* pAStarCurrentNode, GxPathNode* pGoalNode, GxPath* pPath, GxList* pOpenNodeList, GxList* pCloseNodeList, GxClassBaseRoot* pObject, SEARCH_LENGTH length);
    void rewindPath(GxPath* pPath, GxPathNode* pNode);
    f32 calculateCostFast(GxPathNode* pCurrentNode, GxPathNode* pGoalNode, GxPathNode::GxConnect* pConnect, GxClassBaseRoot* pObject, SEARCH_LENGTH length);
    f32 calculateCost(GxPathNode* pCurrentNode, GxPathNode* pNextNode, GxClassBaseRoot* pObject, SEARCH_LENGTH length);
    f32 calculateCostHeuristics(GxPathNode* pCurrentNode, GxPathNode* pNextNode, GxPathNode* pGoalNode, GxClassBaseRoot* pObject, SEARCH_LENGTH length);
    b32 isIncludeAStarNode(GxList* pAStarList, GxPathNode* pNode) const;
    b32 isCloseNode(GxListClassBaseReference* pCloseNodeList, GxPathNode* pNode) const;
    u32 getConnectMax(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    constexpr s32 getId(void) const { return _id; }
    constexpr void setId(s32 id){ _id = id; }
    constexpr void setShape(GxShape* pShape){ _pShape = pShape; }
    GX_FORCE_INLINE void addNode(GxPathNode* pNode){ _nodeList.addBottom(pNode); }
    void addRoute(GxPath* pRoute, s32 id);
    void eraseAllNode(void);
    void eraseAllRoute(void);
    GxPathNode* getNode(u32 id);
    GxPathNode* getNode(u32 dataIndex, s32 dataValue);
    GxPathNode* getNearNode(const GxVector3& position, u32 attribute = 0, const GxVector3* pTargetPosition = nullptr);
    GxPathNode* getFarNode(const GxVector3& position);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    s32 _id;                                            
    GxShape* _pShape;                                   
    GxListClassBaseReference _nodeList;                 
    GxListClassBase _routeList;                         
    s32 _routeId[GxResPathSet::ROUTE_NODE_DATA_MAX];    
 
};
 
//===========================================================================
//===========================================================================
class GxPathSetAreaRRT : public GxPathSet::GxPathSetArea
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxPathSetAreaRRT, GxPathSet::GxPathSetArea)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxPathSetAreaRRT)
 
    
    enum class TREE_TYPE
    {
        GROUND,     
        AIR,        
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxPathSetAreaRRT(void){};
    ~GxPathSetAreaRRT(void) override{};
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    void createRRT(const GxVector3& startPosition, const GxVector3& goalPosition, TREE_TYPE treeType = TREE_TYPE::GROUND, f32 searchAreaSize = 30.0f, f32 maxConnectLength = 2.0f, u32 maxNode = 32, f32 goalCheckDistance = 2.0f);
 
};
 
GX_CHARACTER_NAMESPACE_END()