Blast 1.1.3. See docs/release_notes.txt.v1.1.3_rc1

1 files changed, 210 insertions, 210 deletions

diff --git a/sdk/toolkit/include/NvBlastTkGroup.h b/sdk/toolkit/include/NvBlastTkGroup.h
index e704b28..4a7a4a9 100644..100755
--- a/sdk/toolkit/include/NvBlastTkGroup.h
+++ b/sdk/toolkit/include/NvBlastTkGroup.h
@@ -1,210 +1,210 @@
-// 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-2018 NVIDIA Corporation. All rights reserved.
-
-
-#ifndef NVBLASTTKGROUP_H
-#define NVBLASTTKGROUP_H
-
-#include "NvBlastTkIdentifiable.h"
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-// Forward declarations
-class TkActor;
-
-
-/**
-Descriptor for a TkGroup.  TkGroup uses a number of TkGroupWorker to process its actors.
-@see TkGroupWorker, TkGroup::setWorkerCount
-*/
-struct TkGroupDesc
-{
-	uint32_t		workerCount;			//!< The number of expected TkWorkers to process the TkGroup concurrently.
-};
-
-
-/**
-Used to collect internal counters using TkGroup::getStats (for profile builds only)
-@see TkGroup::getStats()
-*/
-struct TkGroupStats
-{
-	NvBlastTimers	timers;					//!< Accumulated time spent in blast low-level functions, see NvBlastTimers
-	uint32_t		processedActorsCount;	//!< Accumulated number of processed actors in all TkWorker
-	int64_t			workerTime;				//!< Accumulated time spent executing TkWorker::run. Unit is ticks, see NvBlastTimers.
-};
-
-
-/**
-A worker as provided by TkGroup::acquireWorker(). It manages the necessary memory for parallel processing.
-The group can be processed concurrently by calling process() from different threads using a different TkGroupWorker each.
-
-TkActors that have been damaged with applyFracture() such that they may be split into separate
-actors are split by this function. TkActors that have damage queued through the actor's damage() function
-will be fractured and split by this function.
-*/
-class TkGroupWorker
-{
-public:
-	/**
-	Process a job of this worker's TkGroup.
-
-	/param[in]	jobId	a job id in the range (0, TkGroup::startProcess()]
-	*/
-	virtual void	process(uint32_t jobId) = 0;
-};
-
-
-/**
-A group is a processing unit, to which the user may add TkActors.  New actors generated from splitting a TkActor
-are automatically put into the same group.  However, any actor may be removed from its group and placed into
-another group (or no group) by the user's choice.
-
-When the group's process function is called, all actors' damage buffers will be processed and turned into fracture events
-and the actor is split if applicable.
-
-This work can be done in multiple threads with the help of TkGroupWorker:  
-Instead of calling the process function, commence the procedure with startProcess which returns the number of jobs to process.  
-Each concurrent thread uses an acquired TkGroupWorker to process the jobs.
-Over the whole procedure, each job must be processed once and only once.  
-Jobs can be processed in any order.  TkGroupWorkers can be returned and acquired later by another task.
-After processing every job and returning all the workers to the group, endProcess concludes the procedure.
-*/
-class TkGroup : public TkIdentifiable
-{
-public:
-	/**
-	Add the actor to this group, if the actor does not currently belong to a group.
-
-	\param[in]	actor	The actor to add.
-
-	\return true if successful, false otherwise.
-	*/
-	virtual bool			addActor(TkActor& actor) = 0;
-
-	/**
-	The number of actors currently in this group.
-
-	\return the number of TkActors that currently exist in this group.
-	*/
-	virtual uint32_t		getActorCount() const = 0;
-
-	/**
-	Retrieve an array of pointers (into the user-supplied buffer) to actors.
-
-	\param[out]	buffer		A user-supplied array of TkActor pointers.
-	\param[in]	bufferSize	The number of elements available to write into buffer.
-	\param[in]	indexStart	The starting index of the actor.
-
-	\return the number of TkActor pointers written to the buffer.
-	*/
-	virtual uint32_t		getActors(TkActor** buffer, uint32_t bufferSize, uint32_t indexStart = 0) const = 0;
-
-	/**
-	Lock this group for processing concurrently with TkGroupWorker.  The group is unlocked again with the endProcess() function.
-
-	\return The number of jobs to process. TkGroupWorker::process must be called once for each jobID from 0 to this number-1.
-			See TkGroup::process for a single threaded example.
-	*/
-	virtual uint32_t		startProcess() = 0;
-
-	/**
-	Unlock this group after all jobs were processed with TkGroupWorker.  All workers must have been returned with returnWorker().
-	This function gathers the results of the split operations on the actors in this group.  Events will be dispatched
-	to notify listeners of new and deleted actors.
-
-	Note that groups concurrently dispatching events for the same TkFamily require synchronization in the TkFamily's Listener.
-	However, concurrent use of endProcess is not recommended in this version. It should be called from the main thread.
-
-	\return		true	if the group was processing
-	*/
-	virtual bool			endProcess() = 0;
-
-	/**
-	Set the expected number of concurrent worker threads that will process this group concurrently.
-	*/
-	virtual void			setWorkerCount(uint32_t workerCount) = 0;
-
-	/**
-	\return The total amount of workers allocated for this group.
-	*/
-	virtual uint32_t		getWorkerCount() const = 0;
-
-	/**
-	Acquire one worker to process the group concurrently on a thread.
-	The worker must be returned with returnWorker() before endProcess() is called on its group.
-
-	\return A worker for this group (at most getWorkerCount) or nullptr if none is available.
-	*/
-	virtual TkGroupWorker*	acquireWorker() = 0;
-
-	/**
-	Return a worker previously acquired with acquireWorker() to this TkGroup.
-
-	\param[in] The TkGroupWorker previously acquired from this TkGroup.
-	*/
-	virtual void			returnWorker(TkGroupWorker*) = 0;
-
-	/**
-	Helper function to process the group synchronously on a single thread.
-	*/
-            void			process();
-
-	/**
-	For profile builds only, request stats of the last successful processing. Inactive in other builds.
-	The times and counters reported account for all the TkWorker (accumulated) taking part in the processing.
-
-	\param[in]	stats	The struct to be filled in.
-	*/
-	virtual void			getStats(TkGroupStats& stats) const = 0;
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-NV_INLINE void Nv::Blast::TkGroup::process()
-{
-	uint32_t jobCount = startProcess();
-	if (jobCount > 0)
-	{
-		TkGroupWorker* worker = acquireWorker();
-		for (uint32_t i = 0; i < jobCount; i++)
-		{
-			worker->process(i);
-		}
-		returnWorker(worker);
-	}
-	endProcess();
-}
-
-
-#endif // ifndef NVBLASTTKGROUP_H
+// 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-2018 NVIDIA Corporation. All rights reserved.

+

+

+#ifndef NVBLASTTKGROUP_H

+#define NVBLASTTKGROUP_H

+

+#include "NvBlastTkIdentifiable.h"

+

+

+namespace Nv

+{

+namespace Blast

+{

+

+// Forward declarations

+class TkActor;

+

+

+/**

+Descriptor for a TkGroup.  TkGroup uses a number of TkGroupWorker to process its actors.

+@see TkGroupWorker, TkGroup::setWorkerCount

+*/

+struct TkGroupDesc

+{

+	uint32_t		workerCount;			//!< The number of expected TkWorkers to process the TkGroup concurrently.

+};

+

+

+/**

+Used to collect internal counters using TkGroup::getStats (for profile builds only)

+@see TkGroup::getStats()

+*/

+struct TkGroupStats

+{

+	NvBlastTimers	timers;					//!< Accumulated time spent in blast low-level functions, see NvBlastTimers

+	uint32_t		processedActorsCount;	//!< Accumulated number of processed actors in all TkWorker

+	int64_t			workerTime;				//!< Accumulated time spent executing TkWorker::run. Unit is ticks, see NvBlastTimers.

+};

+

+

+/**

+A worker as provided by TkGroup::acquireWorker(). It manages the necessary memory for parallel processing.

+The group can be processed concurrently by calling process() from different threads using a different TkGroupWorker each.

+

+TkActors that have been damaged with applyFracture() such that they may be split into separate

+actors are split by this function. TkActors that have damage queued through the actor's damage() function

+will be fractured and split by this function.

+*/

+class TkGroupWorker

+{

+public:

+	/**

+	Process a job of this worker's TkGroup.

+

+	/param[in]	jobId	a job id in the range (0, TkGroup::startProcess()]

+	*/

+	virtual void	process(uint32_t jobId) = 0;

+};

+

+

+/**

+A group is a processing unit, to which the user may add TkActors.  New actors generated from splitting a TkActor

+are automatically put into the same group.  However, any actor may be removed from its group and placed into

+another group (or no group) by the user's choice.

+

+When the group's process function is called, all actors' damage buffers will be processed and turned into fracture events

+and the actor is split if applicable.

+

+This work can be done in multiple threads with the help of TkGroupWorker:  

+Instead of calling the process function, commence the procedure with startProcess which returns the number of jobs to process.  

+Each concurrent thread uses an acquired TkGroupWorker to process the jobs.

+Over the whole procedure, each job must be processed once and only once.  

+Jobs can be processed in any order.  TkGroupWorkers can be returned and acquired later by another task.

+After processing every job and returning all the workers to the group, endProcess concludes the procedure.

+*/

+class TkGroup : public TkIdentifiable

+{

+public:

+	/**

+	Add the actor to this group, if the actor does not currently belong to a group.

+

+	\param[in]	actor	The actor to add.

+

+	\return true if successful, false otherwise.

+	*/

+	virtual bool			addActor(TkActor& actor) = 0;

+

+	/**

+	The number of actors currently in this group.

+

+	\return the number of TkActors that currently exist in this group.

+	*/

+	virtual uint32_t		getActorCount() const = 0;

+

+	/**

+	Retrieve an array of pointers (into the user-supplied buffer) to actors.

+

+	\param[out]	buffer		A user-supplied array of TkActor pointers.

+	\param[in]	bufferSize	The number of elements available to write into buffer.

+	\param[in]	indexStart	The starting index of the actor.

+

+	\return the number of TkActor pointers written to the buffer.

+	*/

+	virtual uint32_t		getActors(TkActor** buffer, uint32_t bufferSize, uint32_t indexStart = 0) const = 0;

+

+	/**

+	Lock this group for processing concurrently with TkGroupWorker.  The group is unlocked again with the endProcess() function.

+

+	\return The number of jobs to process. TkGroupWorker::process must be called once for each jobID from 0 to this number-1.

+			See TkGroup::process for a single threaded example.

+	*/

+	virtual uint32_t		startProcess() = 0;

+

+	/**

+	Unlock this group after all jobs were processed with TkGroupWorker.  All workers must have been returned with returnWorker().

+	This function gathers the results of the split operations on the actors in this group.  Events will be dispatched

+	to notify listeners of new and deleted actors.

+

+	Note that groups concurrently dispatching events for the same TkFamily require synchronization in the TkFamily's Listener.

+	However, concurrent use of endProcess is not recommended in this version. It should be called from the main thread.

+

+	\return		true	if the group was processing

+	*/

+	virtual bool			endProcess() = 0;

+

+	/**

+	Set the expected number of concurrent worker threads that will process this group concurrently.

+	*/

+	virtual void			setWorkerCount(uint32_t workerCount) = 0;

+

+	/**

+	\return The total amount of workers allocated for this group.

+	*/

+	virtual uint32_t		getWorkerCount() const = 0;

+

+	/**

+	Acquire one worker to process the group concurrently on a thread.

+	The worker must be returned with returnWorker() before endProcess() is called on its group.

+

+	\return A worker for this group (at most getWorkerCount) or nullptr if none is available.

+	*/

+	virtual TkGroupWorker*	acquireWorker() = 0;

+

+	/**

+	Return a worker previously acquired with acquireWorker() to this TkGroup.

+

+	\param[in] The TkGroupWorker previously acquired from this TkGroup.

+	*/

+	virtual void			returnWorker(TkGroupWorker*) = 0;

+

+	/**

+	Helper function to process the group synchronously on a single thread.

+	*/

+            void			process();

+

+	/**

+	For profile builds only, request stats of the last successful processing. Inactive in other builds.

+	The times and counters reported account for all the TkWorker (accumulated) taking part in the processing.

+

+	\param[in]	stats	The struct to be filled in.

+	*/

+	virtual void			getStats(TkGroupStats& stats) const = 0;

+};

+

+} // namespace Blast

+} // namespace Nv

+

+

+NV_INLINE void Nv::Blast::TkGroup::process()

+{

+	uint32_t jobCount = startProcess();

+	if (jobCount > 0)

+	{

+		TkGroupWorker* worker = acquireWorker();

+		for (uint32_t i = 0; i < jobCount; i++)

+		{

+			worker->process(i);

+		}

+		returnWorker(worker);

+	}

+	endProcess();

+}

+

+

+#endif // ifndef NVBLASTTKGROUP_H