Updating to [email protected] and [email protected] with a new directory structure.

NvBlast folder is gone, files have been moved to top level directory.  README is changed to reflect this.

1 files changed, 732 insertions, 0 deletions

diff --git a/sdk/lowlevel/source/NvBlastActor.h b/sdk/lowlevel/source/NvBlastActor.h
new file mode 100644
index 0000000..42879e7
--- /dev/null
+++ b/sdk/lowlevel/source/NvBlastActor.h
@@ -0,0 +1,732 @@
+/*
+* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
+*
+* NVIDIA CORPORATION and its licensors retain all intellectual property
+* and proprietary rights in and to this software, 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.
+*/
+
+#ifndef NVBLASTACTOR_H
+#define NVBLASTACTOR_H
+
+
+#include "NvBlastAsset.h"
+#include "NvBlastDLink.h"
+#include "NvBlastIteratorBase.h"
+#include "NvBlastSupportGraph.h"
+
+#include <cstring>
+
+
+namespace Nv
+{
+namespace Blast
+{
+
+// Forward declarations
+class FamilyGraph;
+struct FamilyHeader;
+
+/**
+Internal implementation of solver actor.
+
+These objects are stored within the family in a single array.  A pointer to a Actor class will be given
+to the user through the NvBlastActor opaque type.
+*/
+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) {}
+
+	//////// Accessors ////////
+
+	/**
+	Find the family (see FamilyHeader) that this actor belongs to.
+
+	\return	a pointer to the FamilyHeader for this actor.
+	*/
+	FamilyHeader*		getFamilyHeader() const;
+
+	/**
+	Utility to get the asset this actor is associated with, through its family.
+
+	\return	the asset associated with this actor.
+	*/
+	const Asset*		getAsset() const;
+
+	/**
+	Since this object is not deleted (unless the family is deleted), we use m_familyOffset
+	to determine if the actor is valid, or "active."  When no actors in an instance return isActive(),
+	it should be safe to delete the family.
+
+	\return true iff this actor is valid for use (active).
+	*/
+	bool				isActive() const;
+
+	/**
+	Whether or not this actor represents a subsupport chunk.  If the actor contains a subsupport chunk, then it can have only that chunk.
+
+	\return true iff this actor contains a chunk which is a descendant of a support chunk.
+	*/
+	bool				isSubSupportChunk() const;
+
+	/**
+	Whether or not this actor represents a single support chunk.  If the actor contains a single support chunk, it can have no other
+	chunks associated with it.
+
+	\return true iff this actor contains exactly one support chunk.
+	*/
+	bool				isSingleSupportChunk() const;
+
+	/**
+	Utility to calculate actor index.
+
+	\return the index of this actor in the FamilyHeader's getActors() array.
+	*/
+	uint32_t			getIndex() const;
+
+	/**
+	The number of visible chunks.  This is calculated from updateVisibleChunksFromGraphNodes().
+	See also getFirstVisibleChunkIndex.
+
+	\return the number of chunks in the actor's visible chunk index list.
+	*/
+	uint32_t			getVisibleChunkCount() const;
+
+	/**
+	Access to visible chunk linked list for this actor.  The index returned is that of a link in the FamilyHeader's getVisibleChunkIndexLinks().
+
+	\return the index of the head of the visible chunk linked list.
+	*/
+	uint32_t			getFirstVisibleChunkIndex() const;
+
+	/**
+	The number of graph nodes, corresponding to support chunks, for this actor.
+	See also getFirstGraphNodeIndex.
+
+	\return the number of graph nodes in the actor's graph node index list.
+	*/
+	uint32_t			getGraphNodeCount() const;
+
+	/**
+	The number of leaf chunks for this actor.
+
+	\return number of leaf chunks for this actor.
+	*/
+	uint32_t			getLeafChunkCount() const;
+
+	/**
+	Access to graph node linked list for this actor.  The index returned is that of a link in the FamilyHeader's getGraphNodeIndexLinks().
+
+	\return the index of the head of the graph node linked list.
+	*/
+	uint32_t			getFirstGraphNodeIndex() const;
+
+	/**
+	Access to the index of the first subsupport chunk.
+
+	\return the index of the first subsupport chunk.
+	*/
+	uint32_t			getFirstSubsupportChunkIndex() const;
+
+	/**
+	Access to the support graph.
+
+	\return the support graph associated with this actor.
+	*/
+	const SupportGraph*	getGraph() const;
+
+	/**
+	Access the instance graph for islands searching.
+
+	Return the dynamic data generated for the support graph.  (See FamilyGraph.)
+	This is used to store current connectivity information based upon bond and chunk healths, as well as cached intermediate data for faster incremental updates.
+	*/
+	FamilyGraph*		getFamilyGraph() const;
+
+	/**
+	Access to the chunks, of type NvBlastChunk.
+
+	\return an array of size m_chunkCount.
+	*/
+	NvBlastChunk*		getChunks() const;
+
+	/**
+	Access to the bonds, of type NvBlastBond.
+
+	\return an array of size m_bondCount.
+	*/
+	NvBlastBond*		getBonds() const;
+
+	/**
+	Access to the health for each support chunk and subsupport chunk, of type float.
+
+	Use getAsset()->getContiguousLowerSupportIndex() to map lower-support chunk indices into the range of indices valid for this array.
+
+	\return a float array of chunk healths.
+	*/
+	float*				getLowerSupportChunkHealths() const;
+
+	/**
+	Access to the start of the subsupport chunk health array.
+
+	\return the array of health values associated with all descendants of support chunks.
+	*/
+	float*				getSubsupportChunkHealths() const;
+
+	/**
+	Bond health for the interfaces between two chunks, of type float.  Since the bond is shared by two chunks, the same bond health is used for chunk[i] -> chunk[j] as for chunk[j] -> chunk[i].
+
+	\return the array of healths associated with all bonds in the support graph.
+	*/
+	float*				getBondHealths() const;
+
+	/**
+	Graph node index links, of type uint32_t.  The successor to index[i] is m_graphNodeIndexLinksOffset[i].  A value of invalidIndex<uint32_t>() indicates no successor.
+
+	getGraphNodeIndexLinks returns an array of size m_asset->m_graphNodeCount.
+	*/
+	const uint32_t*		getGraphNodeIndexLinks() const;
+
+
+	//////// Iterators ////////
+
+	/**
+	Visible chunk iterator.  Usage:
+
+	Given a solver actor a,
+
+	for (Actor::VisibleChunkIt i = a; (bool)i; ++i)
+	{
+		uint32_t visibleChunkIndex = (uint32_t)i;
+
+		// visibleChunkIndex references the asset index list
+	}
+
+	*/
+	class VisibleChunkIt : public DListIt<uint32_t>
+	{
+	public:
+		/** Constructed from an actor. */
+		VisibleChunkIt(const Actor& actor);
+	};
+
+	/**
+	Graph node iterator.  Usage:
+
+	Given a solver actor a,
+
+	for (Actor::GraphNodeIt i = a; (bool)i; ++i)
+	{
+	uint32_t graphNodeIndex = (uint32_t)i;
+
+	// graphNodeIndex references the asset's graph node index list
+	}
+
+	*/
+	class GraphNodeIt : public LListIt<uint32_t>
+	{
+	public:
+		/** Constructed from an actor. */
+		GraphNodeIt(const Actor& actor);
+	};
+
+
+	//////// Operations ////////
+
+	/**
+	Create an actor from a descriptor (creates a family).  This actor will represent an unfractured instance of the asset.
+	The asset must be in a valid state, for example each chunk hierarchy in it must contain at least one support chunk (a single
+	support chunk in a hierarchy corresponds to the root chunk).  This will always be the case for assets created by NvBlastCreateAsset.
+
+	\param[in] family	Family in which to create a new actor.  The family must be valid and have no other actors in it.  (See createFamily.)
+	\param[in] desc		Actor initialization data, must be a valid pointer.
+	\param[in] scratch	User-supplied scratch memory of size createRequiredScratch(desc) bytes.
+	\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
+
+	\return the new actor if the input is valid (by the conditions described above), NULL otherwise.
+	*/
+	static Actor*		create(NvBlastFamily* family, const NvBlastActorDesc* desc, void* scratch, NvBlastLog logFn);
+
+	/**
+	Returns the size of the scratch space (in bytes) required to be passed into the create function, based upon
+	the family that will be passed to the create function.
+
+	\param[in] family	The family being instanced.
+
+	\return the number of bytes required.
+	*/
+	static size_t		createRequiredScratch(const NvBlastFamily* family);
+
+	/**
+	Deserialize a single Actor from a buffer.  An actor family must given, into which
+	the actor will be inserted if it is compatible.  That is, it must not share any chunks or internal
+	IDs with the actors already present in the block.
+
+	\param[in] family	Family in which to deserialize the actor.
+	\param[in] buffer	Buffer containing the serialized actor data.
+	\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
+
+	\return the deserialized actor if successful, NULL otherwise.
+	*/
+	static Actor*		deserialize(NvBlastFamily* family, const void* buffer, NvBlastLog logFn);
+
+	/**
+	Serialize actor into single-actor buffer.
+
+	\param[out] buffer		User-supplied buffer, must be at least of size given by NvBlastActorGetSerializationSize(actor).
+	\param[in] bufferSize	The size of the user-supplied buffer.  The buffer size must be less than 4GB.  If NvBlastActorGetSerializationSize(actor) >= 4GB, this actor cannot be serialized with this method.
+	\param[in] logFn		User-supplied message function (see NvBlastLog definition).  May be NULL.
+
+	\return the number of bytes written to the buffer, or 0 if there is an error (such as an under-sized buffer).
+	*/
+	uint32_t			serialize(void* buffer, uint32_t bufferSize, NvBlastLog logFn) const;
+
+	/**
+	Calculate the space required to serialize this actor.
+
+	\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
+
+	\return the required buffer size in bytes.
+	*/
+	uint32_t			serializationRequiredStorage(NvBlastLog logFn) const;
+
+	/**
+	Release this actor's association with a family, if any.  This actor should be considered deleted
+	after this function is called.
+
+	\return true if release was successful (actor was active).
+	*/
+	bool				release();
+
+
+	//////// Damage and fracturing methods ////////
+
+	/**
+	Damage bond between two chunks by health amount (instance graph also will be notified in case bond is broken after).
+	*/
+	uint32_t			damageBond(uint32_t nodeIndex0, uint32_t nodeIndex1, float healthDamage);
+
+	/**
+	TODO: document
+	*/
+	void				damageBond(uint32_t nodeIndex0, uint32_t nodeIndex1, uint32_t bondIndex, float healthDamage);
+
+	/**
+	TODO: document
+	*/
+	uint32_t			damageBond(const NvBlastBondFractureData& cmd);
+
+	/**
+	See NvBlastActorGenerateFracture
+	*/
+	void				generateFracture(NvBlastFractureBuffers* commandBuffers, const NvBlastDamageProgram& program, const NvBlastProgramParams* programParams, NvBlastLog logFn, NvBlastTimers* timers) const;
+
+	/**
+	Hierarchically distribute damage to child chunks.
+
+	\param chunkIndex		asset chunk index to hierarchically damage
+	\param suboffset		index of the first sub-support health
+	\param healthDamage		damage strength to apply
+	\param chunkHealths		instance chunk healths
+	\param chunks			asset chunk collection
+	*/
+	void				fractureSubSupportNoEvents(uint32_t chunkIndex, uint32_t suboffset, float healthDamage, float* chunkHealths, const NvBlastChunk* chunks);
+
+	/**
+	Hierarchically distribute damage to child chunks, recording a fracture event for each health damage applied.
+
+	If outBuffer is too small, events are dropped but the chunks are still damaged.
+
+	\param chunkIndex		asset chunk index to hierarchically damage
+	\param suboffset		index of the first sub-support health
+	\param healthDamage		damage strength to apply
+	\param chunkHealths		instance chunk healths
+	\param chunks			asset chunk collection
+	\param outBuffer		target buffer for fracture events
+	\param currentIndex		current position in outBuffer - returns the number of damaged chunks
+	\param maxCount			capacity of outBuffer
+	*/
+	void				fractureSubSupport(uint32_t chunkIndex, uint32_t suboffset, float healthDamage, float* chunkHealths, const NvBlastChunk* chunks, NvBlastChunkFractureData* outBuffer, uint32_t* currentIndex, const uint32_t maxCount);
+
+	/**
+	Apply chunk fracture commands hierarchically.
+
+	\param chunkFractureCount	number of chunk fracture commands to apply
+	\param chunkFractures		array of chunk fracture commands
+	*/
+	void				fractureNoEvents(uint32_t chunkFractureCount, const NvBlastChunkFractureData* chunkFractures);
+
+	/**
+	Apply chunk fracture commands hierarchically, recording a fracture event for each health damage applied.
+
+	If events array is too small, events are dropped but the chunks are still damaged.
+
+	\param chunkFractureCount	number of chunk fracture commands to apply
+	\param commands				array of chunk fracture commands
+	\param events				target buffer for fracture events
+	\param eventsSize			number of available entries in 'events'
+	\param count				returns the number of damaged chunks
+	*/
+	void				fractureWithEvents(uint32_t chunkFractureCount, const NvBlastChunkFractureData* commands, NvBlastChunkFractureData* events, uint32_t eventsSize, uint32_t* count);
+
+	/**
+	Apply chunk fracture commands hierarchically, recording a fracture event for each health damage applied.
+
+	In-Place version: fracture commands are replaced by fracture events.
+
+	If inoutbuffer array is too small, events are dropped but the chunks are still damaged.
+
+	\param chunkFractureCount	number of chunk fracture commands to apply
+	\param inoutbuffer			array of chunk fracture commands to be replaced by events
+	\param eventsSize			number of available entries in inoutbuffer
+	\param count				returns the number of damaged chunks
+	*/
+	void				fractureInPlaceEvents(uint32_t chunkFractureCount, NvBlastChunkFractureData* inoutbuffer, uint32_t eventsSize, uint32_t* count);
+
+	/**
+	See NvBlastActorApplyFracture
+	*/
+	void				applyFracture(NvBlastFractureBuffers* eventBuffers, const NvBlastFractureBuffers* commands, NvBlastLog logFn, NvBlastTimers* timers);
+
+	/**
+	The scratch space required to call the findIslands function, or the split function, in bytes.
+	
+	\return the number of bytes required.
+	*/
+	size_t				splitRequiredScratch() const;
+
+	/**
+	See NvBlastActorSplit
+	*/
+	uint32_t			split(NvBlastActorSplitEvent* result, uint32_t newActorsMaxCount, void* scratch, NvBlastLog logFn, NvBlastTimers* timers);
+
+	/**
+	Perform islands search.  Bonds which are broken when their health values drop to zero (or below) may lead
+	to new islands of chunks which need to be split into new actors.  This function labels all nodes in the instance
+	graph (see FamilyGraph) with a unique index per island that may be used as actor indices for new islands.
+
+	\param[in] scratch	User-supplied scratch memory of size splitRequiredScratch().
+
+	\return	the number of new islands found.
+	*/
+	uint32_t			findIslands(void* scratch);
+
+	/**
+	Partition this actor into smaller pieces.
+
+	If this actor represents a single support or subsupport chunk, then after this operation
+	this actor will released if child chunks are created (see Return value), and its pointer no longer valid for use (unless it appears in the newActors list).
+
+	This function will not split a leaf chunk actor.  In that case, the actor is not destroyed and this function returns 0.
+
+	\param[in] newActors		user-supplied array of actor pointers to hold the actors generated from this partitioning.
+								This array must be of size equal to the number of leaf chunks in the asset, to guarantee
+								that all actors are reported.  (See AssetDataHeader::m_leafChunkCount.)
+	\param[in] newActorsSize	The size of the user-supplied newActors array.
+	\param[in] logFn			User-supplied message function (see NvBlastLog definition).  May be NULL.
+
+	\return	the number of new actors created.  If greater than newActorsSize, some actors are not reported in the newActors array.
+	*/
+	uint32_t			partition(Actor** newActors, uint32_t newActorsSize, NvBlastLog logFn);
+
+	/**
+	Recalculate the visible chunk list for this actor based upon it graph node list (does not modify subsupport chunk actors)
+	*/
+	void				updateVisibleChunksFromGraphNodes();
+
+	/**
+	Partition this actor into smaller pieces if it is a single lower-support chunk actor.  Use this function on single support or sub-support chunks.
+
+	After this operation, if successful (child chunks created, see Return value), this actor will released, and its pointer no longer valid for use.
+
+	This function will not split a leaf chunk actor.  In that case, the actor is not destroyed and this function returns 0.
+
+	\param[in] newActors		User-supplied array of actor pointers to hold the actors generated from this partitioning.  Note: this actor will be released.
+								This array must be of size equal to the lower-support chunk's child count, to guarantee that all actors are reported.
+	\param[in] newActorsSize	The size of the user-supplied newActors array.
+	\param[in] logFn			User-supplied message function (see NvBlastLog definition).  May be NULL.
+
+	\return the number of new actors created.
+	*/
+	uint32_t			partitionSingleLowerSupportChunk(Actor** newActors, uint32_t newActorsSize, NvBlastLog logFn);
+
+	/**
+	Partition this actor into smaller pieces.  Use this function if this actor contains more than one support chunk. 
+
+	After this operation, if successful, this actor will released, and its pointer no longer valid for use (unless it appears in the newActors list).
+
+	\param[in] newActors		User-supplied array of actor pointers to hold the actors generated from this partitioning.  Note: this actor will not be released,
+								but will hold a subset of the graph nodes that it had before the function was called.
+								This array must be of size equal to the number of graph nodes in the asset, to guarantee
+								that all actors are reported.
+	\param[in] newActorsSize	The size of the user-supplied newActors array.
+	\param[in] logFn			User-supplied message function (see NvBlastLog definition).  May be NULL.
+
+	\return the number of new actors created.
+	*/
+	uint32_t			partitionMultipleGraphNodes(Actor** newActors, uint32_t newActorsSize, NvBlastLog logFn);
+
+private:
+
+	//////// Data ////////
+
+	/**
+	Offset to block of memory which holds the data associated with all actors in this actor's lineage.
+	This offset is positive.  The block address is this object's pointer _minus_ the m_familyOffset.
+	This value is initialized to 0, which denotes an invalid actor.  Actors should be obtained through
+	the FamilyHeader::borrowActor API, which will create a valid offset, and
+	the FamilyHeader::returnActor API, which will zero the offset.
+	*/
+	uint32_t	m_familyOffset;
+
+	/**
+	The index of the head of a doubly-linked list of visible chunk indices.  If m_firstVisibleChunkIndex == invalidIndex<uint32_t>(),
+	then there are no visible chunks.
+	*/
+	uint32_t	m_firstVisibleChunkIndex;
+
+	/**
+	The number of elements in the visible chunk list.
+	*/
+	uint32_t	m_visibleChunkCount;
+
+	/**
+	The index of the head of a singly-linked list of graph node indices.  If m_firstGraphNodeIndex == invalidIndex<uint32_t>(),
+	then there are no graph nodes.
+	*/
+	uint32_t	m_firstGraphNodeIndex;
+
+	/**
+	The number of elements in the graph node list.
+	*/
+	uint32_t	m_graphNodeCount;
+
+	/**
+	The number of leaf chunks in this actor.
+	*/
+	uint32_t	m_leafChunkCount;
+};
+
+} // namespace Blast
+} // namespace Nv
+
+
+#include "NvBlastFamily.h"
+
+
+namespace Nv
+{
+namespace Blast
+{
+
+//////// Actor inline methods ////////
+
+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)
+{
+	NVBLAST_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
+}
+
+
+//////// Actor::VisibleChunkIt inline methods ////////
+
+NV_INLINE Actor::VisibleChunkIt::VisibleChunkIt(const Actor& actor) : DListIt<uint32_t>(actor.m_firstVisibleChunkIndex, actor.getFamilyHeader()->getVisibleChunkIndexLinks())
+{
+}
+
+
+//////// Actor::GraphNodeIt inline methods ////////
+
+NV_INLINE Actor::GraphNodeIt::GraphNodeIt(const Actor& actor) : LListIt<uint32_t>(actor.m_firstGraphNodeIndex, actor.getFamilyHeader()->getGraphNodeIndexLinks())
+{
+}
+
+} // namespace Blast
+} // namespace Nv
+
+
+/**
+Returns the closest chunk asset index for a supported actor.
+Helper functions still used in tests. 
+Has become obsolete with introduction of chunkMap and its inverse.
+*/
+uint32_t NvBlastActorClosestChunk(const float point[4], const NvBlastActor* actor, NvBlastLog logFn);
+
+
+#endif // ifndef NVBLASTACTOR_H