NvBlastActor.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 NVBLASTACTOR_H
#define NVBLASTACTOR_H


#include "NvBlastAsset.h"
#include "NvBlastDLink.h"
#include "NvBlastIteratorBase.h"
#include "NvBlastSupportGraph.h"
#include "NvBlastFamilyGraph.h"
#include "NvBlastPreprocessorInternal.h"

#include <cstring>


namespace Nv
{
namespace Blast
{

// Forward declarations
class FamilyGraph;
struct FamilyHeader;

class Actor : public NvBlastActor
{
    friend struct FamilyHeader;

    friend void updateVisibleChunksFromSupportChunk<>(Actor*, IndexDLink<uint32_t>*, uint32_t*, uint32_t, uint32_t, const NvBlastChunk*, uint32_t);

public:
    Actor() : m_familyOffset(0), m_firstVisibleChunkIndex(UINT32_MAX), m_visibleChunkCount(0), m_firstGraphNodeIndex(UINT32_MAX), m_graphNodeCount(0), m_leafChunkCount(0) {}


    FamilyHeader*       getFamilyHeader() const;

    const Asset*        getAsset() const;

    bool                isActive() const;

    bool                isSubSupportChunk() const;

    bool                isSingleSupportChunk() const;

    uint32_t            getIndex() const;

    uint32_t            getVisibleChunkCount() const;

    uint32_t            getFirstVisibleChunkIndex() const;

    uint32_t            getGraphNodeCount() const;

    uint32_t            getLeafChunkCount() const;

    uint32_t            getFirstGraphNodeIndex() const;

    uint32_t            getFirstSubsupportChunkIndex() const;

    const SupportGraph* getGraph() const;

    FamilyGraph*        getFamilyGraph() const;

    NvBlastChunk*       getChunks() const;

    NvBlastBond*        getBonds() const;

    float*              getLowerSupportChunkHealths() const;

    float*              getSubsupportChunkHealths() const;

    float*              getBondHealths() const;

    const uint32_t*     getGraphNodeIndexLinks() const;



    class VisibleChunkIt : public DListIt<uint32_t>
    {
    public:
        VisibleChunkIt(const Actor& actor);
    };

    class GraphNodeIt : public LListIt<uint32_t>
    {
    public:
        GraphNodeIt(const Actor& actor);
    };



    static Actor*       create(NvBlastFamily* family, const NvBlastActorDesc* desc, void* scratch, NvBlastLog logFn);

    static size_t       createRequiredScratch(const NvBlastFamily* family);

    static Actor*       deserialize(NvBlastFamily* family, const void* buffer, NvBlastLog logFn);

    uint32_t            serialize(void* buffer, uint32_t bufferSize, NvBlastLog logFn) const;

    uint32_t            serializationRequiredStorage(NvBlastLog logFn) const;

    bool                release();



    void                generateFracture(NvBlastFractureBuffers* commandBuffers, const NvBlastDamageProgram& program, const void* programParams, NvBlastLog logFn, NvBlastTimers* timers) const;

    uint32_t            damageBond(uint32_t nodeIndex0, uint32_t nodeIndex1, float healthDamage);

    void                damageBond(uint32_t nodeIndex0, uint32_t nodeIndex1, uint32_t bondIndex, float healthDamage);

    uint32_t            damageBond(const NvBlastBondFractureData& cmd);

    void                applyFracture(NvBlastFractureBuffers* eventBuffers, const NvBlastFractureBuffers* commands, NvBlastLog logFn, NvBlastTimers* timers);

    size_t              splitRequiredScratch() const;

    uint32_t            split(NvBlastActorSplitEvent* result, uint32_t newActorsMaxCount, void* scratch, NvBlastLog logFn, NvBlastTimers* timers);

    uint32_t            findIslands(void* scratch);

    uint32_t            partition(Actor** newActors, uint32_t newActorsSize, NvBlastLog logFn);

    void                updateVisibleChunksFromGraphNodes();

    uint32_t            partitionSingleLowerSupportChunk(Actor** newActors, uint32_t newActorsSize, NvBlastLog logFn);

    uint32_t            partitionMultipleGraphNodes(Actor** newActors, uint32_t newActorsSize, NvBlastLog logFn);

    bool                isBoundToWorld() const;

    bool                isSplitRequired() const;

private:


    uint32_t    m_familyOffset;

    uint32_t    m_firstVisibleChunkIndex;

    uint32_t    m_visibleChunkCount;

    uint32_t    m_firstGraphNodeIndex;

    uint32_t    m_graphNodeCount;

    uint32_t    m_leafChunkCount;
};

} // namespace Blast
} // namespace Nv


#include "NvBlastFamily.h"


namespace Nv
{
namespace Blast
{


NV_INLINE FamilyHeader* Actor::getFamilyHeader() const
{
    NVBLAST_ASSERT(isActive());
    return (FamilyHeader*)((uintptr_t)this - (uintptr_t)m_familyOffset);
}


NV_INLINE const Asset* Actor::getAsset() const
{
    return getFamilyHeader()->m_asset;
}


NV_INLINE bool Actor::isActive() const
{
    return m_familyOffset != 0;
}


NV_INLINE bool Actor::isSubSupportChunk() const
{
    return m_graphNodeCount == 0;
}


NV_INLINE bool Actor::isSingleSupportChunk() const
{
    return m_graphNodeCount == 1;
}


NV_INLINE uint32_t Actor::getIndex() const
{
    NVBLAST_ASSERT(isActive());
    const FamilyHeader* header = getFamilyHeader();
    NVBLAST_ASSERT(header != nullptr);
    const size_t index = this - header->getActors();
    NVBLAST_ASSERT(index <= UINT32_MAX);
    return (uint32_t)index;
}


NV_INLINE uint32_t Actor::getVisibleChunkCount() const
{
    return m_visibleChunkCount;
}


NV_INLINE uint32_t Actor::getFirstVisibleChunkIndex() const
{
    return m_firstVisibleChunkIndex;
}


NV_INLINE uint32_t Actor::getGraphNodeCount() const
{
    return m_graphNodeCount;
}


NV_INLINE uint32_t Actor::getLeafChunkCount() const
{
    return m_leafChunkCount;
}


NV_INLINE uint32_t Actor::getFirstGraphNodeIndex() const
{
    return m_firstGraphNodeIndex;
}

NV_INLINE uint32_t Actor::getFirstSubsupportChunkIndex() const
{
    return getAsset()->m_firstSubsupportChunkIndex;
}

NV_INLINE const SupportGraph* Actor::getGraph() const
{
    return &getAsset()->m_graph;
}

NV_INLINE FamilyGraph* Actor::getFamilyGraph() const
{
    return getFamilyHeader()->getFamilyGraph();
}

NV_INLINE NvBlastChunk* Actor::getChunks() const
{
    return getAsset()->getChunks();
}

NV_INLINE NvBlastBond* Actor::getBonds() const
{
    return getAsset()->getBonds();
}

NV_INLINE float* Actor::getLowerSupportChunkHealths() const
{
    return getFamilyHeader()->getLowerSupportChunkHealths();
}

NV_INLINE float*    Actor::getSubsupportChunkHealths() const
{
    return getFamilyHeader()->getSubsupportChunkHealths();
}

NV_INLINE float* Actor::getBondHealths() const
{
    return getFamilyHeader()->getBondHealths();
}

NV_INLINE const uint32_t* Actor::getGraphNodeIndexLinks() const
{
    return getFamilyHeader()->getGraphNodeIndexLinks();
}


NV_INLINE bool Actor::release()
{
    // Do nothing if this actor is not currently active.
    if (!isActive())
    {
        return false;
    }

    FamilyHeader* header = getFamilyHeader();

    // Clear the graph node list
    uint32_t* graphNodeIndexLinks = getFamilyHeader()->getGraphNodeIndexLinks();
    while (!isInvalidIndex(m_firstGraphNodeIndex))
    {
        const uint32_t graphNodeIndex = m_firstGraphNodeIndex;
        m_firstGraphNodeIndex = graphNodeIndexLinks[m_firstGraphNodeIndex];
        graphNodeIndexLinks[graphNodeIndex] = invalidIndex<uint32_t>();
        --m_graphNodeCount;
    }
    NVBLAST_ASSERT(m_graphNodeCount == 0);

    const Asset* asset = getAsset();

    // Clear the visible chunk list
    IndexDLink<uint32_t>* visibleChunkIndexLinks = header->getVisibleChunkIndexLinks();
    uint32_t* chunkActorIndices = header->getChunkActorIndices();
    while (!isInvalidIndex(m_firstVisibleChunkIndex))
    {
        // Descendants of the visible actor may be accessed again if the actor is deserialized.  Clear subtree.
        for (Asset::DepthFirstIt i(*asset, m_firstVisibleChunkIndex, true); (bool)i; ++i)
        {
            chunkActorIndices[(uint32_t)i] = invalidIndex<uint32_t>();
        }
        IndexDList<uint32_t>().removeListHead(m_firstVisibleChunkIndex, visibleChunkIndexLinks);
        --m_visibleChunkCount;
    }
    NVBLAST_ASSERT(m_visibleChunkCount == 0);

    // Clear the leaf chunk count
    m_leafChunkCount = 0;

    // This invalidates the actor and decrements the reference count
    header->returnActor(*this);

    return true;
}


NV_INLINE uint32_t Actor::partition(Actor** newActors, uint32_t newActorsSize, NvBlastLog logFn)
{
    NVBLASTLL_CHECK(newActorsSize == 0 || newActors != nullptr, logFn, "Nv::Blast::Actor::partition: NULL newActors pointer array input with non-zero newActorCount.", return 0);

    // Call one of two partition functions depending on the actor's support status
    return m_graphNodeCount <= 1 ?
        partitionSingleLowerSupportChunk(newActors, newActorsSize, logFn) : // This actor will partition into subsupport chunks
        partitionMultipleGraphNodes(newActors, newActorsSize, logFn);       // This actor will partition into support chunks
}


NV_INLINE bool Actor::isBoundToWorld() const
{
    const SupportGraph& graph = *getGraph();

    if (graph.m_nodeCount == 0)
    {
        return false;   // This shouldn't happen
    }

    const uint32_t lastGraphChunkIndex = graph.getChunkIndices()[graph.m_nodeCount - 1];

    if (!isInvalidIndex(lastGraphChunkIndex))
    {
        return false;   // There is no world node
    }

    return getFamilyGraph()->getIslandIds()[graph.m_nodeCount - 1] == getIndex();
}


NV_INLINE bool Actor::isSplitRequired() const
{
    NVBLAST_ASSERT(isActive());

    if (getGraphNodeCount() <= 1)
    {
        uint32_t chunkHealthIndex = isSingleSupportChunk() ? getIndex() : getFirstVisibleChunkIndex() - getFirstSubsupportChunkIndex() + getGraph()->m_nodeCount;
        float* chunkHealths = getLowerSupportChunkHealths();
        if (chunkHealths[chunkHealthIndex] <= 0.0f)
        {
            const uint32_t chunkIndex = m_graphNodeCount == 0 ? m_firstVisibleChunkIndex : getGraph()->getChunkIndices()[m_firstGraphNodeIndex];
            if (!isInvalidIndex(chunkIndex))
            {
                const NvBlastChunk& chunk = getChunks()[chunkIndex];
                uint32_t childCount = chunk.childIndexStop - chunk.firstChildIndex;
                return childCount > 0;
            }
        }
    }
    else
    {
        uint32_t* firstDirtyNodeIndices = getFamilyGraph()->getFirstDirtyNodeIndices();
        if (!isInvalidIndex(firstDirtyNodeIndices[getIndex()]))
        {
            return true;
        }

    }
    return false;
}



NV_INLINE Actor::VisibleChunkIt::VisibleChunkIt(const Actor& actor) : DListIt<uint32_t>(actor.m_firstVisibleChunkIndex, actor.getFamilyHeader()->getVisibleChunkIndexLinks())
{
}



NV_INLINE Actor::GraphNodeIt::GraphNodeIt(const Actor& actor) : LListIt<uint32_t>(actor.m_firstGraphNodeIndex, actor.getFamilyHeader()->getGraphNodeIndexLinks())
{
}



#if NVBLASTLL_CHECK_PARAMS

static inline bool isValid(const NvBlastFractureBuffers* buffers)
{
    if (buffers->chunkFractureCount != 0 && buffers->chunkFractures == nullptr)
        return false;

    if (buffers->bondFractureCount != 0 && buffers->bondFractures == nullptr)
        return false;

    return true;
}
#endif


} // namespace Blast
} // namespace Nv


#endif // ifndef NVBLASTACTOR_H