Blast 1.1.4. See docs/release_notes.txt.v1.1.4_rc1

4 files changed, 832 insertions, 0 deletions

diff --git a/sdk/extensions/authoringCommon/include/NvBlastExtAuthoringAccelerator.h b/sdk/extensions/authoringCommon/include/NvBlastExtAuthoringAccelerator.h
new file mode 100644
index 0000000..fdbc524
--- /dev/null
+++ b/sdk/extensions/authoringCommon/include/NvBlastExtAuthoringAccelerator.h
@@ -0,0 +1,248 @@
+// 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 NVBLASTEXTAUTHORINGACCELERATOR_H
+#define NVBLASTEXTAUTHORINGACCELERATOR_H
+
+#include <set>
+#include <vector>
+#include "NvBlastExtAuthoringTypes.h"
+
+
+namespace Nv
+{
+	namespace Blast
+	{
+
+		class Mesh;
+
+		/**
+			Acceleration structure interface.
+		*/
+		class SpatialAccelerator
+		{
+		public:
+
+			/**
+				Set state of accelerator to return all facets which possibly can intersect given facet bound.
+				\param[in] pos Vertex buffer
+				\param[in] ed Edge buffer
+				\param[in] fc Facet which should be tested.
+			*/
+			virtual void	setState(const physx::PxBounds3* bounds) = 0;
+
+			/**
+				Set state of accelerator to return all facets which possibly can intersect given facet.
+				\param[in] pos Vertex buffer
+				\param[in] ed Edge buffer
+				\param[in] fc Facet which should be tested.
+			*/
+			virtual void	setState(const Vertex* pos, const Edge* ed, const Facet& fc) = 0;
+			/**
+				Set state of accelerator to return all facets which possibly can cover given point. Needed for testing whether point is inside mesh.
+				\param[in] point Point which should be tested.
+			*/
+			virtual void	setState(const physx::PxVec3& point) = 0;
+			/**
+				Recieve next facet for setted state.
+				\return Next facet index, or -1 if no facets left.
+			*/
+			virtual int32_t	getNextFacet() = 0;
+
+
+			virtual void setPointCmpDirection(int32_t dir) = 0;
+			
+			
+			virtual ~SpatialAccelerator() {};
+		};
+
+
+		/**
+			Dummy accelerator iterates through all facets of mesh.
+		*/
+		class DummyAccelerator : public SpatialAccelerator
+		{
+		public:
+			/**
+				\param[in] count Mesh facets count for which accelerator should be built.
+			*/
+			DummyAccelerator(int32_t count);
+			virtual void	setState(const physx::PxBounds3* bounds) override;
+			virtual void setState(const Vertex* pos, const Edge* ed, const Facet& fc) override;
+			virtual void setState(const physx::PxVec3& point) override;
+			virtual int32_t getNextFacet() override;
+
+			virtual void setPointCmpDirection(int32_t dir) override {};
+		private:
+			int32_t count;
+			int32_t current;
+		};
+
+		struct SegmentToIndex
+		{
+			float coord;
+			uint32_t index;
+			bool end;
+
+			SegmentToIndex(float c, uint32_t i, bool end) : coord(c), index(i), end(end) {};
+
+			bool operator<(const SegmentToIndex& in) const
+			{
+				if (coord < in.coord) return true;
+				if (coord > in.coord) return false;
+				return end < in.end;
+			}
+		};
+
+
+
+		class Grid
+		{
+
+		public:
+
+			friend class GridWalker;
+
+			Grid(int32_t resolution);
+			void setMesh(const Nv::Blast::Mesh* m);
+
+		private:
+			int32_t mResolution;
+			int32_t r3;
+			int32_t mappedFacetCount;
+			physx::PxVec3 spos;
+			physx::PxVec3 deltas;
+			std::vector< std::vector<int32_t> > mSpatialMap;
+		};
+
+		class GridWalker : public SpatialAccelerator // Iterator to traverse the grid
+		{
+		public:
+			GridWalker(Grid* grd);
+
+			virtual void	setState(const physx::PxBounds3* bounds) override;
+			virtual void	setState(const Vertex* pos, const Edge* ed, const Facet& fc) override;
+			virtual void	setState(const physx::PxVec3& point) override;
+			virtual int32_t	getNextFacet() override;
+			virtual void	setPointCmpDirection(int32_t dir) override;
+		private:
+			Grid* mGrid;
+
+			// Iterator data
+			std::vector<uint32_t> alreadyGotFlag;
+			uint32_t alreadyGotValue;
+			std::vector<int32_t> cellList;
+			int32_t gotCells;
+			int32_t mIteratorCell;
+			int32_t mIteratorFacet;
+			int32_t pointCmdDir;
+		};
+
+
+		class SweepingAccelerator : public SpatialAccelerator
+		{
+		public:
+			/**
+			\param[in] count Mesh facets count for which accelerator should be built.
+			*/
+			SweepingAccelerator(Nv::Blast::Mesh* in);
+			virtual void setState(const Vertex* pos, const Edge* ed, const Facet& fc) override;
+			virtual void	setState(const physx::PxBounds3* bounds) override;
+			virtual void setState(const physx::PxVec3& point) override;
+			virtual int32_t getNextFacet() override;
+			virtual void setPointCmpDirection(int32_t dir) override {};
+		private:
+
+
+			/*
+				For fast point test.
+			*/
+			std::vector<std::vector<uint32_t> > xSegm;
+			std::vector<std::vector<uint32_t> > ySegm;
+			std::vector<std::vector<uint32_t> > zSegm;
+			std::vector<uint32_t> indices;
+			std::vector<uint32_t> foundx;
+			std::vector<uint32_t> foundy;
+
+			uint32_t iterId;
+			int32_t current;
+			uint32_t facetCount;
+
+			physx::PxVec3 minimal;
+			physx::PxVec3 maximal;
+
+			physx::PxVec3 rescale;
+	
+
+		};
+
+
+		/**
+			Accelerator which builds map from 3d grid to initial mesh facets. 
+			To find all facets which possibly intersect given one, it return all facets which are pointed by grid cells, which intersects with bounding box of given facet.
+			To find all facets which possibly cover given point, all facets which are pointed by cells in column which contains given point are returned.
+		*/
+		class BBoxBasedAccelerator : public SpatialAccelerator
+		{
+		public:
+			/**
+				\param[in] mesh Mesh for which acceleration structure should be built.
+				\param[in] resolution Resolution on 3d grid.
+			*/
+			BBoxBasedAccelerator(const Mesh* mesh, int32_t resolution);
+			virtual ~BBoxBasedAccelerator();
+			int32_t getNextFacet() override;
+			void setState(const Vertex* pos, const Edge* ed, const Facet& fc) override;
+			void setState(const physx::PxBounds3* bounds) override;
+			void setState(const physx::PxVec3& p) override;
+			void setPointCmpDirection(int32_t dir) override {};
+		private:
+
+			void buildAccelStructure(const Vertex* pos, const Edge* edges, const Facet* fc, int32_t facetCount);
+
+			int32_t mResolution;
+			physx::PxBounds3 mBounds;
+			std::vector< std::vector<int32_t> > mSpatialMap;
+			std::vector<physx::PxBounds3> mCells;
+
+	
+			// Iterator data
+			std::vector<uint32_t> alreadyGotFlag;
+			uint32_t alreadyGotValue;
+			std::vector<int32_t> cellList;
+			int32_t gotCells;
+			//std::vector<int32_t> cellList;
+			int32_t mIteratorCell;
+			int32_t mIteratorFacet;
+		};
+
+	} // namespace Blast
+} // namsepace Nv
+
+
+#endif // ifndef NVBLASTEXTAUTHORINGACCELERATOR_H
diff --git a/sdk/extensions/authoringCommon/include/NvBlastExtAuthoringMesh.h b/sdk/extensions/authoringCommon/include/NvBlastExtAuthoringMesh.h
new file mode 100644
index 0000000..b8a8b72
--- /dev/null
+++ b/sdk/extensions/authoringCommon/include/NvBlastExtAuthoringMesh.h
@@ -0,0 +1,167 @@
+// 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 NVBLASTAUTHORINGMESH_H
+#define NVBLASTAUTHORINGMESH_H
+
+#include "NvBlastExtAuthoringTypes.h"
+
+namespace Nv
+{
+namespace Blast
+{
+
+/**
+	Class for internal mesh representation
+*/
+class Mesh
+{
+public:
+	
+	virtual ~Mesh() {}
+
+	/**
+		Release Mesh memory
+	*/
+	virtual void				release() = 0;
+
+	/**
+		Return true if mesh is valid
+	*/
+	virtual bool				isValid() const = 0;
+
+	/**
+		Return writable pointer on vertices array
+	*/
+	virtual Vertex*				getVerticesWritable() = 0;
+
+	/**
+	Return pointer on vertices array
+	*/
+	virtual const Vertex*		getVertices() const = 0;
+
+
+	/**
+		Return writable pointer on edges array
+	*/
+	virtual Edge*				getEdgesWritable() = 0;
+
+	/**
+	Return pointer on edges array
+	*/
+	virtual const Edge*			getEdges() const = 0;
+
+	/**
+		Return writable pointer on facets array
+	*/
+	virtual Facet*				getFacetsBufferWritable() = 0;
+
+	/**
+	Return pointer on facets array
+	*/
+	virtual const Facet*		getFacetsBuffer() const = 0;
+
+	/**
+		Return writable pointer on specified facet
+	*/
+	virtual Facet*				getFacetWritable(int32_t facet) = 0;
+	/**
+		Return pointer on specified facet
+	*/
+	virtual const Facet*		getFacet(int32_t facet) const = 0;
+
+	/**
+		Return edges count
+	*/
+	virtual uint32_t			getEdgesCount() const = 0;
+
+	/**
+		Return vertices count
+	*/
+	virtual uint32_t			getVerticesCount() const = 0;
+
+	/**
+		Return facet count
+	*/
+	virtual uint32_t			getFacetCount() const = 0;
+
+	/**
+		Return reference on mesh bounding box.
+	*/
+	virtual const physx::PxBounds3&	getBoundingBox() const = 0;
+
+	/**
+		Return writable reference on mesh bounding box.
+	*/
+	virtual physx::PxBounds3&	getBoundingBoxWritable() = 0;
+
+
+	/**
+		Set per-facet material id.
+	*/
+	virtual void	setMaterialId(const int32_t* materialIds) = 0;
+
+	/**
+	Replaces an material id on faces with a new one
+	*/
+	virtual void	replaceMaterialId(int32_t oldMaterialId, int32_t newMaterialId) = 0;
+
+	/**
+		Set per-facet smoothing group.
+	*/
+	virtual void	setSmoothingGroup(const int32_t* smoothingGroups) = 0;
+
+	/**
+		Recalculate bounding box
+	*/
+	virtual void				recalculateBoundingBox() = 0;
+
+	/**
+		Compute mesh volume. Can be used only for triangulated meshes.
+		Return mesh volume. If mesh is not triangulated return 0.
+	*/
+	virtual float				getMeshVolume() = 0;
+
+
+	/**
+		Calculate per-facet bounding boxes.
+	*/
+	virtual void				calcPerFacetBounds() = 0;
+
+	/**
+		Get pointer on facet bounding box, if not calculated return nullptr.
+	*/
+	virtual const physx::PxBounds3*	getFacetBound(uint32_t index) const = 0;
+
+};
+
+} // namespace Blast
+} // namespace Nv
+
+
+#endif // ifndef NVBLASTAUTHORINGMESH_H
diff --git a/sdk/extensions/authoringCommon/include/NvBlastExtAuthoringPatternGenerator.h b/sdk/extensions/authoringCommon/include/NvBlastExtAuthoringPatternGenerator.h
new file mode 100644
index 0000000..e446109
--- /dev/null
+++ b/sdk/extensions/authoringCommon/include/NvBlastExtAuthoringPatternGenerator.h
@@ -0,0 +1,126 @@
+// 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 NVBLASTEXTAUTHORINGPATTERNGENERATOR_H
+#define NVBLASTEXTAUTHORINGPATTERNGENERATOR_H
+
+#include "NvBlastGlobals.h"
+
+namespace Nv
+{
+	namespace Blast
+	{
+		typedef float (*RNG_CALLBACK)(void);
+
+		struct PatternDescriptor
+		{
+			RNG_CALLBACK RNG = nullptr;
+
+			uint32_t interiorMaterialId = 1000;
+		};
+
+		struct UniformPatternDesc : public PatternDescriptor
+		{
+			uint32_t cellsCount	= 2;
+
+			float radiusMin		= 0.0f;
+			float radiusMax		= 1.0f;
+			float radiusDistr	= 1.0f;
+
+			float debrisRadiusMult = 1.0f;
+		};
+
+		struct BeamPatternDesc : public PatternDescriptor
+		{
+			uint32_t cellsCount;
+
+			float radiusMin;
+			float radiusMax;
+		};
+
+		struct RegularRadialPatternDesc : public PatternDescriptor
+		{
+			float radiusMin = 0.0f;
+			float radiusMax = 1.0f;
+			
+			uint32_t radialSteps = 3;
+			uint32_t angularSteps = 8;
+
+			float aperture = .0f;
+
+			float angularNoiseAmplitude = 0.0f;
+			
+			float radialNoiseAmplitude = 0.0f;
+			float radialNoiseFrequency = 0.0f;
+
+			float debrisRadiusMult = 1.0f;
+		};
+
+
+		struct DamagePattern
+		{
+			/**
+			Used to compute activated chunks.
+			*/
+			float activationRadius;
+			float angle; // For cone shape activation
+			enum ActivationDistanceType
+			{
+				Point = 0,
+				Line,
+				Cone
+			};
+			ActivationDistanceType activationType = Point;
+			// ----------------------------------------------
+
+
+			uint32_t cellsCount;
+			class Mesh** cellsMeshes = nullptr;
+
+			virtual void release() = 0;
+		};
+
+		class PatternGenerator
+		{
+		public:
+			virtual DamagePattern* generateUniformPattern(const UniformPatternDesc* desc) = 0;
+			virtual DamagePattern* generateBeamPattern(const BeamPatternDesc* desc) = 0;
+			virtual DamagePattern* generateRegularRadialPattern(const RegularRadialPatternDesc* desc) = 0;
+
+
+			virtual DamagePattern* generateVoronoiPattern(uint32_t pointCount, const physx::PxVec3* points, int32_t interiorMaterialId) = 0;
+			virtual void release() = 0;
+		};
+
+		NVBLAST_API void savePatternToObj(DamagePattern* pattern);
+		
+	} // namespace Blast
+} // namespace Nv
+
+
+#endif // ifndef NVBLASTEXTAUTHORINGMESHCLEANER_H
\ No newline at end of file
diff --git a/sdk/extensions/authoringCommon/include/NvBlastExtAuthoringTypes.h b/sdk/extensions/authoringCommon/include/NvBlastExtAuthoringTypes.h
new file mode 100644
index 0000000..729453b
--- /dev/null
+++ b/sdk/extensions/authoringCommon/include/NvBlastExtAuthoringTypes.h
@@ -0,0 +1,291 @@
+// 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 NVBLASTAUTHORINGTYPES_H
+#define NVBLASTAUTHORINGTYPES_H
+
+#include <PxVec3.h>
+#include <PxVec2.h>
+#include <PxBounds3.h>
+#include "NvBlastTypes.h"
+
+#define NOT_VALID_VERTEX UINT32_MAX
+
+namespace Nv
+{
+namespace Blast
+{
+
+/**
+	Edge representation
+*/
+struct Edge
+{
+	uint32_t s, e;
+	Edge() : s(NOT_VALID_VERTEX), e(NOT_VALID_VERTEX){}
+	Edge(uint32_t s, uint32_t e) : s(s), e(e) {}
+	bool operator<(const Edge& b) const
+	{
+		if (s == b.s)
+			return e < b.e;
+		else
+			return s < b.s;
+	}
+	uint32_t operator[](uint32_t i) const
+	{
+		return *(reinterpret_cast<const uint32_t*>(this) + i);
+	}
+
+};
+
+/**
+	Mesh vertex representation
+*/
+struct Vertex
+{
+	physx::PxVec3 p; // Position
+	physx::PxVec3 n; // Normal
+	physx::PxVec2 uv[1]; // UV-coordinates array, currently supported only one UV coordinate.
+};
+
+
+// Interior material ID
+#define MATERIAL_INTERIOR 1000
+#define SMOOTHING_GROUP_INTERIOR 1000
+
+
+
+/**
+	Mesh triangle representation
+*/
+struct Triangle
+{
+	Triangle() {};
+	Triangle(Vertex a, Vertex b, Vertex c) : a(a), b(b), c(c) {};
+	Vertex a, b, c;
+	int32_t userData;
+	int32_t materialId;
+	int32_t smoothingGroup;
+	physx::PxVec3 getNormal() const
+	{
+		return ((b.p - a.p).cross(c.p - a.p));
+	}
+	inline Vertex& getVertex(uint32_t index)
+	{
+		return (&a)[index];
+	}
+	inline const Vertex& getVertex(uint32_t index) const
+	{
+		return (&a)[index];
+	}
+};
+
+
+/**
+	Index based triangle
+*/
+struct TriangleIndexed
+{
+	TriangleIndexed() {};
+	TriangleIndexed(uint32_t a, uint32_t b, uint32_t c) : ea(a), eb(b), ec(c) {};
+
+	uint32_t getOpposite(uint32_t a, uint32_t b)
+	{
+		if (ea != a && ea != b)
+			return ea;
+		if (eb != a && eb != b)
+			return eb;
+		if (ec != a && ec != b)
+			return ec;
+		return NOT_VALID_VERTEX;
+	}
+
+	bool isContainEdge(uint32_t a, uint32_t b)
+	{
+		return (a == ea || a == eb || a == ec) && (b == ea || b == eb || b == ec);
+	}
+
+	Triangle convertToTriangle(Vertex* vertices)
+	{
+		Triangle tr;
+		tr.a = vertices[ea];
+		tr.b = vertices[eb];
+		tr.c = vertices[ec];
+		
+		tr.userData = userData;
+		tr.materialId = materialId;
+		tr.smoothingGroup = smoothingGroup;
+		return tr;
+	}
+
+	uint32_t ea, eb, ec;
+	int32_t materialId;
+	int32_t smoothingGroup;
+	int32_t userData;
+};
+
+
+
+
+/**
+	Mesh facet representation
+*/
+struct Facet
+{
+	int32_t		firstEdgeNumber;
+	uint32_t	edgesCount;
+	int64_t		userData;
+	int32_t		materialId;
+	int32_t		smoothingGroup;
+	Facet(int32_t fEdge = 0, uint32_t eCount = 0, int32_t materialId = 0, int64_t userData = 0, int32_t smoothingGroup = 0) : firstEdgeNumber(fEdge), edgesCount(eCount), userData(userData), materialId(materialId), smoothingGroup(smoothingGroup) {}
+};
+
+/**
+	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() {};
+};
+
+/**
+	Collision hull geometry format.
+*/
+struct CollisionHull
+{
+	/**
+	Collision hull polygon format.
+	*/
+	struct HullPolygon
+	{
+		// Polygon base plane
+		float		mPlane[4];
+		// Number vertices in polygon
+		uint16_t	mNbVerts;
+		// First index in CollisionHull.indices array for this polygon
+		uint16_t	mIndexBase;
+	};
+	///**
+
+	uint32_t		pointsCount;
+	uint32_t		indicesCount;
+	uint32_t		polygonDataCount;
+	physx::PxVec3*	points;
+	uint32_t*		indices;
+	HullPolygon*	polygonData;
+
+	virtual ~CollisionHull() {}
+
+	virtual void release() = 0;
+};
+
+/**
+	Authoring results. Which contains NvBlastAsset, render and collision meshes
+*/
+struct AuthoringResult
+{
+	uint32_t				chunkCount; //Number of chunks in Blast asset
+
+	uint32_t				bondCount; //Number of bonds in Blast asset
+
+	NvBlastAsset*			asset; //Blast asset
+
+	/**
+		assetToFractureChunkIdMap used for getting internal FractureChunkId with FractureTool::getChunkId.
+		FractureChunkId = FractureTool.getChunkId(aResult.assetToFractureChunkIdMap(AssetChunkId);
+	*/
+	uint32_t*				assetToFractureChunkIdMap;
+
+	/**
+		Offsets for render mesh geometry. Contains chunkCount + 1 element.
+		First triangle for i-th chunk: aResult.geometry[aResult.geometryOffset[i]]
+		aResult.geometryOffset[chunkCount+1] is total number of triangles in geometry
+	*/
+	uint32_t*				geometryOffset;
+
+	Triangle*				geometry; //Raw array of Triangle for all chunks
+
+	NvBlastChunkDesc*		chunkDescs; //Array of chunk descriptors. Contains chunkCount elements
+
+	NvBlastBondDesc*		bondDescs; //Array of bond descriptors. Contains bondCount elements
+
+	/**
+		Collision hull offsets. Contains chunkCount + 1 element.
+		First collision hull for i-th chunk: aResult.collisionHull[aResult.collisionHullOffset[i]]
+		aResult.collisionHullOffset[chunkCount+1] is total number of collision hulls in collisionHull
+	*/
+	uint32_t*				collisionHullOffset;
+
+	CollisionHull**			collisionHull; //Raw array of pointers to collision hull for all chunks.
+
+	/**
+		Array of chunk physics parameters. Contains chunkCount elements
+	*/
+	struct ExtPxChunk*		physicsChunks;
+
+	/**
+		Array of phisics subchunks (convex mesh) descriptors. 
+		Use collisionHullOffset for accessing elements.
+	*/
+	struct ExtPxSubchunk*	physicsSubchunks;
+
+	/**
+		Array of material names.
+	*/
+	const char** materialNames;
+	/**
+		Size of array of material names.
+	*/
+
+	uint32_t materialCount;
+
+	//// Member functions ////
+	virtual ~AuthoringResult() {}
+
+	/**
+		Free collision hulls data
+	*/
+	virtual void releaseCollisionHulls() = 0;
+
+	/**
+		Free all data and AuthoringResult
+	*/
+	virtual void release() = 0;
+};
+
+
+} // namespace Blast
+} // namespace Nv
+
+
+#endif // ifndef NVBLASTAUTHORINGTYPES_H