GxAttackHit.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_PHYSICS_NAMESPACE_BEGIN()
//===========================================================================
//===========================================================================
class GxAttackHit : public GxCollision
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS( GxAttackHit, GxCollision )
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE( GxAttackHit )
 
    
    static const GxColor COLOR_OBJECT_ATTACK;   
    static const GxColor COLOR_OBJECT_DAMAGE;
 
    class GxWorld;
    class GxObject;
 
    class   GxConditionInformationAttackHit;
    struct  GxRayCallback;
    struct  GxConvexCallback;
                
protected:
    //-----------------------------------------------------------
    //
    //-----------------------------------------------------------
    class GxPairRecord : public GxClassBase
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // RTTI定義
        GX_RTTI_CLASS(GxAttackHit::GxPairRecord, GxClassBase)
        // GxClassBase継承クラス用禁止宣言
        GX_PROHIBIT_CLASS_BASE(GxPairRecord)
 
    protected:
        static constexpr u32 ID_COUNT = 16;     
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxPairRecord(void);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        void reset(void);
 
        b32 check(u32 attackId, u32 damageGroup) const;
 
        void addData(u32 attackId, u32 damageGroup);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    protected:
        u32 _idIndex;                       
        u32 _attackObjId[ID_COUNT];         
        u32 _damageObjGroup[ID_COUNT];      
 
    };
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GxAttackHit(void);
    ~GxAttackHit(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxCollision::GxObject* allocObject(void) override;
 
    GxObject* getObject(u32 index);
 
    void update(void) override;
 
    static void initializeUniqueId(void);
 
    static void clearUniqueId(void);
 
    static u32 getUniqueId(u32 threadNumber);
 
    void initializeTargetId(void);
 
    b32 isSamePair(u32 attackId, u32 damageGroup) const;
 
    void setPairData(u32 attackId, u32 damageGroup);
 
    b32 isInvincible(void) const { return _isInvincible; }
 
    constexpr void setInvincibleTime(f32 time) { _invincibleTime = time; }
 
    constexpr void setDeltaTimeRatio(f32 deltaTimeRatio) { _deltaTimeRatio = deltaTimeRatio; }
 
#if GX_DEVELOP
    void developDrawObjectAttackHit( PRIMITIVE_FILL_MODE fillMode = PRIMITIVE_FILL_MODE::WIRE);
 
    GX_FORCE_INLINE static void setDevelopDrawAttackHit( b32 display ) { getGxSysMain()->setDevelopFlag(DEVELOP_FLAG_COLLISION_DRAW_ATTACK_HIT, display); }
 
    GX_FORCE_INLINE static b32 getDevelopDrawAttackHit( void ) { return getGxSysMain()->isOnDevelopFlag(DEVELOP_FLAG_COLLISION_DRAW_ATTACK_HIT); }
#endif // GX_DEVELOP
 
protected:
    GxCollision::GxObject* addObject(void) override;
 
    GX_FORCE_INLINE GxPairRecord* getPairRecord( void ) { return &_pairRecord; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    static u32*                 _pUniqueIdTable;        
    static u32                  _uniqueIdTableCount;    
 
    GxPairRecord                _pairRecord;            
    f32                         _invincibleTime;        
    b32                         _isInvincible;          
    f32                         _deltaTimeRatio;        
 
};
 
//===========================================================================
//===========================================================================
class GxAttackHit::GxWorld : public GxCollision::GxWorld
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS( GxAttackHit::GxWorld, GxCollision::GxWorld )
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxWorld)
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxWorld(void);
    ~GxWorld(void) override {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
#if GX_DEVELOP
    void check(void) override;
#endif // GX_DEVELOP
 
    //  note:旧hit()
    void postBulletUpdate(void) override;
 
    GxCollision::GxRayCallback* createRayCallback( const btVector3& rayFrom, const btVector3& rayEnd, GxConditionInformation* pConditionInfo ) override;
 
    GxCollision::GxConvexCallback* createConvexCallback( const btVector3& checkFrom, const btVector3& checkEnd, GxConditionInformation* pConditionInfo ) override;
 
protected:
    void calculateHitObject(btPersistentManifold* pPersistentManifold);
 
    virtual void calculateAttackDirection( GxVector3& direction, GxObject* pAttack, GxObject* pDamage, const GxVector3& hitPositionOnDamage );
 
};
 
//===========================================================================
//===========================================================================
class GxAttackHit::GxObject : public GxCollision::GxObject
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS( GxAttackHit::GxObject, GxCollision::GxObject )
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE( GxObject )
 
    
    typedef void (GxClassBaseRoot::* HIT_CALLBACK)(GxAttackHit::GxObject* pHit);
 
protected:
    enum class SHIFT
    {
        ATTACK_HIT_ONE_HIT = 0,         
        ATTACK_HIT_CAPSULE_OLD_NEW,     
        ATTACK_HIT_DUMMY_0,             
        ATTACK_HIT_DUMMY_1,             
        ATTACK_HIT_MAX,                 
    };
public:
    enum ATTRIBUTE
    {
        ATTRIBUTE_ONE_HIT               = (1L << static_cast<s32>(SHIFT::ATTACK_HIT_ONE_HIT)),          
        ATTRIBUTE_MULTISPHERE_OLD_NEW   = (1L << static_cast<s32>(SHIFT::ATTACK_HIT_CAPSULE_OLD_NEW)),
    };
 
    enum class ATTACK_DIRECT
    {
        MANUAL = 0,             
        OLD_NEW,                
        CENTER_HIT_POSITION,    
        UNIT_DIFF,              
        UNIT_AXIS_Z,            
        MAX,                    
    };
#if GX_DEVELOP
    GX_ENUM_TABLE_MAX(ATTACK_DIRECT)
#endif //GX_DEVELOP
 
    enum class TYPE
    {
        ERROR_,     
        ATTACK,     
        DAMAGE,     
        MAX,        
    };
#if GX_DEVELOP
    GX_ENUM_TABLE_MAX(TYPE)
#endif //GX_DEVELOP
 
    enum GROUP
    {
        GROUP_ATTACK    = (0x01 << 0),  
        GROUP_DAMAGE    = (0x01 << 1),  
    };
 
    class GxAttackRecord;
    class GxDamageRecord;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxObject(void);
 
    ~GxObject(void) override;
 
    void initialize(b32 active, u32 id, const GxMatrixAffine* pMatrix0, const GxVector3& offset0, const GxMatrixAffine* pMatrix1, const GxVector3& offset1) override;
 
    GX_FORCE_INLINE void initializeActiveOff(void) override { initializeUpdate(); }
 
    void initializeUpdate(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    b32 isNeedCheck(GxCollision::GxObject* pCollisionObject) override;
 
    void update(void) override;
 
    void setHitParam(void);
 
    b32 allocAttackRecord(void);
 
    void initializeAttackRecord(void);
 
    u32 getAttackRecordIndex(u32 idDamage);
 
    void registerAttackRecord(u32 index, GxAttackHit::GxObject* pTarget, const GxVector3& position, const GxVector3& vector, const GxVector3& normal, u32 idDamage);
 
    b32 allocDamageRecord(void);
 
    void initializeDamageRecord(void);
 
#if GX_DEVELOP
    static  GxGuiBase* createGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index = 0);
#endif // GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    constexpr u32 getAttribute(void) const { return _attribute; }
    constexpr void setAttribute(u32 attribute) { _attribute = attribute; }
    constexpr void onAttribute(u32 attribute) { _attribute |= attribute; }
    constexpr void offAttribute(u32 attribute) { _attribute &= ~attribute; }
 
    constexpr ATTACK_DIRECT getAttackDirecType( void ) const { return _attackDirectType; }
    constexpr void setAttackDirecType( ATTACK_DIRECT type ) { _attackDirectType = type; }
 
    constexpr TYPE getType(void) const { return _type; }
    void setType(TYPE type);
 
    constexpr s32 getPriority(void) const { return _priority; }
    constexpr void setPriority(s32 priority) { _priority = priority; }
 
    constexpr u32 getDamageGroup(void) const { return _damageGroup; }
    constexpr void setDamageGroup(u32 damageGroup) { _damageGroup = damageGroup; }
 
    GX_FORCE_INLINE b32 getResult(void) const { return _result; }
    GX_FORCE_INLINE void setResult(b32 result) { _result = result; }
 
    constexpr GxObject* getTarget(void) { return _pTarget; }
    constexpr void setTarget(GxObject* pTarget) { _pTarget = pTarget; }
 
    GX_FORCE_INLINE const GxVector3& getOldCenter( void ) const { return _oldCenter; }
 
    void executeHitCallback( void );
    constexpr void setHitCallback(HIT_CALLBACK pCallBack) { _pHitCallback = pCallBack; }
 
    GX_FORCE_INLINE const GxVector3& getHitPosOnDamage(void) { return _hitPositionOnDamage; }
    GX_FORCE_INLINE void setHitPosOnDamage(const GxVector3& position) { _hitPositionOnDamage = position; }
 
    GX_FORCE_INLINE const GxVector3& getHitDirection(void) const { return _hitDirection; }
    GX_FORCE_INLINE void setHitDirection(const GxVector3& vector) { _hitDirection = vector; }
 
    GX_FORCE_INLINE const GxVector3& getHitNormal(void) const { return _hitNormal; }
    GX_FORCE_INLINE void setHitNormal(const GxVector3& normal) { _hitNormal = normal; }
 
    constexpr GxAttackRecord* getAttackRecord(void) const { return _pAttackRecord; }
 
    constexpr GxDamageRecord* getDamageRecord(void) const { return _pDamageRecord; }
 
    constexpr f32 getPower(void) const { return _power; }
    constexpr void setPower(f32 power) { _power = power; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    HIT_CALLBACK        _pHitCallback;      
    ATTACK_DIRECT       _attackDirectType;  
    TYPE                _type;              
    u32                 _attribute;         
    s32                 _priority;          
    u32                 _damageGroup;       
    b32                 _result;            
    GxObject*           _pTarget;           
    GxVector3           _oldCenter;         
 
    GxVector3           _hitPositionOnDamage;   
    GxVector3           _hitDirection;      
    GxVector3           _hitNormal;         
    f32                 _power;             
 
    GxAttackRecord*     _pAttackRecord;     
    GxDamageRecord*     _pDamageRecord;     
 
};
 
//===========================================================================
//===========================================================================
class GxAttackHit::GxObject::GxAttackRecord : public GxClassBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxAttackHit::GxObject::GxAttackRecord, GxClassBase)
    // new, delete定義
    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::PHYSICS)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE( GxAttackRecord )
 
    
    static constexpr u32 DETAIL_NUM = 16;   
 
    struct GxDetail
    {
        GxVector3               _positionOnDamage;  
        GxVector3               _direction;         
        GxVector3               _normal;            
        f32                     _distanceSquare;    
        b32                     _isActive;          
        GxAttackHit::GxObject*  _pTarget;           
        u32                     _id;                
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxAttackRecord(void);
 
    ~GxAttackRecord(void) override {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    void initialize(void);
 
    u32 getIndex(u32 idDamage);
 
    void registerInfo(u32 index, GxAttackHit::GxObject* pTarget, const GxVector3& position, const GxVector3& vector, const GxVector3& normal, f32 distance, u32 damageID);
 
    GX_FORCE_INLINE GxDetail& getDetail(u32 index) { return _infoSub[index]; }
 
    void sortDetail(void);
 
    constexpr u32 getRegisterCount(void) { return _index; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    u32         _index;                 
    GxDetail    _infoSub[DETAIL_NUM];   
 
};
 
//===========================================================================
//===========================================================================
class GxAttackHit::GxObject::GxDamageRecord : public GxClassBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxAttackHit::GxObject::GxDamageRecord, GxClassBase )
    // new, delete定義
    GX_OPERATOR_NEW_DELETE( GxAllocatorList::ALLOCATOR_TYPE::PHYSICS )
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE( GxDamageRecord )
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxDamageRecord(void);
 
    ~GxDamageRecord(void) override {}
 
    void initialize(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    constexpr void addDamageSum(f32 power) { _damageSum += power; }
    constexpr f32 getDamageSum(void) const { return _damageSum; }
 
    constexpr f32 getDamageMax(void) const { return _damageMax; }
    constexpr void setDamageMax(f32 power) { _damageMax = power; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    f32     _damageSum;             
    f32     _damageMax;             
 
};
 
//===========================================================================
//===========================================================================
class GxAttackHit::GxConditionInformationAttackHit : public GxCollision::GxConditionInformation
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxAttackHit::GxConditionInformationAttackHit, GxCollision::GxConditionInformation )
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxConditionInformationAttackHit(void) : _type(GxObject::TYPE::ERROR_) {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxObject::TYPE _type;       
 
};
 
//===========================================================================
//===========================================================================
struct GxAttackHit::GxRayCallback : public GxCollision::GxRayCallback
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxRayCallback( const btVector3& rayFromWorld, const btVector3& rayToWorld, GxConditionInformation* pConditionInfo )
        : GxCollision::GxRayCallback( rayFromWorld, rayToWorld, pConditionInfo )
    {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    bool needsCollision(btBroadphaseProxy* pProxy) const override;
 
};
 
//===========================================================================
//===========================================================================
struct GxAttackHit::GxConvexCallback : public GxCollision::GxConvexCallback
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxConvexCallback( const btVector3& rayFromWorld, const btVector3& rayToWorld, GxConditionInformation* pConditionInfo )
        : GxCollision::GxConvexCallback( rayFromWorld, rayToWorld, pConditionInfo )
    {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    bool needsCollision(btBroadphaseProxy* pProxy) const override;
 
};
 
GX_PHYSICS_NAMESPACE_END()