NvBlastTkActorImpl.h

Go to the documentation of this file.

// This code contains NVIDIA Confidential Information and is disclosed to you
// under a form of NVIDIA software license agreement provided separately to you.
//
// Notice
// NVIDIA Corporation and its licensors retain all intellectual property and
// proprietary rights in and to this software and related documentation and
// any modifications thereto. Any use, reproduction, disclosure, or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA Corporation is strictly prohibited.
//
// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
//
// Information and code furnished is believed to be accurate and reliable.
// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
// information or for any infringement of patents or other rights of third parties that may
// result from its use. No license is granted by implication or otherwise under any patent
// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
// This code supersedes and replaces all information previously supplied.
// NVIDIA Corporation products are not authorized for use as critical
// components in life support devices or systems without express written approval of
// NVIDIA Corporation.
//
// Copyright (c) 2016-2020 NVIDIA Corporation. All rights reserved.


#ifndef NVBLASTTKACTORIMPL_H
#define NVBLASTTKACTORIMPL_H


#include "NvBlastTkCommon.h"

#include "NvBlastAssert.h"
#include "NvBlastDLink.h"
#include "NvBlastIteratorBase.h"

#include "NvBlastTkJointImpl.h"

#include "NvBlast.h"

#include "NvBlastTkActor.h"

#include "PxFlags.h"

namespace Nv
{
namespace Blast
{

// Forward declarations:
class TkGroupImpl;
class TkFamilyImpl;
class TkAssetImpl;
class TkJointImpl;


struct TkActorFlag
{
    enum Enum
    {
        DAMAGED = (1 << 0), 
        PENDING = (1 << 1), 
    };
};


class TkActorImpl : public TkActor
{
public:
    TkActorImpl();
    ~TkActorImpl();

    // Begin TkActor
    virtual const NvBlastActor* getActorLL() const override;

    virtual TkFamily&           getFamily() const override;

    virtual uint32_t            getIndex() const override;

    virtual TkGroup*            getGroup() const override;

    virtual TkGroup*            removeFromGroup() override;

    virtual const TkAsset*      getAsset() const override;

    virtual uint32_t            getVisibleChunkCount() const override;

    virtual uint32_t            getVisibleChunkIndices(uint32_t* visibleChunkIndices, uint32_t visibleChunkIndicesSize) const override;

    virtual uint32_t            getGraphNodeCount() const override;

    virtual uint32_t            getGraphNodeIndices(uint32_t* graphNodeIndices, uint32_t graphNodeIndicesSize) const override;

    virtual const float*        getBondHealths() const override;

    virtual uint32_t            getSplitMaxActorCount() const override;

    virtual void                damage(const NvBlastDamageProgram& program, const void* programParams) override;

    virtual bool                isPending() const override;

    virtual void                generateFracture(NvBlastFractureBuffers* commands, const NvBlastDamageProgram& program, const void* programParams) const override;

    virtual void                applyFracture(NvBlastFractureBuffers* eventBuffers, const NvBlastFractureBuffers* commands) override;

    virtual uint32_t            getJointCount() const override;

    virtual uint32_t            getJoints(TkJoint** joints, uint32_t jointsSize) const override;

    virtual bool                isBoundToWorld() const override;
    // End TkActor

    // Begin TkObject
    virtual void                release() override;
    // End TkObject


    // Public methods
    
    static TkActorImpl*         create(const TkActorDesc& desc);

    bool                        isActive() const;

    NvBlastFamily*              getFamilyLL() const;

    TkFamilyImpl&               getFamilyImpl() const;

    uint32_t                    getIndexInternal() const;

    TkGroupImpl*                getGroupImpl() const;

    NvBlastActor*               getActorLLInternal() const;

    uint32_t                    getJointCountInternal() const;

    class JointIt : public DList::It
    {
    public:
        JointIt(const TkActorImpl& actor, Direction dir = Forward);

        TkJointImpl* operator * () const;
    };

    operator Nv::Blast::TkActorData() const;

private:
    void                        markAsDamaged();
    bool                        isDamaged() const;

    void                        makePending();

    void                        addJoint(TkJointLink& jointLink);
    void                        removeJoint(TkJointLink& jointLink);

    struct DamageData
    {
        NvBlastDamageProgram program;
        const void*          programParams;
    };

    // Data

    NvBlastActor*                           m_actorLL;            
    TkFamilyImpl*                           m_family;             
    TkGroupImpl*                            m_group;              
    uint32_t                                m_groupJobIndex;      
    physx::PxFlags<TkActorFlag::Enum, char> m_flags;              
    Array<DamageData>::type                 m_damageBuffer;       
    uint32_t                                m_jointCount;         
    DList                                   m_jointList;          

//#if NV_PROFILE
    NvBlastTimers                           m_timers;           
//#endif

    friend class TkWorker;                  // m_damageBuffer and m_flags 
    friend class TkGroupImpl;
    friend class TkFamilyImpl;
    friend class TkJointImpl;
    friend class TkFrameworkImpl;
};



NV_INLINE TkFamilyImpl& TkActorImpl::getFamilyImpl() const
{
    NVBLAST_ASSERT(m_family != nullptr);

    return *m_family;
}


NV_INLINE uint32_t TkActorImpl::getIndexInternal() const
{
    NVBLAST_ASSERT(isActive());
    return NvBlastActorGetIndex(m_actorLL, logLL);
}


NV_INLINE NvBlastActor* TkActorImpl::getActorLLInternal() const
{
    return m_actorLL;
}


NV_INLINE uint32_t TkActorImpl::getJointCountInternal() const
{
    return m_jointCount;
}


NV_INLINE TkGroupImpl* TkActorImpl::getGroupImpl() const
{
    return m_group;
}


NV_INLINE bool TkActorImpl::isActive() const
{
    return m_actorLL != nullptr;
}


NV_INLINE bool TkActorImpl::isPending() const
{
    return m_flags.isSet(TkActorFlag::PENDING);
}


NV_INLINE void TkActorImpl::addJoint(TkJointLink& jointLink)
{
    NVBLAST_ASSERT(m_jointList.isSolitary(jointLink));

    m_jointList.insertHead(jointLink);
    ++m_jointCount;
}


NV_INLINE void TkActorImpl::removeJoint(TkJointLink& jointLink)
{
    NVBLAST_ASSERT(!m_jointList.isSolitary(jointLink));
    NVBLAST_ASSERT(m_jointCount > 0);
    if (m_jointCount > 0)
    {
        --m_jointCount;
        m_jointList.remove(jointLink);
    }
}



NV_INLINE TkActorImpl::JointIt::JointIt(const TkActorImpl& actor, Direction dir) : DList::It(actor.m_jointList, dir) {}


NV_INLINE TkJointImpl* TkActorImpl::JointIt::operator * () const
{
    const DLink* link = (const DLink*)(*this);
    return reinterpret_cast<const TkJointLink*>(link)->m_joint;
}

} // namespace Blast
} // namespace Nv


#endif // ifndef NVBLASTTKACTORIMPL_H