Changes for 1.1.1

See README.md

6 files changed, 1320 insertions, 162 deletions

diff --git a/sdk/extensions/shaders/include/NvBlastExtDamageShaders.h b/sdk/extensions/shaders/include/NvBlastExtDamageShaders.h
index 8daf9cf..b7962cd 100644
--- a/sdk/extensions/shaders/include/NvBlastExtDamageShaders.h
+++ b/sdk/extensions/shaders/include/NvBlastExtDamageShaders.h
@@ -30,6 +30,7 @@
 #define NVBLASTEXTDAMAGESHADERS_H
 
 #include "NvBlastTypes.h"
+#include "NvBlastDebugRender.h"
 
 
 /**
@@ -38,6 +39,49 @@ A few example damage shader implementations.
 
 
 ///////////////////////////////////////////////////////////////////////////////
+//  Damage Accelerator 
+///////////////////////////////////////////////////////////////////////////////
+
+class NvBlastExtDamageAccelerator
+{
+public:
+	virtual void release() = 0;
+
+	virtual Nv::Blast::DebugBuffer fillDebugRender(int depth = -1, bool segments = false) = 0;
+};
+
+NVBLAST_API NvBlastExtDamageAccelerator* NvBlastExtDamageAcceleratorCreate(const NvBlastAsset* asset, int type);
+
+
+///////////////////////////////////////////////////////////////////////////////
+//  Damage Program
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+Damage program params.
+
+Custom user params to be passed in shader functions. This structure hints recommended parameters layout, but it
+doesn't required to be this way.
+
+The idea of this 'hint' is that damage parameters are basically 2 entities: material + damage description.
+1. Material is something that describes an actor properties (e.g. mass, stiffness, fragility) which are not expected to be changed often.
+2. Damage description is something that describes particular damage event (e.g. position, radius and force of explosion).
+
+Also this damage program hints that there could be more than one damage event happening and processed per one shader call (for efficiency reasons).
+So different damage descriptions can be stacked and passed in one shader call (while material is kept the same obviously).
+*/
+struct NvBlastExtProgramParams
+{
+	NvBlastExtProgramParams(const void*	desc, const void* material_ = nullptr, NvBlastExtDamageAccelerator* accelerator_ = nullptr)
+		: damageDesc(desc), material(material_), accelerator(accelerator_) {}
+
+	const void*	damageDesc;			//!<	array of damage descriptions
+	const void*	material;			//!<	pointer to material
+	NvBlastExtDamageAccelerator*	accelerator;
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
 //  Common Material 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -95,38 +139,20 @@ NOTE: The signature of shader functions are equal to NvBlastGraphShaderFunction
 They are not expected to be called directly.
 @see NvBlastGraphShaderFunction, NvBlastSubgraphShaderFunction
 */
-NVBLAST_API void NvBlastExtFalloffGraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastGraphShaderActor* actor, const NvBlastProgramParams* params);
-NVBLAST_API void NvBlastExtFalloffSubgraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastSubgraphShaderActor* actor, const NvBlastProgramParams* params);
-NVBLAST_API void NvBlastExtCutterGraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastGraphShaderActor* actor, const NvBlastProgramParams* params);
-NVBLAST_API void NvBlastExtCutterSubgraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastSubgraphShaderActor* actor, const NvBlastProgramParams* params);
-
-
-/**
-Helper Radial Falloff Damage function.
-
-Basically it calls NvBlastActorGenerateFracture and then NvBlastActorApplyFracture with Radial Falloff shader.
-
-\param[in,out]	actor				The NvBlastActor to apply fracture to.
-\param[in,out]	buffers				Target buffers to hold applied command events.
-\param[in]		damageDescBuffer	Damage descriptors array.
-\param[in]		damageDescCount		Size of damage descriptors array.
-\param[in]		material			Material to use.
-\param[in]		logFn				User-supplied message function (see NvBlastLog definition).  May be NULL.
-\param[in,out]	timers				If non-NULL this struct will be filled out with profiling information for the step, in profile build configurations.
-
-\return true iff any fracture was applied.
-*/
-NVBLAST_API bool NvBlastExtDamageActorRadialFalloff(NvBlastActor* actor, NvBlastFractureBuffers* buffers, const NvBlastExtRadialDamageDesc* damageDescBuffer, uint32_t damageDescCount, const NvBlastExtMaterial* material, NvBlastLog logFn, NvBlastTimers* timers);
+NVBLAST_API void NvBlastExtFalloffGraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastGraphShaderActor* actor, const void* params);
+NVBLAST_API void NvBlastExtFalloffSubgraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastSubgraphShaderActor* actor, const void* params);
+NVBLAST_API void NvBlastExtCutterGraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastGraphShaderActor* actor, const void* params);
+NVBLAST_API void NvBlastExtCutterSubgraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastSubgraphShaderActor* actor, const void* params);
 
 
 ///////////////////////////////////////////////////////////////////////////////
-//  Segment Radial Damage
+//  Capsule Radial Damage
 ///////////////////////////////////////////////////////////////////////////////
 
 /**
-Segment Radial Damage Desc
+Capsule Radial Damage Desc
 */
-struct NvBlastExtSegmentRadialDamageDesc
+struct NvBlastExtCapsuleRadialDamageDesc
 {
 	float	damage;			//!<	normalized damage amount, range: [0, 1] (maximum health value to be reduced)
 	float	position0[3];	//!<	damage segment point A position
@@ -136,17 +162,17 @@ struct NvBlastExtSegmentRadialDamageDesc
 };
 
 /**
-Segment Radial Falloff damage for both graph and subgraph shaders.
+Capsule Radial Falloff damage for both graph and subgraph shaders.
 
-For every bond/chunk damage is calculated from the distance to line segment AB described in NvBlastExtSegmentRadialDamageDesc.
+For every bond/chunk damage is calculated from the distance to line segment AB described in NvBlastExtCapsuleRadialDamageDesc.
 If distance is smaller then minRadius, full compressive amount of damage is applied. From minRadius to maxRaidus it linearly falls off to zero.
 
 NOTE: The signature of shader functions are equal to NvBlastGraphShaderFunction and NvBlastSubgraphShaderFunction respectively.
 They are not expected to be called directly.
 @see NvBlastGraphShaderFunction, NvBlastSubgraphShaderFunction
 */
-NVBLAST_API void NvBlastExtSegmentFalloffGraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastGraphShaderActor* actor, const NvBlastProgramParams* params);
-NVBLAST_API void NvBlastExtSegmentFalloffSubgraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastSubgraphShaderActor* actor, const NvBlastProgramParams* params);
+NVBLAST_API void NvBlastExtCapsuleFalloffGraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastGraphShaderActor* actor, const void* params);
+NVBLAST_API void NvBlastExtCapsuleFalloffSubgraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastSubgraphShaderActor* actor, const void* params);
 
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -174,8 +200,78 @@ NOTE: The signature of shader functions are equal to NvBlastGraphShaderFunction
 They are not expected to be called directly.
 @see NvBlastGraphShaderFunction, NvBlastSubgraphShaderFunction
 */
-NVBLAST_API void NvBlastExtShearGraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastGraphShaderActor* actor, const NvBlastProgramParams* params);
-NVBLAST_API void NvBlastExtShearSubgraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastSubgraphShaderActor* actor, const NvBlastProgramParams* params);
+NVBLAST_API void NvBlastExtShearGraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastGraphShaderActor* actor, const void* params);
+NVBLAST_API void NvBlastExtShearSubgraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastSubgraphShaderActor* actor, const void* params);
+
+
+///////////////////////////////////////////////////////////////////////////////
+//  Triangle Intersection Damage
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+Triangle Intersection Damage Desc
+*/
+struct NvBlastExtTriangleIntersectionDamageDesc
+{
+	float	damage;			//!<	normalized damage amount, range: [0, 1] (maximum health value to be reduced)
+	NvcVec3	position0;		//!<	triangle point A position
+	NvcVec3	position1;		//!<	triangle point B position
+	NvcVec3	position2;		//!<	triangle point C position
+};
+
+/**
+Triangle Intersection damage for both graph and subgraph shaders.
+
+Every bond is considered to be a segment connecting two chunk centroids. For every bond (segment) intersection with passed triangle is checked. If intersects
+full damage is applied on bond.
+For subgraph shader segments are formed as connections between it's subchunks centroids. Intersection is check in the same fashion.
+
+The idea is that if you want to cut an object say with the laser sword, you can form a triangle by taking the position of a sword on this timeframe and on previous one.
+So that nothing will be missed in terms of space and time. By sweeping sword through whole object it will be cut in halves inevitably, since all bonds segments form connected graph.
+
+NOTE: The signature of shader functions are equal to NvBlastGraphShaderFunction and NvBlastSubgraphShaderFunction respectively.
+They are not expected to be called directly.
+@see NvBlastGraphShaderFunction, NvBlastSubgraphShaderFunction
+*/
+NVBLAST_API void NvBlastExtTriangleIntersectionGraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastGraphShaderActor* actor, const void* params);
+NVBLAST_API void NvBlastExtTriangleIntersectionSubgraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastSubgraphShaderActor* actor, const void* params);
+
+
+///////////////////////////////////////////////////////////////////////////////
+//  Impact Spread
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+Impact Spread Damage Desc
+*/
+struct NvBlastExtImpactSpreadDamageDesc
+{
+	float	damage;			//!<	normalized damage amount, range: [0, 1] (maximum health value to be reduced)
+	float	position[3];	//!<	origin of damage action
+
+	float	minRadius;		//!<	inner radius of damage action
+	float	maxRadius;		//!<	outer radius of damage action
+};
+
+/**
+Impact Spread Damage Shaders.
+
+It assumes that position is somewhere on the chunk and looks for nearest chunk to this position and damages it. 
+Then it does breadth-first support graph traversal. For radial falloff metric distance is measured along the edges of the graph.
+That allows to avoid damaging parts which are near in space but disjointed topologically. For example if you hit one column of an arc 
+it would take much bigger radius for damage to travel to the other column than in the simple radial damage.
+
+Shader is designed to be used with impact damage, where it is know in advance that actual hit happened.
+
+This shader requires NvBlastExtDamageAccelerator passed in, it request scratch memory from it, therefore it is also designed to work
+only in single threaded mode. It can easily be changed by passing scratch memory as a part of NvBlastExtProgramParams if required.
+
+NOTE: The signature of shader functions are equal to NvBlastGraphShaderFunction and NvBlastSubgraphShaderFunction respectively.
+They are not expected to be called directly.
+@see NvBlastGraphShaderFunction, NvBlastSubgraphShaderFunction
+*/
+NVBLAST_API void NvBlastExtImpactSpreadGraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastGraphShaderActor* actor, const void* params);
+NVBLAST_API void NvBlastExtImpactSpreadSubgraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastSubgraphShaderActor* actor, const void* params);
 
 
 #endif // NVBLASTEXTDAMAGESHADERS_H
diff --git a/sdk/extensions/shaders/source/NvBlastExtDamageAcceleratorAABBTree.cpp b/sdk/extensions/shaders/source/NvBlastExtDamageAcceleratorAABBTree.cpp
new file mode 100644
index 0000000..bf2eb59
--- /dev/null
+++ b/sdk/extensions/shaders/source/NvBlastExtDamageAcceleratorAABBTree.cpp
@@ -0,0 +1,380 @@
+// 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-2017 NVIDIA Corporation. All rights reserved.
+
+#include "NvBlastExtDamageAcceleratorAABBTree.h"
+#include "NvBlastIndexFns.h"
+#include "NvBlastAssert.h"
+#include "PxVec4.h"
+#include <algorithm>
+
+using namespace physx;
+
+
+namespace Nv
+{
+namespace Blast
+{
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//													Creation
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ExtDamageAcceleratorAABBTree* ExtDamageAcceleratorAABBTree::create(const NvBlastAsset* asset)
+{
+	ExtDamageAcceleratorAABBTree* tree = NVBLAST_NEW(Nv::Blast::ExtDamageAcceleratorAABBTree) ();
+	tree->build(asset);
+	return tree;
+}
+
+
+void ExtDamageAcceleratorAABBTree::release()
+{
+	NVBLAST_DELETE(this, ExtDamageAcceleratorAABBTree);
+}
+
+
+void ExtDamageAcceleratorAABBTree::build(const NvBlastAsset* asset)
+{
+	NVBLAST_ASSERT(m_root == nullptr);
+
+	const NvBlastSupportGraph graph = NvBlastAssetGetSupportGraph(asset, logLL);
+	const NvBlastBond* bonds = NvBlastAssetGetBonds(asset, logLL);
+	const NvBlastChunk* chunks = NvBlastAssetGetChunks(asset, logLL);
+	const uint32_t N = NvBlastAssetGetBondCount(asset, logLL);
+
+	m_indices.resizeUninitialized(N);
+	m_points.resizeUninitialized(N);
+	m_segments.resizeUninitialized(N);
+	m_bonds.resizeUninitialized(N);
+	m_nodes.reserve(2 * N);
+
+	for (uint32_t node0 = 0; node0 < graph.nodeCount; ++node0)
+	{
+		for (uint32_t j = graph.adjacencyPartition[node0]; j < graph.adjacencyPartition[node0 + 1]; ++j)
+		{
+			uint32_t bondIndex = graph.adjacentBondIndices[j];
+			uint32_t node1 = graph.adjacentNodeIndices[j];
+			if (node0 < node1)
+			{
+				const NvBlastBond& bond = bonds[bondIndex];
+				const PxVec3& p = (reinterpret_cast<const PxVec3&>(bond.centroid));
+				m_points[bondIndex] = p;
+				m_indices[bondIndex] = bondIndex;
+				m_bonds[bondIndex].node0 = node0;
+				m_bonds[bondIndex].node1 = node1;
+
+				// filling bond segments as a connection of 2 chunk centroids
+				const uint32_t chunk0 = graph.chunkIndices[node0];
+				const uint32_t chunk1 = graph.chunkIndices[node1];
+				if (isInvalidIndex(chunk1))
+				{
+					// for world node we don't have it's centroid, so approximate with projection on bond normal 
+					m_segments[bondIndex].p0 = (reinterpret_cast<const PxVec3&>(chunks[chunk0].centroid));
+					const PxVec3 normal = (reinterpret_cast<const PxVec3&>(bond.normal));
+					m_segments[bondIndex].p1 = m_segments[bondIndex].p0 + normal * (p - m_segments[bondIndex].p0).dot(normal) * 2;
+
+				}
+				else
+				{
+					m_segments[bondIndex].p0 = (reinterpret_cast<const PxVec3&>(chunks[chunk0].centroid));
+					m_segments[bondIndex].p1 = (reinterpret_cast<const PxVec3&>(chunks[chunk1].centroid));
+				}
+			}
+		}
+
+	}
+
+	int rootIndex = N > 0 ? createNode(0, N - 1, 0) : -1;
+	m_root = rootIndex >= 0 ? &m_nodes[rootIndex] : nullptr;
+}
+
+int ExtDamageAcceleratorAABBTree::createNode(uint32_t startIdx, uint32_t endIdx, uint32_t depth)
+{
+	if (startIdx > endIdx)
+		return -1;
+
+	Node node;
+	node.first = startIdx;
+	node.last = endIdx;
+
+	// calc node bounds
+	node.pointsBound = PxBounds3::empty();
+	node.segmentsBound = PxBounds3::empty();
+	for (uint32_t i = node.first; i <= node.last; i++)
+	{
+		const uint32_t idx = m_indices[i];
+		node.pointsBound.include(m_points[idx]);
+		node.segmentsBound.include(m_segments[idx].p0);
+		node.segmentsBound.include(m_segments[idx].p1);
+	}
+
+	// select axis of biggest extent
+	const PxVec3 ext = node.pointsBound.getExtents();
+	uint32_t axis = 0;
+	for (uint32_t k = 1; k < 3; k++)
+	{
+		if (ext[k] > ext[axis])
+		{
+			axis = k;
+		}
+	}
+
+	// split on selected axis and partially sort around the middle
+	const uint32_t mid = startIdx + (endIdx - startIdx) / 2;
+	std::nth_element(m_indices.begin() + startIdx, m_indices.begin() + mid, m_indices.begin() + endIdx + 1, [&](uint32_t lhs, uint32_t rhs)
+	{
+		return m_points[lhs][axis] < m_points[rhs][axis];
+	});
+
+	const uint32_t BUCKET = 32;
+	if (endIdx - startIdx > BUCKET && mid > startIdx && mid < endIdx)
+	{
+		node.child[0] = createNode(startIdx, mid, depth + 1);
+		node.child[1] = createNode(mid + 1, endIdx, depth + 1);
+	}
+	else
+	{
+		node.child[0] = -1;
+		node.child[1] = -1;
+	}
+
+	m_nodes.pushBack(node);
+
+	return m_nodes.size() - 1;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//														Queries
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+void ExtDamageAcceleratorAABBTree::findInBounds(const physx::PxBounds3& bounds, ResultCallback& callback, bool segments) const
+{
+	if (m_root)
+	{
+		if (segments)
+			findSegmentsInBounds(*m_root, callback, bounds);
+		else
+			findPointsInBounds(*m_root, callback, bounds);
+		callback.dispatch();
+	}
+}
+
+void ExtDamageAcceleratorAABBTree::findPointsInBounds(const Node& node, ResultCallback& callback, const physx::PxBounds3& bounds) const
+{
+	if (!bounds.intersects(node.pointsBound))
+	{
+		return;
+	}
+
+	// if search bound contains node bound, simply add all point indexes.
+	if (node.pointsBound.isInside(bounds))
+	{
+		for (uint32_t i = node.first; i <= node.last; i++)
+			pushResult(callback, m_indices[i]);
+		return;  // early pruning.
+	}
+
+	if (node.child[0] < 0)
+	{
+		for (uint32_t i = node.first; i <= node.last; i++)
+		{
+			const uint32_t idx = m_indices[i];
+			if (bounds.contains(m_points[idx]))
+				pushResult(callback, idx);
+		}
+
+		return;
+	}
+
+	// check whether child nodes are in range.
+	for (uint32_t c = 0; c < 2; ++c)
+	{
+		findPointsInBounds(m_nodes[node.child[c]], callback, bounds);
+	}
+}
+
+void ExtDamageAcceleratorAABBTree::findSegmentsInBounds(const Node& node, ResultCallback& callback, const physx::PxBounds3& bounds) const
+{
+	if (!bounds.intersects(node.segmentsBound))
+	{
+		return;
+	}
+
+	// if search bound contains node bound, simply add all point indexes.
+	if (node.segmentsBound.isInside(bounds))
+	{
+		for (uint32_t i = node.first; i <= node.last; i++)
+			pushResult(callback, m_indices[i]);
+		return;  // early pruning.
+	}
+
+	if (node.child[0] < 0)
+	{
+		for (uint32_t i = node.first; i <= node.last; i++)
+		{
+			const uint32_t idx = m_indices[i];
+			if (bounds.contains(m_segments[idx].p0) || bounds.contains(m_segments[idx].p1))
+				pushResult(callback, idx);
+		}
+
+		return;
+	}
+
+	// check whether child nodes are in range.
+	for (uint32_t c = 0; c < 2; ++c)
+	{
+		findSegmentsInBounds(m_nodes[node.child[c]], callback, bounds);
+	}
+}
+
+bool intersectSegmentPlane(const PxVec3& v1, const PxVec3& v2, const PxPlane& p)
+{
+	const bool s1 = p.distance(v1) > 0.f;
+	const bool s2 = p.distance(v2) > 0.f;
+	return (s1 && !s2) || (s2 && !s1);
+}
+
+bool intersectBoundsPlane(const PxBounds3& b, const PxPlane& p)
+{
+	const PxVec3 extents = b.getExtents();
+	const PxVec3 center = b.getCenter();
+
+	float r =  extents.x * PxAbs(p.n.x) + extents.y * PxAbs(p.n.y) + extents.z * PxAbs(p.n.z);
+	float s = p.n.dot(center) + p.d;
+
+	return PxAbs(s) <= r;
+}
+
+void ExtDamageAcceleratorAABBTree::findBondSegmentsPlaneIntersected(const physx::PxPlane& plane, ResultCallback& resultCallback) const
+{
+	if (m_root)
+	{
+		findSegmentsPlaneIntersected(*m_root, resultCallback, plane);
+		resultCallback.dispatch();
+	}
+}
+
+void ExtDamageAcceleratorAABBTree::findSegmentsPlaneIntersected(const Node& node, ResultCallback& callback, const physx::PxPlane& plane) const
+{
+	if (!intersectBoundsPlane(node.segmentsBound, plane))
+	{
+		return;
+	}
+
+	if (node.child[0] < 0)
+	{
+		for (uint32_t i = node.first; i <= node.last; i++)
+		{
+			const uint32_t idx = m_indices[i];
+			if (intersectSegmentPlane(m_segments[idx].p0, m_segments[idx].p1, plane))
+				pushResult(callback, idx);
+		}
+
+		return;
+	}
+
+	// check whether child nodes are in range.
+	for (uint32_t c = 0; c < 2; ++c)
+	{
+		findSegmentsPlaneIntersected(m_nodes[node.child[c]], callback, plane);
+	}
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//													Debug Render
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+static uint32_t PxVec4ToU32Color(const PxVec4& color)
+{
+	uint32_t c = 0;
+	c |= (int)(color.w * 255); c <<= 8;
+	c |= (int)(color.z * 255); c <<= 8;
+	c |= (int)(color.y * 255); c <<= 8;
+	c |= (int)(color.x * 255);
+	return c;
+}
+
+Nv::Blast::DebugBuffer ExtDamageAcceleratorAABBTree::fillDebugRender(int depth, bool segments)
+{
+	Nv::Blast::DebugBuffer debugBuffer = { nullptr, 0 };
+
+	m_debugLineBuffer.clear();
+
+	if (m_root)
+	{
+		fillDebugBuffer(*m_root, 0, depth, segments);
+	}
+
+	debugBuffer.lines = m_debugLineBuffer.begin();
+	debugBuffer.lineCount = m_debugLineBuffer.size();
+
+	return debugBuffer;
+}
+
+void ExtDamageAcceleratorAABBTree::fillDebugBuffer(const Node& node, int currentDepth, int depth, bool segments)
+{
+	if (depth < 0 || currentDepth == depth)
+	{
+		const PxVec4 LEAF_COLOR(1.0f, 1.0f, 1.0f, 1.0f);
+		const PxVec4 NON_LEAF_COLOR(0.3f, 0.3f, 0.3f, 1.0f);
+
+		// draw box
+		const PxBounds3 bounds = segments ? node.segmentsBound : node.pointsBound;
+		const PxVec3 center = bounds.getCenter();
+		const PxVec3 extents = bounds.getExtents();
+
+		const int vs[] = { 0,3,5,6 };
+		for (int i = 0; i < 4; i++)
+		{
+			int v = vs[i];
+			for (int d = 1; d < 8; d <<= 1)
+			{
+				auto flip = [](int x, int k) { return ((x >> k) & 1) * 2.f - 1.f; };
+				const float s = std::pow(0.99f, currentDepth);
+				PxVec3 p0 = center + s * extents.multiply(PxVec3(flip(v, 0), flip(v, 1), flip(v, 2)));
+				PxVec3 p1 = center + s * extents.multiply(PxVec3(flip(v^d, 0), flip(v^d, 1), flip(v^d, 2)));
+				m_debugLineBuffer.pushBack(Nv::Blast::DebugLine(
+					reinterpret_cast<NvcVec3&>(p0), 
+					reinterpret_cast<NvcVec3&>(p1), 
+					PxVec4ToU32Color(LEAF_COLOR * (1.f - (currentDepth + 1) * 0.1f)))
+				);
+			}
+		}
+	}
+
+	for (uint32_t i = 0; i < 2; ++i)
+	{
+		if (node.child[i] >= 0)
+		{
+			fillDebugBuffer(m_nodes[node.child[i]], currentDepth + 1, depth, segments);
+		}
+	}
+}
+
+
+} // namespace Blast
+} // namespace Nv
diff --git a/sdk/extensions/shaders/source/NvBlastExtDamageAcceleratorAABBTree.h b/sdk/extensions/shaders/source/NvBlastExtDamageAcceleratorAABBTree.h
new file mode 100644
index 0000000..872885e
--- /dev/null
+++ b/sdk/extensions/shaders/source/NvBlastExtDamageAcceleratorAABBTree.h
@@ -0,0 +1,148 @@
+// 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-2017 NVIDIA Corporation. All rights reserved.
+
+#pragma once
+
+#include "NvBlastExtDamageAcceleratorInternal.h"
+#include "NvBlast.h"
+#include "NvBlastArray.h"
+
+
+namespace Nv
+{
+namespace Blast
+{
+
+class ExtDamageAcceleratorAABBTree final : public ExtDamageAcceleratorInternal
+{
+public:
+	//////// ctor ////////
+
+	ExtDamageAcceleratorAABBTree() :
+		 m_root(nullptr)
+	{
+	}
+
+	virtual ~ExtDamageAcceleratorAABBTree()
+	{
+	}
+
+	static ExtDamageAcceleratorAABBTree* create(const NvBlastAsset* asset);
+
+
+	//////// interface ////////
+
+	virtual void release() override;
+
+	virtual void findBondCentroidsInBounds(const physx::PxBounds3& bounds, ResultCallback& resultCallback) const override
+	{
+		const_cast<ExtDamageAcceleratorAABBTree*>(this)->findInBounds(bounds, resultCallback, false);
+	}
+
+	virtual void findBondSegmentsInBounds(const physx::PxBounds3& bounds, ResultCallback& resultCallback) const override
+	{
+		const_cast<ExtDamageAcceleratorAABBTree*>(this)->findInBounds(bounds, resultCallback, true);
+
+	}
+
+	virtual void findBondSegmentsPlaneIntersected(const physx::PxPlane& plane, ResultCallback& resultCallback) const override;
+
+	virtual Nv::Blast::DebugBuffer fillDebugRender(int depth, bool segments) override;
+
+	virtual void* getImmediateScratch(size_t size) override
+	{
+		m_scratch.resizeUninitialized(size);
+		return m_scratch.begin();
+	}
+
+
+private:
+	// no copy/assignment
+	ExtDamageAcceleratorAABBTree(ExtDamageAcceleratorAABBTree&);
+	ExtDamageAcceleratorAABBTree& operator=(const ExtDamageAcceleratorAABBTree& tree);
+
+	// Tree node 
+	struct Node
+	{
+		int child[2];
+		uint32_t first;
+		uint32_t last;
+		physx::PxBounds3 pointsBound;
+		physx::PxBounds3 segmentsBound;
+	};
+
+
+	void build(const NvBlastAsset* asset);
+
+	int createNode(uint32_t startIdx, uint32_t endIdx, uint32_t depth);
+
+	void pushResult(ResultCallback& callback, uint32_t pointIndex) const
+	{
+		callback.push(pointIndex, m_bonds[pointIndex].node0, m_bonds[pointIndex].node1);
+	}
+
+	void findInBounds(const physx::PxBounds3& bounds, ResultCallback& callback, bool segments) const;
+
+	void findPointsInBounds(const Node& node, ResultCallback& callback, const physx::PxBounds3& bounds) const;
+
+	void findSegmentsInBounds(const Node& node, ResultCallback& callback, const physx::PxBounds3& bounds) const;
+
+	void findSegmentsPlaneIntersected(const Node& node, ResultCallback& callback, const physx::PxPlane& plane) const;
+
+	void fillDebugBuffer(const Node& node, int currentDepth, int depth, bool segments);
+
+
+	//////// data ////////
+
+	Node*					              m_root;
+	Array<Node>::type		              m_nodes;
+	Array<uint32_t>::type	              m_indices;
+
+	Array<physx::PxVec3>::type		      m_points;
+
+	struct Segment
+	{
+		physx::PxVec3	p0;
+		physx::PxVec3	p1;
+	};
+	Array<Segment>::type			      m_segments;
+
+	struct BondData
+	{
+		uint32_t		node0;
+		uint32_t		node1;
+	};
+	Array<BondData>::type		          m_bonds;
+
+	Array<Nv::Blast::DebugLine>::type     m_debugLineBuffer;
+
+	Array<char>::type					  m_scratch;
+};
+
+
+} // namespace Blast
+} // namespace Nv
diff --git a/sdk/extensions/shaders/source/NvBlastExtDamageAcceleratorInternal.h b/sdk/extensions/shaders/source/NvBlastExtDamageAcceleratorInternal.h
new file mode 100644
index 0000000..2769f4e
--- /dev/null
+++ b/sdk/extensions/shaders/source/NvBlastExtDamageAcceleratorInternal.h
@@ -0,0 +1,96 @@
+// 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-2017 NVIDIA Corporation. All rights reserved.
+
+#pragma once
+
+#include "NvBlastExtDamageShaders.h"
+#include "PxBounds3.h"
+
+
+namespace Nv
+{
+namespace Blast
+{
+
+
+class ExtDamageAcceleratorInternal : public NvBlastExtDamageAccelerator
+{
+public:
+	struct QueryBondData
+	{
+		uint32_t bond;
+		uint32_t node0;
+		uint32_t node1;
+	};
+
+	class ResultCallback
+	{
+	public:
+		ResultCallback(QueryBondData* buffer, uint32_t count) :
+			m_bondBuffer(buffer), m_bondMaxCount(count), m_bondCount(0) {}
+
+		virtual void processResults(const QueryBondData* bondBuffer, uint32_t count) = 0;
+
+		void push(uint32_t bond, uint32_t node0, uint32_t node1)
+		{
+			m_bondBuffer[m_bondCount].bond = bond;
+			m_bondBuffer[m_bondCount].node0 = node0;
+			m_bondBuffer[m_bondCount].node1 = node1;
+			m_bondCount++;
+			if (m_bondCount == m_bondMaxCount)
+			{
+				dispatch();
+			}
+		}
+
+		void dispatch()
+		{
+			if (m_bondCount)
+			{
+				processResults(m_bondBuffer, m_bondCount);
+				m_bondCount = 0;
+			}
+		}
+		
+	private:
+		QueryBondData* m_bondBuffer;
+		uint32_t	   m_bondMaxCount;
+
+		uint32_t	   m_bondCount;
+	};
+
+	virtual void findBondCentroidsInBounds(const physx::PxBounds3& bounds, ResultCallback& resultCallback) const = 0;
+	virtual void findBondSegmentsInBounds(const physx::PxBounds3& bounds, ResultCallback& resultCallback) const = 0;
+	virtual void findBondSegmentsPlaneIntersected(const physx::PxPlane& plane, ResultCallback& resultCallback) const = 0;
+
+	// Non-thread safe! Multiple calls return the same memory.
+	virtual void* getImmediateScratch(size_t size) = 0;
+};
+
+
+} // namespace Blast
+} // namespace Nv
diff --git a/sdk/extensions/shaders/source/NvBlastExtDamageAccelerators.cpp b/sdk/extensions/shaders/source/NvBlastExtDamageAccelerators.cpp
new file mode 100644
index 0000000..4213004
--- /dev/null
+++ b/sdk/extensions/shaders/source/NvBlastExtDamageAccelerators.cpp
@@ -0,0 +1,43 @@
+// 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-2017 NVIDIA Corporation. All rights reserved.
+
+
+//#include "NvBlastExtDamageAcceleratorOctree.h"
+//#include "NvBlastExtDamageAcceleratorKdtree.h"
+#include "NvBlastExtDamageAcceleratorAABBTree.h"
+
+NvBlastExtDamageAccelerator* NvBlastExtDamageAcceleratorCreate(const NvBlastAsset* asset, int type)
+{
+	switch (type)
+	{
+		case 0:
+			return nullptr;
+		default:
+			return Nv::Blast::ExtDamageAcceleratorAABBTree::create(asset);
+			break;
+	}
+}
diff --git a/sdk/extensions/shaders/source/NvBlastExtDamageShaders.cpp b/sdk/extensions/shaders/source/NvBlastExtDamageShaders.cpp
index 8027447..84d3345 100644
--- a/sdk/extensions/shaders/source/NvBlastExtDamageShaders.cpp
+++ b/sdk/extensions/shaders/source/NvBlastExtDamageShaders.cpp
@@ -27,15 +27,21 @@
 
 
 #include "NvBlastExtDamageShaders.h"
+#include "NvBlastExtDamageAcceleratorInternal.h"
 #include "NvBlastIndexFns.h"
 #include "NvBlastMath.h"
 #include "NvBlastGeometry.h"
 #include "NvBlastAssert.h"
+#include "NvBlastFixedQueue.h"
+#include "NvBlastFixedBitmap.h"
 #include "NvBlast.h"
 #include <cmath> // for abs() on linux
+#include <new>
+
 
 using namespace Nv::Blast;
 using namespace Nv::Blast::VecMath;
+using namespace physx;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //													Profiles
@@ -64,13 +70,12 @@ float cutterProfile(float min, float max, float x, float f = 1.0f)
 //													Damage Functions
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-typedef float(*DamageFunction)(const float pos[3], const void* damageDescBuffer, uint32_t damageIndex);
+typedef float(*DamageFunction)(const float pos[3], const void* damageDescBuffer);
 
 template <ProfileFunction profileFn, typename DescT = NvBlastExtRadialDamageDesc>
-float pointDistanceDamage(const float pos[3], const void* damageDescBuffer, uint32_t damageIndex)
+float pointDistanceDamage(const float pos[3], const void* damageDescBuffer)
 {
-	const DescT* damageData = reinterpret_cast<const DescT*>(damageDescBuffer);
-	const DescT& desc = damageData[damageIndex];
+	const DescT& desc = *static_cast<const DescT*>(damageDescBuffer);
 
 	float relativePosition[3];
 	sub(desc.position, pos, relativePosition);
@@ -103,23 +108,47 @@ float distanceToSegment(const float p[3], const float a[3], const float b[3])
 }
 
 template <ProfileFunction profileFn>
-float segmentDistanceDamage(const float pos[3], const void* damageDescBuffer, uint32_t damageIndex)
+float capsuleDistanceDamage(const float pos[3], const void* damageDesc)
 {
-	const NvBlastExtSegmentRadialDamageDesc* damageData = reinterpret_cast<const NvBlastExtSegmentRadialDamageDesc*>(damageDescBuffer);
-	const NvBlastExtSegmentRadialDamageDesc& desc = damageData[damageIndex];
+	const NvBlastExtCapsuleRadialDamageDesc& desc = *static_cast<const NvBlastExtCapsuleRadialDamageDesc*>(damageDesc);
 
 	const float distance = distanceToSegment(pos, desc.position0, desc.position1);
 	const float damage = profileFn(desc.minRadius, desc.maxRadius, distance, desc.damage);
 	return damage;
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//													AABB Functions
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+typedef PxBounds3(*BoundFunction)(const void* damageDesc);
+
+PxBounds3 sphereBounds(const void* damageDesc)
+{
+	const NvBlastExtRadialDamageDesc& desc = *static_cast<const NvBlastExtRadialDamageDesc*>(damageDesc);
+	const physx::PxVec3& p = (reinterpret_cast<const physx::PxVec3&>(desc.position));
+	return physx::PxBounds3::centerExtents(p, physx::PxVec3(desc.maxRadius, desc.maxRadius, desc.maxRadius));
+}
+
+PxBounds3 capsuleBounds(const void* damageDesc)
+{
+	const NvBlastExtCapsuleRadialDamageDesc& desc = *static_cast<const NvBlastExtCapsuleRadialDamageDesc*>(damageDesc);
+	const physx::PxVec3& p0 = (reinterpret_cast<const physx::PxVec3&>(desc.position0));
+	const physx::PxVec3& p1 = (reinterpret_cast<const physx::PxVec3&>(desc.position1));
+	PxBounds3 b = PxBounds3::empty();
+	b.include(p0);
+	b.include(p1);
+	b.fattenFast(desc.maxRadius);
+	return b;
+}
+
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //												Radial Graph Shader Template
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-template <DamageFunction damageFn>
-void RadialProfileGraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastGraphShaderActor* actor, const NvBlastProgramParams* params)
+template <DamageFunction damageFn, BoundFunction boundsFn>
+void RadialProfileGraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastGraphShaderActor* actor, const void* params)
 {
 	const uint32_t* graphNodeIndexLinks = actor->graphNodeIndexLinks;
 	const uint32_t firstGraphNodeIndex = actor->firstGraphNodeIndex;
@@ -128,47 +157,103 @@ void RadialProfileGraphShader(NvBlastFractureBuffers* commandBuffers, const NvBl
 	const uint32_t*	adjacentBondIndices = actor->adjacentBondIndices;
 	const NvBlastBond* assetBonds = actor->assetBonds;
 	const float* familyBondHealths = actor->familyBondHealths;
-
-	const uint32_t damageCount = params->damageDescCount;
+	const NvBlastExtProgramParams* programParams = static_cast<const NvBlastExtProgramParams*>(params);
 
 	uint32_t outCount = 0;
 
-	uint32_t currentNodeIndex = firstGraphNodeIndex;
-	while (!Nv::Blast::isInvalidIndex(currentNodeIndex))
+	auto processBondFn = [&](uint32_t bondIndex, uint32_t node0, uint32_t node1)
 	{
-		for (uint32_t adj = adjacencyPartition[currentNodeIndex]; adj < adjacencyPartition[currentNodeIndex + 1]; adj++)
+		// skip bonds that are already broken or were visited already
+		// TODO: investigate why testing against health > -1.0f seems slower
+		// could reuse the island edge bitmap instead
+		if ((familyBondHealths[bondIndex] > 0.0f))
 		{
-			uint32_t adjacentNodeIndex = adjacentNodeIndices[adj];
-			if (currentNodeIndex < adjacentNodeIndex)
+			const NvBlastBond& bond = assetBonds[bondIndex];
+
+			const float totalBondDamage = damageFn(bond.centroid, programParams->damageDesc);
+			if (totalBondDamage > 0.0f)
 			{
-				uint32_t bondIndex = adjacentBondIndices[adj];
+				NvBlastBondFractureData& outCommand = commandBuffers->bondFractures[outCount++];
+				outCommand.nodeIndex0 = node0;
+				outCommand.nodeIndex1 = node1;
+				outCommand.health = totalBondDamage;
+			}
+		}
+	};
 
-				// skip bonds that are already broken or were visited already
-				// TODO: investigate why testing against health > -1.0f seems slower
-				// could reuse the island edge bitmap instead
-				if ((familyBondHealths[bondIndex] > 0.0f))
-				{
+	const ExtDamageAcceleratorInternal* damageAccelerator = programParams->accelerator ? static_cast<const ExtDamageAcceleratorInternal*>(programParams->accelerator) : nullptr;
+	const uint32_t ACTOR_MINIMUM_NODE_COUNT_TO_ACCELERATE = actor->assetNodeCount / 3;
+	if (damageAccelerator && actor->graphNodeCount > ACTOR_MINIMUM_NODE_COUNT_TO_ACCELERATE)
+	{
+		physx::PxBounds3 bounds = boundsFn(programParams->damageDesc);
 
-					const NvBlastBond& bond = assetBonds[bondIndex];
+		const uint32_t CALLBACK_BUFFER_SIZE = 1000;
 
-					float totalBondDamage = 0.0f;
+		class AcceleratorCallback : public ExtDamageAcceleratorInternal::ResultCallback
+		{
+		public:
+			AcceleratorCallback(NvBlastFractureBuffers* commandBuffers, uint32_t& outCount, const NvBlastGraphShaderActor* actor, const NvBlastExtProgramParams* programParams) :
+				ExtDamageAcceleratorInternal::ResultCallback(m_buffer, CALLBACK_BUFFER_SIZE),
+				m_actor(actor),
+				m_commandBuffers(commandBuffers),
+				m_outCount(outCount),
+				m_programParams(programParams)
+			{
+			}
 
-					for (uint32_t damageIndex = 0; damageIndex < damageCount; damageIndex++)
+			virtual void processResults(const ExtDamageAcceleratorInternal::QueryBondData* bondBuffer, uint32_t count) override
+			{
+				for (uint32_t i = 0; i < count; i++)
+				{
+					const ExtDamageAcceleratorInternal::QueryBondData& bondData = bondBuffer[i];
+					if (m_actor->nodeActorIndices[bondData.node0] == m_actor->actorIndex)
 					{
-						totalBondDamage += damageFn(bond.centroid, params->damageDescBuffer, damageIndex);
+						if ((m_actor->familyBondHealths[bondData.bond] > 0.0f))
+						{
+							const NvBlastBond& bond = m_actor->assetBonds[bondData.bond];
+
+							const float totalBondDamage = damageFn(bond.centroid, m_programParams->damageDesc);
+							if (totalBondDamage > 0.0f)
+							{
+								NvBlastBondFractureData& outCommand = m_commandBuffers->bondFractures[m_outCount++];
+								outCommand.nodeIndex0 = bondData.node0;
+								outCommand.nodeIndex1 = bondData.node1;
+								outCommand.health = totalBondDamage;
+							}
+						}
 					}
+				}
+			}
 
-					if (totalBondDamage > 0.0f)
-					{
-						NvBlastBondFractureData& outCommand = commandBuffers->bondFractures[outCount++];
-						outCommand.nodeIndex0 = currentNodeIndex;
-						outCommand.nodeIndex1 = adjacentNodeIndex;
-						outCommand.health = totalBondDamage;
-					}
+		private:
+			const NvBlastGraphShaderActor* m_actor;
+			NvBlastFractureBuffers* m_commandBuffers;
+			uint32_t& m_outCount;
+			const NvBlastExtProgramParams* m_programParams;
+
+			ExtDamageAcceleratorInternal::QueryBondData m_buffer[CALLBACK_BUFFER_SIZE];
+		};
+
+		AcceleratorCallback cb(commandBuffers, outCount, actor, programParams);
+
+		damageAccelerator->findBondCentroidsInBounds(bounds, cb);
+	}
+	else
+	{
+		uint32_t currentNodeIndex = firstGraphNodeIndex;
+		while (!Nv::Blast::isInvalidIndex(currentNodeIndex))
+		{
+			for (uint32_t adj = adjacencyPartition[currentNodeIndex]; adj < adjacencyPartition[currentNodeIndex + 1]; adj++)
+			{
+				uint32_t adjacentNodeIndex = adjacentNodeIndices[adj];
+				if (currentNodeIndex < adjacentNodeIndex)
+				{
+					uint32_t bondIndex = adjacentBondIndices[adj];
+					processBondFn(bondIndex, currentNodeIndex, adjacentNodeIndex);
 				}
 			}
+			currentNodeIndex = graphNodeIndexLinks[currentNodeIndex];
 		}
-		currentNodeIndex = graphNodeIndexLinks[currentNodeIndex];
 	}
 
 	commandBuffers->bondFractureCount = outCount;
@@ -181,20 +266,16 @@ void RadialProfileGraphShader(NvBlastFractureBuffers* commandBuffers, const NvBl
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 template <DamageFunction damageFn>
-void RadialProfileSubgraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastSubgraphShaderActor* actor, const NvBlastProgramParams* params)
+void RadialProfileSubgraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastSubgraphShaderActor* actor, const void* params)
 {
 	uint32_t chunkFractureCount = 0;
 	uint32_t chunkFractureCountMax = commandBuffers->chunkFractureCount;
 	const uint32_t chunkIndex = actor->chunkIndex;
 	const NvBlastChunk* assetChunks = actor->assetChunks;
 	const NvBlastChunk& chunk = assetChunks[chunkIndex];
+	const NvBlastExtProgramParams* programParams = static_cast<const NvBlastExtProgramParams*>(params);
 
-	float totalDamage = 0.0f;
-	for (uint32_t damageIndex = 0; damageIndex < params->damageDescCount; ++damageIndex)
-	{
-		totalDamage += damageFn(chunk.centroid, params->damageDescBuffer, damageIndex);
-	}
-
+	const float totalDamage = damageFn(chunk.centroid, programParams->damageDesc);
 	if (totalDamage > 0.0f && chunkFractureCount < chunkFractureCountMax)
 	{
 		NvBlastChunkFractureData& frac = commandBuffers->chunkFractures[chunkFractureCount++];
@@ -211,34 +292,34 @@ void RadialProfileSubgraphShader(NvBlastFractureBuffers* commandBuffers, const N
 //												Radial Shaders Instantiation
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-void NvBlastExtFalloffGraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastGraphShaderActor* actor, const NvBlastProgramParams* params)
+void NvBlastExtFalloffGraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastGraphShaderActor* actor, const void* params)
 {
-	RadialProfileGraphShader<pointDistanceDamage<falloffProfile>>(commandBuffers, actor, params);
+	RadialProfileGraphShader<pointDistanceDamage<falloffProfile>, sphereBounds>(commandBuffers, actor, params);
 }
 
-void NvBlastExtFalloffSubgraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastSubgraphShaderActor* actor, const NvBlastProgramParams* params)
+void NvBlastExtFalloffSubgraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastSubgraphShaderActor* actor, const void* params)
 {
 	RadialProfileSubgraphShader<pointDistanceDamage<falloffProfile>>(commandBuffers, actor, params);
 }
 
-void NvBlastExtCutterGraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastGraphShaderActor* actor, const NvBlastProgramParams* params)
+void NvBlastExtCutterGraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastGraphShaderActor* actor, const void* params)
 {
-	RadialProfileGraphShader<pointDistanceDamage<cutterProfile>>(commandBuffers, actor, params);
+	RadialProfileGraphShader<pointDistanceDamage<cutterProfile>, sphereBounds>(commandBuffers, actor, params);
 }
 
-void NvBlastExtCutterSubgraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastSubgraphShaderActor* actor, const NvBlastProgramParams* params)
+void NvBlastExtCutterSubgraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastSubgraphShaderActor* actor, const void* params)
 {
 	RadialProfileSubgraphShader<pointDistanceDamage<cutterProfile>>(commandBuffers, actor, params);
 }
 
-void NvBlastExtSegmentFalloffGraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastGraphShaderActor* actor, const NvBlastProgramParams* params)
+void NvBlastExtCapsuleFalloffGraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastGraphShaderActor* actor, const void* params)
 {
-	RadialProfileGraphShader<segmentDistanceDamage<falloffProfile>>(commandBuffers, actor, params);
+	RadialProfileGraphShader<capsuleDistanceDamage<falloffProfile>, capsuleBounds>(commandBuffers, actor, params);
 }
 
-void NvBlastExtSegmentFalloffSubgraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastSubgraphShaderActor* actor, const NvBlastProgramParams* params)
+void NvBlastExtCapsuleFalloffSubgraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastSubgraphShaderActor* actor, const void* params)
 {
-	RadialProfileSubgraphShader<segmentDistanceDamage<falloffProfile>>(commandBuffers, actor, params);
+	RadialProfileSubgraphShader<capsuleDistanceDamage<falloffProfile>>(commandBuffers, actor, params);
 }
 
 
@@ -246,123 +327,437 @@ void NvBlastExtSegmentFalloffSubgraphShader(NvBlastFractureBuffers* commandBuffe
 //													Shear Shader
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-void NvBlastExtShearGraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastGraphShaderActor* actor, const NvBlastProgramParams* params)
+void NvBlastExtShearGraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastGraphShaderActor* actor, const void* params)
 {
 	uint32_t chunkFractureCount = 0;
 	uint32_t chunkFractureCountMax = commandBuffers->chunkFractureCount;
 	uint32_t bondFractureCount = 0;
 	uint32_t bondFractureCountMax = commandBuffers->bondFractureCount;
+	const NvBlastExtProgramParams* programParams = static_cast<const NvBlastExtProgramParams*>(params);
+	const NvBlastExtShearDamageDesc& desc = *static_cast<const NvBlastExtShearDamageDesc*>(programParams->damageDesc);
+	const uint32_t* graphNodeIndexLinks = actor->graphNodeIndexLinks;
+	const uint32_t firstGraphNodeIndex = actor->firstGraphNodeIndex;
+	const uint32_t* chunkIndices = actor->chunkIndices;
+	const uint32_t*	adjacencyPartition = actor->adjacencyPartition;
+	const uint32_t*	adjacentNodeIndices = actor->adjacentNodeIndices;
+	const uint32_t*	adjacentBondIndices = actor->adjacentBondIndices;
+	const NvBlastBond* assetBonds = actor->assetBonds;
+	const NvBlastChunk* assetChunks = actor->assetChunks;
+	const float* familyBondHealths = actor->familyBondHealths;
+	const float* supportChunkHealths = actor->supportChunkHealths;
 
-	for (uint32_t i = 0; i < params->damageDescCount; ++i)
+	uint32_t closestNode = findClosestNode(desc.position
+		, firstGraphNodeIndex, graphNodeIndexLinks
+		, adjacencyPartition, adjacentNodeIndices, adjacentBondIndices
+		, assetBonds, familyBondHealths
+		, assetChunks, supportChunkHealths, chunkIndices);
+
+	uint32_t nodeIndex = closestNode;
+	float maxDist = 0.0f;
+	uint32_t nextNode = invalidIndex<uint32_t>();
+
+	if (chunkFractureCount < chunkFractureCountMax)
 	{
-		const NvBlastExtShearDamageDesc& desc = reinterpret_cast<const NvBlastExtShearDamageDesc*>(params->damageDescBuffer)[i];
-		const uint32_t* graphNodeIndexLinks = actor->graphNodeIndexLinks;
-		const uint32_t firstGraphNodeIndex = actor->firstGraphNodeIndex;
-		const uint32_t* chunkIndices = actor->chunkIndices;
-		const uint32_t*	adjacencyPartition = actor->adjacencyPartition;
-		const uint32_t*	adjacentNodeIndices = actor->adjacentNodeIndices;
-		const uint32_t*	adjacentBondIndices = actor->adjacentBondIndices;
-		const NvBlastBond* assetBonds = actor->assetBonds;
-		const NvBlastChunk* assetChunks = actor->assetChunks;
-		const float* familyBondHealths = actor->familyBondHealths;
-		const float* supportChunkHealths = actor->supportChunkHealths;
-
-		uint32_t closestNode = findClosestNode(desc.position
-			, firstGraphNodeIndex, graphNodeIndexLinks
-			, adjacencyPartition, adjacentNodeIndices, adjacentBondIndices
-			, assetBonds, familyBondHealths
-			, assetChunks, supportChunkHealths, chunkIndices);
-
-		uint32_t nodeIndex = closestNode;
-		float maxDist = 0.0f;
-		uint32_t nextNode = invalidIndex<uint32_t>();
-
-		if (chunkFractureCount < chunkFractureCountMax)
+		const uint32_t chunkIndex = chunkIndices[nodeIndex];
+		const NvBlastChunk& chunk = assetChunks[chunkIndex];
+		NvBlastChunkFractureData& frac = commandBuffers->chunkFractures[chunkFractureCount++];
+		frac.chunkIndex = chunkIndex;
+		frac.health = pointDistanceDamage<falloffProfile, NvBlastExtShearDamageDesc>(chunk.centroid, programParams->damageDesc);
+	}
+
+	do {
+		const uint32_t startIndex = adjacencyPartition[nodeIndex];
+		const uint32_t stopIndex = adjacencyPartition[nodeIndex + 1];
+
+
+		for (uint32_t adjacentNodeIndex = startIndex; adjacentNodeIndex < stopIndex; adjacentNodeIndex++)
 		{
-			const uint32_t chunkIndex = chunkIndices[nodeIndex];
-			const NvBlastChunk& chunk = assetChunks[chunkIndex];
-			NvBlastChunkFractureData& frac = commandBuffers->chunkFractures[chunkFractureCount++];
-			frac.chunkIndex = chunkIndex;
-			frac.health = pointDistanceDamage<falloffProfile, NvBlastExtShearDamageDesc>(chunk.centroid, params->damageDescBuffer, i);
-		}
+			const uint32_t neighbourIndex = adjacentNodeIndices[adjacentNodeIndex];
+			const uint32_t bondIndex = adjacentBondIndices[adjacentNodeIndex];
+			const NvBlastBond& bond = assetBonds[bondIndex];
 
-		do {
-			const uint32_t startIndex = adjacencyPartition[nodeIndex];
-			const uint32_t stopIndex = adjacencyPartition[nodeIndex + 1];
+			if (!(familyBondHealths[bondIndex] > 0.0f))
+				continue;
 
+			float shear = 1 * std::abs(1 - std::abs(VecMath::dot(desc.normal, bond.normal)));
 
-			for (uint32_t adjacentNodeIndex = startIndex; adjacentNodeIndex < stopIndex; adjacentNodeIndex++)
+			float d[3]; VecMath::sub(bond.centroid, desc.position, d);
+			float ahead = VecMath::dot(d, desc.normal);
+			if (ahead > maxDist)
 			{
-				const uint32_t neighbourIndex = adjacentNodeIndices[adjacentNodeIndex];
-				const uint32_t bondIndex = adjacentBondIndices[adjacentNodeIndex];
-				const NvBlastBond& bond = assetBonds[bondIndex];
+				maxDist = ahead;
+				nextNode = neighbourIndex;
+			}
 
-				if (!(familyBondHealths[bondIndex] > 0.0f))
-					continue;
+			const float damage = pointDistanceDamage<falloffProfile, NvBlastExtShearDamageDesc>(bond.centroid, programParams->damageDesc);
+			if (damage > 0.0f && bondFractureCount < bondFractureCountMax)
+			{
+				NvBlastBondFractureData& frac = commandBuffers->bondFractures[bondFractureCount++];
+				frac.userdata = bond.userData;
+				frac.nodeIndex0 = nodeIndex;
+				frac.nodeIndex1 = neighbourIndex;
+				frac.health = shear * damage;
+			}
+		}
 
-				float shear = 1 * std::abs(1 - std::abs(VecMath::dot(desc.normal, bond.normal)));
+		if (nodeIndex == nextNode)
+			break;
+
+		nodeIndex = nextNode;
+	} while (!isInvalidIndex(nextNode));
+
+	commandBuffers->bondFractureCount = bondFractureCount;
+	commandBuffers->chunkFractureCount = chunkFractureCount;
+}
+
+void NvBlastExtShearSubgraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastSubgraphShaderActor* actor, const void* params)
+{
+	RadialProfileSubgraphShader<pointDistanceDamage<falloffProfile, NvBlastExtShearDamageDesc>>(commandBuffers, actor, params);
+}
 
-				float d[3]; VecMath::sub(bond.centroid, desc.position, d);
-				float ahead = VecMath::dot(d, desc.normal);
-				if (ahead > maxDist)
-				{
-					maxDist = ahead;
-					nextNode = neighbourIndex;
-				}
 
-				const float damage = pointDistanceDamage<falloffProfile, NvBlastExtShearDamageDesc>(bond.centroid, params->damageDescBuffer, i);
-				if (damage > 0.0f && bondFractureCount < bondFractureCountMax)
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//												Triangle Intersection Damage
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+#define SMALL_NUMBER	(1.e-4f)
+
+bool intersectSegmentTriangle(const PxVec3& p, const PxVec3& q, const PxVec3& a, const PxVec3& b, const PxVec3& c, const PxPlane& trianglePlane)
+{
+	const PxVec3 N = trianglePlane.n;
+	const float D = trianglePlane.d;
+
+	PxVec3 intersectPoint;
+	float t = (-D - (p.dot(N))) / ((q - p).dot(N));
+	// If the parameter value is not between 0 and 1, there is no intersection
+	if (t > -SMALL_NUMBER && t < 1.f + SMALL_NUMBER)
+	{
+		intersectPoint = p + t * (q - p);
+	}
+	else
+	{
+		return false;
+	}
+
+	// Compute the normal of the triangle
+	const PxVec3 TriNorm = (b - a).cross(c - a);
+
+	// Compute twice area of triangle ABC
+	const float AreaABCInv = 1.0f / (N.dot(TriNorm));
+
+	// Compute v contribution
+	const float AreaPBC = N.dot((b - intersectPoint).cross(c - intersectPoint));
+	const float v = AreaPBC * AreaABCInv;
+	if (v <= 0.f)
+		return false;
+
+	// Compute w contribution
+	const float AreaPCA = N.dot((c - intersectPoint).cross(a - intersectPoint));
+	const float w = AreaPCA * AreaABCInv;
+	if (w <= 0.f)
+		return false;
+
+	const float u = 1.0f - v - w;
+	return u > 0.f;
+}
+
+void NvBlastExtTriangleIntersectionGraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastGraphShaderActor* actor, const void* params)
+{
+	const uint32_t* graphNodeIndexLinks = actor->graphNodeIndexLinks;
+	const uint32_t firstGraphNodeIndex = actor->firstGraphNodeIndex;
+	const uint32_t*	adjacencyPartition = actor->adjacencyPartition;
+	const uint32_t*	adjacentNodeIndices = actor->adjacentNodeIndices;
+	const uint32_t*	adjacentBondIndices = actor->adjacentBondIndices;
+	const NvBlastBond* assetBonds = actor->assetBonds;
+	const NvBlastChunk* assetChunks = actor->assetChunks;
+	const uint32_t* chunkIndices = actor->chunkIndices;
+	const float* familyBondHealths = actor->familyBondHealths;
+	const NvBlastExtProgramParams* programParams = static_cast<const NvBlastExtProgramParams*>(params);
+	const NvBlastExtTriangleIntersectionDamageDesc& desc = *static_cast<const NvBlastExtTriangleIntersectionDamageDesc*>(programParams->damageDesc);
+	const physx::PxVec3& t0 = (reinterpret_cast<const physx::PxVec3&>(desc.position0));
+	const physx::PxVec3& t1 = (reinterpret_cast<const physx::PxVec3&>(desc.position1));
+	const physx::PxVec3& t2 = (reinterpret_cast<const physx::PxVec3&>(desc.position2));
+	const PxPlane trianglePlane(t0, t1, t2);
+
+	uint32_t outCount = 0;
+
+	const ExtDamageAcceleratorInternal* damageAccelerator = programParams->accelerator ? static_cast<const ExtDamageAcceleratorInternal*>(programParams->accelerator) : nullptr;
+	const uint32_t ACTOR_MINIMUM_NODE_COUNT_TO_ACCELERATE = actor->assetNodeCount / 3;
+	if (damageAccelerator && actor->graphNodeCount > ACTOR_MINIMUM_NODE_COUNT_TO_ACCELERATE)
+	{
+		const uint32_t CALLBACK_BUFFER_SIZE = 1000;
+
+		class AcceleratorCallback : public ExtDamageAcceleratorInternal::ResultCallback
+		{
+		public:
+			AcceleratorCallback(NvBlastFractureBuffers* commandBuffers, uint32_t& outCount, const NvBlastGraphShaderActor* actor, const NvBlastExtTriangleIntersectionDamageDesc& desc) :
+				ExtDamageAcceleratorInternal::ResultCallback(m_buffer, CALLBACK_BUFFER_SIZE),
+				m_actor(actor),
+				m_commandBuffers(commandBuffers),
+				m_outCount(outCount),
+				m_desc(desc)
+			{
+			}
+
+			virtual void processResults(const ExtDamageAcceleratorInternal::QueryBondData* bondBuffer, uint32_t count) override
+			{
+				const physx::PxVec3& t0 = (reinterpret_cast<const physx::PxVec3&>(m_desc.position0));
+				const physx::PxVec3& t1 = (reinterpret_cast<const physx::PxVec3&>(m_desc.position1));
+				const physx::PxVec3& t2 = (reinterpret_cast<const physx::PxVec3&>(m_desc.position2));
+				const PxPlane trianglePlane(t0, t1, t2);
+
+				for (uint32_t i = 0; i < count; i++)
 				{
-					NvBlastBondFractureData& frac = commandBuffers->bondFractures[bondFractureCount++];
-					frac.userdata = bond.userData;
-					frac.nodeIndex0 = nodeIndex;
-					frac.nodeIndex1 = neighbourIndex;
-					frac.health = shear * damage;
+					const ExtDamageAcceleratorInternal::QueryBondData& bondData = bondBuffer[i];
+					if (m_actor->nodeActorIndices[bondData.node0] == m_actor->actorIndex)
+					{
+						if ((m_actor->familyBondHealths[bondData.bond] > 0.0f))
+						{
+							const NvBlastBond& bond = m_actor->assetBonds[bondData.bond];
+							const uint32_t chunkIndex0 = m_actor->chunkIndices[bondData.node0];
+							const uint32_t chunkIndex1 = m_actor->chunkIndices[bondData.node1];
+							const physx::PxVec3& c0 = (reinterpret_cast<const physx::PxVec3&>(m_actor->assetChunks[chunkIndex0].centroid));
+							const PxVec3& normal = (reinterpret_cast<const PxVec3&>(bond.normal));
+							const PxVec3& bondCentroid = (reinterpret_cast<const PxVec3&>(bond.centroid));
+							const physx::PxVec3& c1 = isInvalidIndex(chunkIndex1) ? (c0 + normal * (bondCentroid - c0).dot(normal)) :
+								(reinterpret_cast<const physx::PxVec3&>(m_actor->assetChunks[chunkIndex1].centroid));
+
+							if(intersectSegmentTriangle(c0, c1, t0, t1, t2, trianglePlane))
+							{
+								NvBlastBondFractureData& outCommand = m_commandBuffers->bondFractures[m_outCount++];
+								outCommand.nodeIndex0 = bondData.node0;
+								outCommand.nodeIndex1 = bondData.node1;
+								outCommand.health = m_desc.damage;
+							}
+						}
+					}
 				}
 			}
 
-			if (nodeIndex == nextNode)
-				break;
+		private:
+			const NvBlastGraphShaderActor* m_actor;
+			NvBlastFractureBuffers* m_commandBuffers;
+			uint32_t& m_outCount;
+			const NvBlastExtTriangleIntersectionDamageDesc& m_desc;
+
+			ExtDamageAcceleratorInternal::QueryBondData m_buffer[CALLBACK_BUFFER_SIZE];
+		};
 
-			nodeIndex = nextNode;
-		} while (!isInvalidIndex(nextNode));
+		AcceleratorCallback cb(commandBuffers, outCount, actor, desc);
+
+		damageAccelerator->findBondSegmentsPlaneIntersected(trianglePlane, cb);
+	}
+	else 
+	{
+		uint32_t currentNodeIndex = firstGraphNodeIndex;
+		while (!Nv::Blast::isInvalidIndex(currentNodeIndex))
+		{
+			for (uint32_t adj = adjacencyPartition[currentNodeIndex]; adj < adjacencyPartition[currentNodeIndex + 1]; adj++)
+			{
+				uint32_t adjacentNodeIndex = adjacentNodeIndices[adj];
+				if (currentNodeIndex < adjacentNodeIndex)
+				{
+					uint32_t bondIndex = adjacentBondIndices[adj];
+					// skip bonds that are already broken or were visited already
+					// TODO: investigate why testing against health > -1.0f seems slower
+					// could reuse the island edge bitmap instead
+					if ((familyBondHealths[bondIndex] > 0.0f))
+					{
+						const NvBlastBond& bond = assetBonds[bondIndex];
+						const uint32_t chunkIndex0 = chunkIndices[currentNodeIndex];
+						const uint32_t chunkIndex1 = chunkIndices[adjacentNodeIndex];
+						const physx::PxVec3& c0 = (reinterpret_cast<const physx::PxVec3&>(assetChunks[chunkIndex0].centroid));
+						const PxVec3& normal = (reinterpret_cast<const PxVec3&>(bond.normal));
+						const PxVec3& bondCentroid = (reinterpret_cast<const PxVec3&>(bond.centroid));
+						const physx::PxVec3& c1 = isInvalidIndex(chunkIndex1) ? (c0 + normal * (bondCentroid - c0).dot(normal)) : 
+							(reinterpret_cast<const physx::PxVec3&>(assetChunks[chunkIndex1].centroid));
+
+						if (intersectSegmentTriangle(c0, c1, t0, t1, t2, trianglePlane))
+						{
+							NvBlastBondFractureData& outCommand = commandBuffers->bondFractures[outCount++];
+							outCommand.nodeIndex0 = currentNodeIndex;
+							outCommand.nodeIndex1 = adjacentNodeIndex;
+							outCommand.health = desc.damage;
+						}
+					}
+				}
+			}
+			currentNodeIndex = graphNodeIndexLinks[currentNodeIndex];
+		}
 	}
 
-	commandBuffers->bondFractureCount = bondFractureCount;
-	commandBuffers->chunkFractureCount = chunkFractureCount;
+	commandBuffers->bondFractureCount = outCount;
+	commandBuffers->chunkFractureCount = 0;
 }
 
-void NvBlastExtShearSubgraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastSubgraphShaderActor* actor, const NvBlastProgramParams* params)
+void NvBlastExtTriangleIntersectionSubgraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastSubgraphShaderActor* actor, const void* params)
 {
-	RadialProfileSubgraphShader<pointDistanceDamage<falloffProfile, NvBlastExtShearDamageDesc>>(commandBuffers, actor, params);
+	uint32_t chunkFractureCount = 0;
+	uint32_t chunkFractureCountMax = commandBuffers->chunkFractureCount;
+	const uint32_t chunkIndex = actor->chunkIndex;
+	const NvBlastChunk* assetChunks = actor->assetChunks;
+	const NvBlastChunk& chunk = assetChunks[chunkIndex];
+	const NvBlastExtProgramParams* programParams = static_cast<const NvBlastExtProgramParams*>(params);
+	const NvBlastExtTriangleIntersectionDamageDesc& desc = *static_cast<const NvBlastExtTriangleIntersectionDamageDesc*>(programParams->damageDesc);
+	const physx::PxVec3& t0 = (reinterpret_cast<const physx::PxVec3&>(desc.position0));
+	const physx::PxVec3& t1 = (reinterpret_cast<const physx::PxVec3&>(desc.position1));
+	const physx::PxVec3& t2 = (reinterpret_cast<const physx::PxVec3&>(desc.position2));
+	const PxPlane trianglePlane(t0, t1, t2);
+
+	for (uint32_t subChunkIndex = chunk.firstChildIndex; subChunkIndex < chunk.childIndexStop; subChunkIndex++)
+	{
+		const physx::PxVec3& c0 = (reinterpret_cast<const physx::PxVec3&>(assetChunks[subChunkIndex].centroid));
+		const physx::PxVec3& c1 = (reinterpret_cast<const physx::PxVec3&>(assetChunks[subChunkIndex + 1].centroid));
+		if (chunkFractureCount < chunkFractureCountMax && intersectSegmentTriangle(c0, c1, t0, t1, t2, trianglePlane))
+		{
+			NvBlastChunkFractureData& frac = commandBuffers->chunkFractures[chunkFractureCount++];
+			frac.chunkIndex = chunkIndex;
+			frac.health = desc.damage;
+			break;
+		}
+	}
+
+	commandBuffers->bondFractureCount = 0;
+	commandBuffers->chunkFractureCount = chunkFractureCount;
 }
 
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//												Helper Functions
+//												 Impact Spread Shader
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-bool NvBlastExtDamageActorRadialFalloff(NvBlastActor* actor, NvBlastFractureBuffers* buffers, const NvBlastExtRadialDamageDesc* damageDescBuffer, uint32_t damageDescCount, const NvBlastExtMaterial* material, NvBlastLog logFn, NvBlastTimers* timers)
+void NvBlastExtImpactSpreadGraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastGraphShaderActor* actor, const void* params)
 {
-	NvBlastDamageProgram program =
+	uint32_t chunkFractureCount = 0;
+	uint32_t chunkFractureCountMax = commandBuffers->chunkFractureCount;
+	uint32_t bondFractureCount = 0;
+	uint32_t bondFractureCountMax = commandBuffers->bondFractureCount;
+	const NvBlastExtProgramParams* programParams = static_cast<const NvBlastExtProgramParams*>(params);
+	const NvBlastExtImpactSpreadDamageDesc& desc = *static_cast<const NvBlastExtImpactSpreadDamageDesc*>(programParams->damageDesc);
+	const uint32_t* graphNodeIndexLinks = actor->graphNodeIndexLinks;
+	const uint32_t firstGraphNodeIndex = actor->firstGraphNodeIndex;
+	const uint32_t* chunkIndices = actor->chunkIndices;
+	const uint32_t*	adjacencyPartition = actor->adjacencyPartition;
+	const uint32_t*	adjacentNodeIndices = actor->adjacentNodeIndices;
+	const uint32_t*	adjacentBondIndices = actor->adjacentBondIndices;
+	const NvBlastBond* assetBonds = actor->assetBonds;
+	const NvBlastChunk* assetChunks = actor->assetChunks;
+	const float* familyBondHealths = actor->familyBondHealths;
+	const float* supportChunkHealths = actor->supportChunkHealths;
+
+	// Find nearest chunk. 
+	uint32_t closestNode = findClosestNode(desc.position
+		, firstGraphNodeIndex, graphNodeIndexLinks
+		, adjacencyPartition, adjacentNodeIndices, adjacentBondIndices
+		, assetBonds, familyBondHealths
+		, assetChunks, supportChunkHealths, chunkIndices);
+
+	uint32_t nodeIndex = closestNode;
+
+	// Damage this chunk
+	if (chunkFractureCount < chunkFractureCountMax)
 	{
-		NvBlastExtFalloffGraphShader,
-		NvBlastExtFalloffSubgraphShader
-	};
+		const uint32_t chunkIndex = chunkIndices[nodeIndex];
+		NvBlastChunkFractureData& frac = commandBuffers->chunkFractures[chunkFractureCount++];
+		frac.chunkIndex = chunkIndex;
+		frac.health = desc.damage;
+	}
 
-	NvBlastProgramParams params =
+	// Breadth-first support graph traversal. For radial falloff metric distance is measured along the edges of the graph
+	ExtDamageAcceleratorInternal* damageAccelerator = programParams->accelerator ? static_cast<ExtDamageAcceleratorInternal*>(programParams->accelerator) : nullptr;
+	NVBLAST_ASSERT_WITH_MESSAGE(damageAccelerator, "This shader requires damage accelerator passed");
+	if (damageAccelerator)
 	{
-		damageDescBuffer,
-		damageDescCount,
-		material
-	};
+		struct NodeData
+		{
+			uint32_t index;
+			float distance;
+		};
+
+		// Calculating scratch size and requesting it from the accelerator
+		const uint32_t bondCount = actor->adjacencyPartition[actor->assetNodeCount];
+		const size_t nodeQueueSize = align16(FixedQueue<NodeData>::requiredMemorySize(actor->graphNodeCount));
+		const size_t visitedBitmapSize = align16(FixedBitmap::requiredMemorySize(bondCount));
+		const size_t scratchSize = 16 + nodeQueueSize + visitedBitmapSize;
+
+		void* scratch = damageAccelerator->getImmediateScratch(scratchSize);
+
+		// prepare intermediate data on scratch
+		scratch = (void*)align16((size_t)scratch); // Bump to 16-byte alignment
+		FixedQueue<NodeData>* nodeQueue = new (scratch)FixedQueue<NodeData>(actor->graphNodeCount);
+		scratch = pointerOffset(scratch, align16(nodeQueueSize));
+		FixedBitmap* visitedBitmap = new (scratch)FixedBitmap(bondCount);
+		scratch = pointerOffset(scratch, align16(FixedBitmap::requiredMemorySize(bondCount)));
+
+		// initalize traversal
+		nodeQueue->pushBack({ nodeIndex, 0.f });
+		visitedBitmap->clear();
+
+		while (!nodeQueue->empty())
+		{
+			NodeData currentNode = nodeQueue->popFront();
+			const uint32_t startIndex = adjacencyPartition[currentNode.index];
+			const uint32_t stopIndex = adjacencyPartition[currentNode.index + 1];
+
+			for (uint32_t adjacentNodeIndex = startIndex; adjacentNodeIndex < stopIndex; adjacentNodeIndex++)
+			{
+				const uint32_t neighbourIndex = adjacentNodeIndices[adjacentNodeIndex];
+				const uint32_t bondIndex = adjacentBondIndices[adjacentNodeIndex];
+				const NvBlastBond& bond = assetBonds[bondIndex];
+
+				const PxVec3& bondCentroid = (reinterpret_cast<const PxVec3&>(bond.centroid));
+
+				if (!(familyBondHealths[bondIndex] > 0.0f))
+					continue;
+				
+				if (visitedBitmap->test(bondIndex))
+					continue;
+				visitedBitmap->set(bondIndex);
+
+				const uint32_t chunkIndex0 = chunkIndices[currentNode.index];
+				const uint32_t chunkIndex1 = chunkIndices[neighbourIndex];
+				const physx::PxVec3& c0 = reinterpret_cast<const physx::PxVec3&>(assetChunks[chunkIndex0].centroid);
+				bool isNeighbourWorldChunk = isInvalidIndex(chunkIndex1);
+				const physx::PxVec3& c1 = isNeighbourWorldChunk ? bondCentroid : (reinterpret_cast<const physx::PxVec3&>(assetChunks[chunkIndex1].centroid));
+
+				const float distance = (c1 - c0).magnitude() * (isNeighbourWorldChunk ? 2.f : 1.f);
+				float totalDistance = currentNode.distance + distance;
+				float totalDamage = falloffProfile(desc.minRadius, desc.maxRadius, totalDistance);
+				if (totalDamage > 0.0f && bondFractureCount < bondFractureCountMax)
+				{
+					NvBlastBondFractureData& frac = commandBuffers->bondFractures[bondFractureCount++];
+					frac.userdata = bond.userData;
+					frac.nodeIndex0 = currentNode.index;
+					frac.nodeIndex1 = neighbourIndex;
+					frac.health = totalDamage;
+					if (!isNeighbourWorldChunk)
+					{
+						nodeQueue->pushBack({ neighbourIndex, totalDistance });
+					}
+				}
+			}
+		}
+	}
+
+	commandBuffers->bondFractureCount = bondFractureCount;
+	commandBuffers->chunkFractureCount = chunkFractureCount;
+}
 
-	NvBlastActorGenerateFracture(buffers, actor, program, &params, logFn, timers);
-	if (buffers->bondFractureCount > 0 || buffers->chunkFractureCount > 0)
+void NvBlastExtImpactSpreadSubgraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastSubgraphShaderActor* actor, const void* params)
+{
+	uint32_t chunkFractureCount = 0;
+	uint32_t chunkFractureCountMax = commandBuffers->chunkFractureCount;
+	const uint32_t chunkIndex = actor->chunkIndex;
+	const NvBlastExtProgramParams* programParams = static_cast<const NvBlastExtProgramParams*>(params);
+	const NvBlastExtImpactSpreadDamageDesc& desc = *static_cast<const NvBlastExtImpactSpreadDamageDesc*>(programParams->damageDesc);
+
+	if (chunkFractureCount < chunkFractureCountMax)
 	{
-		NvBlastActorApplyFracture(nullptr, actor, buffers, logFn, timers);
-		return true;
+		NvBlastChunkFractureData& frac = commandBuffers->chunkFractures[chunkFractureCount++];
+		frac.chunkIndex = chunkIndex;
+		frac.health = desc.damage;
 	}
 
-	return false;
-}
\ No newline at end of file
+	commandBuffers->bondFractureCount = 0;
+	commandBuffers->chunkFractureCount = chunkFractureCount;
+}