NvBlastAsset.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 NVBLASTASSET_H
#define NVBLASTASSET_H


#include "NvBlastSupportGraph.h"
#include "NvBlast.h"
#include "NvBlastAssert.h"
#include "NvBlastIndexFns.h"
#include "NvBlastChunkHierarchy.h"


namespace Nv
{
namespace Blast
{

class Asset : public NvBlastAsset
{
public:

    struct ChunkAnnotation
    {
        enum Enum
        {
            Parent = (1 << 0),
            Support = (1 << 1),
            SuperSupport = (1 << 2),

            // Combinations
            UpperSupport = Support | SuperSupport
        };
    };


    static Asset*   create(void* mem, const NvBlastAssetDesc* desc, void* scratch, NvBlastLog logFn);

    static size_t   getMemorySize(const NvBlastAssetDesc* desc);

    static size_t   createRequiredScratch(const NvBlastAssetDesc* desc);


    uint32_t        getUpperSupportChunkCount() const;

    uint32_t        getLowerSupportChunkCount() const;

    uint32_t        getBondCount() const;

    uint32_t        getHierarchyCount() const;

    uint32_t        getContiguousLowerSupportIndex(uint32_t chunkIndex) const;


    // Static functions

    static bool     ensureExactSupportCoverage(uint32_t& supportChunkCount, uint32_t& leafChunkCount, char* chunkAnnotation, uint32_t chunkCount, NvBlastChunkDesc* chunkDescs, bool testOnly, NvBlastLog logFn);

    static bool     testForValidChunkOrder(uint32_t chunkCount, const NvBlastChunkDesc* chunkDescs, const char* chunkAnnotation, void* scratch);



    NvBlastDataBlock    m_header;

    NvBlastID           m_ID;

    uint32_t            m_chunkCount;

    SupportGraph        m_graph;

    uint32_t            m_leafChunkCount;

    uint32_t            m_firstSubsupportChunkIndex;

    uint32_t            m_bondCount;

    NvBlastBlockArrayData(NvBlastChunk, m_chunksOffset, getChunks, m_chunkCount);

    NvBlastBlockArrayData(NvBlastBond, m_bondsOffset, getBonds, m_bondCount);

    NvBlastBlockArrayData(uint32_t, m_subtreeLeafChunkCountsOffset, getSubtreeLeafChunkCounts, m_chunkCount);

    NvBlastBlockArrayData(uint32_t, m_chunkToGraphNodeMapOffset, getChunkToGraphNodeMap, m_chunkCount);



    class DepthFirstIt : public ChunkDepthFirstIt
    {
    public:
        DepthFirstIt(const Asset& asset, uint32_t startChunkIndex, bool upperSupportOnly = false) :
            ChunkDepthFirstIt(asset.getChunks(), startChunkIndex, upperSupportOnly ? asset.getUpperSupportChunkCount() : asset.m_chunkCount) {}
    };
};



NV_INLINE uint32_t Asset::getUpperSupportChunkCount() const
{
    return m_firstSubsupportChunkIndex;
}


NV_INLINE uint32_t Asset::getLowerSupportChunkCount() const
{
    return m_graph.m_nodeCount + (m_chunkCount - m_firstSubsupportChunkIndex);
}


NV_INLINE uint32_t Asset::getBondCount() const
{
    NVBLAST_ASSERT((m_graph.getAdjacencyPartition()[m_graph.m_nodeCount] & 1) == 0);    // The bidirectional graph data should have an even number of edges
    return m_graph.getAdjacencyPartition()[m_graph.m_nodeCount] / 2;    // Directional bonds, divide by two
}


NV_INLINE uint32_t Asset::getHierarchyCount() const
{
    const NvBlastChunk* chunks = getChunks();
    for (uint32_t i = 0; i < m_chunkCount; ++i)
    {
        if (!isInvalidIndex(chunks[i].parentChunkIndex))
        {
            return i;
        }
    }
    return m_chunkCount;
}


NV_INLINE uint32_t Asset::getContiguousLowerSupportIndex(uint32_t chunkIndex) const
{
    NVBLAST_ASSERT(chunkIndex < m_chunkCount);

    return chunkIndex < m_firstSubsupportChunkIndex ? getChunkToGraphNodeMap()[chunkIndex] : (chunkIndex - m_firstSubsupportChunkIndex + m_graph.m_nodeCount);
}


//JDM: Expose this so serialization layer can use it.
NVBLAST_API Asset* initializeAsset(void* mem, NvBlastID id, uint32_t chunkCount, uint32_t graphNodeCount, uint32_t leafChunkCount, uint32_t firstSubsupportChunkIndex, uint32_t bondCount, NvBlastLog logFn);

} // namespace Blast
} // namespace Nv


#endif // ifndef NVBLASTASSET_H