Blast SDK 1.1.5 prerelease #1v1.1.5_pre1

5 files changed, 370 insertions, 474 deletions

diff --git a/sdk/extensions/authoring/include/NvBlastExtAuthoring.h b/sdk/extensions/authoring/include/NvBlastExtAuthoring.h
index 5b6c5d6..829e13f 100755
--- a/sdk/extensions/authoring/include/NvBlastExtAuthoring.h
+++ b/sdk/extensions/authoring/include/NvBlastExtAuthoring.h
@@ -31,30 +31,23 @@
 

 #include "NvBlastExtAuthoringTypes.h"

 

-namespace physx

-{

-	class PxCooking;

-	class PxPhysicsInsertionCallback;

-}

-

 namespace Nv

 {

-	namespace Blast

-	{

-		class Mesh;

-		class VoronoiSitesGenerator;

-		class CutoutSet;

-		class FractureTool;

-		class ConvexMeshBuilder;

-		class BlastBondGenerator;

-		class MeshCleaner;

-		class PatternGenerator;

-		class Grid;

-		class GridWalker;

-		struct CollisionParams;

-		struct CollisionHull;

-	}

-}

+namespace Blast

+{

+class Mesh;

+class VoronoiSitesGenerator;

+class CutoutSet;

+class RandomGeneratorBase;

+class FractureTool;

+class ConvexMeshBuilder;

+class BlastBondGenerator;

+class MeshCleaner;

+class PatternGenerator;

+class Grid;

+class GridWalker;

+}  // namespace Blast

+}  // namespace Nv

 

 struct NvBlastExtAssetUtilsBondDesc;

 

@@ -71,8 +64,9 @@ User should call release() after usage.
 

 \return pointer to Nv::Blast::Mesh if it was created succefully otherwise return nullptr

 */

-NVBLAST_API Nv::Blast::Mesh* NvBlastExtAuthoringCreateMesh(const physx::PxVec3* positions, const physx::PxVec3* normals,

-	const physx::PxVec2* uv, uint32_t verticesCount, const uint32_t* indices, uint32_t indicesCount);

+NVBLAST_API Nv::Blast::Mesh*

+NvBlastExtAuthoringCreateMesh(const NvcVec3* positions, const NvcVec3* normals, const NvcVec2* uv,

+                              uint32_t verticesCount, const uint32_t* indices, uint32_t indicesCount);

 

 /**

 Constructs mesh object from triangles represented as arrays of vertices, indices and per facet material.

@@ -87,8 +81,9 @@ User should call Mesh::release() after usage.
 

 \return pointer to Nv::Blast::Mesh if it was created succefully otherwise return nullptr

 */

-NVBLAST_API Nv::Blast::Mesh* NvBlastExtAuthoringCreateMeshOnlyTriangles(const void* vertices, uint32_t verticesCount, 

-	uint32_t* indices, uint32_t indexCount, void* materials = nullptr, uint32_t materialStride = 4);

+NVBLAST_API Nv::Blast::Mesh*

+NvBlastExtAuthoringCreateMeshOnlyTriangles(const void* vertices, uint32_t verticesCount, uint32_t* indices,

+                                           uint32_t indexCount, void* materials = nullptr, uint32_t materialStride = 4);

 

 /**

 Constructs mesh object from array of vertices, edges and facets.

@@ -103,8 +98,9 @@ User should call release() after usage.
 

 \return pointer to Nv::Blast::Mesh if it was created succefully otherwise return nullptr

 */

-NVBLAST_API Nv::Blast::Mesh* NvBlastExtAuthoringCreateMeshFromFacets(const void* vertices, const void* edges, const void* facets,

-	uint32_t verticesCount, uint32_t edgesCount, uint32_t facetsCount);

+NVBLAST_API Nv::Blast::Mesh*

+NvBlastExtAuthoringCreateMeshFromFacets(const void* vertices, const void* edges, const void* facets,

+                                        uint32_t verticesCount, uint32_t edgesCount, uint32_t facetsCount);

 

 /**

 Voronoi sites should not be generated outside of the fractured mesh, so VoronoiSitesGenerator

@@ -113,8 +109,8 @@ should be supplied with fracture mesh.
 \param[in] rnd			User supplied random value generator.

 \return					Pointer to VoronoiSitesGenerator. User's code should release it after usage.

 */

-NVBLAST_API Nv::Blast::VoronoiSitesGenerator* NvBlastExtAuthoringCreateVoronoiSitesGenerator(Nv::Blast::Mesh* mesh,

-	Nv::Blast::RandomGeneratorBase* rng);

+NVBLAST_API Nv::Blast::VoronoiSitesGenerator*

+NvBlastExtAuthoringCreateVoronoiSitesGenerator(Nv::Blast::Mesh* mesh, Nv::Blast::RandomGeneratorBase* rng);

 

 /** Instantiates a blank CutoutSet */

 NVBLAST_API Nv::Blast::CutoutSet* NvBlastExtAuthoringCreateCutoutSet();

@@ -128,14 +124,17 @@ by one byte in the buffer.
 \param pixelBuffer		pointer to be beginning of the pixel buffer

 \param bufferWidth		the width of the buffer in pixels

 \param bufferHeight		the height of the buffer in pixels

-\param segmentationErrorThreshold	Reduce the number of vertices on curve untill segmentation error is smaller then specified. By default set it to 0.001.

-\param snapThreshold	the pixel distance at which neighboring cutout vertices and segments may be fudged into alignment. By default set it to 1.

+\param segmentationErrorThreshold	Reduce the number of vertices on curve untill segmentation error is smaller then

+specified. By default set it to 0.001. \param snapThreshold	the pixel distance at which neighboring cutout vertices and

+segments may be fudged into alignment. By default set it to 1.

 \param periodic			whether or not to use periodic boundary conditions when creating cutouts from the map

 \param expandGaps		expand cutout regions to gaps or keep it as is

 

 */

-NVBLAST_API void NvBlastExtAuthoringBuildCutoutSet(Nv::Blast::CutoutSet& cutoutSet, const uint8_t* pixelBuffer, 

-	uint32_t bufferWidth, uint32_t bufferHeight, float segmentationErrorThreshold, float snapThreshold, bool periodic, bool expandGaps);

+NVBLAST_API void

+NvBlastExtAuthoringBuildCutoutSet(Nv::Blast::CutoutSet& cutoutSet, const uint8_t* pixelBuffer, uint32_t bufferWidth,

+                                  uint32_t bufferHeight, float segmentationErrorThreshold, float snapThreshold,

+                                  bool periodic, bool expandGaps);

 

 /**

 Create FractureTool object.

@@ -147,15 +146,38 @@ NVBLAST_API Nv::Blast::FractureTool* NvBlastExtAuthoringCreateFractureTool();
 Create BlastBondGenerator

 \return Pointer to created BlastBondGenerator. User's code should release it after usage.

 */

-NVBLAST_API Nv::Blast::BlastBondGenerator* NvBlastExtAuthoringCreateBondGenerator(physx::PxCooking* cooking, 

-	physx::PxPhysicsInsertionCallback* insertionCallback);

+NVBLAST_API Nv::Blast::BlastBondGenerator* NvBlastExtAuthoringCreateBondGenerator(Nv::Blast::ConvexMeshBuilder* builder);

 

 /**

-Create ConvexMeshBuilder

-\return Pointer to created ConvexMeshBuilder. User's code should release it after usage.

+Build convex mesh decomposition.

+\param[in] mesh				Triangle mesh to decompose.

+\param[in] triangleCount	Number of triangles in mesh.

+\param[in] params			Parameters for convex mesh decomposition builder.

+\param[out] convexes		The resulting convex hulls.

+

+\return Number of created convex hulls.

+*/

+NVBLAST_API int32_t NvBlastExtAuthoringBuildMeshConvexDecomposition(Nv::Blast::ConvexMeshBuilder* cmb,

+                                                                    const Nv::Blast::Triangle* mesh,

+                                                                    uint32_t triangleCount,

+                                                                    const Nv::Blast::ConvexDecompositionParams& params,

+                                                                    Nv::Blast::CollisionHull**& convexes);

+

+

+/**

+    Convex geometry trimming.

+    Using slicing with noised slicing surface can result in intersecting collision geometry.

+    It leads to unstable behaviour of rigid body simulation.

+    This method trims all intersecting parts of collision geometry.

+    As a drawback, trimming collision geometry can lead to penetrating render meshes during simulation.

+

+    \param[in]		chunksCount	Number of chunks

+    \param[in,out]	in			ConvexHull geometry which should be clipped.

+    \param[in]		chunkDepth	Array of depth levels of convex hulls corresponding chunks.

+

 */

-NVBLAST_API Nv::Blast::ConvexMeshBuilder* NvBlastExtAuthoringCreateConvexMeshBuilder(physx::PxCooking* cooking,

-	physx::PxPhysicsInsertionCallback* insertionCallback);

+NVBLAST_API void NvBlastExtAuthoringTrimCollisionGeometry(Nv::Blast::ConvexMeshBuilder* cmb, uint32_t chunksCount,

+                                                          Nv::Blast::CollisionHull** in, const uint32_t* chunkDepth);

 

 

 /**

@@ -165,13 +187,8 @@ Transforms collision hull in place using scale, rotation, transform.
 \param[in]		rotation	Pointer to rotation to be applied. Can be nullptr.

 \param[in]		translation	Pointer to translation to be applied. Can be nullptr.

 */

-NVBLAST_API void NvBlastExtAuthoringTransformCollisionHullInPlace

-(

-	Nv::Blast::CollisionHull* hull,

-	const physx::PxVec3* scaling,

-	const physx::PxQuat* rotation,

-	const physx::PxVec3* translation

-);

+NVBLAST_API void NvBlastExtAuthoringTransformCollisionHullInPlace(Nv::Blast::CollisionHull* hull, const NvcVec3* scaling,

+                                                                  const NvcQuat* rotation, const NvcVec3* translation);

 

 /**

 Transforms collision hull in place using scale, rotation, transform.

@@ -180,13 +197,9 @@ Transforms collision hull in place using scale, rotation, transform.
 \param[in]		rotation	Pointer to rotation to be applied. Can be nullptr.

 \param[in]		translation	Pointer to translation to be applied. Can be nullptr.

 */

-NVBLAST_API Nv::Blast::CollisionHull* NvBlastExtAuthoringTransformCollisionHull

-(

-	const Nv::Blast::CollisionHull* hull,

-	const physx::PxVec3* scaling,

-	const physx::PxQuat* rotation,

-	const physx::PxVec3* translation

-);

+NVBLAST_API Nv::Blast::CollisionHull*

+NvBlastExtAuthoringTransformCollisionHull(const Nv::Blast::CollisionHull* hull, const NvcVec3* scaling,

+                                          const NvcQuat* rotation, const NvcVec3* translation);

 

 /**

 Performs pending fractures and generates fractured asset, render and collision geometry

@@ -194,43 +207,55 @@ Performs pending fractures and generates fractured asset, render and collision g
 \param[in]  fTool				Fracture tool created by NvBlastExtAuthoringCreateFractureTool

 \param[in]  bondGenerator		Bond generator created by NvBlastExtAuthoringCreateBondGenerator

 \param[in]  collisionBuilder	Collision builder created by NvBlastExtAuthoringCreateConvexMeshBuilder

-\param[in]  defaultSupportDepth All new chunks will be marked as support if its depth equal to defaultSupportDepth. 

-								By default leaves (chunks without children) marked as support.

-\param[in]  collisionParam		Parameters of collision hulls generation. 

+\param[in]  defaultSupportDepth All new chunks will be marked as support if its depth equal to defaultSupportDepth.

+                                By default leaves (chunks without children) marked as support.

+\param[in]  collisionParam		Parameters of collision hulls generation.

 \return		Authoring result

 */

-NVBLAST_API Nv::Blast::AuthoringResult* NvBlastExtAuthoringProcessFracture(Nv::Blast::FractureTool& fTool,

-	Nv::Blast::BlastBondGenerator& bondGenerator, Nv::Blast::ConvexMeshBuilder& collisionBuilder, const Nv::Blast::CollisionParams& collisionParam, int32_t defaultSupportDepth = -1);

+NVBLAST_API Nv::Blast::AuthoringResult*

+NvBlastExtAuthoringProcessFracture(Nv::Blast::FractureTool& fTool, Nv::Blast::BlastBondGenerator& bondGenerator,

+                                   Nv::Blast::ConvexMeshBuilder& collisionBuilder,

+                                   const Nv::Blast::ConvexDecompositionParams& collisionParam,

+                                   int32_t defaultSupportDepth = -1);

+

+

+/**

+Releases collision data for AuthoringResult. AuthoringResult should be created by NvBlast.

+*/

+NVBLAST_API void NvBlastExtAuthoringReleaseAuthoringResultCollision(Nv::Blast::ConvexMeshBuilder& collisionBuilder, Nv::Blast::AuthoringResult* ar);

+

+/**

+Releases AuthoringResult data. AuthoringResult should be created by NvBlast.

+*/

+NVBLAST_API void NvBlastExtAuthoringReleaseAuthoringResult(Nv::Blast::ConvexMeshBuilder& collisionBuilder, Nv::Blast::AuthoringResult* ar);

+

 

 /**

 Updates graphics mesh only

 

 \param[in]  fTool				Fracture tool created by NvBlastExtAuthoringCreateFractureTool

-\param[out] ares				AuthoringResult object which contains chunks, for which rendermeshes will be updated (e.g. to tweak UVs). Initially should be created by NvBlastExtAuthoringProcessFracture.

+\param[out] ares				AuthoringResult object which contains chunks, for which rendermeshes will be updated

+(e.g. to tweak UVs). Initially should be created by NvBlastExtAuthoringProcessFracture.

 */

 NVBLAST_API void NvBlastExtAuthoringUpdateGraphicsMesh(Nv::Blast::FractureTool& fTool, Nv::Blast::AuthoringResult& ares);

 

 /**

 Build collision meshes

 

-\param[in,out]	ares				AuthoringResult object which contains chunks, for which collision meshes will be built.

-\param[in]		collisionBuilder	Reference to ConvexMeshBuilder instance.

-\param[in]		collisionParam		Parameters of collision hulls generation.

+\param[in,out]	ares				AuthoringResult object which contains chunks, for which collision meshes will be

+built. \param[in]		collisionBuilder	Reference to ConvexMeshBuilder instance. \param[in]		collisionParam

+Parameters of collision hulls generation.

 \param[in]		chunksToProcessCount Number of chunk indices in chunksToProcess memory buffer.

 \param[in]		chunksToProcess		Chunk indices for which collision mesh should be built.

 */

-NVBLAST_API void NvBlastExtAuthoringBuildCollisionMeshes

-(

-	Nv::Blast::AuthoringResult& ares, 

-	Nv::Blast::ConvexMeshBuilder& collisionBuilder, 

-	const Nv::Blast::CollisionParams& collisionParam, 

-	uint32_t chunksToProcessCount,

-	uint32_t* chunksToProcess

-);

+NVBLAST_API void NvBlastExtAuthoringBuildCollisionMeshes(Nv::Blast::AuthoringResult& ares,

+                                                         Nv::Blast::ConvexMeshBuilder& collisionBuilder,

+                                                         const Nv::Blast::ConvexDecompositionParams& collisionParam,

+                                                         uint32_t chunksToProcessCount, uint32_t* chunksToProcess);

 

 /**

-	Creates MeshCleaner object

-	\return pointer to Nv::Blast::Mesh if it was created succefully otherwise return nullptr

+    Creates MeshCleaner object

+    \return pointer to Nv::Blast::Mesh if it was created succefully otherwise return nullptr

 */

 NVBLAST_API Nv::Blast::MeshCleaner* NvBlastExtAuthoringCreateMeshCleaner();

 

@@ -245,43 +270,38 @@ NOTE: This function allocates memory using the allocator in NvBlastGlobals, to c
 descriptor arrays returned. The user must free this memory after use with NVBLAST_FREE

 

 \param[in]	components			An array of assets to merge, of size componentCount.

-\param[in]	scales				If not NULL, an array of size componentCount of scales to apply to the geometric data in the chunks and bonds. If NULL, no scaling is applied.

-\param[in]	rotations			If not NULL, an array of size componentCount of rotations to apply to the geometric data in the chunks and bonds.  The quaternions MUST be normalized.

-								If NULL, no rotations are applied.

-\param[in]	translations		If not NULL, an array of of size componentCount of translations to apply to the geometric data in the chunks and bonds.  If NULL, no translations are applied.

-\param[in]	convexHullOffsets	For each component, an array of chunkSize+1 specifying the start of the convex hulls for that chunk inside the chunkHulls array for that component.

-\param[in]	chunkHulls			For each component, an array of CollisionHull* specifying the collision geometry for the chunks in that component.

-\param[in]	componentCount		The size of the components and relativeTransforms arrays.

+\param[in]	scales				If not NULL, an array of size componentCount of scales to apply to the geometric data in

+the chunks and bonds. If NULL, no scaling is applied. \param[in]	rotations			If not NULL, an array of size

+componentCount of rotations to apply to the geometric data in the chunks and bonds.  The quaternions MUST be normalized.

+                                If NULL, no rotations are applied.

+\param[in]	translations		If not NULL, an array of of size componentCount of translations to apply to the

+geometric data in the chunks and bonds.  If NULL, no translations are applied. \param[in]	convexHullOffsets	For each

+component, an array of chunkSize+1 specifying the start of the convex hulls for that chunk inside the chunkHulls array

+for that component. \param[in]	chunkHulls			For each component, an array of CollisionHull* specifying the

+collision geometry for the chunks in that component. \param[in]	componentCount		The size of the components and

+relativeTransforms arrays.

 \param[out]	newBondDescs		Descriptors of type NvBlastExtAssetUtilsBondDesc for new bonds between components.

 \param[in]	maxSeparation		Maximal distance between chunks which can be connected by bond.

 \return the number of bonds in newBondDescs

 */

-NVBLAST_API uint32_t NvBlastExtAuthoringFindAssetConnectingBonds

-(

-	const NvBlastAsset** components,

-	const physx::PxVec3* scales,

-	const physx::PxQuat* rotations,

-	const physx::PxVec3* translations,

-	const uint32_t** convexHullOffsets,

-	const Nv::Blast::CollisionHull*** chunkHulls,

-	uint32_t componentCount,

-	NvBlastExtAssetUtilsBondDesc*& newBondDescs,

-	float maxSeparation = 0.0f

-);

+NVBLAST_API uint32_t NvBlastExtAuthoringFindAssetConnectingBonds(

+    const NvBlastAsset** components, const NvcVec3* scales, const NvcQuat* rotations, const NvcVec3* translations,

+    const uint32_t** convexHullOffsets, const Nv::Blast::CollisionHull*** chunkHulls, uint32_t componentCount,

+    NvBlastExtAssetUtilsBondDesc*& newBondDescs, float maxSeparation = 0.0f);

 

 /**

-Returns pattern generator used for generating fracture patterns for Real Time (RT) fracture

+Returns pattern generator used for generating fracture patterns.

 */

 NVBLAST_API Nv::Blast::PatternGenerator* NvBlastExtAuthoringCreatePatternGenerator();

 

 /**

-TODO

+Create spatial grid for mesh.

 */

 NVBLAST_API Nv::Blast::Grid* NvBlastExtAuthoringCreateGridAccelerator(uint32_t resolution, const Nv::Blast::Mesh* m);

 

 /**

-TODO

+Create GridWalker - SpatialAccelerator which use Grid for faster mesh sampling.

 */

 NVBLAST_API Nv::Blast::GridWalker* NvBlastExtAuthoringCreateGridWalker(Nv::Blast::Grid* parent);

 

-#endif // ifndef NVBLASTAUTHORING_H

+#endif  // ifndef NVBLASTAUTHORING_H

diff --git a/sdk/extensions/authoring/include/NvBlastExtAuthoringBondGenerator.h b/sdk/extensions/authoring/include/NvBlastExtAuthoringBondGenerator.h
index 55e252e..6345e6d 100755
--- a/sdk/extensions/authoring/include/NvBlastExtAuthoringBondGenerator.h
+++ b/sdk/extensions/authoring/include/NvBlastExtAuthoringBondGenerator.h
@@ -31,13 +31,6 @@
 

 #include "NvBlastExtAuthoringTypes.h"

 

-namespace physx

-{

-class PxPlane;

-class PxCooking;

-class PxPhysicsInsertionCallback;

-}

-

 struct NvBlastBondDesc;

 struct NvBlastChunkDesc;

 struct NvBlastBond;

@@ -68,10 +61,9 @@ struct BondGenerationConfig
 

 struct PlaneChunkIndexer

 {

-	PlaneChunkIndexer(int32_t chunkId, int32_t trId, physx::PxPlane pl) : chunkId(chunkId), trId(trId), plane(pl) {}

 	int32_t chunkId;

 	int32_t trId;

-	physx::PxPlane plane;

+	NvcPlane plane;

 };

 

 

diff --git a/sdk/extensions/authoring/include/NvBlastExtAuthoringCollisionBuilder.h b/sdk/extensions/authoring/include/NvBlastExtAuthoringCollisionBuilder.h
deleted file mode 100755
index d174850..0000000
--- a/sdk/extensions/authoring/include/NvBlastExtAuthoringCollisionBuilder.h
+++ /dev/null
@@ -1,141 +0,0 @@
-// 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 NVBLASTEXTAUTHORINGCOLLISIONBUILDER_H

-#define NVBLASTEXTAUTHORINGCOLLISIONBUILDER_H

-

-#include "NvBlastTypes.h"

-

-namespace physx

-{

-class PxCooking;

-class PxPhysicsInsertionCallback;

-class PxVec3;

-class PxConvexMesh;

-}

-

-

-namespace Nv

-{

-namespace Blast

-{

-

-struct CollisionHull;

-struct Triangle;

-struct Vertex;

-

-struct CollisionParams

-{

-	CollisionParams()

-	{

-		setDefault();

-	}

-	void setDefault()

-	{

-		maximumNumberOfHulls = 8;

-		maximumNumberOfVerticesPerHull = 64;

-		voxelGridResolution = 1000000;

-		concavity = 0.0025f;

-	}

-	uint32_t maximumNumberOfHulls; // Maximum number of convex hull generated for one chunk. If equal to 1 convex decomposition is disabled.

-	uint32_t maximumNumberOfVerticesPerHull; // Controls the maximum number of triangles per convex-hull (default=64, range=4-1024)

-	uint32_t voxelGridResolution; // Voxel grid resolution used for chunk convex decomposition (default=1,000,000, range=10,000-16,000,000).

-	float concavity; // Value between 0 and 1, controls how accurate hull generation is

-};

-

-/**

-	ConvexMeshBuilder provides routine to build collision hulls from array of vertices.

-	Collision hull is built as convex hull of provided point set.

-	If due to some reason building of convex hull is failed, collision hull is built as bounding box of vertex set.

-*/

-class ConvexMeshBuilder

-{

-public:

-	virtual ~ConvexMeshBuilder() {}

-

-	/**

-	Release ConvexMeshBuilder memory

-	*/

-	virtual void					release() = 0;

-

-	/**

-		Method creates CollisionHull from provided array of vertices.

-		\param[in]  verticesCount	Number of vertices

-		\param[in]	vertexData		Vertex array of some object, for which collision geometry should be built

-		\param[out] output			Reference on CollisionHull object in which generated geometry should be saved

-	*/

-	virtual CollisionHull*			buildCollisionGeometry(uint32_t verticesCount, const physx::PxVec3* vertexData) = 0;

-

-	/**

-	Method creates PxConvexMesh from provided array of vertices.

-	\param[in]  verticesCount		Number of vertices

-	\param[in]	vertexData			Vertex array of some object, for which collision geometry should be built

-

-	\return pointer to the PxConvexMesh object if it was built successfully, 'nullptr' otherwise.

-	*/

-	virtual physx::PxConvexMesh*	buildConvexMesh(uint32_t verticesCount, const physx::PxVec3* vertexData) = 0;

-

-

-	/**

-		Method creates PxConvexMesh from provided ConvexHull geometry

-		\param[in]	hull			ConvexHull geometry

-

-		\return pointer to the PxConvexMesh object if it was built successfully, 'nullptr' otherwise.

-	*/

-	virtual physx::PxConvexMesh*	buildConvexMesh(const CollisionHull& hull) = 0;

-

-	virtual physx::PxConvexMesh*	buildConvexMeshRT(const Nv::Blast::Vertex* vrs, uint32_t count) = 0;

-

-

-	/**

-		Convex geometry trimming. 

-		Using slicing with noised slicing surface can result in intersecting collision geometry.

-		It leads to unstable behaviour of rigid body simulation. 

-		This method trims all intersecting parts of collision geometry.

-		As a drawback, trimming collision geometry can lead to penetrating render meshes during simulation.

-

-		\param[in]		chunksCount	Number of chunks

-		\param[in,out]	in			ConvexHull geometry which should be clipped. 

-		\param[in]		chunkDepth	Array of depth levels of convex hulls corresponding chunks.

-

-	*/

-	virtual void					trimCollisionGeometry(uint32_t chunksCount, CollisionHull** in, const uint32_t* chunkDepth) = 0;

-

-

-	/**

-		Create mesh convex decomposition

-	*/

-	virtual int32_t					buildMeshConvexDecomposition(const Nv::Blast::Triangle* mesh, uint32_t triangleCount, const CollisionParams& params, CollisionHull** &convexes) = 0;

-

-};

-

-} // namespace Blast

-} // namespace Nv

-

-

-#endif // ifndef NVBLASTEXTAUTHORINGCOLLISIONBUILDER_H

diff --git a/sdk/extensions/authoring/include/NvBlastExtAuthoringCutout.h b/sdk/extensions/authoring/include/NvBlastExtAuthoringCutout.h
index 0702afd..10ffdd0 100755
--- a/sdk/extensions/authoring/include/NvBlastExtAuthoringCutout.h
+++ b/sdk/extensions/authoring/include/NvBlastExtAuthoringCutout.h
@@ -55,7 +55,7 @@ public:
 	Applies to the cutout indexed by cutoutIndex:

 	Returns the vertex indexed by vertexIndex.  (Only the X and Y coordinates are used.)

 	*/

-	virtual const physx::PxVec3&	getCutoutVertex(uint32_t cutoutIndex, uint32_t loopIndex, uint32_t vertexIndex) const = 0;

+	virtual const NvcVec3&			getCutoutVertex(uint32_t cutoutIndex, uint32_t loopIndex, uint32_t vertexIndex) const = 0;

 

 	/**

 	If smoothing group should be changed for adjacent to this vertex faces return true

@@ -70,11 +70,7 @@ public:
 	/**

 	The dimensions of the fracture map used to create the cutout set.

 	*/

-	virtual const physx::PxVec2&	getDimensions() const = 0;

-

-	/** Serialization */

-	//virtual void			serialize(physx::PxFileBuf& stream) const = 0;

-	//virtual void			deserialize(physx::PxFileBuf& stream) = 0;

+	virtual const NvcVec2&			getDimensions() const = 0;

 

 	/** Releases all memory and deletes itself. */

 	virtual void					release() = 0;

diff --git a/sdk/extensions/authoring/include/NvBlastExtAuthoringFractureTool.h b/sdk/extensions/authoring/include/NvBlastExtAuthoringFractureTool.h
index fd3d985..b11851e 100755
--- a/sdk/extensions/authoring/include/NvBlastExtAuthoringFractureTool.h
+++ b/sdk/extensions/authoring/include/NvBlastExtAuthoringFractureTool.h
@@ -42,26 +42,39 @@ class Mesh;
 class CutoutSet;

 

 /*

-	Chunk data, chunk with chunkId == 0 is always source mesh.

+    Chunk data, chunk with chunkId == 0 is always source mesh.

 */

 struct ChunkInfo

 {

 	enum ChunkFlags

 	{

-		NO_FLAGS = 0,

+		NO_FLAGS                   = 0,

 		CREATED_BY_ISLAND_DETECTOR = 1

 	};

 

-	Mesh*	meshData;

-	int32_t	parent;

-	int32_t	chunkId;

+	Mesh* meshData;

+	int32_t parent;

+	int32_t chunkId;

 	uint32_t flags;

-	bool	isLeaf;

-	bool	isChanged;

+	bool isLeaf;

+	bool isChanged;

+};

+

+/**

+    Abstract base class for user-defined random value generator.

+*/

+class RandomGeneratorBase

+{

+  public:

+	// Generates uniformly distributed value in [0, 1] range.

+	virtual float getRandomValue() = 0;

+	// Seeds random value generator

+	virtual void seed(int32_t seed) = 0;

+	virtual ~RandomGeneratorBase(){};

 };

 

 /*

-	Noise fracturing configuration for chunks's faces

+    Noise fracturing configuration for chunks's faces

 */

 struct NoiseConfiguration

 {

@@ -70,12 +83,12 @@ struct NoiseConfiguration
 

 	Amplitude of cutting surface noise. If it is 0 - noise is disabled.

 	*/

-	float	amplitude = 0.f;

+	float amplitude = 0.f;

 

 	/**

 	Frequencey of cutting surface noise.

 	*/

-	float	frequency = 1.f;

+	float frequency = 1.f;

 

 	/**

 	Octave number in slicing surface noise.

@@ -85,65 +98,67 @@ struct NoiseConfiguration
 	/**

 	Sampling interval for surface grid.

 	*/

-	physx::PxVec3 samplingInterval = physx::PxVec3(1.f);

+	NvcVec3 samplingInterval = { 1, 1, 1 };

 };

 

 /*

-	Slicing fracturing configuration

+    Slicing fracturing configuration

 */

 struct SlicingConfiguration

 {

 	/**

-		Number of slices in each direction

+	    Number of slices in each direction

 	*/

-	int32_t	x_slices = 1, y_slices = 1, z_slices = 1;

+	int32_t x_slices = 1, y_slices = 1, z_slices = 1;

 

 	/**

-		Offset variation, value in [0, 1]

+	    Offset variation, value in [0, 1]

 	*/

-	float	offset_variations = 0.f;

+	float offset_variations = 0.f;

 

 	/**

-		Angle variation, value in [0, 1]

+	    Angle variation, value in [0, 1]

 	*/

-	float	angle_variations = 0.f;

+	float angle_variations = 0.f;

 

 	/*

-		Noise parameters for faces between sliced chunks

+	    Noise parameters for faces between sliced chunks

 	*/

 	NoiseConfiguration noise;

 };

 

 /**

-	Cutout fracturing configuration

+    Cutout fracturing configuration

 */

 struct CutoutConfiguration

 {

 	/**

-		Set of grouped convex loop patterns for cutout in normal direction.

-		Not required for PLANE_ONLY mode

+	    Set of grouped convex loop patterns for cutout in normal direction.

+	    Not required for PLANE_ONLY mode

 	*/

 	CutoutSet* cutoutSet = nullptr;

 

 	/**

-		Transform for initial pattern position and orientation.

-		By default 2d pattern lies in XY plane (Y is up) the center of pattern is (0, 0)

+	    Transform for initial pattern position and orientation.

+	    By default 2d pattern lies in XY plane (Y is up) the center of pattern is (0, 0)

 	*/

-	physx::PxTransform transform = physx::PxTransform(physx::PxIdentity);

+	NvcTransform transform = {{0, 0, 0, 1}, {0, 0, 0}};

 

 	/**

-		Scale for pattern. Unscaled pattern has size (1, 1).

-		For negative scale pattern will be placed at the center of chunk and scaled with max distance between points of its AABB

+	    Scale for pattern. Unscaled pattern has size (1, 1).

+	    For negative scale pattern will be placed at the center of chunk and scaled with max distance between points of

+	   its AABB

 	*/

-	physx::PxVec2 scale = physx::PxVec2(-1, -1);

+	NvcVec2 scale = { -1, -1 };

 

 	/**

-		Conic aperture in degree, for cylindric cutout set it to 0.

+	    Conic aperture in degree, for cylindric cutout set it to 0.

 	*/

 	float aperture = 0.f;

 

 	/**

-		If relative transform is set - position will be displacement vector from chunk's center. Otherwise from global origin.

+	    If relative transform is set - position will be displacement vector from chunk's center. Otherwise from global

+	   origin.

 	*/

 	bool isRelativeTransform = true;

 

@@ -153,347 +168,361 @@ struct CutoutConfiguration
 	bool useSmoothing = false;

 

 	/**

-		Noise parameters for cutout surface, see NoiseConfiguration.

+	    Noise parameters for cutout surface, see NoiseConfiguration.

 	*/

 	NoiseConfiguration noise;

 };

 

 /**

-	Class for voronoi sites generation inside supplied mesh.

+    Class for voronoi sites generation inside supplied mesh.

 */

 class VoronoiSitesGenerator

 {

-public:

+  public:

 	virtual ~VoronoiSitesGenerator() {}

 

 	/**

-		Release VoronoiSitesGenerator memory

+	    Release VoronoiSitesGenerator memory

 	*/

-	virtual void						release() = 0;

+	virtual void release() = 0;

 

 	/**

-		Set base fracture mesh

+	    Set base fracture mesh

 	*/

-	virtual void						setBaseMesh(const Mesh* mesh) = 0;

+	virtual void setBaseMesh(const Mesh* mesh) = 0;

 

 	/**

-		Access to generated voronoi sites.

-		\param[out]				Pointer to generated voronoi sites

-		\return					Count of generated voronoi sites.

+	    Access to generated voronoi sites.

+	    \param[out]				Pointer to generated voronoi sites

+	    \return					Count of generated voronoi sites.

 	*/

-	virtual uint32_t					getVoronoiSites(const physx::PxVec3*& sites) = 0;

-	

+	virtual uint32_t getVoronoiSites(const NvcVec3*& sites) = 0;

+

 	/**

-		Add site in particular point

-		\param[in] site		Site coordinates

+	    Add site in particular point

+	    \param[in] site		Site coordinates

 	*/

-	virtual void						addSite(const physx::PxVec3& site) = 0;

+	virtual void addSite(const NvcVec3& site) = 0;

 	/**

-		Uniformly generate sites inside the mesh

-		\param[in] numberOfSites	Number of generated sites

+	    Uniformly generate sites inside the mesh

+	    \param[in] numberOfSites	Number of generated sites

 	*/

-	virtual void						uniformlyGenerateSitesInMesh(uint32_t numberOfSites) = 0;

+	virtual void uniformlyGenerateSitesInMesh(uint32_t numberOfSites) = 0;

 

 	/**

-		Generate sites in clustered fashion

-		\param[in] numberOfClusters	Number of generated clusters

-		\param[in] sitesPerCluster	Number of sites in each cluster

-		\param[in] clusterRadius	Voronoi cells cluster radius

+	    Generate sites in clustered fashion

+	    \param[in] numberOfClusters	Number of generated clusters

+	    \param[in] sitesPerCluster	Number of sites in each cluster

+	    \param[in] clusterRadius	Voronoi cells cluster radius

 	*/

-	virtual void						clusteredSitesGeneration(uint32_t numberOfClusters, uint32_t sitesPerCluster, float clusterRadius) = 0;

+	virtual void clusteredSitesGeneration(uint32_t numberOfClusters, uint32_t sitesPerCluster, float clusterRadius) = 0;

 

 	/**

-		Radial pattern of sites generation

-		\param[in] center		Center of generated pattern

-		\param[in] normal		Normal to plane in which sites are generated

-		\param[in] radius		Pattern radius

-		\param[in] angularSteps	Number of angular steps

-		\param[in] radialSteps	Number of radial steps

-		\param[in] angleOffset	Angle offset at each radial step

-		\param[in] variability	Randomness of sites distribution 

+	    Radial pattern of sites generation

+	    \param[in] center		Center of generated pattern

+	    \param[in] normal		Normal to plane in which sites are generated

+	    \param[in] radius		Pattern radius

+	    \param[in] angularSteps	Number of angular steps

+	    \param[in] radialSteps	Number of radial steps

+	    \param[in] angleOffset	Angle offset at each radial step

+	    \param[in] variability	Randomness of sites distribution

 	*/

-	virtual void						radialPattern(const physx::PxVec3& center, const physx::PxVec3& normal, float radius, int32_t angularSteps, int32_t radialSteps, float angleOffset = 0.0f, float variability = 0.0f) = 0;

+	virtual void radialPattern(const NvcVec3& center, const NvcVec3& normal, float radius, int32_t angularSteps,

+	                           int32_t radialSteps, float angleOffset = 0.0f, float variability = 0.0f) = 0;

 

 	/**

-		Generate sites inside sphere

-		\param[in] count		Count of generated sites

-		\param[in] radius		Radius of sphere

-		\param[in] center		Center of sphere

+	    Generate sites inside sphere

+	    \param[in] count		Count of generated sites

+	    \param[in] radius		Radius of sphere

+	    \param[in] center		Center of sphere

 	*/

-	virtual void						generateInSphere(const uint32_t count, const float radius, const physx::PxVec3& center) = 0;

+	virtual void generateInSphere(const uint32_t count, const float radius, const NvcVec3& center) = 0;

 

 	/**

-		Set stencil mesh. With stencil mesh sites are generated only inside both of fracture and stencil meshes. 

-		\param[in] stencil		Stencil mesh.

+	    Set stencil mesh. With stencil mesh sites are generated only inside both of fracture and stencil meshes.

+	    \param[in] stencil		Stencil mesh.

 	*/

-	virtual void						setStencil(const Mesh* stencil) = 0;

+	virtual void setStencil(const Mesh* stencil) = 0;

 

 	/**

-		Removes stencil mesh

+	    Removes stencil mesh

 	*/

-	virtual void						clearStencil() = 0;

+	virtual void clearStencil() = 0;

 

-	/** 

-		Deletes sites inside supplied sphere

-		\param[in] radius				Radius of sphere

-		\param[in] center				Center of sphere

-		\param[in] eraserProbability	Probability of removing some particular site

+	/**

+	    Deletes sites inside supplied sphere

+	    \param[in] radius				Radius of sphere

+	    \param[in] center				Center of sphere

+	    \param[in] eraserProbability	Probability of removing some particular site

 	*/

-	virtual void						deleteInSphere(const float radius, const physx::PxVec3& center, const float eraserProbability = 1) = 0;

+	virtual void deleteInSphere(const float radius, const NvcVec3& center, const float eraserProbability = 1) = 0;

 };

 

 /**

-	FractureTool class provides methods to fracture provided mesh and generate Blast asset data

+    FractureTool class provides methods to fracture provided mesh and generate Blast asset data

 */

 class FractureTool

 {

 

-public:

+  public:

 	virtual ~FractureTool() {}

 

 	/**

-		Release FractureTool memory

+	    Release FractureTool memory

 	*/

-	virtual void									release() = 0;

+	virtual void release() = 0;

 

 	/**

-		Reset FractureTool state.

+	    Reset FractureTool state.

 	*/

-	virtual void									reset() = 0;

-	

-	

+	virtual void reset() = 0;

+

+

 	/**

-		Set input mesh which will be fractured, FractureTool will be reseted.

+	    Set input mesh which will be fractured, FractureTool will be reseted.

 	*/

-	virtual void									setSourceMesh(const Mesh* mesh) = 0;

+	virtual void setSourceMesh(const Mesh* mesh) = 0;

 

 	/**

-		Set chunk mesh, parentId should be valid, return id of new chunk.

+	    Set chunk mesh, parentId should be valid, return id of new chunk.

 	*/

-	virtual int32_t									setChunkMesh(const Mesh* mesh, int32_t parentId) = 0;

+	virtual int32_t setChunkMesh(const Mesh* mesh, int32_t parentId) = 0;

 

 	/**

-	Set the material id to use for new interior faces. Defaults to MATERIAL_INTERIOR

+	Set the material id to use for new interior faces. Defaults to kMaterialInteriorId

 	*/

-	virtual void									setInteriorMaterialId(int32_t materialId) = 0;

+	virtual void setInteriorMaterialId(int32_t materialId) = 0;

 

 	/**

 	Gets the material id to use for new interior faces

 	*/

-	virtual int32_t									getInteriorMaterialId() const = 0;

+	virtual int32_t getInteriorMaterialId() const = 0;

 

 	/**

 	Replaces an material id on faces with a new one

 	*/

-	virtual void									replaceMaterialId(int32_t oldMaterialId, int32_t newMaterialId) = 0;

+	virtual void replaceMaterialId(int32_t oldMaterialId, int32_t newMaterialId) = 0;

 

 	/**

-		Get chunk mesh in polygonal representation. User's code should release it after usage.

+	    Get chunk mesh in polygonal representation. User's code should release it after usage.

 	*/

-	virtual Mesh*									createChunkMesh(int32_t chunkId) = 0;

+	virtual Mesh* createChunkMesh(int32_t chunkId) = 0;

 

 	/**

-		Input mesh is scaled and transformed internally to fit unit cube centered in origin.

-		Method provides offset vector and scale parameter;

+	    Input mesh is scaled and transformed internally to fit unit cube centered in origin.

+	    Method provides offset vector and scale parameter;

 	*/

-	virtual void									getTransformation(physx::PxVec3& offset, float& scale) = 0;

+	virtual void getTransformation(NvcVec3& offset, float& scale) = 0;

 

 

 	/**

-		Fractures specified chunk with voronoi method.

-		\param[in] chunkId				Chunk to fracture

-		\param[in] cellPoints			Array of voronoi sites

-		\param[in] replaceChunk			if 'true', newly generated chunks will replace source chunk, if 'false', newly generated chunks will be at next depth level, source chunk will be parent for them.

-										Case replaceChunk == true && chunkId == 0 considered as wrong input parameters

-		\return   If 0, fracturing is successful.

+	    Fractures specified chunk with voronoi method.

+	    \param[in] chunkId				Chunk to fracture

+	    \param[in] cellPoints			Array of voronoi sites

+	    \param[in] replaceChunk			if 'true', newly generated chunks will replace source chunk, if 'false', newly

+	   generated chunks will be at next depth level, source chunk will be parent for them. Case replaceChunk == true &&

+	   chunkId == 0 considered as wrong input parameters \return   If 0, fracturing is successful.

 	*/

-	virtual int32_t									voronoiFracturing(uint32_t chunkId, uint32_t cellCount, const physx::PxVec3* cellPoints, bool replaceChunk) = 0;

+	virtual int32_t

+	voronoiFracturing(uint32_t chunkId, uint32_t cellCount, const NvcVec3* cellPoints, bool replaceChunk) = 0;

 

 	/**

-		Fractures specified chunk with voronoi method. Cells can be scaled along x,y,z axes.

-		\param[in] chunkId				Chunk to fracture

-		\param[in] cellPoints			Array of voronoi sites

-		\param[in] cellPoints			Array of voronoi sites

-		\param[in] scale				Voronoi cells scaling factor

-		\param[in] rotation				Voronoi cells rotation. Has no effect without cells scale factor

-		\param[in] replaceChunk			if 'true', newly generated chunks will replace source chunk, if 'false', newly generated chunks will be at next depth level, source chunk will be parent for them.

-									    Case replaceChunk == true && chunkId == 0 considered as wrong input parameters

-		\return   If 0, fracturing is successful.

+	    Fractures specified chunk with voronoi method. Cells can be scaled along x,y,z axes.

+	    \param[in] chunkId				Chunk to fracture

+	    \param[in] cellPoints			Array of voronoi sites

+	    \param[in] cellPoints			Array of voronoi sites

+	    \param[in] scale				Voronoi cells scaling factor

+	    \param[in] rotation				Voronoi cells rotation. Has no effect without cells scale factor

+	    \param[in] replaceChunk			if 'true', newly generated chunks will replace source chunk, if 'false', newly

+	   generated chunks will be at next depth level, source chunk will be parent for them. Case replaceChunk == true &&

+	   chunkId == 0 considered as wrong input parameters \return   If 0, fracturing is successful.

 	*/

-	virtual int32_t									voronoiFracturing(uint32_t chunkId, uint32_t cellCount, const physx::PxVec3* cellPoints, const physx::PxVec3& scale, const physx::PxQuat& rotation, bool replaceChunk) = 0;

+	virtual int32_t voronoiFracturing(uint32_t chunkId, uint32_t cellCount, const NvcVec3* cellPoints,

+	                                  const NvcVec3& scale, const NvcQuat& rotation, bool replaceChunk) = 0;

 

 

 	/**

-		Fractures specified chunk with slicing method.

-		\param[in] chunkId				Chunk to fracture

-		\param[in] conf					Slicing parameters, see SlicingConfiguration.

-		\param[in] replaceChunk			if 'true', newly generated chunks will replace source chunk, if 'false', newly generated chunks will be at next depth level, source chunk will be parent for them.

-										Case replaceChunk == true && chunkId == 0 considered as wrong input parameters

-		\param[in] rnd					User supplied random number generator

+	    Fractures specified chunk with slicing method.

+	    \param[in] chunkId				Chunk to fracture

+	    \param[in] conf					Slicing parameters, see SlicingConfiguration.

+	    \param[in] replaceChunk			if 'true', newly generated chunks will replace source chunk, if 'false', newly

+	   generated chunks will be at next depth level, source chunk will be parent for them. Case replaceChunk == true &&

+	   chunkId == 0 considered as wrong input parameters \param[in] rnd					User supplied random number

+	   generator

 

-		\return   If 0, fracturing is successful.

+	    \return   If 0, fracturing is successful.

 	*/

-	virtual int32_t									slicing(uint32_t chunkId, const SlicingConfiguration& conf, bool replaceChunk, RandomGeneratorBase* rnd) = 0;

+	virtual int32_t

+	slicing(uint32_t chunkId, const SlicingConfiguration& conf, bool replaceChunk, RandomGeneratorBase* rnd) = 0;

 

 	/**

-		Cut chunk with plane.

-		\param[in] chunkId				Chunk to fracture

-		\param[in] normal				Plane normal

-		\param[in] position				Point on plane

-		\param[in] noise				Noise configuration for plane-chunk intersection, see NoiseConfiguration.

-		\param[in] replaceChunk			if 'true', newly generated chunks will replace source chunk, if 'false', newly generated chunks will be at next depth level, source chunk will be parent for them.

-		Case replaceChunk == true && chunkId == 0 considered as wrong input parameters

-		\param[in] rnd					User supplied random number generator

+	    Cut chunk with plane.

+	    \param[in] chunkId				Chunk to fracture

+	    \param[in] normal				Plane normal

+	    \param[in] position				Point on plane

+	    \param[in] noise				Noise configuration for plane-chunk intersection, see NoiseConfiguration.

+	    \param[in] replaceChunk			if 'true', newly generated chunks will replace source chunk, if 'false', newly

+	   generated chunks will be at next depth level, source chunk will be parent for them. Case replaceChunk == true &&

+	   chunkId == 0 considered as wrong input parameters \param[in] rnd					User supplied random number

+	   generator

 

-		\return   If 0, fracturing is successful.

+	    \return   If 0, fracturing is successful.

 	*/

-	virtual int32_t									cut(uint32_t chunkId, const physx::PxVec3& normal, const physx::PxVec3& position, const NoiseConfiguration& noise, bool replaceChunk, RandomGeneratorBase* rnd) = 0;

+	virtual int32_t cut(uint32_t chunkId, const NvcVec3& normal, const NvcVec3& position,

+	                    const NoiseConfiguration& noise, bool replaceChunk, RandomGeneratorBase* rnd) = 0;

 

 	/**

-		Cutout fracture for specified chunk.

-		\param[in] chunkId				Chunk to fracture

-		\param[in] conf					Cutout parameters, see CutoutConfiguration.

-		\param[in] replaceChunk			if 'true', newly generated chunks will replace source chunk, if 'false', newly generated chunks will be at next depth level, source chunk will be parent for them.

-										Case replaceChunk == true && chunkId == 0 considered as wrong input parameters

-		\param[in] rnd					User supplied random number generator

+	    Cutout fracture for specified chunk.

+	    \param[in] chunkId				Chunk to fracture

+	    \param[in] conf					Cutout parameters, see CutoutConfiguration.

+	    \param[in] replaceChunk			if 'true', newly generated chunks will replace source chunk, if 'false', newly

+	   generated chunks will be at next depth level, source chunk will be parent for them. Case replaceChunk == true &&

+	   chunkId == 0 considered as wrong input parameters \param[in] rnd					User supplied random number

+	   generator

 

-		\return   If 0, fracturing is successful.

+	    \return   If 0, fracturing is successful.

 	*/

-	virtual int32_t									cutout(uint32_t chunkId, CutoutConfiguration conf, bool replaceChunk, RandomGeneratorBase* rnd) = 0;

+	virtual int32_t cutout(uint32_t chunkId, CutoutConfiguration conf, bool replaceChunk, RandomGeneratorBase* rnd) = 0;

 

 

 	/**

-		Creates resulting fractured mesh geometry from intermediate format

+	    Creates resulting fractured mesh geometry from intermediate format

 	*/

-	virtual void									finalizeFracturing() = 0;

-	

+	virtual void finalizeFracturing() = 0;

+

 	/**

-		Returns overall number of chunks in fracture.

+	    Returns overall number of chunks in fracture.

 	*/

-	virtual uint32_t								getChunkCount() const = 0;

+	virtual uint32_t getChunkCount() const = 0;

 

 	/**

-		Get chunk information

+	    Get chunk information

 	*/

-	virtual const ChunkInfo&    					getChunkInfo(int32_t chunkIndex) = 0;

+	virtual const ChunkInfo& getChunkInfo(int32_t chunkIndex) = 0;

 

 	/**

-		Get percentage of mesh overlap.

-		percentage computed as volume(intersection(meshA , meshB)) / volume (meshA) 

-		\param[in] meshA Mesh A

-		\param[in] meshB Mesh B

-		\return mesh overlap percentage

+	    Get percentage of mesh overlap.

+	    percentage computed as volume(intersection(meshA , meshB)) / volume (meshA)

+	    \param[in] meshA Mesh A

+	    \param[in] meshB Mesh B

+	    \return mesh overlap percentage

 	*/

-	virtual float									getMeshOverlap(const Mesh& meshA, const Mesh& meshB) = 0;

+	virtual float getMeshOverlap(const Mesh& meshA, const Mesh& meshB) = 0;

 

 	/**

-		Get chunk base mesh

-		\param[in] chunkIndex Chunk index

-		\param[out] output Array of triangles to be filled

-		\return number of triangles in base mesh

+	    Get chunk base mesh

+	    \param[in] chunkIndex Chunk index

+	    \param[out] output Array of triangles to be filled

+	    \return number of triangles in base mesh

 	*/

-	virtual uint32_t								getBaseMesh(int32_t chunkIndex, Triangle*& output) = 0;

+	virtual uint32_t getBaseMesh(int32_t chunkIndex, Triangle*& output) = 0;

 

 	/**

-		Update chunk base mesh

-		\note Doesn't allocates output array, Triangle* output should be preallocated by user

-		\param[in] chunkIndex Chunk index

-		\param[out] output Array of triangles to be filled

-		\return number of triangles in base mesh

+	    Update chunk base mesh

+	    \note Doesn't allocates output array, Triangle* output should be preallocated by user

+	    \param[in] chunkIndex Chunk index

+	    \param[out] output Array of triangles to be filled

+	    \return number of triangles in base mesh

 	*/

-	virtual uint32_t								updateBaseMesh(int32_t chunkIndex, Triangle* output) = 0;

+	virtual uint32_t updateBaseMesh(int32_t chunkIndex, Triangle* output) = 0;

 

 	/**

-		Return index of chunk with specified chunkId

-		\param[in] chunkId Chunk ID

-		\return Chunk index in internal buffer, if not exist -1 is returned.

+	    Return index of chunk with specified chunkId

+	    \param[in] chunkId Chunk ID

+	    \return Chunk index in internal buffer, if not exist -1 is returned.

 	*/

-	virtual int32_t									getChunkIndex(int32_t chunkId) = 0;

+	virtual int32_t getChunkIndex(int32_t chunkId) = 0;

 

 	/**

-		Return id of chunk with specified index.

-		\param[in] chunkIndex Chunk index

-		\return Chunk id or -1 if there is no such chunk.

+	    Return id of chunk with specified index.

+	    \param[in] chunkIndex Chunk index

+	    \return Chunk id or -1 if there is no such chunk.

 	*/

-	virtual int32_t									getChunkId(int32_t chunkIndex) = 0;

+	virtual int32_t getChunkId(int32_t chunkIndex) = 0;

 

 	/**

-		Return depth level of the given chunk

-		\param[in] chunkId Chunk ID

-		\return Chunk depth or -1 if there is no such chunk.

+	    Return depth level of the given chunk

+	    \param[in] chunkId Chunk ID

+	    \return Chunk depth or -1 if there is no such chunk.

 	*/

-	virtual int32_t									getChunkDepth(int32_t chunkId) = 0;

+	virtual int32_t getChunkDepth(int32_t chunkId) = 0;

 

 	/**

-		Return array of chunks IDs with given depth.

-		\param[in]  depth Chunk depth

-		\param[out] Pointer to array of chunk IDs

-		\return Number of chunks in array

+	    Return array of chunks IDs with given depth.

+	    \param[in]  depth Chunk depth

+	    \param[out] Pointer to array of chunk IDs

+	    \return Number of chunks in array

 	*/

-	virtual uint32_t								getChunksIdAtDepth(uint32_t depth, int32_t*& chunkIds) = 0;

+	virtual uint32_t getChunksIdAtDepth(uint32_t depth, int32_t*& chunkIds) = 0;

 

 	/**

-		Get result geometry without noise as vertex and index buffers, where index buffers contain series of triplets

-		which represent triangles.

-		\param[out] vertexBuffer Array of vertices to be filled

-		\param[out] indexBuffer Array of indices to be filled

-		\param[out] indexBufferOffsets Array of offsets in indexBuffer for each base mesh. 

-					Contains getChunkCount() + 1 elements. Last one is indexBuffer size

-		\return Number of vertices in vertexBuffer

+	    Get result geometry without noise as vertex and index buffers, where index buffers contain series of triplets

+	    which represent triangles.

+	    \param[out] vertexBuffer Array of vertices to be filled

+	    \param[out] indexBuffer Array of indices to be filled

+	    \param[out] indexBufferOffsets Array of offsets in indexBuffer for each base mesh.

+	                Contains getChunkCount() + 1 elements. Last one is indexBuffer size

+	    \return Number of vertices in vertexBuffer

 	*/

-	virtual uint32_t								getBufferedBaseMeshes(Vertex*& vertexBuffer, uint32_t*& indexBuffer, uint32_t*& indexBufferOffsets) = 0;

+	virtual uint32_t

+	getBufferedBaseMeshes(Vertex*& vertexBuffer, uint32_t*& indexBuffer, uint32_t*& indexBufferOffsets) = 0;

 

 	/**

-		Set automatic islands removing. May cause instabilities.

-		\param[in] isRemoveIslands Flag whether remove or not islands.

+	    Set automatic islands removing. May cause instabilities.

+	    \param[in] isRemoveIslands Flag whether remove or not islands.

 	*/

-	virtual void									setRemoveIslands(bool isRemoveIslands) = 0;

+	virtual void setRemoveIslands(bool isRemoveIslands) = 0;

 

 	/**

-		Try find islands and remove them on some specifical chunk. If chunk has childs, island removing can lead to wrong results! Apply it before further chunk splitting.

-		\param[in] chunkId Chunk ID which should be checked for islands

-		\return Number of found islands is returned

+	    Try find islands and remove them on some specifical chunk. If chunk has childs, island removing can lead to

+	   wrong results! Apply it before further chunk splitting. \param[in] chunkId Chunk ID which should be checked for

+	   islands \return Number of found islands is returned

 	*/

-	virtual int32_t									islandDetectionAndRemoving(int32_t chunkId, bool createAtNewDepth = false) = 0;

+	virtual int32_t islandDetectionAndRemoving(int32_t chunkId, bool createAtNewDepth = false) = 0;

 

 	/**

-		Check if input mesh contains open edges. Open edges can lead to wrong fracturing results.

-		\return true if mesh contains open edges

+	    Check if input mesh contains open edges. Open edges can lead to wrong fracturing results.

+	    \return true if mesh contains open edges

 	*/

-	virtual bool									isMeshContainOpenEdges(const Mesh* input) = 0;

+	virtual bool isMeshContainOpenEdges(const Mesh* input) = 0;

 

 	/**

-		Delete all children for specified chunk (also recursively delete chidren of children).

-		\param[in] chunkId Chunk ID which children should be deleted

-		\return true if one or more chunks were removed

+	    Delete all children for specified chunk (also recursively delete chidren of children).

+	    \param[in] chunkId Chunk ID which children should be deleted

+	    \return true if one or more chunks were removed

 	*/

-	virtual bool									deleteAllChildrenOfChunk(int32_t chunkId) = 0;

+	virtual bool deleteAllChildrenOfChunk(int32_t chunkId) = 0;

 

 	/**

-		Optimize chunk hierarhy for better runtime performance. 

-		It tries to unite chunks to groups of some size in order to transform flat hierarchy (all chunks are children of single root) 

-		to tree like hieracrhy with limited number of children for each chunk.

-		\param[in] maxAtLevel	If number of children of some chunk less then maxAtLevel then it would be considered as already optimized and skipped.

-		\param[in] maxGroupSize	Max number of children for processed chunks.

+	    Optimize chunk hierarhy for better runtime performance.

+	    It tries to unite chunks to groups of some size in order to transform flat hierarchy (all chunks are children of

+	    single root) to tree like hieracrhy with limited number of children for each chunk.

+        \param[in] maxAtLevel	If number of children of some chunk less then maxAtLevel then it would be considered as already

+            optimized and skipped.

+        \param[in] maxGroupSize Max number of children for processed chunks. \param[in] removeOriginalChunks.

+        \param[in] adjChunks    Optional index pairs to describe chunk adjacency.  May be NULL.

+        \param[in] adjChunksSize If 'adjChunks' is not NULL, the number of index pairs in the adjChunks array.

+        \param[in] removeOriginalChunks If true, original chunks that are merged are removed.

 	*/

-	virtual void									uniteChunks(uint32_t maxAtLevel, uint32_t maxGroupSize) = 0;

+	virtual void uniteChunks(uint32_t maxAtLevel, uint32_t maxGroupSize,

+                             const NvcVec2i* adjChunks, uint32_t adjChunksSize,

+	                         bool removeOriginalChunks = false) = 0;

 

 	/**

-		Rescale interior uv coordinates of given chunk to fit square of given size.

-		\param[in] side Size of square side

-		\param[in] chunkId Chunk ID for which UVs should be scaled.

+	    Rescale interior uv coordinates of given chunk to fit square of given size.

+	    \param[in] side Size of square side

+	    \param[in] chunkId Chunk ID for which UVs should be scaled.

 	*/

-	virtual void									fitUvToRect(float side, uint32_t chunkId) = 0;

+	virtual void fitUvToRect(float side, uint32_t chunkId) = 0;

 

 	/**

-		Rescale interior uv coordinates of all existing chunks to fit square of given size, relative sizes will be preserved.

-		\param[in] side Size of square side

+	    Rescale interior uv coordinates of all existing chunks to fit square of given size, relative sizes will be

+	   preserved. \param[in] side Size of square side

 	*/

-	virtual void									fitAllUvToRect(float side) = 0;

-

+	virtual void fitAllUvToRect(float side) = 0;

 };

 

-} // namespace Blast

-} // namespace Nv

+}  // namespace Blast

+}  // namespace Nv

 

-#endif // ifndef NVBLASTAUTHORINGFRACTURETOOL_H

+#endif  // ifndef NVBLASTAUTHORINGFRACTURETOOL_H