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

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

213 files changed, 0 insertions, 41706 deletions

diff --git a/NvBlast/sdk/CMakeLists.txt b/NvBlast/sdk/CMakeLists.txt
deleted file mode 100644
index 6c816a2..0000000
--- a/NvBlast/sdk/CMakeLists.txt
+++ /dev/null
@@ -1,90 +0,0 @@
-cmake_minimum_required(VERSION 3.3)
-
-project(BlastSDK CXX)
-
-CMAKE_POLICY(SET CMP0057 NEW) # Enable IN_LIST
-
-IF(NOT DEFINED BLAST_ROOT_DIR)
-	
-	STRING(REPLACE "\\" "/" BRD_TEMP $ENV{BLAST_ROOT_DIR})
-	
-	# This env variable is set by GenerateProjects.bat, and is no longer available when CMake rebuilds, so this stores it in the cache
-	SET(BLAST_ROOT_DIR ${BRD_TEMP} CACHE INTERNAL "Root of the Blast source tree")
-
-ENDIF()
-
-IF(NOT EXISTS ${BLAST_ROOT_DIR})
-	MESSAGE(FATAL_ERROR "BLAST_ROOT_DIR environment variable wasn't set or was invalid.")
-ENDIF()
-
-SET(GW_DEPS_ROOT $ENV{PM_PACKAGES_ROOT})
-
-# Add the project specific CMake modules to the module path
-LIST(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/compiler/cmake/modules/)
-
-IF(NOT DEFINED CMAKEMODULES_VERSION)
-	SET(CMAKEMODULES_VERSION $ENV{PM_CMakeModules_VERSION} CACHE INTERNAL "CMakeModules version from generation batch")
-ENDIF()
-
-#TODO: More elegance
-IF(NOT EXISTS ${GW_DEPS_ROOT}/CMakeModules/${CMAKEMODULES_VERSION})
-	MESSAGE(FATAL_ERROR "Could not find CMakeModules at ${GW_DEPS_ROOT}")
-ENDIF()
-
-SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${GW_DEPS_ROOT}/CMakeModules/${CMAKEMODULES_VERSION}")
-
-MESSAGE("Module path:" ${CMAKE_MODULE_PATH})
-
-IF(CMAKE_CONFIGURATION_TYPES)
-	SET(CMAKE_CONFIGURATION_TYPES debug profile checked release)
-	SET(CMAKE_CONFIGURATION_TYPES "${CMAKE_CONFIGURATION_TYPES}" CACHE STRING
-		"Reset config to what we need" 
-		FORCE)
-	
-	SET(CMAKE_SHARED_LINKER_FLAGS_CHECKED "")
-	SET(CMAKE_SHARED_LINKER_FLAGS_PROFILE "")
-	
-ENDIF()
-
-# Default to appending "DEBUG", "PROFILE", etc to produced artifacts
-IF(NOT DEFINED APPEND_CONFIG_NAME)
-	SET(APPEND_CONFIG_NAME ON)
-ENDIF()
-
-IF (APPEND_CONFIG_NAME)
-	MESSAGE("Appending config to output names")
-
-	SET(CMAKE_DEBUG_POSTFIX "DEBUG")
-	SET(CMAKE_PROFILE_POSTFIX "PROFILE")
-	SET(CMAKE_CHECKED_POSTFIX "CHECKED")
-	SET(CMAKE_RELEASE_POSTFIX "")
-ENDIF()
-
-INCLUDE(SetOutputPaths)
-
-# Either have to define a single output path, or each one.
-
-IF(NOT DEFINED BL_OUTPUT_DIR)
-	IF (NOT DEFINED BL_LIB_OUTPUT_DIR)
-		MESSAGE(FATAL_ERROR "BL_LIB_OUTPUT_DIR not defined - Define either BL_OUTPUT_DIR or BL_LIB_OUTPUT_DIR and BL_DLL_OUTPUT_DIR and BL_EXE_OUTPUT_DIR")
-	ENDIF()
-
-	IF (NOT DEFINED BL_DLL_OUTPUT_DIR)
-		MESSAGE(FATAL_ERROR "BL_DLL_OUTPUT_DIR not defined - Define either BL_OUTPUT_DIR or BL_LIB_OUTPUT_DIR and BL_DLL_OUTPUT_DIR and BL_EXE_OUTPUT_DIR")
-	ENDIF()
-
-	IF (NOT DEFINED BL_EXE_OUTPUT_DIR)
-		MESSAGE(FATAL_ERROR "BL_EXE_OUTPUT_DIR not defined - Define either BL_OUTPUT_DIR or BL_LIB_OUTPUT_DIR and BL_DLL_OUTPUT_DIR and BL_EXE_OUTPUT_DIR")
-	ENDIF()
-	
-	SetLibOutputPath(${BL_LIB_OUTPUT_DIR})
-	SetDllOutputPath(${BL_DLL_OUTPUT_DIR})
-	SetExeOutputPath(${BL_EXE_OUTPUT_DIR})
-ELSE()
-	SetSingleOutputPath(${BL_OUTPUT_DIR})
-ENDIF()
-
-SET(PROJECT_CMAKE_FILES_DIR compiler/cmake/)
-
-# Include the platform specific configuration
-INCLUDE(${PROJECT_CMAKE_FILES_DIR}/${TARGET_BUILD_PLATFORM}/CMakeLists.txt)
diff --git a/NvBlast/sdk/common/NvBlastAssert.cpp b/NvBlast/sdk/common/NvBlastAssert.cpp
deleted file mode 100644
index 7731a53..0000000
--- a/NvBlast/sdk/common/NvBlastAssert.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
- *
- * NVIDIA CORPORATION and its licensors retain all intellectual property
- * and proprietary rights in and to this software, related documentation
- * and any modifications thereto.  Any use, reproduction, disclosure or
- * distribution of this software and related documentation without an express
- * license agreement from NVIDIA CORPORATION is strictly prohibited.
- */
-
-
-#include "NvBlastAssert.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#if NV_WINDOWS_FAMILY
-#include <crtdbg.h>
-#endif
-
-extern "C"
-{
-
-void NvBlastAssertHandler(const char* expr, const char* file, int line, bool& ignore)
-{
-	NV_UNUSED(ignore); // is used only in debug windows config
-	char buffer[1024];
-#if NV_WINDOWS_FAMILY
-	sprintf_s(buffer, 1024, "%s(%d) : Assertion failed: %s\n", file, line, expr);
-#else
-	sprintf(buffer, "%s(%d) : Assertion failed: %s\n", file, line, expr);
-#endif
-	puts(buffer);
-#if NV_WINDOWS_FAMILY && NV_DEBUG
-	// _CrtDbgReport returns -1 on error, 1 on 'retry', 0 otherwise including 'ignore'.
-	// Hitting 'abort' will terminate the process immediately.
-	int result = _CrtDbgReport(_CRT_ASSERT, file, line, NULL, "%s", buffer);
-	int mode = _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_REPORT_MODE);
-	ignore = _CRTDBG_MODE_WNDW == mode && result == 0;
-	if (ignore)
-		return;
-	__debugbreak();
-#elif (NV_WINDOWS_FAMILY && NV_CHECKED) || NV_CLANG
-	__debugbreak();
-#else
-	abort();
-#endif
-}
-
-} // extern "C"
diff --git a/NvBlast/sdk/common/NvBlastAssert.h b/NvBlast/sdk/common/NvBlastAssert.h
deleted file mode 100644
index b1b7ca5..0000000
--- a/NvBlast/sdk/common/NvBlastAssert.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
- *
- * NVIDIA CORPORATION and its licensors retain all intellectual property
- * and proprietary rights in and to this software, related documentation
- * and any modifications thereto.  Any use, reproduction, disclosure or
- * distribution of this software and related documentation without an express
- * license agreement from NVIDIA CORPORATION is strictly prohibited.
- */
-
-#ifndef NVBLASTASSERT_H
-#define NVBLASTASSERT_H
-
-
-#include "NvBlastPreprocessor.h"
-
-
-#if !NV_ENABLE_ASSERTS
-#define NVBLAST_ASSERT(exp) ((void)0)
-#define NVBLAST_ALWAYS_ASSERT_MESSAGE(exp) ((void)0)
-#define NVBLAST_ASSERT_WITH_MESSAGE(condition, message) ((void)0)
-#else
-#if NV_VC
-#define NVBLAST_CODE_ANALYSIS_ASSUME(exp)                                                                     \
-	__analysis_assume(!!(exp)) // This macro will be used to get rid of analysis warning messages if a NVBLAST_ASSERT is used
-// to "guard" illegal mem access, for example.
-#else
-#define NVBLAST_CODE_ANALYSIS_ASSUME(exp)
-#endif
-#define NVBLAST_ASSERT(exp)                                                                                   \
-{                                                                                                             \
-	static bool _ignore = false;                                                                              \
-	if (!(exp) && !_ignore) NvBlastAssertHandler(#exp, __FILE__, __LINE__, _ignore);                          \
-	NVBLAST_CODE_ANALYSIS_ASSUME(exp);                                                                        \
-} ((void)0)
-#define NVBLAST_ALWAYS_ASSERT_MESSAGE(exp)                                                                    \
-{                                                                                                             \
-	static bool _ignore = false;                                                                              \
-	if(!_ignore)                                                                                              \
-	{                                                                                                         \
-		NvBlastAssertHandler(exp, __FILE__, __LINE__, _ignore);                                               \
-	}                                                                                                         \
-} ((void)0)
-#define NVBLAST_ASSERT_WITH_MESSAGE(exp, message)                                                             \
-{                                                                                                             \
-	static bool _ignore = false;                                                                              \
-	if (!(exp) && !_ignore) NvBlastAssertHandler(message, __FILE__, __LINE__, _ignore);                       \
-	NVBLAST_CODE_ANALYSIS_ASSUME(exp);                                                                        \
-} ((void)0)
-#endif
-
-#define NVBLAST_ALWAYS_ASSERT() NVBLAST_ASSERT(0)
-
-
-extern "C"
-{
-
-NVBLAST_API void NvBlastAssertHandler(const char* expr, const char* file, int line, bool& ignore);
-
-} // extern "C"
-
-
-#endif // #ifndef NVBLASTASSERT_H
diff --git a/NvBlast/sdk/common/NvBlastAtomic.cpp b/NvBlast/sdk/common/NvBlastAtomic.cpp
deleted file mode 100644
index 6b9d94b..0000000
--- a/NvBlast/sdk/common/NvBlastAtomic.cpp
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
- *
- * NVIDIA CORPORATION and its licensors retain all intellectual property
- * and proprietary rights in and to this software, related documentation
- * and any modifications thereto.  Any use, reproduction, disclosure or
- * distribution of this software and related documentation without an express
- * license agreement from NVIDIA CORPORATION is strictly prohibited.
- */
-
-
-#include "NvBlastAtomic.h"
-
-#include <string.h>
-#include <stdlib.h>
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//												Windows/XBOXONE Implementation
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-#if NV_WINDOWS_FAMILY || NV_XBOXONE
-
-#include "NvBlastIncludeWindows.h"
-
-int32_t atomicIncrement(volatile int32_t* val)
-{
-	return (int32_t)InterlockedIncrement((volatile LONG*)val);
-}
-
-int32_t atomicDecrement(volatile int32_t* val)
-{
-	return (int32_t)InterlockedDecrement((volatile LONG*)val);
-}
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//												Unix/PS4 Implementation
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-#elif(NV_UNIX_FAMILY || NV_PS4)
-
-int32_t atomicIncrement(volatile int32_t* val)
-{
-	return __sync_add_and_fetch(val, 1);
-}
-
-int32_t atomicDecrement(volatile int32_t* val)
-{
-	return __sync_sub_and_fetch(val, 1);
-}
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//												Unsupported Platforms
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-#else
-
-#error "Platform not supported!"
-
-#endif
-
-
-} // namespace Blast
-} // namespace Nv
-
diff --git a/NvBlast/sdk/common/NvBlastAtomic.h b/NvBlast/sdk/common/NvBlastAtomic.h
deleted file mode 100644
index a3e6755..0000000
--- a/NvBlast/sdk/common/NvBlastAtomic.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
- *
- * NVIDIA CORPORATION and its licensors retain all intellectual property
- * and proprietary rights in and to this software, related documentation
- * and any modifications thereto.  Any use, reproduction, disclosure or
- * distribution of this software and related documentation without an express
- * license agreement from NVIDIA CORPORATION is strictly prohibited.
- */
-
-#ifndef NVBLASTATOMIC_H
-#define NVBLASTATOMIC_H
-
-#include "NvBlastTypes.h"
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-/* increment the specified location. Return the incremented value */
-int32_t atomicIncrement(volatile int32_t* val);
-
-
-/* decrement the specified location. Return the decremented value */
-int32_t atomicDecrement(volatile int32_t* val);
-
-} // namespace Blast
-} // namespace Nv
-
-#endif // #ifndef NVBLASTATOMIC_H
diff --git a/NvBlast/sdk/common/NvBlastDLink.h b/NvBlast/sdk/common/NvBlastDLink.h
deleted file mode 100644
index bfcee24..0000000
--- a/NvBlast/sdk/common/NvBlastDLink.h
+++ /dev/null
@@ -1,285 +0,0 @@
-/*
- * Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
- *
- * NVIDIA CORPORATION and its licensors retain all intellectual property
- * and proprietary rights in and to this software, related documentation
- * and any modifications thereto.  Any use, reproduction, disclosure or
- * distribution of this software and related documentation without an express
- * license agreement from NVIDIA CORPORATION is strictly prohibited.
- */
-
-#ifndef NVBLASTDLINK_H
-#define NVBLASTDLINK_H
-
-
-#include "NvBlastAssert.h"
-#include "NvBlastIndexFns.h"
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-template<typename IndexType>
-struct IndexDLink
-{
-	IndexType	m_adj[2];
-};
-
-
-template<typename IndexType>
-class IndexDList
-{
-public:
-	void		initLinksSolitary(IndexDLink<IndexType>* links, IndexType linkCount)
-	{
-		for (IndexType i = 0; i < linkCount; ++i)
-		{
-			links[i].m_adj[0] = invalidIndex<IndexType>();
-			links[i].m_adj[1] = invalidIndex<IndexType>();
-		}
-	}
-
-	void		initLinksChain(IndexDLink<IndexType>* links, IndexType linkCount)
-	{
-		if (linkCount > 0)
-		{
-			links[0].m_adj[0] = invalidIndex<IndexType>();
-			for (IndexType i = 1; i < linkCount; ++i)
-			{
-				links[i - 1].m_adj[1] = i;
-				links[i].m_adj[0] = i - 1;
-			}
-			links[linkCount - 1].m_adj[1] = invalidIndex<IndexType>();
-		}
-	}
-
-	IndexType	getAdj(IndexDLink<IndexType>* links, IndexType linkIndex, int which)
-	{
-		return links[linkIndex].m_adj[which & 1];
-	}
-
-	void		remove(IndexDLink<IndexType>* links, IndexType linkIndex)
-	{
-		IndexDLink<IndexType>& link = links[linkIndex];
-		const IndexType adj0 = link.m_adj[0];
-		const IndexType adj1 = link.m_adj[1];
-		if (!isInvalidIndex(adj1))
-		{
-			links[adj1].m_adj[0] = adj0;
-			link.m_adj[1] = invalidIndex<IndexType>();
-		}
-		if (!isInvalidIndex(adj0))
-		{
-			links[adj0].m_adj[1] = adj1;
-			link.m_adj[0] = invalidIndex<IndexType>();
-		}
-	}
-
-	bool		isSolitary(IndexDLink<IndexType>* links, IndexType linkIndex)
-	{
-		const IndexDLink<IndexType>& link = links[linkIndex];
-		return isInvalidIndex(link.m_adj[0]) && isInvalidIndex(link.m_adj[1]);
-	}
-
-	void		insertListHead(IndexType& listHead, IndexDLink<IndexType>* links, IndexType linkIndex)
-	{
-		NVBLAST_ASSERT(!isInvalidIndex(linkIndex));
-		if (!isInvalidIndex(listHead))
-		{
-			links[listHead].m_adj[0] = linkIndex;
-		}
-		links[linkIndex].m_adj[1] = listHead;
-		listHead = linkIndex;
-	}
-
-	IndexType	removeListHead(IndexType& listHead, IndexDLink<IndexType>* links)
-	{
-		const IndexType linkIndex = listHead;
-		if (!isInvalidIndex(linkIndex))
-		{
-			listHead = links[linkIndex].m_adj[1];
-			if (!isInvalidIndex(listHead))
-			{
-				links[listHead].m_adj[0] = invalidIndex<IndexType>();
-			}
-			links[linkIndex].m_adj[1] = invalidIndex<IndexType>();
-		}
-		return linkIndex;
-	}
-
-	void		removeFromList(IndexType& listHead, IndexDLink<IndexType>* links, IndexType linkIndex)
-	{
-		NVBLAST_ASSERT(!isInvalidIndex(linkIndex));
-		if (listHead == linkIndex)
-		{
-			listHead = links[linkIndex].m_adj[1];
-		}
-		remove(links, linkIndex);
-	}
-};
-
-
-struct DLink
-{
-	DLink() : m_prev(nullptr), m_next(nullptr) {}
-
-	DLink*	getPrev() const
-	{
-		return m_prev;
-	}
-
-	DLink*	getNext() const
-	{
-		return m_next;
-	}
-
-private:
-	DLink*	m_prev;
-	DLink*	m_next;
-
-	friend class DList;
-};
-
-
-class DList
-{
-public:
-	DList() : m_head(nullptr), m_tail(nullptr) {}
-
-	bool	isEmpty() const
-	{
-		NVBLAST_ASSERT((m_head == nullptr) == (m_tail == nullptr));
-		return m_head == nullptr;
-	}
-
-	bool	isSolitary(const DLink& link) const
-	{
-		return link.m_prev == nullptr && link.m_next == nullptr && m_head != &link;
-	}
-
-	DLink*	getHead() const
-	{
-		return m_head;
-	}
-
-	DLink*	getTail() const
-	{
-		return m_tail;
-	}
-
-	bool	insertHead(DLink& link)
-	{
-		NVBLAST_ASSERT(isSolitary(link));
-		if (!isSolitary(link))
-		{
-			return false;
-		}
-
-		link.m_next = m_head;
-		if (m_head != nullptr)
-		{
-			m_head->m_prev = &link;
-		}
-		m_head = &link;
-		if (m_tail == nullptr)
-		{
-			m_tail = &link;
-		}
-
-		return true;
-	}
-
-	bool	insertTail(DLink& link)
-	{
-		NVBLAST_ASSERT(isSolitary(link));
-		if (!isSolitary(link))
-		{
-			return false;
-		}
-
-		link.m_prev = m_tail;
-		if (m_tail != nullptr)
-		{
-			m_tail->m_next = &link;
-		}
-		m_tail = &link;
-		if (m_head == nullptr)
-		{
-			m_head = &link;
-		}
-
-		return true;
-	}
-
-	void	remove(DLink& link)
-	{
-		if (link.m_prev != nullptr)
-		{
-			link.m_prev->m_next = link.m_next;
-		}
-		else
-		if (m_head == &link)
-		{
-			m_head = link.m_next;
-		}
-
-		if (link.m_next != nullptr)
-		{
-			link.m_next->m_prev = link.m_prev;
-		}
-		else
-		if (m_tail == &link)
-		{
-			m_tail = link.m_prev;
-		}
-
-		link.m_next = link.m_prev = nullptr;
-	}
-
-	class It
-	{
-	public:
-		enum Direction { Reverse, Forward };
-
-		It(const DList& list, Direction dir = Forward) : m_curr(dir == Forward ? list.getHead() : list.getTail()) {}
-
-		/** Validity of current value. */
-		operator bool() const
-		{
-			return m_curr != nullptr;
-		}
-
-		/** Current value. */
-		operator const DLink*() const
-		{
-			return m_curr;
-		}
-
-		/** Pre-increment. */
-		const DLink*	operator ++ ()
-		{
-			return m_curr = m_curr->getNext();
-		}
-
-		/** Pre-deccrement. */
-		const DLink*	operator -- ()
-		{
-			return m_curr = m_curr->getPrev();
-		}
-
-	private:
-		const DLink*	m_curr;
-	};
-
-private:
-	DLink*	m_head;
-	DLink*	m_tail;
-};
-
-} // end namespace Blast
-} // end namespace Nv
-
-
-#endif // #ifndef NVBLASTDLINK_H
diff --git a/NvBlast/sdk/common/NvBlastFixedArray.h b/NvBlast/sdk/common/NvBlastFixedArray.h
deleted file mode 100644
index 654158b..0000000
--- a/NvBlast/sdk/common/NvBlastFixedArray.h
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTFIXEDARRAY_H
-#define NVBLASTFIXEDARRAY_H
-
-#include "NvBlastAssert.h"
-#include "NvBlastMemory.h"
-
-namespace Nv
-{
-namespace Blast
-{
-
-/*!
-FixedArray is a sequential container which is intended to be used with placement new on chunk of memory.
-It'll use following memory for data layout. As follows:
-
-// some memory
-char ​*buf = new char[64 *​ 1024];
-
-// placement new on this memory
-FixedArray<SomeClass>* arr = new (buf) FixedArray<SomeClass>();
-
-// you can get max requiredMemorySize by an array of 'capacity' elements count to use memory left
-buf = buf + FixedArray<SomeClass>::requiredMemorySize(capacity);
-
-buf:
-
-+------------------------------------------------------------+
-|  uint32_t  |  T[0]  |  T[1]  |  T[2]  |         ...        |
-+------------------------------------------------------------+
-
-
-!!!TODO:
-- check ctor/dtor of elements calls
-*/
-template <class T>
-class FixedArray
-{
-public:
-	explicit FixedArray() : m_size(0)
-	{
-	}
-
-	static size_t requiredMemorySize(uint32_t capacity)
-	{
-		return align16(sizeof(FixedArray<T>)) + align16(capacity * sizeof(T));
-	}
-
-	NV_FORCE_INLINE T& pushBack(T& t)
-	{
-		new (data() + m_size) T(t);
-		return data()[m_size++];
-	}
-
-	T popBack()
-	{
-		NVBLAST_ASSERT(m_size);
-		T t = data()[m_size - 1];
-		data()[--m_size].~T();
-		return t;
-	}
-
-	void clear()
-	{
-		for(T* first = data(); first < data() + m_size; ++first)
-			first->~T();
-		m_size = 0;
-	}
-
-	NV_FORCE_INLINE void forceSize_Unsafe(uint32_t s)
-	{
-		m_size = s;
-	}
-
-	NV_FORCE_INLINE T& operator[](uint32_t idx)
-	{
-		NVBLAST_ASSERT(idx < m_size);
-		return data()[idx];
-	}
-
-	NV_FORCE_INLINE const T& operator[](uint32_t idx) const
-	{
-		NVBLAST_ASSERT(idx < m_size);
-		return data()[idx];
-	}
-
-	NV_FORCE_INLINE T& at(uint32_t idx)
-	{
-		NVBLAST_ASSERT(idx < m_size);
-		return data()[idx];
-	}
-
-	NV_FORCE_INLINE const T& at(uint32_t idx) const
-	{
-		NVBLAST_ASSERT(idx < m_size);
-		return data()[idx];
-	}
-
-	NV_FORCE_INLINE uint32_t size() const
-	{
-		return m_size;
-	}
-
-private:
-	uint32_t m_size;
-
-	NV_FORCE_INLINE T* data()
-	{
-		return (T*)((char*)this + sizeof(FixedArray<T>));
-	}
-
-private:
-	FixedArray(const FixedArray& that);
-};
-
-} // namespace Blast
-} // namespace Nv
-
-#endif // ifndef NVBLASTFIXEDARRAY_H
diff --git a/NvBlast/sdk/common/NvBlastFixedBitmap.h b/NvBlast/sdk/common/NvBlastFixedBitmap.h
deleted file mode 100644
index af835cf..0000000
--- a/NvBlast/sdk/common/NvBlastFixedBitmap.h
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTFIXEDBITMAP_H
-#define NVBLASTFIXEDBITMAP_H
-
-#include "NvBlastAssert.h"
-#include "NvBlastMemory.h"
-#include <cstring>
-
-namespace Nv
-{
-namespace Blast
-{
-
-/*!
-FixedBitmap is a bitset (bitmap) of fixed side, it's intended to be used with placement new on chunk of memory.
-It'll use following memory for data layout. As follows:
-
-// some memory
-char ​*buf = new char[64 *​ 1024];
-
-const uint32_t bitsCount = 100;
-
-// placement new on this memory
-FixedBitmap* arr = new (buf) FixedBitmap(bitsCount);
-
-// you can get max requiredMemorySize by an bitMap to use memory left
-buf = buf + FixedBitmap<SomeClass>::requiredMemorySize(bitsCount);
-
-buf:
-
-+------------------------------------------------------------+
-|  uint32_t  |  word0  |  word1  |  word2  |       ...       |
-+------------------------------------------------------------+
-
-*/
-class FixedBitmap
-{
-public:
-	explicit FixedBitmap(uint32_t bitsCount)
-	{
-		m_bitsCount = bitsCount;
-	}
-
-	static uint32_t getWordsCount(uint32_t bitsCount)
-	{
-		return (bitsCount + 31) >> 5;
-	}
-
-	static size_t requiredMemorySize(uint32_t bitsCount)
-	{
-		return align16(sizeof(FixedBitmap)) + align16(getWordsCount(bitsCount) * sizeof(uint32_t));
-	}
-
-	void clear()
-	{
-		memset(data(), 0, getWordsCount(m_bitsCount) * sizeof(uint32_t));
-	}
-
-	void fill()
-	{
-		const uint32_t wordCount = getWordsCount(m_bitsCount);
-		uint32_t* mem = data();
-		memset(mem, 0xFF, wordCount * sizeof(uint32_t));
-		const uint32_t bitsRemainder = m_bitsCount & 31;
-		if (bitsRemainder > 0)
-		{
-			mem[wordCount - 1] &= ~(0xFFFFFFFF << bitsRemainder);
-		}
-	}
-
-	int test(uint32_t index) const
-	{
-		NVBLAST_ASSERT(index < m_bitsCount);
-		return data()[index >> 5] & (1 << (index & 31));
-	}
-
-	void set(uint32_t index)
-	{
-		NVBLAST_ASSERT(index < m_bitsCount);
-		data()[index >> 5] |= 1 << (index & 31);
-	}
-
-	void reset(uint32_t index)
-	{
-		NVBLAST_ASSERT(index < m_bitsCount);
-		data()[index >> 5] &= ~(1 << (index & 31));
-	}
-
-private:
-	uint32_t m_bitsCount;
-
-	NV_FORCE_INLINE uint32_t* data()
-	{
-		return (uint32_t*)((char*)this + sizeof(FixedBitmap));
-	}
-
-	NV_FORCE_INLINE const uint32_t* data() const
-	{
-		return (uint32_t*)((char*)this + sizeof(FixedBitmap));
-	}
-
-private:
-	FixedBitmap(const FixedBitmap& that);
-};
-
-} // namespace Blast
-} // namespace Nv
-
-#endif // ifndef NVBLASTFIXEDBITMAP_H
diff --git a/NvBlast/sdk/common/NvBlastFixedBoolArray.h b/NvBlast/sdk/common/NvBlastFixedBoolArray.h
deleted file mode 100644
index 253bed6..0000000
--- a/NvBlast/sdk/common/NvBlastFixedBoolArray.h
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTFIXEDBOOLARRAY_H
-#define NVBLASTFIXEDBOOLARRAY_H
-
-#include "NvBlastAssert.h"
-#include "NvBlastMemory.h"
-#include <cstring>
-
-namespace Nv
-{
-namespace Blast
-{
-
-/*!
-FixedBoolArray is an array of bools of fixed size, it's intended to be used with placement new on chunk of memory.
-It'll use following memory for data layout. As follows:
-
-// some memory
-char ​*buf = new char[64 *​ 1024];
-
-const uint32_t size = 100;
-
-// placement new on this memory
-FixedBoolArray* arr = new (buf) FixedBoolArray(size);
-
-// you can get max requiredMemorySize by an bitMap to use memory left
-buf = buf + FixedBoolArray<SomeClass>::requiredMemorySize(size);
-
-buf:
-
-+------------------------------------------------------------+
-|  uint32_t  |  bool0  |  bool1  |  bool2  |       ...       |
-+------------------------------------------------------------+
-
-*/
-class FixedBoolArray
-{
-public:
-	explicit FixedBoolArray(uint32_t size)
-	{
-		m_size = size;
-	}
-
-	static size_t requiredMemorySize(uint32_t size)
-	{
-		return align16(sizeof(FixedBoolArray)) + align16(size);
-	}
-
-	void clear()
-	{
-		memset(data(), 0, m_size);
-	}
-
-	void fill()
-	{
-		memset(data(), 1, m_size);
-	}
-
-	int test(uint32_t index) const
-	{
-		NVBLAST_ASSERT(index < m_size);
-		return data()[index];
-	}
-
-	void set(uint32_t index)
-	{
-		NVBLAST_ASSERT(index < m_size);
-		data()[index] = 1;
-	}
-
-	void reset(uint32_t index)
-	{
-		NVBLAST_ASSERT(index < m_size);
-		data()[index] = 0;
-	}
-
-private:
-	uint32_t m_size;
-
-	NV_FORCE_INLINE char* data()
-	{
-		return ((char*)this + sizeof(FixedBoolArray));
-	}
-
-	NV_FORCE_INLINE const char* data() const
-	{
-		return ((char*)this + sizeof(FixedBoolArray));
-	}
-
-private:
-	FixedBoolArray(const FixedBoolArray& that);
-};
-
-} // namespace Blast
-} // namespace Nv
-
-#endif // ifndef NVBLASTFIXEDBOOLARRAY_H
diff --git a/NvBlast/sdk/common/NvBlastFixedPriorityQueue.h b/NvBlast/sdk/common/NvBlastFixedPriorityQueue.h
deleted file mode 100644
index 5079edb..0000000
--- a/NvBlast/sdk/common/NvBlastFixedPriorityQueue.h
+++ /dev/null
@@ -1,192 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTFIXEDPRIORITYQUEUE_H
-#define NVBLASTFIXEDPRIORITYQUEUE_H
-
-#include "NvBlastAssert.h"
-#include "NvBlastMemory.h"
-
-namespace Nv
-{
-
-namespace Blast
-{
-
-/*!
-FixedPriorityQueue is a priority queue container which is intended to be used with placement new on chunk of memory.
-It'll use following memory for data layout. As follows:
-
-// some memory
-char ​*buf = new char[64 *​ 1024];
-
-// placement new on this memory
-FixedPriorityQueue<SomeClass>* arr = new (buf) FixedPriorityQueue<SomeClass>();
-
-// you can get max requiredMemorySize by an array of 'capacity' elements count to use memory left
-buf = buf + FixedPriorityQueue<SomeClass>::requiredMemorySize(capacity);
-
-buf:
-
-+------------------------------------------------------------+
-|  uint32_t  |  T[0]  |  T[1]  |  T[2]  |         ...        |
-+------------------------------------------------------------+
-
-*/
-
-template <typename A>
-struct Less
-{
-	bool operator()(const A& a, const A& b) const
-	{
-		return a < b;
-	}
-};
-
-
-template<class Element, class Comparator = Less<Element> >
-class FixedPriorityQueue : protected Comparator // inherit so that stateless comparators take no space
-{
-public:
-	FixedPriorityQueue(const Comparator& less = Comparator()) : Comparator(less), mHeapSize(0)
-	{
-	}
-		
-	~FixedPriorityQueue()
-	{
-	}
-
-	static size_t requiredMemorySize(uint32_t capacity)
-	{
-		return align16(sizeof(FixedPriorityQueue<Element, Comparator>)) + align16(capacity * sizeof(Element));
-	}
-		
-	//! Get the element with the highest priority
-	const Element top() const
-	{
-		return data()[0];
-	}
-
-	//! Get the element with the highest priority
-	Element top()
-	{
-		return data()[0];
-	}
-		
-	//! Check to whether the priority queue is empty
-	bool empty() const
-	{
-		return (mHeapSize == 0);
-	}
-		
-	//! Empty the priority queue
-	void clear()
-	{
-		mHeapSize = 0;
-	}  
-
-	//! Insert a new element into the priority queue. Only valid when size() is less than Capacity
-	void push(const Element& value)
-	{
-		uint32_t newIndex;
-		uint32_t parentIndex = parent(mHeapSize);
-
-		for (newIndex = mHeapSize; newIndex > 0 && compare(value, data()[parentIndex]); newIndex = parentIndex, parentIndex= parent(newIndex)) 
-		{
-			data()[ newIndex ] = data()[parentIndex];
-		}
-		data()[newIndex] = value; 
-		mHeapSize++;
-		NVBLAST_ASSERT(valid());
-	}
-
-	//! Delete the highest priority element. Only valid when non-empty.
-	Element pop()
-	{
-		NVBLAST_ASSERT(mHeapSize > 0);
-		uint32_t i, child;
-		//try to avoid LHS
-		uint32_t tempHs = mHeapSize-1;
-		mHeapSize = tempHs;
-		Element min = data()[0];
-		Element last = data()[tempHs];
-			
-		for (i = 0; (child = left(i)) < tempHs; i = child) 
-		{
-			/* Find highest priority child */
-			const uint32_t rightChild = child + 1;
-			
-			child += ((rightChild < tempHs) & compare((data()[rightChild]), (data()[child]))) ? 1 : 0;
-
-			if(compare(last, data()[child]))
-				break;
-
-			data()[i] = data()[child];
-		}
-		data()[ i ] = last;
-			
-		NVBLAST_ASSERT(valid());
-		return min;
-	} 
-
-	//! Make sure the priority queue sort all elements correctly
-	bool valid() const
-	{
-		const Element& min = data()[0];
-		for(uint32_t i=1; i<mHeapSize; ++i)
-		{
-			if(compare(data()[i], min))
-				return false;
-		}
-
-		return true;
-	}
-
-	//! Return number of elements in the priority queue
-	uint32_t size() const
-	{
-		return mHeapSize;
-	}
-
-private:
-	uint32_t mHeapSize;
-
-	NV_FORCE_INLINE Element* data()
-	{
-		return (Element*)((char*)this + sizeof(FixedPriorityQueue<Element, Comparator>));
-	}
-
-	NV_FORCE_INLINE Element* data() const
-	{
-		return (Element*)((char*)this + sizeof(FixedPriorityQueue<Element, Comparator>));
-	}
-
-	bool compare(const Element& a, const Element& b) const
-	{
-		return Comparator::operator()(a,b);
-	}
-
-	static uint32_t left(uint32_t nodeIndex) 
-	{
-		return (nodeIndex << 1) + 1;
-	}
-		
-	static uint32_t parent(uint32_t nodeIndex) 
-	{
-		return (nodeIndex - 1) >> 1;
-	}
-
-	FixedPriorityQueue<Element, Comparator>& operator = (const FixedPriorityQueue<Element, Comparator>);
-};
-
-} // namespace Blast
-} // namespace Nv
-
-#endif // ifndef NVBLASTFIXEDPRIORITYQUEUE_H
diff --git a/NvBlast/sdk/common/NvBlastGeometry.h b/NvBlast/sdk/common/NvBlastGeometry.h
deleted file mode 100644
index e83ff95..0000000
--- a/NvBlast/sdk/common/NvBlastGeometry.h
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-
-#ifndef NVBLASTGEOMETRY_H
-#define NVBLASTGEOMETRY_H
-
-#include "NvBlastTypes.h"
-#include "NvBlastMath.h"
-
-#include<limits>
-
-
-namespace Nv {
-namespace Blast{
-
-NV_FORCE_INLINE uint32_t findNodeByPositionLinked(const float point[4],
-	const uint32_t firstGraphNodeIndex, const uint32_t* familyGraphNodeIndexLinks,
-	const uint32_t* adjacencyPartition, const uint32_t* adjacentNodeIndices, const uint32_t* adjacentBondIndices,
-	const NvBlastBond* bonds, const float* bondHealths)
-{
-	uint32_t nodeIndex = firstGraphNodeIndex;
-	uint32_t closestNode = nodeIndex;
-	float minDist = std::numeric_limits<float>().max();
-
-	while (!Nv::Blast::isInvalidIndex(nodeIndex))
-	{
-		const uint32_t startIndex = adjacencyPartition[nodeIndex];
-		const uint32_t stopIndex = adjacencyPartition[nodeIndex + 1];
-
-		for (uint32_t adjacentIndex = startIndex; adjacentIndex < stopIndex; adjacentIndex++)
-		{
-			const uint32_t neighbourIndex = adjacentNodeIndices[adjacentIndex];
-			if (nodeIndex < neighbourIndex)
-			{
-				const uint32_t bondIndex = adjacentBondIndices[adjacentIndex];
-				if (bondHealths[bondIndex] > 0.0f)
-				{
-					const NvBlastBond& bond = bonds[bondIndex];
-
-					const float* centroid = bond.centroid;
-					float d[3]; VecMath::sub(point, centroid, d);
-					float dist = VecMath::dot(d, d);
-
-					if (dist < minDist)
-					{
-						minDist = dist;
-						float s = VecMath::dot(d, bond.normal);
-						closestNode = s < 0 ? nodeIndex : neighbourIndex;
-					}
-				}
-			}
-		}
-		nodeIndex = familyGraphNodeIndexLinks[nodeIndex];
-	}
-
-	return closestNode;
-}
-
-
-NV_FORCE_INLINE uint32_t findNodeByPosition(const float point[4],
-	const uint32_t graphNodesCount, const uint32_t* graphNodeIndices,
-	const uint32_t* adjacencyPartition, const uint32_t* adjacentNodeIndices, const uint32_t* adjacentBondIndices,
-	const NvBlastBond* bonds, const float* bondHealths)
-{
-	uint32_t closestNode = graphNodesCount > 2 ? invalidIndex<uint32_t>() : graphNodeIndices[0];
-	float minDist = std::numeric_limits<float>().max();
-
-	for (uint32_t i = 0; i < graphNodesCount; i++)
-	{
-		const uint32_t nodeIndex = graphNodeIndices[i];
-		const uint32_t startIndex = adjacencyPartition[nodeIndex];
-		const uint32_t stopIndex = adjacencyPartition[nodeIndex + 1];
-
-		for (uint32_t adjacentIndex = startIndex; adjacentIndex < stopIndex; adjacentIndex++)
-		{
-			const uint32_t bondIndex = adjacentBondIndices[adjacentIndex];
-			if (bondHealths[bondIndex] > 0.0f)
-			{
-				const uint32_t neighbourIndex = adjacentNodeIndices[adjacentIndex];
-				if (nodeIndex < neighbourIndex)
-				{
-					const NvBlastBond& bond = bonds[bondIndex];
-
-					const float* centroid = bond.centroid;
-					float d[3]; VecMath::sub(point, centroid, d);
-					float dist = VecMath::dot(d, d);
-
-					if (dist < minDist)
-					{
-						minDist = dist;
-						float s = VecMath::dot(d, bond.normal);
-						closestNode = s < 0 ? nodeIndex : neighbourIndex;
-					}
-				}
-			}
-		}
-	}
-	return closestNode;
-}
-
-
-NV_FORCE_INLINE uint32_t findNodeByPosition(const float point[4],
-	const uint32_t graphNodesCount, const uint32_t* graphNodeIndices,
-	const NvBlastSupportGraph& graph,
-	const NvBlastBond* bonds, const float* bondHealths)
-{
-	return findNodeByPosition(point, graphNodesCount, graphNodeIndices, graph.adjacencyPartition, graph.adjacentNodeIndices, graph.adjacentBondIndices, bonds, bondHealths);
-}
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // NVBLASTGEOMETRY_H
diff --git a/NvBlast/sdk/common/NvBlastIncludeWindows.h b/NvBlast/sdk/common/NvBlastIncludeWindows.h
deleted file mode 100644
index 9115fd4..0000000
--- a/NvBlast/sdk/common/NvBlastIncludeWindows.h
+++ /dev/null
@@ -1,90 +0,0 @@
-// This code contains NVIDIA Confidential Information and is disclosed to you
-// under a form of NVIDIA software license agreement provided separately to you.
-//
-// Notice
-// NVIDIA Corporation and its licensors retain all intellectual property and
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTINCLUDEWINDOWS_H
-#define NVBLASTINCLUDEWINDOWS_H
-
-#ifndef _WINDOWS_ // windows already included if this is defined
-
-#include "NvBlastPreprocessor.h"
-
-#ifndef _WIN32
-#error "This file should only be included by Windows builds!!"
-#endif
-
-// We only support >= Windows XP, and we need this for critical section and
-#if !NV_WINRT
-#define _WIN32_WINNT 0x0501
-#else
-#define _WIN32_WINNT 0x0602
-#endif
-
-// turn off as much as we can for windows. All we really need is the thread functions(critical sections/Interlocked*
-// etc)
-#define NOGDICAPMASKS
-#define NOVIRTUALKEYCODES
-#define NOWINMESSAGES
-#define NOWINSTYLES
-#define NOSYSMETRICS
-#define NOMENUS
-#define NOICONS
-#define NOKEYSTATES
-#define NOSYSCOMMANDS
-#define NORASTEROPS
-#define NOSHOWWINDOW
-#define NOATOM
-#define NOCLIPBOARD
-#define NOCOLOR
-#define NOCTLMGR
-#define NODRAWTEXT
-#define NOGDI
-#define NOMB
-#define NOMEMMGR
-#define NOMETAFILE
-#define NOMINMAX
-#define NOOPENFILE
-#define NOSCROLL
-#define NOSERVICE
-#define NOSOUND
-#define NOTEXTMETRIC
-#define NOWH
-#define NOWINOFFSETS
-#define NOCOMM
-#define NOKANJI
-#define NOHELP
-#define NOPROFILER
-#define NODEFERWINDOWPOS
-#define NOMCX
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-#if !NV_WINRT
-#define NOUSER
-#define NONLS
-#define NOMSG
-#endif
-
-#pragma warning(push)
-#pragma warning(disable : 4668) //'symbol' is not defined as a preprocessor macro, replacing with '0' for 'directives'
-#include <windows.h>
-#pragma warning(pop)
-
-#if NV_SSE2
-#include <xmmintrin.h>
-#endif
-
-#endif // #ifndef _WINDOWS_
-
-#endif // #ifndef NVBLASTINCLUDEWINDOWS_H
diff --git a/NvBlast/sdk/common/NvBlastIndexFns.h b/NvBlast/sdk/common/NvBlastIndexFns.h
deleted file mode 100644
index a800a73..0000000
--- a/NvBlast/sdk/common/NvBlastIndexFns.h
+++ /dev/null
@@ -1,127 +0,0 @@
-/*
- * Copyright (c) 2008-2017, NVIDIA CORPORATION.  All rights reserved.
- *
- * NVIDIA CORPORATION and its licensors retain all intellectual property
- * and proprietary rights in and to this software, related documentation
- * and any modifications thereto.  Any use, reproduction, disclosure or
- * distribution of this software and related documentation without an express
- * license agreement from NVIDIA CORPORATION is strictly prohibited.
- */
-
-#ifndef NVBLASTINDEXFNS_H
-#define NVBLASTINDEXFNS_H
-
-
-#include "NvBlastTypes.h"
-
-#include <cstring>
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-/**
-Set to invalid index.
-*/
-template<typename T>
-NV_INLINE T invalidIndex()
-{
-	return ~(T)0;
-}
-
-
-/**
-Test for invalid index (max representable integer).
-*/
-template<typename T>
-NV_INLINE bool isInvalidIndex(T index)
-{
-	return index == invalidIndex<T>();
-}
-
-
-/**
-	Create a lookup table for data sorted by a templated index type.
-
-	Note: when using this function with unsigned integer index types invalidIndex<T>() is treated as a value less than zero.
-
-	On input:
-
-		The indices must lie in the interval [indexBase, indexBase+indexRange].
-	
-		indexSource must point to the first index in the data.
-
-		indexCount must be set to the number of indices in the data.
-
-		indexByteStride must be set to the distance, in bytes, between subequent indices.
-
-		lookup must point to a T array of size indexRange+2.
-
-	On return:
-
-		lookup will be filled such that:
-
-			lookup[i] = the position of first data element with index (i + indexBase)
-
-			lookup[indexRange+1] = indexCount
-
-		The last (indexRange+1) element is used so that one may always determine the number of data elements with the given index using:
-
-			count = lookup[i+1] - lookup[i]
-
-		Note, if an index (i + indexBase) is not present in the data then, lookup[i+1] = lookup[i], so the count (above) will correctly be zero.
-		In this case, the actual value of lookup[i] is irrelevant.
-*/
-template<typename T>
-void createIndexStartLookup(T* lookup, T indexBase, T indexRange, T* indexSource, T indexCount, T indexByteStride)
-{
-	++indexBase;	// Ordering invalidIndex<T>() as lowest value
-	T indexPos = 0;
-	for (T i = 0; i <= indexRange; ++i)
-	{
-		for (; indexPos < indexCount; ++indexPos, indexSource = (T*)((uintptr_t)indexSource + indexByteStride))
-		{
-			if (*indexSource + 1 >= i + indexBase)	// +1 to order invalidIndex<T>() as lowest value
-			{
-				lookup[i] = indexPos;
-				break;
-			}
-		}
-		if (indexPos == indexCount)
-		{
-			lookup[i] = indexPos;
-		}
-	}
-	lookup[indexRange + 1] = indexCount;
-}
-
-
-/**
-Creates the inverse of a map, such that inverseMap[map[i]] = i.
-Unmapped indices are set to invalidIndex<T>.
-
-\param[out]		inverseMap		inverse map space of given size
-\param[in]		map				original map of given size, unmapped entries must contain invalidIndex<T>
-\param[in]		size			size of the involved maps
-*/
-template<typename T>
-void invertMap(T* inverseMap, const T* map, const T size)
-{
-	memset(inverseMap, invalidIndex<T>(), size*sizeof(T));
-
-	for (T i = 0; i < size; i++)
-	{
-		if (!isInvalidIndex(map[i]))
-		{
-			inverseMap[map[i]] = i;
-		}
-	}
-}
-
-} // end namespace Blast
-} // end namespace Nv
-
-
-#endif // #ifndef NVBLASTINDEXFNS_H
diff --git a/NvBlast/sdk/common/NvBlastIteratorBase.h b/NvBlast/sdk/common/NvBlastIteratorBase.h
deleted file mode 100644
index 9053f4b..0000000
--- a/NvBlast/sdk/common/NvBlastIteratorBase.h
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
- * Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
- *
- * NVIDIA CORPORATION and its licensors retain all intellectual property
- * and proprietary rights in and to this software, related documentation
- * and any modifications thereto.  Any use, reproduction, disclosure or
- * distribution of this software and related documentation without an express
- * license agreement from NVIDIA CORPORATION is strictly prohibited.
- */
-
-#ifndef NVBLASTITERATORBASE_H
-#define NVBLASTITERATORBASE_H
-
-
-#include "NvBlastIndexFns.h"
-
-namespace Nv
-{
-namespace Blast
-{
-
-/**
-Common functionality and implementation for iterators over an index, using invalidIndex<T>() to indicate termination.
-Derived class needs to implement increment operators.
-*/
-template<typename T>
-class IteratorBase
-{
-public:
-	/** Constructor sets m_curr value */
-	IteratorBase(T curr);
-
-	/** Validity of current value. */
-	operator	bool() const;
-
-	/** Current value. */
-	operator	T() const;
-
-protected:
-	T	m_curr;
-};
-
-
-//////// IteratorBase<T> inline methods ////////
-
-template<typename T>
-NV_INLINE IteratorBase<T>::IteratorBase(T curr) : m_curr(curr)
-{
-}
-
-
-template<typename T>
-NV_INLINE IteratorBase<T>::operator bool() const
-{
-	return !isInvalidIndex<T>(m_curr);
-}
-
-
-template<typename T>
-NV_INLINE IteratorBase<T>::operator T() const
-{
-	return m_curr;
-}
-
-
-/**
-Common functionality and implementation for an indexed linked list iterator
-*/
-template<typename IndexType>
-class LListIt : public IteratorBase<IndexType>
-{
-public:
-	LListIt(IndexType curr, IndexType* links);
-
-	/** Pre-increment.  Only use if valid() == true. */
-	uint32_t	operator ++ ();
-
-protected:
-	IndexType*	m_links;
-};
-
-
-//////// LListIt<IndexType> inline methods ////////
-
-template<typename IndexType>
-NV_INLINE LListIt<IndexType>::LListIt(IndexType curr, IndexType* links) : IteratorBase<IndexType>(curr), m_links(links)
-{
-}
-
-
-template<typename IndexType>
-NV_INLINE uint32_t LListIt<IndexType>::operator ++ ()
-{
-	NVBLAST_ASSERT((bool)(*this));
-	return (this->m_curr = m_links[this->m_curr]);
-}
-
-
-/**
-Common functionality and implementation for an IndexDList<IndexType> iterator
-*/
-template<typename IndexType>
-class DListIt : public IteratorBase<IndexType>
-{
-public:
-	DListIt(IndexType curr, IndexDLink<IndexType>* links);
-
-	/** Pre-increment.  Only use if valid() == true. */
-	uint32_t	operator ++ ();
-
-protected:
-	IndexDLink<IndexType>*	m_links;
-};
-
-
-//////// DListIt<IndexType> inline methods ////////
-
-template<typename IndexType>
-NV_INLINE DListIt<IndexType>::DListIt(IndexType curr, IndexDLink<IndexType>* links) : IteratorBase<IndexType>(curr), m_links(links)
-{
-}
-
-
-template<typename IndexType>
-NV_INLINE uint32_t DListIt<IndexType>::operator ++ ()
-{
-	NVBLAST_ASSERT((bool)(*this));
-	return (this->m_curr = m_links[this->m_curr].m_adj[1]);
-}
-
-} // end namespace Blast
-} // end namespace Nv
-
-
-#endif // #ifndef NVBLASTITERATORBASE_H
diff --git a/NvBlast/sdk/common/NvBlastMath.h b/NvBlast/sdk/common/NvBlastMath.h
deleted file mode 100644
index 0a29f14..0000000
--- a/NvBlast/sdk/common/NvBlastMath.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
- *
- * NVIDIA CORPORATION and its licensors retain all intellectual property
- * and proprietary rights in and to this software, related documentation
- * and any modifications thereto.  Any use, reproduction, disclosure or
- * distribution of this software and related documentation without an express
- * license agreement from NVIDIA CORPORATION is strictly prohibited.
- */
-
-#ifndef NVBLASTMATH_H
-#define NVBLASTMATH_H
-
-#include <math.h>
-
-namespace Nv
-{
-namespace Blast
-{
-
-namespace VecMath
-{
-
-
-NV_INLINE void div(float a[3], float divisor)
-{
-	for (int i = 0; i < 3; i++)
-		a[i] /= divisor;
-}
-
-NV_INLINE void mul(float a[3], float multiplier)
-{
-	for (int i = 0; i < 3; i++)
-		a[i] *= multiplier;
-}
-
-NV_INLINE void add(const float a[3], float b[3])
-{
-	for (int i = 0; i < 3; i++)
-		b[i] = a[i] + b[i];
-}
-	
-NV_INLINE void add(const float a[3], const float b[3], float r[3])
-{
-	for (int i = 0; i < 3; i++)
-		r[i] = a[i] + b[i];
-}
-
-NV_INLINE void sub(const float a[3], const float b[3], float r[3])
-{
-	for (int i = 0; i < 3; i++)
-		r[i] = a[i] - b[i];
-}
-
-NV_INLINE float dot(const float a[3], const float b[3])
-{
-	float r = 0;
-	for (int i = 0; i < 3; i++)
-		r += a[i] * b[i];
-	return r;
-}
-
-NV_INLINE float normal(const float a[3], float r[3])
-{
-	float length = sqrtf(dot(a, a));
-	for (int i = 0; i < 3; i++)
-		r[i] = a[i] / length;
-
-	return length;
-}
-
-
-} // namespace VecMath
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // #ifndef NVBLASTMATH_H
diff --git a/NvBlast/sdk/common/NvBlastMemory.h b/NvBlast/sdk/common/NvBlastMemory.h
deleted file mode 100644
index 0fb6a06..0000000
--- a/NvBlast/sdk/common/NvBlastMemory.h
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
- * Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
- *
- * NVIDIA CORPORATION and its licensors retain all intellectual property
- * and proprietary rights in and to this software, related documentation
- * and any modifications thereto.  Any use, reproduction, disclosure or
- * distribution of this software and related documentation without an express
- * license agreement from NVIDIA CORPORATION is strictly prohibited.
- */
-
-#ifndef NVBLASTMEMORY_H
-#define NVBLASTMEMORY_H
-
-#include <math.h>
-
-namespace Nv
-{
-namespace Blast
-{
-
-
-/**
-Utility function to align the given value to the next 16-byte boundary.
-
-Returns the aligned value.
-*/
-template<typename T>
-NV_INLINE T align16(T value)
-{
-	return (value + 0xF)&~(T)0xF;
-}
-
-
-/** Offset void* pointer by 'offset' bytes helper-functions */
-
-template <typename T>
-NV_INLINE T pointerOffset(void* p, ptrdiff_t offset)
-{
-	return reinterpret_cast<T>(reinterpret_cast<char*>(p)+offset);
-}
-
-template <typename T>
-NV_INLINE T pointerOffset(const void* p, ptrdiff_t offset)
-{
-	return reinterpret_cast<T>(reinterpret_cast<const char*>(p)+offset);
-}
-
-NV_INLINE const void* pointerOffset(const void* p, ptrdiff_t offset)
-{
-	return pointerOffset<const void*>(p, offset);
-}
-
-NV_INLINE void* pointerOffset(void* p, ptrdiff_t offset)
-{
-	return pointerOffset<void*>(p, offset);
-}
-
-} // namespace Blast
-} // namespace Nv
-
-
-/** Block data offset and accessor macro. */
-#define NvBlastBlockData(_dataType, _name, _accessor) \
-_dataType* _accessor() const \
-{ \
-	return (_dataType*)((uintptr_t)this + _name); \
-} \
-uint32_t _name
-
-
-/** Block data offset and accessor macro for an array (includes an _accessor##ArraySize() function which returns the last expression). */
-#define NvBlastBlockArrayData(_dataType, _name, _accessor, _sizeExpr) \
-_dataType* _accessor() const \
-{ \
-	return (_dataType*)((uintptr_t)this + _name); \
-} \
-uint32_t _accessor##ArraySize() const \
-{ \
-	return _sizeExpr; \
-} \
-uint32_t _name
-
-
-/** Block data offset generation macros. */
-
-/** Start offset generation with this. */
-#define NvBlastCreateOffsetStart(_baseOffset) \
-size_t _lastOffset = _baseOffset; \
-size_t _lastSize = 0
-
-/** Create the next offset generation with this.  The value will be aligned to a 16-byte boundary. */
-#define NvBlastCreateOffsetAlign16(_name, _size) \
-_name = align16(_lastOffset + _lastSize); \
-_lastOffset = _name; \
-_lastSize = _size
-
-/** End offset generation with this.  It evaluates to the (16-byte aligned) total size of the data block. */
-#define NvBlastCreateOffsetEndAlign16() \
-align16(_lastOffset + _lastSize)
-
-
-/** Stack allocation */
-#if NV_WINDOWS_FAMILY
-#include <malloc.h>
-#define NvBlastAlloca(x) _alloca(x)
-#elif NV_LINUX || NV_ANDROID
-#include <malloc.h>
-#define NvBlastAlloca(x) alloca(x)
-#elif NV_APPLE_FAMILY
-#include <alloca.h>
-#define NvBlastAlloca(x) alloca(x)
-#elif NV_PS4
-#include <memory.h>
-#define NvBlastAlloca(x) alloca(x)
-#elif NV_XBOXONE
-#include <malloc.h>
-#define NvBlastAlloca(x) alloca(x)
-#endif
-
-#define NvBlastAllocaAligned16(x) (void*)(((uintptr_t)PxAlloca(x + 0xF) + 0xF) & ~(uintptr_t)0xF)
-
-
-#endif // #ifndef NVBLASTMEMORY_H
diff --git a/NvBlast/sdk/common/NvBlastPreprocessorInternal.h b/NvBlast/sdk/common/NvBlastPreprocessorInternal.h
deleted file mode 100644
index 2d3e185..0000000
--- a/NvBlast/sdk/common/NvBlastPreprocessorInternal.h
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTPREPROCESSORINTERNAL_H
-#define NVBLASTPREPROCESSORINTERNAL_H
-
-
-#include "NvPreprocessor.h"
-
-
-/** Blast will check function parameters for debug and checked builds. */
-#define NVBLAST_CHECK_PARAMS (NV_DEBUG || NV_CHECKED)
-
-
-#if NVBLAST_CHECK_PARAMS
-#define NVBLAST_CHECK(_expr, _logFn, _msg, _onFail)																		\
-	{																													\
-		if(!(_expr))																									\
-		{																												\
-			if (_logFn) { _logFn(NvBlastMessage::Error, _msg, __FILE__, __LINE__); }									\
-			{ _onFail; };																								\
-		}																												\
-	}																													
-#else
-#define NVBLAST_CHECK(_expr, _logFn, _msg, _onFail) NV_UNUSED(_logFn)
-#endif
-
-
-#endif // ifndef NVBLASTPREPROCESSORINTERNAL_H
diff --git a/NvBlast/sdk/common/NvBlastTime.cpp b/NvBlast/sdk/common/NvBlastTime.cpp
deleted file mode 100644
index b16e573..0000000
--- a/NvBlast/sdk/common/NvBlastTime.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastTime.h"
-#include "NvBlast.h"
-#include <cstring>
-
-namespace Nv
-{
-namespace Blast
-{
-
-const double Time::s_secondsPerTick = Time::getTickDuration();
-
-} // namespace Blast
-} // namespace Nv
diff --git a/NvBlast/sdk/common/NvBlastTime.h b/NvBlast/sdk/common/NvBlastTime.h
deleted file mode 100644
index 47af36b..0000000
--- a/NvBlast/sdk/common/NvBlastTime.h
+++ /dev/null
@@ -1,108 +0,0 @@
-// This code contains NVIDIA Confidential Information and is disclosed to you
-// under a form of NVIDIA software license agreement provided separately to you.
-//
-// Notice
-// NVIDIA Corporation and its licensors retain all intellectual property and
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTTIME_H
-#define NVBLASTTIME_H
-
-#include "NvBlastTypes.h"
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-class Time
-{
-public:
-	Time() : m_lastTickCount(getTimeTicks()) {}
-
-	int64_t			getElapsedTicks()
-	{
-		const int64_t lastTickCount = m_lastTickCount;
-		m_lastTickCount = getTimeTicks();
-		return m_lastTickCount - lastTickCount;
-	}
-
-	int64_t			peekElapsedTicks() const
-	{
-		return getTimeTicks() - m_lastTickCount;
-	}
-
-	int64_t			getLastTickCount() const
-	{
-		return m_lastTickCount;
-	}
-
-	static double	seconds(int64_t ticks)
-	{
-		return s_secondsPerTick * ticks;
-	}
-
-private:
-	int64_t			getTimeTicks() const;
-	static double	getTickDuration();
-
-	int64_t				m_lastTickCount;
-	static const double	s_secondsPerTick;
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-//////// Time inline functions for various platforms ////////
-
-#if NV_MICROSOFT_FAMILY
-
-#include "NvBlastIncludeWindows.h"
-
-NV_INLINE int64_t Nv::Blast::Time::getTimeTicks() const
-{
-	LARGE_INTEGER a;
-	QueryPerformanceCounter(&a);
-	return a.QuadPart;
-}
-
-NV_INLINE double Nv::Blast::Time::getTickDuration()
-{
-	LARGE_INTEGER a;
-	QueryPerformanceFrequency(&a);
-	return 1.0 / (double)a.QuadPart;
-}
-
-#elif NV_UNIX_FAMILY
-
-#include <time.h>
-
-NV_INLINE int64_t Nv::Blast::Time::getTimeTicks() const
-{
-	struct timespec mCurrTimeInt;
-	clock_gettime(CLOCK_REALTIME, &mCurrTimeInt);
-	return (static_cast<int64_t>(mCurrTimeInt.tv_sec) * 1000000000) + (static_cast<int64_t>(mCurrTimeInt.tv_nsec));
-}
-
-NV_INLINE double Nv::Blast::Time::getTickDuration()
-{
-	return 1.e-9;
-}
-
-#elif NV_PS4
-
-#include "ps4/NvBlastTimePS4.h"
-
-#endif
-
-#endif // #ifndef NVBLASTTIME_H
diff --git a/NvBlast/sdk/common/NvBlastTimers.cpp b/NvBlast/sdk/common/NvBlastTimers.cpp
deleted file mode 100644
index ec93134..0000000
--- a/NvBlast/sdk/common/NvBlastTimers.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlast.h"
-#include "NvBlastTime.h"
-#include <cstring>
-
-
-extern "C"
-{
-
-void NvBlastTimersReset(NvBlastTimers* timers)
-{
-	memset(timers, 0, sizeof(NvBlastTimers));
-}
-
-double NvBlastTicksToSeconds(int64_t ticks)
-{
-	return Nv::Blast::Time::seconds(ticks);
-}
-
-} // extern "C"
diff --git a/NvBlast/sdk/compiler/cmake/NvBlast.cmake b/NvBlast/sdk/compiler/cmake/NvBlast.cmake
deleted file mode 100644
index 5ac9ce9..0000000
--- a/NvBlast/sdk/compiler/cmake/NvBlast.cmake
+++ /dev/null
@@ -1,89 +0,0 @@
-#
-# Build NvBlast common
-#
-
-SET(COMMON_SOURCE_DIR ${PROJECT_SOURCE_DIR}/common)
-SET(SOLVER_SOURCE_DIR ${PROJECT_SOURCE_DIR}/lowlevel/source)
-SET(PUBLIC_INCLUDE_DIR ${PROJECT_SOURCE_DIR}/lowlevel/include)
-
-# Include here after the directories are defined so that the platform specific file can use the variables.
-include(${PROJECT_CMAKE_FILES_DIR}/${TARGET_BUILD_PLATFORM}/NvBlast.cmake)
-
-SET(COMMON_FILES
-	${BLAST_PLATFORM_COMMON_FILES}
-	
-	${COMMON_SOURCE_DIR}/NvBlastAssert.cpp
-	${COMMON_SOURCE_DIR}/NvBlastAssert.h
-	${COMMON_SOURCE_DIR}/NvBlastAtomic.cpp
-	${COMMON_SOURCE_DIR}/NvBlastAtomic.h
-	${COMMON_SOURCE_DIR}/NvBlastDLink.h
-	${COMMON_SOURCE_DIR}/NvBlastFixedArray.h
-	${COMMON_SOURCE_DIR}/NvBlastFixedBitmap.h
-	${COMMON_SOURCE_DIR}/NvBlastFixedBoolArray.h
-	${COMMON_SOURCE_DIR}/NvBlastFixedPriorityQueue.h
-	${COMMON_SOURCE_DIR}/NvBlastGeometry.h
-#	${COMMON_SOURCE_DIR}/NvBlastIndexFns.cpp
-	${COMMON_SOURCE_DIR}/NvBlastIndexFns.h
-	${COMMON_SOURCE_DIR}/NvBlastIteratorBase.h
-	${COMMON_SOURCE_DIR}/NvBlastMath.h
-	${COMMON_SOURCE_DIR}/NvBlastMemory.h
-	${COMMON_SOURCE_DIR}/NvBlastPreprocessorInternal.h
-	${COMMON_SOURCE_DIR}/NvBlastTime.cpp
-	${COMMON_SOURCE_DIR}/NvBlastTime.h
-	${COMMON_SOURCE_DIR}/NvBlastTimers.cpp
-)
-
-SET(PUBLIC_FILES
-	${PUBLIC_INCLUDE_DIR}/NvBlast.h
-	${PUBLIC_INCLUDE_DIR}/NvBlastPreprocessor.h
-	${PUBLIC_INCLUDE_DIR}/NvBlastTypes.h
-	${PUBLIC_INCLUDE_DIR}/NvPreprocessor.h
-)
-
-SET(SOLVER_FILES
-	${SOLVER_SOURCE_DIR}/NvBlastActor.cpp
-	${SOLVER_SOURCE_DIR}/NvBlastActor.h
-	${SOLVER_SOURCE_DIR}/NvBlastFamilyGraph.cpp
-	${SOLVER_SOURCE_DIR}/NvBlastFamilyGraph.h
-	${SOLVER_SOURCE_DIR}/NvBlastActorSerializationBlock.cpp
-	${SOLVER_SOURCE_DIR}/NvBlastActorSerializationBlock.h
-	${SOLVER_SOURCE_DIR}/NvBlastAsset.cpp
-	${SOLVER_SOURCE_DIR}/NvBlastAssetHelper.cpp
-	${SOLVER_SOURCE_DIR}/NvBlastAsset.h
-	${SOLVER_SOURCE_DIR}/NvBlastSupportGraph.h
-	${SOLVER_SOURCE_DIR}/NvBlastChunkHierarchy.h
-	${SOLVER_SOURCE_DIR}/NvBlastFamily.cpp
-	${SOLVER_SOURCE_DIR}/NvBlastFamily.h
-)
-
-ADD_LIBRARY(NvBlast ${BLAST_LIB_TYPE} 
-	${COMMON_FILES}
-	${PUBLIC_FILES}
-	${SOLVER_FILES}
-)
-
-SOURCE_GROUP("common" FILES ${COMMON_FILES})
-SOURCE_GROUP("public" FILES ${PUBLIC_FILES})
-SOURCE_GROUP("solver" FILES ${SOLVER_FILES})
-
-# Target specific compile options
-
-
-TARGET_INCLUDE_DIRECTORIES(NvBlast 
-	PRIVATE ${BLAST_PLATFORM_INCLUDES}
-
-	PUBLIC ${PUBLIC_INCLUDE_DIR}
-	PRIVATE ${COMMON_SOURCE_DIR}
-)
-
-TARGET_COMPILE_DEFINITIONS(NvBlast 
-	PRIVATE ${BLAST_COMPILE_DEFS}
-)
-
-SET_TARGET_PROPERTIES(NvBlast PROPERTIES 
-	PDB_NAME_DEBUG "NvBlast${CMAKE_DEBUG_POSTFIX}"
-	PDB_NAME_CHECKED "NvBlast${CMAKE_CHECKED_POSTFIX}"
-	PDB_NAME_PROFILE "NvBlast${CMAKE_PROFILE_POSTFIX}"
-	PDB_NAME_RELEASE "NvBlast${CMAKE_RELEASE_POSTFIX}"
-)
-
diff --git a/NvBlast/sdk/compiler/cmake/NvBlastExtAuthoring.cmake b/NvBlast/sdk/compiler/cmake/NvBlastExtAuthoring.cmake
deleted file mode 100644
index dda8056..0000000
--- a/NvBlast/sdk/compiler/cmake/NvBlastExtAuthoring.cmake
+++ /dev/null
@@ -1,106 +0,0 @@
-#
-# Build NvBlastExt Common
-#
-
-
-SET(COMMON_SOURCE_DIR ${PROJECT_SOURCE_DIR}/common)
-
-SET(AUTHORING_EXT_SOURCE_DIR ${PROJECT_SOURCE_DIR}/extensions/authoring/source)
-SET(COMMON_EXT_SOURCE_DIR ${PROJECT_SOURCE_DIR}/extensions/common/source)
-SET(AUTHORING_EXT_INCLUDE_DIR ${PROJECT_SOURCE_DIR}/extensions/authoring/include)
-
-FIND_PACKAGE(PxSharedSDK $ENV{PM_PxShared_VERSION} REQUIRED)
-FIND_PACKAGE(PhysXSDK $ENV{PM_PhysX_VERSION} REQUIRED)
-
-# Include here after the directories are defined so that the platform specific file can use the variables.
-include(${PROJECT_CMAKE_FILES_DIR}/${TARGET_BUILD_PLATFORM}/NvBlastExtAuthoring.cmake)
-
-SET(COMMON_FILES
-	${BLASTEXT_PLATFORM_COMMON_FILES}
-	
-	#${COMMON_SOURCE_DIR}/NvBlastAssert.cpp
-	#${COMMON_SOURCE_DIR}/NvBlastAssert.h
-)
-
-SET(PUBLIC_FILES
-	${AUTHORING_EXT_INCLUDE_DIR}/NvBlastExtAuthoringBondGenerator.h
-	${AUTHORING_EXT_INCLUDE_DIR}/NvBlastExtAuthoringCollisionBuilder.h
-	${AUTHORING_EXT_INCLUDE_DIR}/NvBlastExtAuthoringFractureTool.h
-	${AUTHORING_EXT_INCLUDE_DIR}/NvBlastExtAuthoringMesh.h
-	${AUTHORING_EXT_INCLUDE_DIR}/NvBlastExtAuthoringTypes.h
-)
-
-SET(EXT_AUTHORING_FILES
-	${AUTHORING_EXT_SOURCE_DIR}/NvBlastExtAuthoringAccelerator.cpp
-	${AUTHORING_EXT_SOURCE_DIR}/NvBlastExtAuthoringAccelerator.h
-	${AUTHORING_EXT_SOURCE_DIR}/NvBlastExtAuthoringBondGenerator.cpp
-	${AUTHORING_EXT_SOURCE_DIR}/NvBlastExtAuthoringBooleanTool.cpp
-	${AUTHORING_EXT_SOURCE_DIR}/NvBlastExtAuthoringBooleanTool.h
-	${AUTHORING_EXT_SOURCE_DIR}/NvBlastExtAuthoringCollisionBuilder.cpp
-	${AUTHORING_EXT_SOURCE_DIR}/NvBlastExtAuthoringMesh.cpp
-	${AUTHORING_EXT_SOURCE_DIR}/NvBlastExtAuthoringPerlinNoise.h
-	${AUTHORING_EXT_SOURCE_DIR}/NvBlastExtAuthoringTriangulator.cpp
-	${AUTHORING_EXT_SOURCE_DIR}/NvBlastExtAuthoringTriangulator.h
-	${AUTHORING_EXT_SOURCE_DIR}/NvBlastExtAuthoringVSA.h
-	${AUTHORING_EXT_SOURCE_DIR}/NvBlastExtAuthoringFractureTool.cpp
-	${AUTHORING_EXT_SOURCE_DIR}/NvBlastExtTriangleProcessor.cpp
-	${AUTHORING_EXT_SOURCE_DIR}/NvBlastExtTriangleProcessor.h
-	${AUTHORING_EXT_SOURCE_DIR}/NvBlastExtApexSharedParts.cpp
-	${AUTHORING_EXT_SOURCE_DIR}/NvBlastExtApexSharedParts.h
-	${AUTHORING_EXT_SOURCE_DIR}/NvBlastExtAuthoringInternalCommon.h	
-)
-
-ADD_LIBRARY(NvBlastExtAuthoring STATIC 
-	${COMMON_FILES}
-	${PUBLIC_FILES}
-
-	${EXT_AUTHORING_FILES}
-)
-
-SOURCE_GROUP("common" FILES ${COMMON_FILES})
-SOURCE_GROUP("public" FILES ${PUBLIC_FILES})
-SOURCE_GROUP("src" FILES ${EXT_AUTHORING_FILES})
-
-
-# Target specific compile options
-
-TARGET_INCLUDE_DIRECTORIES(NvBlastExtAuthoring 
-	PRIVATE ${BLASTEXT_PLATFORM_INCLUDES}
-
-	PUBLIC ${PROJECT_SOURCE_DIR}/lowlevel/include
-	PUBLIC ${AUTHORING_EXT_INCLUDE_DIR}
-
-	PRIVATE ${PROJECT_SOURCE_DIR}/common
-	PRIVATE ${COMMON_EXT_SOURCE_DIR}
-	
-	PRIVATE ${AUTHORING_EXT_SOURCE_DIR}
-
-	PRIVATE ${PHYSXSDK_INCLUDE_DIRS}
-	PRIVATE ${PXSHAREDSDK_INCLUDE_DIRS}
-)
-
-TARGET_COMPILE_DEFINITIONS(NvBlastExtAuthoring
-	PRIVATE ${BLASTEXT_COMPILE_DEFS}
-)
-
-# Warning disables for Capn Proto
-TARGET_COMPILE_OPTIONS(NvBlastExtAuthoring
-	PRIVATE ${BLASTEXT_PLATFORM_COMPILE_OPTIONS}
-)
-
-SET_TARGET_PROPERTIES(NvBlastExtAuthoring PROPERTIES 
-	PDB_NAME_DEBUG "NvBlastExtAuthoring${CMAKE_DEBUG_POSTFIX}"
-	PDB_NAME_CHECKED "NvBlastExtAuthoring${CMAKE_CHECKED_POSTFIX}"
-	PDB_NAME_PROFILE "NvBlastExtAuthoring${CMAKE_PROFILE_POSTFIX}"
-	PDB_NAME_RELEASE "NvBlastExtAuthoring${CMAKE_RELEASE_POSTFIX}"
-)
-
-# Do final direct sets after the target has been defined
-TARGET_LINK_LIBRARIES(NvBlastExtAuthoring 
-	PRIVATE NvBlast
-	PUBLIC ${BLASTEXT_PLATFORM_LINKED_LIBS}
-	PUBLIC $<$<CONFIG:debug>:${PHYSX3_LIB_DEBUG}> $<$<CONFIG:debug>:${PHYSX3EXTENSIONS_LIB_DEBUG}> $<$<CONFIG:debug>:${PXFOUNDATION_LIB_DEBUG}>
-	PUBLIC $<$<CONFIG:checked>:${PHYSX3_LIB_CHECKED}> $<$<CONFIG:checked>:${PHYSX3EXTENSIONS_LIB_CHECKED}> $<$<CONFIG:checked>:${PXFOUNDATION_LIB_CHECKED}>
-	PUBLIC $<$<CONFIG:profile>:${PHYSX3_LIB_PROFILE}> $<$<CONFIG:profile>:${PHYSX3EXTENSIONS_LIB_PROFILE}> $<$<CONFIG:profile>:${PXFOUNDATION_LIB_PROFILE}>
-	PUBLIC $<$<CONFIG:release>:${PHYSX3_LIB}> $<$<CONFIG:release>:${PHYSX3EXTENSIONS_LIB}> $<$<CONFIG:release>:${PXFOUNDATION_LIB}>
-)
diff --git a/NvBlast/sdk/compiler/cmake/NvBlastExtConverterLL.cmake b/NvBlast/sdk/compiler/cmake/NvBlastExtConverterLL.cmake
deleted file mode 100644
index c84b60d..0000000
--- a/NvBlast/sdk/compiler/cmake/NvBlastExtConverterLL.cmake
+++ /dev/null
@@ -1,77 +0,0 @@
-#
-# Build NvBlastExtConverterLL Common
-#
-
-
-SET(COMMON_SOURCE_DIR ${PROJECT_SOURCE_DIR}/common)
-SET(CONVERTERLL_EXT_SOURCE_DIR ${PROJECT_SOURCE_DIR}/extensions/converter/source)
-SET(CONVERTERLL_EXT_INCLUDE_DIR ${PROJECT_SOURCE_DIR}/extensions/converter/include)
-
-
-# Include here after the directories are defined so that the platform specific file can use the variables.
-include(${PROJECT_CMAKE_FILES_DIR}/${TARGET_BUILD_PLATFORM}/NvBlastExtConverterLL.cmake)
-
-SET(COMMON_FILES
-	${BLASTEXT_PLATFORM_COMMON_FILES}
-	
-	${COMMON_SOURCE_DIR}/NvBlastAssert.cpp
-	${COMMON_SOURCE_DIR}/NvBlastAssert.h
-)
-
-SET(PUBLIC_FILES
-	${CONVERTERLL_EXT_INCLUDE_DIR}/NvBlastExtDataConverter.h
-)
-
-SET(EXT_CONVERSION_FILES
-	${CONVERTERLL_EXT_SOURCE_DIR}/conversion/NvBlastExtAssetBlockVersionConverter_v0_v1.h
-	${CONVERTERLL_EXT_SOURCE_DIR}/conversion/NvBlastExtBinaryBlockConverter.cpp
-	${CONVERTERLL_EXT_SOURCE_DIR}/conversion/NvBlastExtBinaryBlockConverter.h
-	${CONVERTERLL_EXT_SOURCE_DIR}/conversion/NvBlastExtDataConverter.cpp
-)
-
-ADD_LIBRARY(NvBlastExtConverterLL STATIC
-	${COMMON_FILES}
-	${PUBLIC_FILES}
-
-	${EXT_CONVERSION_FILES}
-)
-
-SOURCE_GROUP("common" FILES ${COMMON_FILES})
-SOURCE_GROUP("public" FILES ${PUBLIC_FILES})
-SOURCE_GROUP("src\\conversion" FILES ${EXT_CONVERSION_FILES})
-
-
-# Target specific compile options
-
-TARGET_INCLUDE_DIRECTORIES(NvBlastExtConverterLL 
-	PRIVATE ${BLASTEXT_PLATFORM_INCLUDES}
-
-	PUBLIC ${PROJECT_SOURCE_DIR}/converter/include
-	PUBLIC ${CONVERTERLL_EXT_INCLUDE_DIR}
-
-	PRIVATE ${CONVERTERLL_EXT_SOURCE_DIR}/conversion
-	PRIVATE ${PROJECT_SOURCE_DIR}/common
-)
-
-TARGET_COMPILE_DEFINITIONS(NvBlastExtConverterLL
-	PRIVATE ${BLASTEXT_COMPILE_DEFS}
-)
-
-# Warning disables for Capn Proto
-TARGET_COMPILE_OPTIONS(NvBlastExtConverterLL
-	PRIVATE ${BLASTEXT_PLATFORM_COMPILE_OPTIONS}
-)
-
-SET_TARGET_PROPERTIES(NvBlastExtConverterLL PROPERTIES 
-	PDB_NAME_DEBUG "NvBlastExtConverterLL${CMAKE_DEBUG_POSTFIX}"
-	PDB_NAME_CHECKED "NvBlastExtConverterLL${CMAKE_CHECKED_POSTFIX}"
-	PDB_NAME_PROFILE "NvBlastExtConverterLL${CMAKE_PROFILE_POSTFIX}"
-	PDB_NAME_RELEASE "NvBlastExtConverterLL${CMAKE_RELEASE_POSTFIX}"
-)
-
-# Do final direct sets after the target has been defined
-#TARGET_LINK_LIBRARIES(NvBlastExtConverterLL NvBlast ${PHYSXSDK_LIBRARIES} ${APEXSDK_LIBRARIES} ${PXSHAREDSDK_LIBRARIES})
-TARGET_LINK_LIBRARIES(NvBlastExtConverterLL 
-	PUBLIC NvBlast 
-	PUBLIC ${BLASTEXT_PLATFORM_LINKED_LIBS}
-)
diff --git a/NvBlast/sdk/compiler/cmake/NvBlastExtImport.cmake b/NvBlast/sdk/compiler/cmake/NvBlastExtImport.cmake
deleted file mode 100644
index 3d7b27a..0000000
--- a/NvBlast/sdk/compiler/cmake/NvBlastExtImport.cmake
+++ /dev/null
@@ -1,95 +0,0 @@
-#
-# Build NvBlastExt Common
-#
-
-
-SET(COMMON_SOURCE_DIR ${PROJECT_SOURCE_DIR}/common)
-
-SET(COMMON_EXT_SOURCE_DIR ${PROJECT_SOURCE_DIR}/extensions/common/source)
-SET(IMPORT_EXT_SOURCE_DIR ${PROJECT_SOURCE_DIR}/extensions/import/source)
-SET(IMPORT_EXT_INCLUDE_DIR ${PROJECT_SOURCE_DIR}/extensions/import/include)
-SET(PHYSX_EXT_INCLUDE_DIR ${PROJECT_SOURCE_DIR}/extensions/physx/include)
-
-FIND_PACKAGE(PhysXSDK $ENV{PM_PhysX_VERSION} REQUIRED)
-FIND_PACKAGE(ApexSDK $ENV{PM_Apex_VERSION} REQUIRED)
-FIND_PACKAGE(PxSharedSDK $ENV{PM_PxShared_VERSION} REQUIRED)
-
-# Include here after the directories are defined so that the platform specific file can use the variables.
-include(${PROJECT_CMAKE_FILES_DIR}/${TARGET_BUILD_PLATFORM}/NvBlastExtImport.cmake)
-
-SET(COMMON_FILES
-	${BLASTEXT_PLATFORM_COMMON_FILES}
-	
-	${COMMON_SOURCE_DIR}/NvBlastAssert.cpp
-	${COMMON_SOURCE_DIR}/NvBlastAssert.h
-)
-
-SET(PUBLIC_FILES
-	${IMPORT_EXT_INCLUDE_DIR}/NvBlastExtApexImportTool.h
-)
-
-SET(EXT_IMPORT_FILES
-	${IMPORT_EXT_SOURCE_DIR}/NvBlastExtApexDestruction.cpp
-	${IMPORT_EXT_SOURCE_DIR}/NvBlastExtApexDestruction.h
-	${IMPORT_EXT_SOURCE_DIR}/NvBlastExtApexImportTool.cpp
-	${IMPORT_EXT_SOURCE_DIR}/NvBlastExtScopedResource.cpp
-	${IMPORT_EXT_SOURCE_DIR}/NvBlastExtScopedResource.h
-)
-
-ADD_LIBRARY(NvBlastExtImport STATIC
-	${COMMON_FILES}
-	${PUBLIC_FILES}
-
-	${EXT_IMPORT_FILES}
-)
-
-SOURCE_GROUP("common" FILES ${COMMON_FILES})
-SOURCE_GROUP("public" FILES ${PUBLIC_FILES})
-SOURCE_GROUP("src" FILES ${EXT_IMPORT_FILES})
-
-
-# Target specific compile options
-
-TARGET_INCLUDE_DIRECTORIES(NvBlastExtImport 
-	PRIVATE ${BLASTEXT_PLATFORM_INCLUDES}
-
-	PUBLIC ${PROJECT_SOURCE_DIR}/lowlevel/include
-	PUBLIC ${PROJECT_SOURCE_DIR}/toolkit/include
-	PUBLIC ${PHYSX_EXT_INCLUDE_DIR}
-	PUBLIC ${IMPORT_EXT_INCLUDE_DIR}
-
-	PRIVATE ${PROJECT_SOURCE_DIR}/common
-	PRIVATE ${COMMON_EXT_SOURCE_DIR}
-	
-	PRIVATE ${IMPORT_EXT_SOURCE_DIR}
-
-	PRIVATE ${PHYSXSDK_INCLUDE_DIRS}
-	PRIVATE ${APEXSDK_INCLUDE_DIRS}
-	PRIVATE ${PXSHAREDSDK_INCLUDE_DIRS}
-)
-
-TARGET_COMPILE_DEFINITIONS(NvBlastExtImport
-	PRIVATE ${BLASTEXT_COMPILE_DEFS}
-)
-
-# Warning disables for Capn Proto
-TARGET_COMPILE_OPTIONS(NvBlastExtImport
-	PRIVATE ${BLASTEXT_PLATFORM_COMPILE_OPTIONS}
-)
-
-SET_TARGET_PROPERTIES(NvBlastExtImport PROPERTIES 
-	PDB_NAME_DEBUG "NvBlastExtImport${CMAKE_DEBUG_POSTFIX}"
-	PDB_NAME_CHECKED "NvBlastExtImport${CMAKE_CHECKED_POSTFIX}"
-	PDB_NAME_PROFILE "NvBlastExtImport${CMAKE_PROFILE_POSTFIX}"
-	PDB_NAME_RELEASE "NvBlastExtImport${CMAKE_RELEASE_POSTFIX}"
-)
-
-# Do final direct sets after the target has been defined
-TARGET_LINK_LIBRARIES(NvBlastExtImport 
-	PRIVATE NvBlast NvBlastTk NvBlastExtAuthoring
-	PUBLIC ${BLASTEXT_PLATFORM_LINKED_LIBS}
-	PUBLIC $<$<CONFIG:debug>:${APEXFRAMEWORK_LIB_DEBUG}> $<$<CONFIG:debug>:${PSFASTXML_LIB_DEBUG}>
-	PUBLIC $<$<CONFIG:checked>:${APEXFRAMEWORK_LIB_CHECKED}> $<$<CONFIG:checked>:${PSFASTXML_LIB_CHECKED}>
-	PUBLIC $<$<CONFIG:profile>:${APEXFRAMEWORK_LIB_PROFILE}> $<$<CONFIG:profile>:${PSFASTXML_LIB_PROFILE}>
-	PUBLIC $<$<CONFIG:release>:${APEXFRAMEWORK_LIB}> $<$<CONFIG:release>:${PSFASTXML_LIB}>
-)
diff --git a/NvBlast/sdk/compiler/cmake/NvBlastExtPhysX.cmake b/NvBlast/sdk/compiler/cmake/NvBlastExtPhysX.cmake
deleted file mode 100644
index d2d0f0a..0000000
--- a/NvBlast/sdk/compiler/cmake/NvBlastExtPhysX.cmake
+++ /dev/null
@@ -1,113 +0,0 @@
-#
-# Build NvBlastExtPhysX Common
-#
-
-
-SET(COMMON_SOURCE_DIR ${PROJECT_SOURCE_DIR}/common)
-
-SET(COMMON_EXT_SOURCE_DIR ${PROJECT_SOURCE_DIR}/extensions/common/source)
-SET(PHYSX_EXT_SOURCE_DIR ${PROJECT_SOURCE_DIR}/extensions/physx/source)
-SET(COMMON_EXT_INCLUDE_DIR ${PROJECT_SOURCE_DIR}/extensions/common/include)
-SET(PHYSX_EXT_INCLUDE_DIR ${PROJECT_SOURCE_DIR}/extensions/physx/include)
-
-FIND_PACKAGE(PhysXSDK $ENV{PM_PhysX_VERSION} REQUIRED)
-FIND_PACKAGE(PxSharedSDK $ENV{PM_PxShared_VERSION} REQUIRED)
-
-# Include here after the directories are defined so that the platform specific file can use the variables.
-include(${PROJECT_CMAKE_FILES_DIR}/${TARGET_BUILD_PLATFORM}/NvBlastExtPhysX.cmake)
-
-SET(COMMON_FILES
-	${BLASTEXT_PLATFORM_COMMON_FILES}
-	
-	${COMMON_SOURCE_DIR}/NvBlastAssert.cpp
-	${COMMON_SOURCE_DIR}/NvBlastAssert.h
-)
-
-SET(PUBLIC_FILES
-	${PHYSX_EXT_INCLUDE_DIR}/NvBlastExtImpactDamageManager.h
-	${PHYSX_EXT_INCLUDE_DIR}/NvBlastExtPx.h
-	${PHYSX_EXT_INCLUDE_DIR}/NvBlastExtPxActor.h
-	${PHYSX_EXT_INCLUDE_DIR}/NvBlastExtPxAsset.h
-	${PHYSX_EXT_INCLUDE_DIR}/NvBlastExtPxFamily.h
-	${PHYSX_EXT_INCLUDE_DIR}/NvBlastExtPxListener.h
-	${PHYSX_EXT_INCLUDE_DIR}/NvBlastExtPxManager.h
-	${PHYSX_EXT_INCLUDE_DIR}/NvBlastExtStressSolver.h
-	${PHYSX_EXT_INCLUDE_DIR}/NvBlastExtSync.h
-)
-
-SET(EXT_PHYSICS_FILES
-	${PHYSX_EXT_SOURCE_DIR}/physics/NvBlastExtImpulseStressSolver.h
-	${PHYSX_EXT_SOURCE_DIR}/physics/NvBlastExtImpactDamageManager.cpp
-	${PHYSX_EXT_SOURCE_DIR}/physics/NvBlastExtImpulseStressSolver.cpp
-	${PHYSX_EXT_SOURCE_DIR}/physics/NvBlastExtPxActorImpl.h
-	${PHYSX_EXT_SOURCE_DIR}/physics/NvBlastExtPxActorImpl.cpp
-	${PHYSX_EXT_SOURCE_DIR}/physics/NvBlastExtPxAssetImpl.h
-	${PHYSX_EXT_SOURCE_DIR}/physics/NvBlastExtPxAssetImpl.cpp
-	${PHYSX_EXT_SOURCE_DIR}/physics/NvBlastExtPxFamilyImpl.h
-	${PHYSX_EXT_SOURCE_DIR}/physics/NvBlastExtPxFamilyImpl.cpp
-	${PHYSX_EXT_SOURCE_DIR}/physics/NvBlastExtPxManagerImpl.h
-	${PHYSX_EXT_SOURCE_DIR}/physics/NvBlastExtPxManagerImpl.cpp
-)
-
-SET(EXT_SYNC_FILES
-	${PHYSX_EXT_SOURCE_DIR}/sync/NvBlastExtSync.cpp
-)
-
-ADD_LIBRARY(NvBlastExtPhysX ${BLASTEXT_PHYSX_LIBTYPE}
-	${COMMON_FILES}
-	${PUBLIC_FILES}
-
-	${EXT_PHYSICS_FILES}
-	${EXT_SYNC_FILES}
-)
-
-SOURCE_GROUP("common" FILES ${COMMON_FILES})
-SOURCE_GROUP("public" FILES ${PUBLIC_FILES})
-SOURCE_GROUP("src\\physics" FILES ${EXT_PHYSICS_FILES})
-SOURCE_GROUP("src\\sync" FILES ${EXT_SYNC_FILES})
-
-
-# Target specific compile options
-
-TARGET_INCLUDE_DIRECTORIES(NvBlastExtPhysX 
-	PRIVATE ${BLASTEXT_PLATFORM_INCLUDES}
-
-	PUBLIC ${PROJECT_SOURCE_DIR}/lowlevel/include
-	PUBLIC ${PHYSX_EXT_INCLUDE_DIR}
-
-	PRIVATE ${PROJECT_SOURCE_DIR}/common
-	PRIVATE ${COMMON_EXT_SOURCE_DIR}
-	
-	PRIVATE ${PHYSX_EXT_SOURCE_DIR}/physics
-	PRIVATE ${PHYSX_EXT_SOURCE_DIR}/sync
-	
-	PUBLIC ${PHYSXSDK_INCLUDE_DIRS}
-	PRIVATE ${PXSHAREDSDK_INCLUDE_DIRS}
-)
-
-TARGET_COMPILE_DEFINITIONS(NvBlastExtPhysX
-	PRIVATE ${BLASTEXT_COMPILE_DEFS}
-)
-
-# Warning disables for Capn Proto
-TARGET_COMPILE_OPTIONS(NvBlastExtPhysX
-	PRIVATE ${BLASTEXT_PLATFORM_COMPILE_OPTIONS}
-)
-
-SET_TARGET_PROPERTIES(NvBlastExtPhysX PROPERTIES 
-	PDB_NAME_DEBUG "NvBlastExtPhysX${CMAKE_DEBUG_POSTFIX}"
-	PDB_NAME_CHECKED "NvBlastExtPhysX${CMAKE_CHECKED_POSTFIX}"
-	PDB_NAME_PROFILE "NvBlastExtPhysX${CMAKE_PROFILE_POSTFIX}"
-	PDB_NAME_RELEASE "NvBlastExtPhysX${CMAKE_RELEASE_POSTFIX}"
-)
-
-# Do final direct sets after the target has been defined
-TARGET_LINK_LIBRARIES(NvBlastExtPhysX 
-	PUBLIC NvBlast NvBlastExtShaders NvBlastTk
-	PUBLIC $<$<CONFIG:debug>:${PHYSX3_LIB_DEBUG}> $<$<CONFIG:debug>:${PHYSX3COOKING_LIB_DEBUG}> $<$<CONFIG:debug>:${PHYSX3EXTENSIONS_LIB_DEBUG}> $<$<CONFIG:debug>:${PXFOUNDATION_LIB_DEBUG}>
-	PUBLIC $<$<CONFIG:checked>:${PHYSX3_LIB_CHECKED}> $<$<CONFIG:checked>:${PHYSX3COOKING_LIB_CHECKED}> $<$<CONFIG:checked>:${PHYSX3EXTENSIONS_LIB_CHECKED}> $<$<CONFIG:checked>:${PXFOUNDATION_LIB_CHECKED}>
-	PUBLIC $<$<CONFIG:profile>:${PHYSX3_LIB_PROFILE}> $<$<CONFIG:profile>:${PHYSX3COOKING_LIB_PROFILE}> $<$<CONFIG:profile>:${PHYSX3EXTENSIONS_LIB_PROFILE}> $<$<CONFIG:profile>:${PXFOUNDATION_LIB_PROFILE}>
-	PUBLIC $<$<CONFIG:release>:${PHYSX3_LIB}> $<$<CONFIG:release>:${PHYSX3COOKING_LIB}> $<$<CONFIG:release>:${PHYSX3EXTENSIONS_LIB}> $<$<CONFIG:release>:${PXFOUNDATION_LIB}>
-
-	PUBLIC ${BLASTEXT_PLATFORM_LINKED_LIBS}
-)
diff --git a/NvBlast/sdk/compiler/cmake/NvBlastExtSerialization.cmake b/NvBlast/sdk/compiler/cmake/NvBlastExtSerialization.cmake
deleted file mode 100644
index 440ad43..0000000
--- a/NvBlast/sdk/compiler/cmake/NvBlastExtSerialization.cmake
+++ /dev/null
@@ -1,200 +0,0 @@
-#
-# Build NvBlastExtSerialization Common
-#
-
-SET(COMMON_SOURCE_DIR ${PROJECT_SOURCE_DIR}/common)
-
-SET(SERIAL_EXT_SOURCE_DIR ${PROJECT_SOURCE_DIR}/extensions/serialization/source)
-SET(SERIAL_EXT_INCLUDE_DIR ${PROJECT_SOURCE_DIR}/extensions/serialization/include)
-SET(TK_INCLUDE_DIR ${BLAST_ROOT_DIR}/sdk/toolkit/include)
-SET(PHYSX_EXT_INCLUDE_DIR ${PROJECT_SOURCE_DIR}/extensions/physx/include)
-SET(PHYSX_EXT_SOURCE_DIR ${PROJECT_SOURCE_DIR}/extensions/physx/source)
-SET(EXT_COMMON_SOURCE_DIR ${PROJECT_SOURCE_DIR}/extensions/common/source)
-SET(EXT_COMMON_INCLUDE_DIR ${PROJECT_SOURCE_DIR}/extensions/common/include)
-
-SET(DTO_SOURCE_DIR ${SERIAL_EXT_SOURCE_DIR}/DTO)
-
-SET(SOLVER_SOURCE_DIR ${PROJECT_SOURCE_DIR}/lowlevel/source)
-
-SET(SERIAL_GENERATED_SOURCE_DIR ${SERIAL_EXT_SOURCE_DIR}/generated)
-
-FIND_PACKAGE(PhysXSDK $ENV{PM_PhysX_VERSION} REQUIRED)
-FIND_PACKAGE(PxSharedSDK $ENV{PM_PxShared_VERSION} REQUIRED)
-FIND_PACKAGE(CapnProtoSDK $ENV{PM_CapnProto_VERSION} REQUIRED)
-
-# Include here after the directories are defined so that the platform specific file can use the variables.
-include(${PROJECT_CMAKE_FILES_DIR}/${TARGET_BUILD_PLATFORM}/NvBlastExtSerialization.cmake)
-
-# Compile the generated files for serialization
-
-INCLUDE(CapnProtoGenerate)
-
-SET(CAPNPC_OUTPUT_DIR ${SERIAL_GENERATED_SOURCE_DIR})
-SET(CAPNPC_SRC_PREFIX ${SERIAL_EXT_SOURCE_DIR})
-CAPNP_GENERATE_CPP(CAPNP_SRCS CAPNP_HDRS ${SERIAL_EXT_SOURCE_DIR}/NvBlastExtSerializationLL.capn ${SERIAL_EXT_SOURCE_DIR}/NvBlastExtSerialization.capn)
-
-SET(COMMON_FILES
-	${BLASTEXTSERIALIZATION_PLATFORM_COMMON_FILES}
-	
-	${COMMON_SOURCE_DIR}/NvBlastAssert.cpp
-	${COMMON_SOURCE_DIR}/NvBlastAssert.h
-	${COMMON_SOURCE_DIR}/NvBlastAtomic.cpp
-	${COMMON_SOURCE_DIR}/NvBlastAtomic.h
-	${COMMON_SOURCE_DIR}/NvBlastDLink.h
-	${COMMON_SOURCE_DIR}/NvBlastFixedArray.h
-	${COMMON_SOURCE_DIR}/NvBlastFixedBitmap.h
-	${COMMON_SOURCE_DIR}/NvBlastFixedBoolArray.h
-	${COMMON_SOURCE_DIR}/NvBlastFixedPriorityQueue.h
-	${COMMON_SOURCE_DIR}/NvBlastGeometry.h
-#	${COMMON_SOURCE_DIR}/NvBlastIndexFns.cpp
-	${COMMON_SOURCE_DIR}/NvBlastIndexFns.h
-	${COMMON_SOURCE_DIR}/NvBlastIteratorBase.h
-	${COMMON_SOURCE_DIR}/NvBlastMath.h
-	${COMMON_SOURCE_DIR}/NvBlastMemory.h
-	${COMMON_SOURCE_DIR}/NvBlastPreprocessorInternal.h
-	${COMMON_SOURCE_DIR}/NvBlastTime.cpp
-	${COMMON_SOURCE_DIR}/NvBlastTime.h
-	${COMMON_SOURCE_DIR}/NvBlastTimers.cpp
-)
-  
-
-SET(EXT_SERIALIZATION_FILES
-	${SERIAL_EXT_SOURCE_DIR}/NvBlastExtSerializationLL.capn
-	${SERIAL_EXT_SOURCE_DIR}/NvBlastExtSerialization.capn
-
-	${SERIAL_EXT_SOURCE_DIR}/NvBlastExtSerialization.h
-	${SERIAL_EXT_SOURCE_DIR}/NvBlastExtSerializationImpl.h
-	${SERIAL_EXT_SOURCE_DIR}/NvBlastExtSerializationLLImpl.h
-
-	${SERIAL_EXT_SOURCE_DIR}/NvBlastExtSerializationLLInterface.cpp
-	${SERIAL_EXT_SOURCE_DIR}/NvBlastExtSerializationInterface.cpp
-	
-	${SERIAL_EXT_SOURCE_DIR}/NvBlastExtOutputStream.h
-	${SERIAL_EXT_SOURCE_DIR}/NvBlastExtOutputStream.cpp
-	${SERIAL_EXT_SOURCE_DIR}/NvBlastExtInputStream.h
-	${SERIAL_EXT_SOURCE_DIR}/NvBlastExtInputStream.cpp
-	
-	${SERIAL_EXT_SOURCE_DIR}/NvBlastExtKJPxInputStream.h
-	${SERIAL_EXT_SOURCE_DIR}/NvBlastExtKJPxInputStream.cpp
-	
-	${SERIAL_EXT_SOURCE_DIR}/NvBlastExtKJPxOutputStream.h
-	${SERIAL_EXT_SOURCE_DIR}/NvBlastExtKJPxOutputStream.cpp
-)
-
-SET(DTO_SOURCE_FILES
-	${DTO_SOURCE_DIR}/DTOMacros.h
-	${DTO_SOURCE_DIR}/AssetDTO.h
-	${DTO_SOURCE_DIR}/AssetDTO.cpp
-	${DTO_SOURCE_DIR}/TkAssetDTO.h
-	${DTO_SOURCE_DIR}/TkAssetDTO.cpp
-	${DTO_SOURCE_DIR}/ExtPxAssetDTO.h
-	${DTO_SOURCE_DIR}/ExtPxAssetDTO.cpp
-	${DTO_SOURCE_DIR}/PxVec3DTO.h
-	${DTO_SOURCE_DIR}/PxVec3DTO.cpp
-	${DTO_SOURCE_DIR}/NvBlastChunkDTO.h
-	${DTO_SOURCE_DIR}/NvBlastChunkDTO.cpp
-	${DTO_SOURCE_DIR}/NvBlastBondDTO.h
-	${DTO_SOURCE_DIR}/NvBlastBondDTO.cpp
-	${DTO_SOURCE_DIR}/NvBlastIDDTO.h
-	${DTO_SOURCE_DIR}/NvBlastIDDTO.cpp
-	${DTO_SOURCE_DIR}/TkAssetJointDescDTO.h
-	${DTO_SOURCE_DIR}/TkAssetJointDescDTO.cpp
-	${DTO_SOURCE_DIR}/ExtPxChunkDTO.h
-	${DTO_SOURCE_DIR}/ExtPxChunkDTO.cpp
-	${DTO_SOURCE_DIR}/ExtPxSubchunkDTO.h
-	${DTO_SOURCE_DIR}/ExtPxSubchunkDTO.cpp
-	${DTO_SOURCE_DIR}/PxQuatDTO.h
-	${DTO_SOURCE_DIR}/PxQuatDTO.cpp
-	${DTO_SOURCE_DIR}/PxTransformDTO.h
-	${DTO_SOURCE_DIR}/PxTransformDTO.cpp
-	${DTO_SOURCE_DIR}/PxMeshScaleDTO.h
-	${DTO_SOURCE_DIR}/PxMeshScaleDTO.cpp
-	${DTO_SOURCE_DIR}/PxConvexMeshGeometryDTO.h
-	${DTO_SOURCE_DIR}/PxConvexMeshGeometryDTO.cpp
-	
-	
-	
-)
-
-SET(EXT_SERIALIZATION_INCLUDES
-	${SERIAL_EXT_INCLUDE_DIR}/NvBlastExtSerializationLLInterface.h
-	${SERIAL_EXT_INCLUDE_DIR}/NvBlastExtSerializationInterface.h
-)
-
-ADD_LIBRARY(NvBlastExtSerialization ${BLASTEXTSERIALIZATION_LIB_TYPE} 
-	${COMMON_FILES}
-
-	${DTO_SOURCE_FILES}
-	
-	${EXT_SERIALIZATION_INCLUDES}
-	${EXT_SERIALIZATION_FILES}
-	
-	${CAPNP_SRCS}
-	${CAPNP_HDRS}
-	
-	${MD5_FILES}
-)
-
-SOURCE_GROUP("common" FILES ${COMMON_FILES})
-
-SOURCE_GROUP("include" FILES ${EXT_SERIALIZATION_INCLUDES})
-SOURCE_GROUP("src\\serialization" FILES ${EXT_SERIALIZATION_FILES})
-SOURCE_GROUP("src\\serialization\\DTO" FILES ${DTO_SOURCE_FILES})
-SOURCE_GROUP("src\\serialization\\generated" FILES ${CAPNP_SRCS} ${CAPNP_HDRS})
-
-
-# Target specific compile options
-
-TARGET_INCLUDE_DIRECTORIES(NvBlastExtSerialization 
-	PRIVATE ${BLASTEXTSERIALIZATION_PLATFORM_INCLUDES}
-
-	PRIVATE ${PROJECT_SOURCE_DIR}/common
-	PRIVATE ${PROJECT_SOURCE_DIR}/lowlevel/include
-	PRIVATE ${PROJECT_SOURCE_DIR}/lowlevel/source
-
-	PRIVATE ${TK_INCLUDE_DIR}
-	
-	PUBLIC ${SERIAL_EXT_INCLUDE_DIR}
-	PUBLIC ${SERIAL_EXT_SOURCE_DIR}
-	PUBLIC ${DTO_SOURCE_DIR}
-	
-	PRIVATE ${PHYSX_EXT_INCLUDE_DIR}
-	PRIVATE ${PHYSX_EXT_SOURCE_DIR}
-
-	PRIVATE ${EXT_COMMON_SOURCE_DIR}
-	PRIVATE ${EXT_COMMON_INCLUDE_DIR}
-	
-	PUBLIC ${CAPNPROTOSDK_INCLUDE_DIRS}
-	
-	PRIVATE ${COMMON_SOURCE_DIR}
-	
-	PUBLIC ${PHYSXSDK_INCLUDE_DIRS}
-	PRIVATE ${PXSHAREDSDK_INCLUDE_DIRS}
-)
-
-TARGET_COMPILE_DEFINITIONS(NvBlastExtSerialization
-	PUBLIC CAPNP_LITE=1
-	PRIVATE ${BLASTEXTSERIALIZATION_COMPILE_DEFS}
-)
-
-# Warning disables for Capn Proto
-TARGET_COMPILE_OPTIONS(NvBlastExtSerialization
-	PRIVATE ${BLASTEXTSERIALIZATION_COMPILE_OPTIONS}
-)
-
-SET_TARGET_PROPERTIES(NvBlastExtSerialization PROPERTIES 
-	PDB_NAME_DEBUG "NvBlastExtSerialization${CMAKE_DEBUG_POSTFIX}"
-	PDB_NAME_CHECKED "NvBlastExtSerialization${CMAKE_CHECKED_POSTFIX}"
-	PDB_NAME_PROFILE "NvBlastExtSerialization${CMAKE_PROFILE_POSTFIX}"
-	PDB_NAME_RELEASE "NvBlastExtSerialization${CMAKE_RELEASE_POSTFIX}"
-)
-
-# Do final direct sets after the target has been defined
-TARGET_LINK_LIBRARIES(NvBlastExtSerialization 
-	PRIVATE NvBlast NvBlastExtPhysX NvBlastTk ${CAPNPROTOSDK_LIBRARIES}
-	PUBLIC $<$<CONFIG:debug>:${PHYSX3_LIB_DEBUG}> $<$<CONFIG:debug>:${PHYSX3COOKING_LIB_DEBUG}>
-	PUBLIC $<$<CONFIG:checked>:${PHYSX3_LIB_CHECKED}> $<$<CONFIG:checked>:${PHYSX3COOKING_LIB_CHECKED}>
-	PUBLIC $<$<CONFIG:profile>:${PHYSX3_LIB_PROFILE}> $<$<CONFIG:profile>:${PHYSX3COOKING_LIB_PROFILE}>
-	PUBLIC $<$<CONFIG:release>:${PHYSX3_LIB}> $<$<CONFIG:release>:${PHYSX3COOKING_LIB}>
-	
-)
diff --git a/NvBlast/sdk/compiler/cmake/NvBlastExtSerializationLL.cmake b/NvBlast/sdk/compiler/cmake/NvBlastExtSerializationLL.cmake
deleted file mode 100644
index da1a9d2..0000000
--- a/NvBlast/sdk/compiler/cmake/NvBlastExtSerializationLL.cmake
+++ /dev/null
@@ -1,151 +0,0 @@
-#
-# Build NvBlastExtSerializationLL Common
-#
-
-SET(COMMON_SOURCE_DIR ${PROJECT_SOURCE_DIR}/common)
-
-SET(SERIAL_EXT_SOURCE_DIR ${PROJECT_SOURCE_DIR}/extensions/serialization/source)
-SET(SERIAL_EXT_INCLUDE_DIR ${PROJECT_SOURCE_DIR}/extensions/serialization/include)
-
-SET(DTO_SOURCE_DIR ${SERIAL_EXT_SOURCE_DIR}/DTO)
-
-SET(SOLVER_SOURCE_DIR ${PROJECT_SOURCE_DIR}/lowlevel/source)
-
-SET(SERIAL_GENERATED_SOURCE_DIR ${SERIAL_EXT_SOURCE_DIR}/generated)
-
-FIND_PACKAGE(CapnProtoSDK $ENV{PM_CapnProto_VERSION} REQUIRED)
-
-# Include here after the directories are defined so that the platform specific file can use the variables.
-include(${PROJECT_CMAKE_FILES_DIR}/${TARGET_BUILD_PLATFORM}/NvBlastExtSerializationLL.cmake)
-
-# Compile the generated files for serialization
-
-INCLUDE(CapnProtoGenerate)
-
-SET(CAPNPC_OUTPUT_DIR ${SERIAL_GENERATED_SOURCE_DIR})
-SET(CAPNPC_SRC_PREFIX ${SERIAL_EXT_SOURCE_DIR})
-CAPNP_GENERATE_CPP(CAPNP_SRCS CAPNP_HDRS ${SERIAL_EXT_SOURCE_DIR}/NvBlastExtSerializationLL.capn)
-
-SET(COMMON_FILES
-	${BLASTEXTSERIALIZATION_PLATFORM_COMMON_FILES}
-	
-	${COMMON_SOURCE_DIR}/NvBlastAssert.cpp
-	${COMMON_SOURCE_DIR}/NvBlastAssert.h
-	${COMMON_SOURCE_DIR}/NvBlastAtomic.cpp
-	${COMMON_SOURCE_DIR}/NvBlastAtomic.h
-	${COMMON_SOURCE_DIR}/NvBlastDLink.h
-	${COMMON_SOURCE_DIR}/NvBlastFixedArray.h
-	${COMMON_SOURCE_DIR}/NvBlastFixedBitmap.h
-	${COMMON_SOURCE_DIR}/NvBlastFixedBoolArray.h
-	${COMMON_SOURCE_DIR}/NvBlastFixedPriorityQueue.h
-	${COMMON_SOURCE_DIR}/NvBlastGeometry.h
-	${COMMON_SOURCE_DIR}/NvBlastIndexFns.h
-	${COMMON_SOURCE_DIR}/NvBlastIteratorBase.h
-	${COMMON_SOURCE_DIR}/NvBlastMath.h
-	${COMMON_SOURCE_DIR}/NvBlastMemory.h
-	${COMMON_SOURCE_DIR}/NvBlastPreprocessorInternal.h
-	${COMMON_SOURCE_DIR}/NvBlastTime.cpp
-	${COMMON_SOURCE_DIR}/NvBlastTime.h
-	${COMMON_SOURCE_DIR}/NvBlastTimers.cpp
-)
-  
-
-SET(EXT_SERIALIZATION_FILES
-	${SERIAL_EXT_SOURCE_DIR}/NvBlastExtSerializationLL.capn
-
-	${SERIAL_EXT_SOURCE_DIR}/NvBlastExtSerialization.h
-	${SERIAL_EXT_SOURCE_DIR}/NvBlastExtSerializationLLImpl.h
-
-	${SERIAL_EXT_SOURCE_DIR}/NvBlastExtSerializationLLInterface.cpp
-	
-	${SERIAL_EXT_SOURCE_DIR}/NvBlastExtOutputStream.h
-	${SERIAL_EXT_SOURCE_DIR}/NvBlastExtOutputStream.cpp
-	${SERIAL_EXT_SOURCE_DIR}/NvBlastExtInputStream.h
-	${SERIAL_EXT_SOURCE_DIR}/NvBlastExtInputStream.cpp
-	
-#	${SERIAL_EXT_SOURCE_DIR}/NvBlastExtKJPxInputStream.h
-#	${SERIAL_EXT_SOURCE_DIR}/NvBlastExtKJPxInputStream.cpp
-	
-#	${SERIAL_EXT_SOURCE_DIR}/NvBlastExtKJPxOutputStream.h
-#	${SERIAL_EXT_SOURCE_DIR}/NvBlastExtKJPxOutputStream.cpp
-)
-
-SET(DTO_SOURCE_FILES
-	${DTO_SOURCE_DIR}/DTOMacros.h
-	${DTO_SOURCE_DIR}/AssetDTO.h
-	${DTO_SOURCE_DIR}/AssetDTO.cpp
-	${DTO_SOURCE_DIR}/NvBlastChunkDTO.h
-	${DTO_SOURCE_DIR}/NvBlastChunkDTO.cpp
-	${DTO_SOURCE_DIR}/NvBlastBondDTO.h
-	${DTO_SOURCE_DIR}/NvBlastBondDTO.cpp
-	${DTO_SOURCE_DIR}/NvBlastIDDTO.h
-	${DTO_SOURCE_DIR}/NvBlastIDDTO.cpp
-)
-
-SET(EXT_SERIALIZATION_INCLUDES
-	${SERIAL_EXT_INCLUDE_DIR}/NvBlastExtSerializationLLInterface.h
-)
-
-ADD_LIBRARY(NvBlastExtSerializationLL ${BLASTEXTSERIALIZATION_LIB_TYPE} 
-	${COMMON_FILES}
-
-	${DTO_SOURCE_FILES}
-	
-	${EXT_SERIALIZATION_INCLUDES}
-	${EXT_SERIALIZATION_FILES}
-	
-	${CAPNP_SRCS}
-	${CAPNP_HDRS}
-	
-	${MD5_FILES}
-)
-
-SOURCE_GROUP("common" FILES ${COMMON_FILES})
-
-SOURCE_GROUP("include" FILES ${EXT_SERIALIZATION_INCLUDES})
-SOURCE_GROUP("src\\serialization" FILES ${EXT_SERIALIZATION_FILES})
-SOURCE_GROUP("src\\serialization\\DTO" FILES ${DTO_SOURCE_FILES})
-SOURCE_GROUP("src\\serialization\\generated" FILES ${CAPNP_SRCS} ${CAPNP_HDRS})
-
-
-# Target specific compile options
-
-TARGET_INCLUDE_DIRECTORIES(NvBlastExtSerializationLL 
-	PRIVATE ${BLASTEXTSERIALIZATION_PLATFORM_INCLUDES}
-
-	PRIVATE ${PROJECT_SOURCE_DIR}/common
-	PRIVATE ${PROJECT_SOURCE_DIR}/lowlevel/include
-	PRIVATE ${PROJECT_SOURCE_DIR}/lowlevel/source
-
-	PRIVATE ${TK_INCLUDE_DIR}
-	
-	PUBLIC ${SERIAL_EXT_INCLUDE_DIR}
-	PUBLIC ${SERIAL_EXT_SOURCE_DIR}
-	PUBLIC ${DTO_SOURCE_DIR}
-	
-	PUBLIC ${CAPNPROTOSDK_INCLUDE_DIRS}
-	
-	PRIVATE ${COMMON_SOURCE_DIR}
-)
-
-TARGET_COMPILE_DEFINITIONS(NvBlastExtSerializationLL
-	PUBLIC CAPNP_LITE=1;BLAST_LL_ALLOC=1
-	PRIVATE ${BLASTEXTSERIALIZATION_COMPILE_DEFS}
-)
-
-# Warning disables for Capn Proto
-TARGET_COMPILE_OPTIONS(NvBlastExtSerializationLL
-	PRIVATE ${BLASTEXTSERIALIZATION_COMPILE_OPTIONS}
-)
-
-SET_TARGET_PROPERTIES(NvBlastExtSerializationLL PROPERTIES 
-	PDB_NAME_DEBUG "NvBlastExtSerializationLL${CMAKE_DEBUG_POSTFIX}"
-	PDB_NAME_CHECKED "NvBlastExtSerializationLL${CMAKE_CHECKED_POSTFIX}"
-	PDB_NAME_PROFILE "NvBlastExtSerializationLL${CMAKE_PROFILE_POSTFIX}"
-	PDB_NAME_RELEASE "NvBlastExtSerializationLL${CMAKE_RELEASE_POSTFIX}"
-)
-
-# Do final direct sets after the target has been defined
-TARGET_LINK_LIBRARIES(NvBlastExtSerializationLL 
-	PRIVATE NvBlast  ${CAPNPROTOSDK_LIBRARIES}
-)
diff --git a/NvBlast/sdk/compiler/cmake/NvBlastExtShaders.cmake b/NvBlast/sdk/compiler/cmake/NvBlastExtShaders.cmake
deleted file mode 100644
index df4a3ad..0000000
--- a/NvBlast/sdk/compiler/cmake/NvBlastExtShaders.cmake
+++ /dev/null
@@ -1,74 +0,0 @@
-#
-# Build NvBlastExtShaders Common
-#
-
-
-SET(COMMON_SOURCE_DIR ${PROJECT_SOURCE_DIR}/common)
-SET(SHADERS_EXT_SOURCE_DIR ${PROJECT_SOURCE_DIR}/extensions/shaders/source)
-SET(SHADERS_EXT_INCLUDE_DIR ${PROJECT_SOURCE_DIR}/extensions/shaders/include)
-
-# Include here after the directories are defined so that the platform specific file can use the variables.
-include(${PROJECT_CMAKE_FILES_DIR}/${TARGET_BUILD_PLATFORM}/NvBlastExtShaders.cmake)
-
-SET(COMMON_FILES
-	${BLASTEXT_PLATFORM_COMMON_FILES}
-	
-	${COMMON_SOURCE_DIR}/NvBlastAssert.cpp
-	${COMMON_SOURCE_DIR}/NvBlastAssert.h
-)
-
-SET(PUBLIC_FILES
-	${SHADERS_EXT_INCLUDE_DIR}/NvBlastExtDamageShaders.h
-)
-
-SET(EXT_SOURCE_FILES
-	${SHADERS_EXT_SOURCE_DIR}/NvBlastExtRadialShaders.cpp
-	${SHADERS_EXT_SOURCE_DIR}/NvBlastExtShearShaders.cpp
-)
-
-ADD_LIBRARY(NvBlastExtShaders ${BLAST_EXT_SHARED_LIB_TYPE} 
-	${COMMON_FILES}
-	${PUBLIC_FILES}
-
-	${EXT_SOURCE_FILES}
-)
-
-SOURCE_GROUP("common" FILES ${COMMON_FILES})
-SOURCE_GROUP("public" FILES ${PUBLIC_FILES})
-SOURCE_GROUP("src" FILES ${EXT_SOURCE_FILES})
-
-
-# Target specific compile options
-
-TARGET_INCLUDE_DIRECTORIES(NvBlastExtShaders 
-	PRIVATE ${BLASTEXT_PLATFORM_INCLUDES}
-
-	PUBLIC ${PROJECT_SOURCE_DIR}/lowlevel/include
-	PUBLIC ${SHADERS_EXT_INCLUDE_DIR}
-
-	PRIVATE ${SHADERS_EXT_SOURCE_DIR}
-	PRIVATE ${PROJECT_SOURCE_DIR}/common
-)
-
-TARGET_COMPILE_DEFINITIONS(NvBlastExtShaders
-	PRIVATE ${BLASTEXT_COMPILE_DEFS}
-)
-
-# Warning disables for Capn Proto
-TARGET_COMPILE_OPTIONS(NvBlastExtShaders
-	PRIVATE ${BLASTEXT_PLATFORM_COMPILE_OPTIONS}
-)
-
-SET_TARGET_PROPERTIES(NvBlastExtShaders PROPERTIES 
-	PDB_NAME_DEBUG "NvBlastExtShaders${CMAKE_DEBUG_POSTFIX}"
-	PDB_NAME_CHECKED "NvBlastExtShaders${CMAKE_CHECKED_POSTFIX}"
-	PDB_NAME_PROFILE "NvBlastExtShaders${CMAKE_PROFILE_POSTFIX}"
-	PDB_NAME_RELEASE "NvBlastExtShaders${CMAKE_RELEASE_POSTFIX}"
-)
-
-# Do final direct sets after the target has been defined
-#TARGET_LINK_LIBRARIES(NvBlastExtShaders NvBlast ${PHYSXSDK_LIBRARIES} ${APEXSDK_LIBRARIES} ${PXSHAREDSDK_LIBRARIES})
-TARGET_LINK_LIBRARIES(NvBlastExtShaders 
-	PUBLIC NvBlast 
-	PUBLIC ${BLASTEXT_PLATFORM_LINKED_LIBS}
-)
diff --git a/NvBlast/sdk/compiler/cmake/NvBlastTk.cmake b/NvBlast/sdk/compiler/cmake/NvBlastTk.cmake
deleted file mode 100644
index be9e04a..0000000
--- a/NvBlast/sdk/compiler/cmake/NvBlastTk.cmake
+++ /dev/null
@@ -1,126 +0,0 @@
-#
-# Build NvBlastTk common
-#
-
-SET(TOOLKIT_DIR ${PROJECT_SOURCE_DIR}/toolkit)
-SET(PROFILER_SOURCE_DIR ${PROJECT_SOURCE_DIR}/profiler)
-SET(COMMON_SOURCE_DIR ${PROJECT_SOURCE_DIR}/common)
-
-FIND_PACKAGE(PxSharedSDK $ENV{PM_PxShared_VERSION} REQUIRED)
-
-# Include here after the directories are defined so that the platform specific file can use the variables.
-include(${PROJECT_CMAKE_FILES_DIR}/${TARGET_BUILD_PLATFORM}/NvBlastTk.cmake)
-
-SET(COMMON_FILES
-	${BLASTTK_PLATFORM_COMMON_FILES}
-	
-	${COMMON_SOURCE_DIR}/NvBlastAssert.cpp
-	${COMMON_SOURCE_DIR}/NvBlastAssert.h
-	${COMMON_SOURCE_DIR}/NvBlastAtomic.cpp
-	${COMMON_SOURCE_DIR}/NvBlastAtomic.h
-	${COMMON_SOURCE_DIR}/NvBlastDLink.h
-	${COMMON_SOURCE_DIR}/NvBlastFixedArray.h
-	${COMMON_SOURCE_DIR}/NvBlastFixedBitmap.h
-	${COMMON_SOURCE_DIR}/NvBlastFixedBoolArray.h
-	${COMMON_SOURCE_DIR}/NvBlastFixedPriorityQueue.h
-	${COMMON_SOURCE_DIR}/NvBlastGeometry.h
-#	${COMMON_SOURCE_DIR}/NvBlastIndexFns.cpp
-	${COMMON_SOURCE_DIR}/NvBlastIndexFns.h
-	${COMMON_SOURCE_DIR}/NvBlastIteratorBase.h
-	${COMMON_SOURCE_DIR}/NvBlastMath.h
-	${COMMON_SOURCE_DIR}/NvBlastMemory.h
-	${COMMON_SOURCE_DIR}/NvBlastPreprocessorInternal.h
-	${COMMON_SOURCE_DIR}/NvBlastTime.cpp
-	${COMMON_SOURCE_DIR}/NvBlastTime.h
-	${COMMON_SOURCE_DIR}/NvBlastTimers.cpp
-)
-
-SET(PROFILER_FILES
-	${PROFILER_SOURCE_DIR}/NvBlastProfiler.cpp
-	${PROFILER_SOURCE_DIR}/NvBlastProfilerInternal.h
-)
-
-SET(PUBLIC_FILES
-	${TOOLKIT_DIR}/include/NvBlastTk.h
-	${TOOLKIT_DIR}/include/NvBlastTkActor.h
-	${TOOLKIT_DIR}/include/NvBlastTkAsset.h
-	${TOOLKIT_DIR}/include/NvBlastTkEvent.h
-	${TOOLKIT_DIR}/include/NvBlastTkFamily.h
-	${TOOLKIT_DIR}/include/NvBlastTkFramework.h
-	${TOOLKIT_DIR}/include/NvBlastTkGroup.h
-	${TOOLKIT_DIR}/include/NvBlastTkIdentifiable.h
-	${TOOLKIT_DIR}/include/NvBlastTkJoint.h
-	${TOOLKIT_DIR}/include/NvBlastTkObject.h
-	${TOOLKIT_DIR}/include/NvBlastTkSerializable.h
-	${TOOLKIT_DIR}/include/NvBlastTkType.h
-)
-
-SET(TOOLKIT_FILES
-	${TOOLKIT_DIR}/source/NvBlastTkActorImpl.cpp
-	${TOOLKIT_DIR}/source/NvBlastTkActorImpl.h
-	${TOOLKIT_DIR}/source/NvBlastTkAllocator.cpp
-	${TOOLKIT_DIR}/source/NvBlastTkAllocator.h
-	${TOOLKIT_DIR}/source/NvBlastTkArray.h
-	${TOOLKIT_DIR}/source/NvBlastTkAssetImpl.cpp
-	${TOOLKIT_DIR}/source/NvBlastTkAssetImpl.h
-	${TOOLKIT_DIR}/source/NvBlastTkCommon.h
-	${TOOLKIT_DIR}/source/NvBlastTkEventQueue.h
-	${TOOLKIT_DIR}/source/NvBlastTkFamilyImpl.cpp
-	${TOOLKIT_DIR}/source/NvBlastTkFamilyImpl.h
-	${TOOLKIT_DIR}/source/NvBlastTkFrameworkImpl.cpp
-	${TOOLKIT_DIR}/source/NvBlastTkFrameworkImpl.h
-	${TOOLKIT_DIR}/source/NvBlastTkGroupImpl.cpp
-	${TOOLKIT_DIR}/source/NvBlastTkGroupImpl.h
-	${TOOLKIT_DIR}/source/NvBlastTkGUID.h
-	${TOOLKIT_DIR}/source/NvBlastTkHashMap.h
-	${TOOLKIT_DIR}/source/NvBlastTkHashSet.h
-	${TOOLKIT_DIR}/source/NvBlastTkJointImpl.cpp
-	${TOOLKIT_DIR}/source/NvBlastTkJointImpl.h
-	${TOOLKIT_DIR}/source/NvBlastTkTaskImpl.cpp
-	${TOOLKIT_DIR}/source/NvBlastTkTaskImpl.h
-	${TOOLKIT_DIR}/source/NvBlastTkTypeImpl.h
-)
-
-ADD_LIBRARY(NvBlastTk ${BLASTTK_LIBTYPE} 
-	${COMMON_FILES}
-	${PROFILER_FILES}
-	${PUBLIC_FILES}
-	${TOOLKIT_FILES}
-)
-
-SOURCE_GROUP("common" FILES ${COMMON_FILES})
-SOURCE_GROUP("profiler" FILES ${PROFILER_FILES})
-SOURCE_GROUP("public" FILES ${PUBLIC_FILES})
-SOURCE_GROUP("toolkit" FILES ${TOOLKIT_FILES})
-
-# Target specific compile options
-
-TARGET_INCLUDE_DIRECTORIES(NvBlastTk 
-	PRIVATE ${BLASTTK_PLATFORM_INCLUDES}
-
-	PRIVATE ${PROJECT_SOURCE_DIR}/common
-	PRIVATE ${PROJECT_SOURCE_DIR}/profiler
-	PUBLIC ${PROJECT_SOURCE_DIR}/lowlevel/include
-	PUBLIC ${PROJECT_SOURCE_DIR}/toolkit/include
-	
-	PRIVATE ${PXSHAREDSDK_INCLUDE_DIRS}
-)
-
-TARGET_COMPILE_DEFINITIONS(NvBlastTk 
-	PRIVATE ${BLASTTK_COMPILE_DEFS}
-)
-
-SET_TARGET_PROPERTIES(NvBlastTk PROPERTIES 
-	PDB_NAME_DEBUG "NvBlastTk${CMAKE_DEBUG_POSTFIX}"
-	PDB_NAME_CHECKED "NvBlastTk${CMAKE_CHECKED_POSTFIX}"
-	PDB_NAME_PROFILE "NvBlastTk${CMAKE_PROFILE_POSTFIX}"
-	PDB_NAME_RELEASE "NvBlastTk${CMAKE_RELEASE_POSTFIX}"
-)
-
-# Do final direct sets after the target has been defined
-TARGET_LINK_LIBRARIES(NvBlastTk 
-	PRIVATE NvBlast 
-
-	PUBLIC ${BLASTTK_PLATFORM_LINKED_LIBS}
-)
-
diff --git a/NvBlast/sdk/compiler/cmake/modules/CapnProtoGenerate.cmake b/NvBlast/sdk/compiler/cmake/modules/CapnProtoGenerate.cmake
deleted file mode 100644
index 3579784..0000000
--- a/NvBlast/sdk/compiler/cmake/modules/CapnProtoGenerate.cmake
+++ /dev/null
@@ -1,108 +0,0 @@
-# Configuration variables (optional):
-#   CAPNPC_OUTPUT_DIR
-#       Directory to place compiled schema sources (default: the same directory as the schema file).
-#   CAPNPC_IMPORT_DIRS
-#       List of additional include directories for the schema compiler.
-#       (CMAKE_CURRENT_SOURCE_DIR and CAPNP_INCLUDE_DIRS are always included.)
-#   CAPNPC_SRC_PREFIX
-#       Schema file source prefix (default: CMAKE_CURRENT_SOURCE_DIR).
-#   CAPNPC_FLAGS
-#       Additional flags to pass to the schema compiler.
-# Example usage:
-#
-#   capnp_generate_cpp(CAPNP_SRCS CAPNP_HDRS schema.capnp)
-#   add_executable(a a.cc ${CAPNP_SRCS} ${CAPNP_HDRS})
-#   target_link_library(a ${CAPNP_LIBRARIES})
-#
-# For out-of-source builds:
-#
-#   set(CAPNPC_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR})
-#   include_directories(${CAPNPC_OUTPUT_DIR})
-#   capnp_generate_cpp(...)
-
-function(CAPNP_GENERATE_CPP SOURCES HEADERS)
-  if(NOT ARGN)
-    message(SEND_ERROR "CAPNP_GENERATE_CPP() called without any source files.")
-  endif()
-  if(NOT CAPNP_EXECUTABLE)
-    message(SEND_ERROR "Could not locate capnp executable (CAPNP_EXECUTABLE).")
-  endif()
-  if(NOT CAPNPC_CXX_EXECUTABLE)
-    message(SEND_ERROR "Could not locate capnpc-c++ executable (CAPNPC_CXX_EXECUTABLE).")
-  endif()
-  if(NOT CAPNP_INCLUDE_DIRS)
-    message(SEND_ERROR "Could not locate capnp header files (CAPNP_INCLUDE_DIRS).")
-  endif()
-
-  # Default compiler includes
-  set(include_path -I ${CMAKE_CURRENT_SOURCE_DIR} -I ${CAPNP_INCLUDE_DIRS})
-
-  if(DEFINED CAPNPC_IMPORT_DIRS)
-    # Append each directory as a series of '-I' flags in ${include_path}
-    foreach(directory ${CAPNPC_IMPORT_DIRS})
-      get_filename_component(absolute_path "${directory}" ABSOLUTE)
-      list(APPEND include_path -I ${absolute_path})
-    endforeach()
-  endif()
-
-  if(DEFINED CAPNPC_OUTPUT_DIR)
-    # Prepend a ':' to get the format for the '-o' flag right
-    set(output_dir ":${CAPNPC_OUTPUT_DIR}")
-  else()
-    set(output_dir ":.")
-  endif()
-
-  if(NOT DEFINED CAPNPC_SRC_PREFIX)
-    set(CAPNPC_SRC_PREFIX "${CMAKE_CURRENT_SOURCE_DIR}")
-  endif()
-  get_filename_component(CAPNPC_SRC_PREFIX "${CAPNPC_SRC_PREFIX}" ABSOLUTE)
-
-  set(${SOURCES})
-  set(${HEADERS})
-  foreach(schema_file ${ARGN})
-    get_filename_component(file_path "${schema_file}" ABSOLUTE)
-    get_filename_component(file_dir "${file_path}" PATH)
-
-    # Figure out where the output files will go
-    if (NOT DEFINED CAPNPC_OUTPUT_DIR)
-      set(output_base "${file_path}")
-    else()
-      # Output files are placed in CAPNPC_OUTPUT_DIR, at a location as if they were
-      # relative to CAPNPC_SRC_PREFIX.
-      string(LENGTH "${CAPNPC_SRC_PREFIX}" prefix_len)
-      string(SUBSTRING "${file_path}" 0 ${prefix_len} output_prefix)
-      if(NOT "${CAPNPC_SRC_PREFIX}" STREQUAL "${output_prefix}")
-        message(SEND_ERROR "Could not determine output path for '${schema_file}' ('${file_path}') with source prefix '${CAPNPC_SRC_PREFIX}' into '${CAPNPC_OUTPUT_DIR}'.")
-      endif()
-
-      string(SUBSTRING "${file_path}" ${prefix_len} -1 output_path)
-      set(output_base "${CAPNPC_OUTPUT_DIR}${output_path}")
-    endif()
-
-	MESSAGE("Output base: " ${output_base})
-	MESSAGE("Output path: " ${output_path})
-	MESSAGE("Output dir: " ${output_dir})
-	MESSAGE("Src prefix: " ${CAPNPC_SRC_PREFIX})
-	
-    add_custom_command(
-      OUTPUT "${output_base}.c++" "${output_base}.h"
-      COMMAND "${CAPNP_EXECUTABLE}"
-      ARGS compile 
-          -o ${CAPNPC_CXX_EXECUTABLE}${output_dir}
-		  --verbose
-          --src-prefix ${CAPNPC_SRC_PREFIX}
-          ${include_path}
-          ${CAPNPC_FLAGS}
-          ${file_path}
-      DEPENDS "${schema_file}"
-      COMMENT "Compiling Cap'n Proto schema ${schema_file}"
-      VERBATIM
-    )
-    list(APPEND ${SOURCES} "${output_base}.c++")
-    list(APPEND ${HEADERS} "${output_base}.h")
-  endforeach()
-
-  set_source_files_properties(${${SOURCES}} ${${HEADERS}} PROPERTIES GENERATED TRUE)
-  set(${SOURCES} ${${SOURCES}} PARENT_SCOPE)
-  set(${HEADERS} ${${HEADERS}} PARENT_SCOPE)
-endfunction()
\ No newline at end of file
diff --git a/NvBlast/sdk/compiler/cmake/modules/FindApexSDK.cmake b/NvBlast/sdk/compiler/cmake/modules/FindApexSDK.cmake
deleted file mode 100644
index 9910236..0000000
--- a/NvBlast/sdk/compiler/cmake/modules/FindApexSDK.cmake
+++ /dev/null
@@ -1,399 +0,0 @@
-# - Try to find Apex binary SDK
-# - Sets APEXSDK_LIBS_DEBUG and APEXSDK_LIBS_RELEASE - lists of the libraries found
-# - Sets APEXSDK_INCLUDE_DIRS 
-# - Sets APEXSDK_DLLS - List of the DLLs to copy to the bin directory of projects that depend on this
-
-include(FindPackageHandleStandardArgs)
-
-# Find the includes
-
-# TODO: Do the version stuff properly!
-find_path(APEXSDK_PATH include/Apex.h
-	PATHS 
-	${GW_DEPS_ROOT}/$ENV{PM_Apex_NAME}/${ApexSDK_FIND_VERSION}
-	${GW_DEPS_ROOT}/Apex/${ApexSDK_FIND_VERSION}
-)
-
-if (TARGET_BUILD_PLATFORM STREQUAL "Windows")
-	# If the project pulling in this dependency needs the static crt, then append that to the path.
-	if (STATIC_WINCRT)
-		SET(PXSHARED_CRT_SUFFIX "-staticcrt")
-	else()
-		SET(PXSHARED_CRT_SUFFIX "")
-	endif()
-
-	if (CMAKE_CL_64)
-		SET(APEX_ARCH_FOLDER "win64")
-		SET(APEX_ARCH_FILE "_x64")
-	else()
-		SET(APEX_ARCH_FOLDER "win32")
-		SET(APEX_ARCH_FILE "_x86")
-	endif()
-
-	# What compiler version do we want?
-
-	if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 18.0.0.0 AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.0.0.0)
-		SET(VS_STR "vc12")
-	elseif(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 19.0.0.0)
-		SET(VS_STR "vc14")
-	else()
-		MESSAGE(FATAL_ERROR "Failed to find compatible PxSharedSDK - Only supporting VS2013 and VS2015")
-	endif()
-	
-	SET(LIB_PATH ${APEXSDK_PATH}/lib/${VS_STR}${APEX_ARCH_FOLDER}-cmake${PHYSX_CRT_SUFFIX})
-	SET(CMAKE_FIND_LIBRARY_SUFFIXES ".lib" ".dll")
-
-elseif(TARGET_BUILD_PLATFORM STREQUAL "PS4")
-	SET(LIB_PATH ${APEXSDK_PATH}/lib/vc14ps4-cmake)
-	SET(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
-	SET(CMAKE_FIND_LIBRARY_PREFIXES "lib")
-elseif(TARGET_BUILD_PLATFORM STREQUAL "XboxOne")
-	SET(LIB_PATH ${APEXSDK_PATH}/lib/vc14xboxone-cmake)
-	SET(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
-	SET(CMAKE_FIND_LIBRARY_PREFIXES "lib")
-elseif(TARGET_BUILD_PLATFORM STREQUAL "linux")
-	SET(LIB_PATH ${APEXSDK_PATH}/lib/linux64-cmake)
-	SET(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
-	SET(CMAKE_FIND_LIBRARY_PREFIXES "lib")
-endif()
-
-find_library(APEXCLOTHING_LIB
-	NAMES APEX_Clothing${APEX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(APEXDESTRUCTIBLE_LIB
-	NAMES APEX_Destructible${APEX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(APEXLEGACY_LIB
-	NAMES APEX_Legacy${APEX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(APEXLOADER_LIB
-	NAMES APEX_Loader${APEX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(APEXCOMMON_LIB
-	NAMES APEXCommon${APEX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(APEXFRAMEWORK_LIB
-	NAMES APEXFramework${APEX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(APEXSHARED_LIB
-	NAMES APEXShared${APEX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-
-find_library(APEXCLOTHING_LIB_DEBUG
-	NAMES APEX_ClothingDEBUG${APEX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(APEXDESTRUCTIBLE_LIB_DEBUG
-	NAMES APEX_DestructibleDEBUG${APEX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(APEXLEGACY_LIB_DEBUG
-	NAMES APEX_LegacyDEBUG${APEX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(APEXLOADER_LIB_DEBUG
-	NAMES APEX_LoaderDEBUG${APEX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(APEXCOMMON_LIB_DEBUG
-	NAMES APEXCommonDEBUG${APEX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(APEXFRAMEWORK_LIB_DEBUG
-	NAMES APEXFrameworkDEBUG${APEX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(APEXSHARED_LIB_DEBUG
-	NAMES APEXSharedDEBUG${APEX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-
-find_library(APEXCLOTHING_LIB_CHECKED
-	NAMES APEX_ClothingCHECKED${APEX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(APEXDESTRUCTIBLE_LIB_CHECKED
-	NAMES APEX_DestructibleCHECKED${APEX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(APEXLEGACY_LIB_CHECKED
-	NAMES APEX_LegacyCHECKED${APEX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(APEXLOADER_LIB_CHECKED
-	NAMES APEX_LoaderCHECKED${APEX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(APEXCOMMON_LIB_CHECKED
-	NAMES APEXCommonCHECKED${APEX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(APEXFRAMEWORK_LIB_CHECKED
-	NAMES APEXFrameworkCHECKED${APEX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(APEXSHARED_LIB_CHECKED
-	NAMES APEXSharedCHECKED${APEX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-
-find_library(APEXCLOTHING_LIB_PROFILE
-	NAMES APEX_ClothingPROFILE${APEX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(APEXDESTRUCTIBLE_LIB_PROFILE
-	NAMES APEX_DestructiblePROFILE${APEX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(APEXLEGACY_LIB_PROFILE
-	NAMES APEX_LegacyPROFILE${APEX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(APEXLOADER_LIB_PROFILE
-	NAMES APEX_LoaderPROFILE${APEX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(APEXCOMMON_LIB_PROFILE
-	NAMES APEXCommonPROFILE${APEX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(APEXFRAMEWORK_LIB_PROFILE
-	NAMES APEXFrameworkPROFILE${APEX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(APEXSHARED_LIB_PROFILE
-	NAMES APEXSharedPROFILE${APEX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-
-
-if (TARGET_BUILD_PLATFORM STREQUAL "Windows")
-
-	SET(DLL_PATH ${APEXSDK_PATH}/bin/${VS_STR}${APEX_ARCH_FOLDER}-cmake${APEX_CRT_SUFFIX})
-
-	find_library(APEXCLOTHING_DLL
-		NAMES APEX_Clothing${APEX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	find_library(APEXDESTRUCTIBLE_DLL
-		NAMES APEX_Destructible${APEX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	find_library(APEXLEGACY_DLL
-		NAMES APEX_Legacy${APEX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	find_library(APEXLOADER_DLL
-		NAMES APEX_Loader${APEX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	find_library(APEXFRAMEWORK_DLL
-		NAMES APEXFramework${APEX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-
-	find_library(APEXCLOTHING_DLL_DEBUG
-		NAMES APEX_ClothingDEBUG${APEX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	find_library(APEXDESTRUCTIBLE_DLL_DEBUG
-		NAMES APEX_DestructibleDEBUG${APEX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	find_library(APEXLEGACY_DLL_DEBUG
-		NAMES APEX_LegacyDEBUG${APEX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	find_library(APEXLOADER_DLL_DEBUG
-		NAMES APEX_LoaderDEBUG${APEX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	find_library(APEXFRAMEWORK_DLL_DEBUG
-		NAMES APEXFrameworkDEBUG${APEX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-
-	find_library(APEXCLOTHING_DLL_CHECKED
-		NAMES APEX_ClothingCHECKED${APEX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	find_library(APEXDESTRUCTIBLE_DLL_CHECKED
-		NAMES APEX_DestructibleCHECKED${APEX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	find_library(APEXLEGACY_DLL_CHECKED
-		NAMES APEX_LegacyCHECKED${APEX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	find_library(APEXLOADER_DLL_CHECKED
-		NAMES APEX_LoaderCHECKED${APEX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	find_library(APEXFRAMEWORK_DLL_CHECKED
-		NAMES APEXFrameworkCHECKED${APEX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-
-	find_library(APEXCLOTHING_DLL_PROFILE
-		NAMES APEX_ClothingPROFILE${APEX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	find_library(APEXDESTRUCTIBLE_DLL_PROFILE
-		NAMES APEX_DestructiblePROFILE${APEX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	find_library(APEXLEGACY_DLL_PROFILE
-		NAMES APEX_LegacyPROFILE${APEX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	find_library(APEXLOADER_DLL_PROFILE
-		NAMES APEX_LoaderPROFILE${APEX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	find_library(APEXFRAMEWORK_DLL_PROFILE
-		NAMES APEXFrameworkPROFILE${APEX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	
-	
-	SET(DLL_VAR_LIST 
-		APEXCLOTHING_DLL 
-		APEXDESTRUCTIBLE_DLL 
-		APEXLEGACY_DLL 
-		APEXLOADER_DLL 
-		APEXFRAMEWORK_DLL 
-	
-		APEXCLOTHING_DLL_DEBUG 
-		APEXDESTRUCTIBLE_DLL_DEBUG 
-		APEXLEGACY_DLL_DEBUG 
-		APEXLOADER_DLL_DEBUG 
-		APEXFRAMEWORK_DLL_DEBUG
-		
-		APEXCLOTHING_DLL_CHECKED 
-		APEXDESTRUCTIBLE_DLL_CHECKED 
-		APEXLEGACY_DLL_CHECKED 
-		APEXLOADER_DLL_CHECKED 
-		APEXFRAMEWORK_DLL_CHECKED
-
-		APEXCLOTHING_DLL_PROFILE 
-		APEXDESTRUCTIBLE_DLL_PROFILE 
-		APEXLEGACY_DLL_PROFILE 
-		APEXLOADER_DLL_PROFILE 
-		APEXFRAMEWORK_DLL_PROFILE
-		
-	)
-endif()
-
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(APEXSDK
-	DEFAULT_MSG
-	APEXSDK_PATH
-
-	APEXCLOTHING_LIB
-	APEXDESTRUCTIBLE_LIB
-	APEXLEGACY_LIB
-	APEXLOADER_LIB
-	APEXCOMMON_LIB
-	APEXFRAMEWORK_LIB
-	APEXSHARED_LIB
-	
-	APEXCLOTHING_LIB_DEBUG
-	APEXDESTRUCTIBLE_LIB_DEBUG
-	APEXLEGACY_LIB_DEBUG
-	APEXLOADER_LIB_DEBUG
-	APEXCOMMON_LIB_DEBUG
-	APEXFRAMEWORK_LIB_DEBUG
-	APEXSHARED_LIB_DEBUG
-
-	APEXCLOTHING_LIB_CHECKED
-	APEXDESTRUCTIBLE_LIB_CHECKED
-	APEXLEGACY_LIB_CHECKED
-	APEXLOADER_LIB_CHECKED
-	APEXCOMMON_LIB_CHECKED
-	APEXFRAMEWORK_LIB_CHECKED
-	APEXSHARED_LIB_CHECKED
-
-	APEXCLOTHING_LIB_PROFILE
-	APEXDESTRUCTIBLE_LIB_PROFILE
-	APEXLEGACY_LIB_PROFILE
-	APEXLOADER_LIB_PROFILE
-	APEXCOMMON_LIB_PROFILE
-	APEXFRAMEWORK_LIB_PROFILE
-	APEXSHARED_LIB_PROFILE
-	
-	${DLL_VAR_LIST}
-)
-
-if (APEXSDK_FOUND)
-	# NOTE: This include list is way too long and reaches into too many internals.
-	# Also may not be good enough for all users.
-	SET(APEXSDK_INCLUDE_DIRS 
-		${APEXSDK_PATH}/public 
-		${APEXSDK_PATH}/include 
-		${APEXSDK_PATH}/common/include 
-		${APEXSDK_PATH}/common/include/autogen 
-		${APEXSDK_PATH}/NvParameterized/include 
-		${APEXSDK_PATH}/include/destructible
-		${APEXSDK_PATH}/include/PhysX3
-		${APEXSDK_PATH}/shared/external/include
-		${APEXSDK_PATH}/shared/internal/include
-		${APEXSDK_PATH}/shared/general/shared
-		${APEXSDK_PATH}/shared/general/RenderDebug/public
-	)
-	
-	SET(APEXSDK_LIBS_RELEASE ${APEXCLOTHING_LIB} ${APEXDESTRUCTIBLE_LIB} ${APEXLEGACY_LIB} ${APEXLOADER_LIB} ${APEXCOMMON_LIB} ${APEXFRAMEWORK_LIB} ${APEXSHARED_LIB}
-		CACHE STRING ""
-	)
-	SET(APEXSDK_LIBS_DEBUG ${APEXCLOTHING_LIB_DEBUG} ${APEXDESTRUCTIBLE_LIB_DEBUG} ${APEXLEGACY_LIB_DEBUG} ${APEXLOADER_LIB_DEBUG} ${APEXCOMMON_LIB_DEBUG} ${APEXFRAMEWORK_LIB_DEBUG} ${APEXSHARED_LIB_DEBUG}
-		CACHE STRING ""
-	)
-	SET(APEXSDK_LIBS_CHECKED ${APEXCLOTHING_LIB_CHECKED} ${APEXDESTRUCTIBLE_LIB_CHECKED} ${APEXLEGACY_LIB_CHECKED} ${APEXLOADER_LIB_CHECKED} ${APEXCOMMON_LIB_CHECKED} ${APEXFRAMEWORK_LIB_CHECKED} ${APEXSHARED_LIB_CHECKED}
-		CACHE STRING ""
-	)
-	SET(APEXSDK_LIBS_PROFILE ${APEXCLOTHING_LIB_PROFILE} ${APEXDESTRUCTIBLE_LIB_PROFILE} ${APEXLEGACY_LIB_PROFILE} ${APEXLOADER_LIB_PROFILE} ${APEXCOMMON_LIB_PROFILE} ${APEXFRAMEWORK_LIB_PROFILE} ${APEXSHARED_LIB_PROFILE}
-		CACHE STRING ""
-	)
-
-	
-	SET(APEXSDK_DLLS 
-		${APEXCLOTHING_DLL} 
-		${APEXDESTRUCTIBLE_DLL} 
-		${APEXLEGACY_DLL} 
-		${APEXLOADER_DLL} 
-		${APEXFRAMEWORK_DLL} 
-		
-		${APEXCLOTHING_DLL_DEBUG} 
-		${APEXDESTRUCTIBLE_DLL_DEBUG} 
-		${APEXLEGACY_DLL_DEBUG} 
-		${APEXLOADER_DLL_DEBUG} 
-		${APEXFRAMEWORK_DLL_DEBUG}
-		
-		${APEXCLOTHING_DLL_CHECKED} 
-		${APEXDESTRUCTIBLE_DLL_CHECKED} 
-		${APEXLEGACY_DLL_CHECKED} 
-		${APEXLOADER_DLL_CHECKED} 
-		${APEXFRAMEWORK_DLL_CHECKED}
-
-		${APEXCLOTHING_DLL_PROFILE} 
-		${APEXDESTRUCTIBLE_DLL_PROFILE} 
-		${APEXLEGACY_DLL_PROFILE} 
-		${APEXLOADER_DLL_PROFILE} 
-		${APEXFRAMEWORK_DLL_PROFILE}
-	)
-	
-	SET(APEXSDK_LIBRARIES "" CACHE STRING "")
-	
-	foreach(x ${APEXSDK_LIBS_RELEASE})
-		list(APPEND APEXSDK_LIBRARIES optimized ${x})
-	endforeach()
-	
-	foreach(x ${APEXSDK_LIBS_DEBUG})
-		list(APPEND APEXSDK_LIBRARIES debug ${x})
-	endforeach()
-endif()
diff --git a/NvBlast/sdk/compiler/cmake/modules/FindCapnProtoSDK.cmake b/NvBlast/sdk/compiler/cmake/modules/FindCapnProtoSDK.cmake
deleted file mode 100644
index f3200ec..0000000
--- a/NvBlast/sdk/compiler/cmake/modules/FindCapnProtoSDK.cmake
+++ /dev/null
@@ -1,111 +0,0 @@
-# - Try to find CapnProto SDK
-# - Sets CAPNPROTOSDK_LIBRARIES - list of the libraries found
-# - Sets CAPNPROTOSDK_INCLUDE_DIRS 
-
-include(FindPackageHandleStandardArgs)
-
-# Find the includes
-
-# TODO: Do the version stuff properly!
-find_path(CAPNPROTOSDK_PATH src/capnp/message.h
-	PATHS ${GW_DEPS_ROOT}/CapnProto/${CapnProtoSDK_FIND_VERSION}
-)
-
-if (TARGET_BUILD_PLATFORM STREQUAL "Windows")
-
-	if (STATIC_WINCRT)
-		SET(CAPNPROTOSDK_CRT_SUFFIX "-mt")
-	else()
-		SET(CAPNPROTOSDK_CRT_SUFFIX "-md")
-	endif()
-
-
-	# If the project pulling in this dependency needs the static crt, then append that to the path.
-	if (CMAKE_CL_64)
-		SET(CAPNPROTOSDK_ARCH_FOLDER "win64")
-	else()
-		SET(CAPNPROTOSDK_ARCH_FOLDER "win32")
-	endif()
-
-	SET(LIB_PATH ${CAPNPROTOSDK_PATH}/bin/${CAPNPROTOSDK_ARCH_FOLDER})
-    SET(EXE_PATH ${CAPNPROTOSDK_PATH}/tools/win32)
-
-
-elseif(TARGET_BUILD_PLATFORM STREQUAL "PS4")
-	SET(LIB_PATH ${CAPNPROTOSDK_PATH}/bin/ps4)
-    SET(EXE_PATH ${CAPNPROTOSDK_PATH}/tools/win32)
-	SET(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
-	SET(CMAKE_FIND_LIBRARY_PREFIXES "lib")
-elseif(TARGET_BUILD_PLATFORM STREQUAL "XboxOne")
-	SET(LIB_PATH ${CAPNPROTOSDK_PATH}/bin/xboxone)
-    SET(EXE_PATH ${CAPNPROTOSDK_PATH}/tools/win32)
-	SET(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
-	SET(CMAKE_FIND_LIBRARY_PREFIXES "lib")
-elseif(TARGET_BUILD_PLATFORM STREQUAL "linux")
-	SET(LIB_PATH ${CAPNPROTOSDK_PATH}/bin/ubuntu64)
-    SET(EXE_PATH ${CAPNPROTOSDK_PATH}/tools/ubuntu64)
-	SET(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
-	SET(CMAKE_FIND_LIBRARY_PREFIXES "lib")
-endif()
-
-find_library(CAPNPROTO_LIB
-	NAMES capnp${CAPNPROTOSDK_CRT_SUFFIX}
-	PATHS ${LIB_PATH}/Release
-)
-find_library(CAPNPROTO_LIB_DEBUG
-	NAMES capnp${CAPNPROTOSDK_CRT_SUFFIX}
-	PATHS ${LIB_PATH}/Debug
-)
-
-find_library(KJ_LIB
-	NAMES kj${CAPNPROTOSDK_CRT_SUFFIX}
-	PATHS ${LIB_PATH}/Release
-)
-find_library(KJ_LIB_DEBUG
-	NAMES kj${CAPNPROTOSDK_CRT_SUFFIX}
-	PATHS ${LIB_PATH}/Debug
-)
-
-find_program(CAPNP_EXECUTABLE
-  NAMES capnp
-  DOC "Cap'n Proto Command-line Tool"
-  PATHS ${EXE_PATH}
-)
-
-find_program(CAPNPC_CXX_EXECUTABLE
-  NAMES capnpc-c++
-  DOC "Capn'n Proto C++ Compiler"
-  PATHS ${EXE_PATH}
-)
-
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(CAPNPROTOSDK
-	DEFAULT_MSG
-	CAPNPROTOSDK_PATH
-
-	CAPNP_EXECUTABLE
-	CAPNPC_CXX_EXECUTABLE
-	
-	CAPNPROTO_LIB
-	KJ_LIB
-	
-	CAPNPROTO_LIB_DEBUG
-	KJ_LIB_DEBUG
-)
-
-if (CAPNPROTOSDK_FOUND)
-	
-	SET(CAPNPROTOSDK_INCLUDE_DIRS 
-		${CAPNPROTOSDK_PATH}/src/
-	)
-
-	SET(CAPNP_INCLUDE_DIRS
-		${CAPNPROTOSDK_INCLUDE_DIRS}
-	)
-	
-	SET(CAPNPROTOSDK_LIBRARIES "" CACHE STRING "")
-	
-	LIST(APPEND CAPNPROTOSDK_LIBRARIES 
-		optimized ${CAPNPROTO_LIB} debug ${CAPNPROTO_LIB_DEBUG}
-		optimized ${KJ_LIB} debug ${KJ_LIB_DEBUG}
-	)
-endif()
diff --git a/NvBlast/sdk/compiler/cmake/modules/FindFBXSDK.cmake b/NvBlast/sdk/compiler/cmake/modules/FindFBXSDK.cmake
deleted file mode 100644
index 7e1bfb4..0000000
--- a/NvBlast/sdk/compiler/cmake/modules/FindFBXSDK.cmake
+++ /dev/null
@@ -1,71 +0,0 @@
-# - Try to find FBX SDK
-# - Sets FBXSDK_LIBRARIES - list of the libraries found
-# - Sets FBXSDK_INCLUDE_DIRS 
-# - Sets FBXSDK_DLLS - List of the DLLs to copy to the bin directory of projects that depend on this
-
-
-include(FindPackageHandleStandardArgs)
-
-# Find the includes
-
-# TODO: Do the version stuff properly!
-find_path(FBXSDK_PATH include/fbxsdk.h
-	PATHS ${GW_DEPS_ROOT}/FBXSDK/${FBXSDK_FIND_VERSION}
-)
-
-if (STATIC_WINCRT)
-	SET(FBXSDK_CRT_SUFFIX "mt")
-else()
-	SET(FBXSDK_CRT_SUFFIX "md")
-endif()
-
-
-# If the project pulling in this dependency needs the static crt, then append that to the path.
-if (CMAKE_CL_64)
-	SET(FBXSDK_ARCH_FOLDER "x64")
-else()
-	SET(FBXSDK_ARCH_FOLDER "x86")
-endif()
-
-# What compiler version do we want?
-
-if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 18.0.0.0 AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.0.0.0)
-	SET(VS_STR "vs2013")
-elseif(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 19.0.0.0)
-	SET(VS_STR "vs2015")
-else()
-	MESSAGE(FATAL_ERROR "Failed to find compatible FBXSDK - Only supporting VS2013 and VS2015")
-endif()
-
-# Now find all of the PhysX libs in the lib directory
-
-SET(LIB_PATH ${FBXSDK_PATH}/lib/${VS_STR}/${FBXSDK_ARCH_FOLDER})
-
-find_library(FBX_LIB
-	NAMES libfbxsdk-${FBXSDK_CRT_SUFFIX}
-	PATHS ${LIB_PATH}/release
-)
-find_library(FBX_LIB_DEBUG
-	NAMES libfbxsdk-${FBXSDK_CRT_SUFFIX}
-	PATHS ${LIB_PATH}/debug
-)
-
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(FBXSDK
-	DEFAULT_MSG
-	FBXSDK_PATH
-	FBX_LIB
-	
-	FBX_LIB_DEBUG
-)
-
-if (FBXSDK_FOUND)
-	
-	SET(FBXSDK_INCLUDE_DIRS 
-		${FBXSDK_PATH}/include 
-		${FBXSDK_PATH}/include/fbxsdk
-	)
-	
-	SET(FBXSDK_LIBRARIES "" CACHE STRING "")
-	
-	LIST(APPEND FBXSDK_LIBRARIES optimized ${FBX_LIB} debug ${FBX_LIB_DEBUG})
-endif()
diff --git a/NvBlast/sdk/compiler/cmake/modules/FindGoogleTestNV.cmake b/NvBlast/sdk/compiler/cmake/modules/FindGoogleTestNV.cmake
deleted file mode 100644
index aebc849..0000000
--- a/NvBlast/sdk/compiler/cmake/modules/FindGoogleTestNV.cmake
+++ /dev/null
@@ -1,132 +0,0 @@
-# - Try to find GoogleTest SDK
-# - Sets GOOGLETEST_LIBRARIES - lists of the libraries found
-# - Sets GOOGLETEST_INCLUDE_DIRS 
-
-include(FindPackageHandleStandardArgs)
-
-# Find the includes
-
-# TODO: Do the version stuff properly!
-find_path(GOOGLETEST_PATH include/gtest/gtest.h
-	PATHS ${GW_DEPS_ROOT}/googletest-linux-x86_64/${GoogleTestNV_FIND_VERSION}
-	${GW_DEPS_ROOT}/googletest-nv/${GoogleTestNV_FIND_VERSION}
-)
-
-if (TARGET_BUILD_PLATFORM STREQUAL "Windows")
-	# If the project pulling in this dependency needs the static crt, then append that to the path.
-
-	if (STATIC_WINCRT)
-		SET(GOOGLETEST_CRT_SUFFIX "-staticcrt")
-	else()
-		SET(GOOGLETEST_CRT_SUFFIX "")
-	endif()
-
-	if (CMAKE_CL_64)
-		SET(GOOGLETEST_ARCH_FOLDER "win64")
-	else()
-		SET(GOOGLETEST_ARCH_FOLDER "win32")
-	endif()
-	
-	if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 18.0.0.0 AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.0.0.0)
-		SET(VS_STR "vc12")
-	elseif(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 19.0.0.0)
-		SET(VS_STR "vc14")
-	else()
-		MESSAGE(FATAL_ERROR "Failed to find compatible FBXSDK - Only supporting VS2013 and VS2015")
-	endif()
-
-
-	# Now find all of the PhysX libs in the lib directory
-
-	SET(LIB_PATH ${GOOGLETEST_PATH}/lib/${VS_STR}${GOOGLETEST_ARCH_FOLDER}-cmake${GOOGLETEST_CRT_SUFFIX})
-
-elseif(TARGET_BUILD_PLATFORM STREQUAL "PS4")
-	SET(LIB_PATH ${GOOGLETEST_PATH}/lib/PS4)
-	SET(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
-	SET(CMAKE_FIND_LIBRARY_PREFIXES "lib")
-elseif(TARGET_BUILD_PLATFORM STREQUAL "XboxOne")
-	SET(LIB_PATH ${GOOGLETEST_PATH}/lib/xboxone-${XDK_VERSION})
-	SET(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
-	SET(CMAKE_FIND_LIBRARY_PREFIXES "lib")
-elseif(TARGET_BUILD_PLATFORM STREQUAL "linux")
-	if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 5.0)
-		SET(LIB_PATH ${GOOGLETEST_PATH}/lib/gcc-5.4)
-	else()
-		SET(LIB_PATH ${GOOGLETEST_PATH}/lib/gcc-4.8)
-	endif()
-	SET(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
-	SET(CMAKE_FIND_LIBRARY_PREFIXES "lib")
-endif()
-
-MESSAGE("GTEst libpath:" ${LIB_PATH})
-
-if(TARGET_BUILD_PLATFORM STREQUAL "linux")
-	find_library(GTEST_LIB
-		NAMES gtest
-		PATHS ${LIB_PATH}
-	)
-
-	find_library(GTEST_MAIN_LIB
-		NAMES gtest_main
-		PATHS ${LIB_PATH}
-	)
-
-    SET(GTEST_LIB_DEBUG ${GTEST_LIB})
-    SET(GTEST_MAIN_LIB_DEBUG ${GTEST_MAIN_LIB})
-else()
-    find_library(GTEST_LIB
-        NAMES gtest
-        PATHS ${LIB_PATH}/Release
-    )
-
-    find_library(GTEST_LIB_DEBUG
-        NAMES gtest
-        PATHS ${LIB_PATH}/Debug
-    )
-
-    find_library(GTEST_MAIN_LIB
-        NAMES gtest_main
-        PATHS ${LIB_PATH}/Release
-    )
-
-    find_library(GTEST_MAIN_LIB_DEBUG
-        NAMES gtest_main
-        PATHS ${LIB_PATH}/Debug
-    )
-endif()
-
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(GOOGLETEST
-	DEFAULT_MSG
-	GOOGLETEST_PATH
-
-    GTEST_LIB 
-    GTEST_MAIN_LIB 
-    GTEST_LIB_DEBUG 
-    GTEST_MAIN_LIB_DEBUG 
-)
-
-if (GOOGLETEST_FOUND)
-	# NOTE: This include list is way too long and reaches into too many internals.
-	# Also may not be good enough for all users.
-	SET(GOOGLETEST_INCLUDE_DIRS 
-		${GOOGLETEST_PATH}/include 
-		${GOOGLETEST_PATH}/include/gtest 
-	)
-	
-	SET(GOOGLETEST_LIBS_RELEASE ${GTEST_LIB} ${GTEST_MAIN_LIB}
-		CACHE STRING ""
-	)
-	SET(GOOGLETEST_LIBS_DEBUG ${GTEST_LIB_DEBUG} ${GTEST_MAIN_LIB_DEBUG}
-		CACHE STRING ""
-	)
-	
-	SET(GOOGLETEST_LIBRARIES "" CACHE STRING "")
-	
-	foreach(x ${GOOGLETEST_LIBS_RELEASE})
-		list(APPEND GOOGLETEST_LIBRARIES optimized ${x})
-	endforeach()
-	
-	foreach(x ${GOOGLETEST_LIBS_DEBUG})
-		list(APPEND GOOGLETEST_LIBRARIES debug ${x})
-	endforeach()
-endif()
diff --git a/NvBlast/sdk/compiler/cmake/modules/FindPhysXSDK.cmake b/NvBlast/sdk/compiler/cmake/modules/FindPhysXSDK.cmake
deleted file mode 100644
index 830e6c5..0000000
--- a/NvBlast/sdk/compiler/cmake/modules/FindPhysXSDK.cmake
+++ /dev/null
@@ -1,566 +0,0 @@
-# - Try to find PhysX binary SDK
-# - Sets PHYSXSDK_LIBS_DEBUG, PHYSXSDK_LIBS_RELEASE, PHYSXSDK_LIBS_CHECKED, PHYSXSDK_LIBS_PROFILE - lists of the libraries found
-# - Sets PHYSXSDK_INCLUDE_DIRS 
-# - Sets PHYSXSDK_DLLS - List of the DLLs to copy to the bin directory of projects that depend on this
-
-include(FindPackageHandleStandardArgs)
-
-MESSAGE("Looking for PhysXSDK ${PhysXSDK_FIND_VERSION} Cached path: ${PHYSXSDK_PATH}")
-# TODO: Do the version stuff properly!
-find_path(PHYSXSDK_PATH Include/PxActor.h
-	PATHS
-	${GW_DEPS_ROOT}/$ENV{PM_PhysX_NAME}/${PhysXSDK_FIND_VERSION}
-	${GW_DEPS_ROOT}/PhysX/${PhysXSDK_FIND_VERSION}
-)
-
-if (TARGET_BUILD_PLATFORM STREQUAL "Windows")
-	# If the project pulling in this dependency needs the static crt, then append that to the path.
-	if (STATIC_WINCRT)
-		SET(PXSHARED_CRT_SUFFIX "-staticcrt")
-	else()
-		SET(PXSHARED_CRT_SUFFIX "")
-	endif()
-
-	if (CMAKE_CL_64)
-		SET(PHYSX_ARCH_FOLDER "win64")
-		SET(PHYSX_ARCH_FILE "_x64")
-	else()
-		SET(PHYSX_ARCH_FOLDER "win32")
-		SET(PHYSX_ARCH_FILE "_x86")
-	endif()
-
-	# What compiler version do we want?
-
-	if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 18.0.0.0 AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.0.0.0)
-		SET(VS_STR "vc12")
-	elseif(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 19.0.0.0)
-		SET(VS_STR "vc14")
-	else()
-		MESSAGE(FATAL_ERROR "Failed to find compatible PxSharedSDK - Only supporting VS2013 and VS2015")
-	endif()
-	
-	SET(LIB_PATH ${PHYSXSDK_PATH}/lib/${VS_STR}${PHYSX_ARCH_FOLDER}-cmake${PHYSX_CRT_SUFFIX})
-	SET(CMAKE_FIND_LIBRARY_SUFFIXES ".lib" ".dll")
-
-elseif(TARGET_BUILD_PLATFORM STREQUAL "PS4")
-	SET(LIB_PATH ${PHYSXSDK_PATH}/lib/vc14ps4-cmake)
-	SET(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
-	SET(CMAKE_FIND_LIBRARY_PREFIXES "lib")
-elseif(TARGET_BUILD_PLATFORM STREQUAL "XboxOne")
-	SET(LIB_PATH ${PHYSXSDK_PATH}/lib/vc14xboxone-cmake)
-	SET(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
-	SET(CMAKE_FIND_LIBRARY_PREFIXES "lib")
-elseif(TARGET_BUILD_PLATFORM STREQUAL "linux")
-	SET(LIB_PATH ${PHYSXSDK_PATH}/lib/linux64-cmake)
-	SET(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
-	SET(CMAKE_FIND_LIBRARY_PREFIXES "lib")
-	SET(PHYSX_ARCH_FILE "_x64")
-endif()
-
-# Now find all of the PhysX libs in the lib directory
-
-find_library(PHYSX3_LIB
-	NAMES PhysX3${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(PHYSX3EXTENSIONS_LIB
-	NAMES PhysX3Extensions${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(PHYSX3CHARACTERKINEMATIC_LIB
-	NAMES PhysX3CharacterKinematic${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(PHYSX3COMMON_LIB
-	NAMES PhysX3Common${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(PHYSX3COOKING_LIB
-	NAMES PhysX3Cooking${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(LOWLEVEL_LIB
-	NAMES LowLevel${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(LOWLEVELAABB_LIB
-	NAMES LowLevelAABB${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(LOWLEVELCLOTH_LIB
-	NAMES LowLevelCloth${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(LOWLEVELDYNAMICS_LIB
-	NAMES LowLevelDynamics${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(LOWLEVELPARTICLES_LIB
-	NAMES LowLevelParticles${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(SCENEQUERY_LIB
-	NAMES SceneQuery${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(SIMULATIONCONTROLLER_LIB
-	NAMES SimulationController${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-
-
-find_library(PHYSX3_LIB_DEBUG
-	NAMES PhysX3DEBUG${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(PHYSX3EXTENSIONS_LIB_DEBUG
-	NAMES PhysX3ExtensionsDEBUG${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(PHYSX3CHARACTERKINEMATIC_LIB_DEBUG
-	NAMES PhysX3CharacterKinematicDEBUG${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(PHYSX3COMMON_LIB_DEBUG
-	NAMES PhysX3CommonDEBUG${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(PHYSX3COOKING_LIB_DEBUG
-	NAMES PhysX3CookingDEBUG${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(LOWLEVEL_LIB_DEBUG
-	NAMES LowLevelDEBUG${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(LOWLEVELAABB_LIB_DEBUG
-	NAMES LowLevelAABBDEBUG${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(LOWLEVELCLOTH_LIB_DEBUG
-	NAMES LowLevelClothDEBUG${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(LOWLEVELDYNAMICS_LIB_DEBUG
-	NAMES LowLevelDynamicsDEBUG${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(LOWLEVELPARTICLES_LIB_DEBUG
-	NAMES LowLevelParticlesDEBUG${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(SCENEQUERY_LIB_DEBUG
-	NAMES SceneQueryDEBUG${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(SIMULATIONCONTROLLER_LIB_DEBUG
-	NAMES SimulationControllerDEBUG${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-
-find_library(PHYSX3_LIB_CHECKED
-	NAMES PhysX3CHECKED${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(PHYSX3EXTENSIONS_LIB_CHECKED
-	NAMES PhysX3ExtensionsCHECKED${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(PHYSX3CHARACTERKINEMATIC_LIB_CHECKED
-	NAMES PhysX3CharacterKinematicCHECKED${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(PHYSX3COMMON_LIB_CHECKED
-	NAMES PhysX3CommonCHECKED${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(PHYSX3COOKING_LIB_CHECKED
-	NAMES PhysX3CookingCHECKED${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(LOWLEVEL_LIB_CHECKED
-	NAMES LowLevelCHECKED${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(LOWLEVELAABB_LIB_CHECKED
-	NAMES LowLevelAABBCHECKED${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(LOWLEVELCLOTH_LIB_CHECKED
-	NAMES LowLevelClothCHECKED${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(LOWLEVELDYNAMICS_LIB_CHECKED
-	NAMES LowLevelDynamicsCHECKED${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(LOWLEVELPARTICLES_LIB_CHECKED
-	NAMES LowLevelParticlesCHECKED${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(SCENEQUERY_LIB_CHECKED
-	NAMES SceneQueryCHECKED${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(SIMULATIONCONTROLLER_LIB_CHECKED
-	NAMES SimulationControllerCHECKED${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-
-find_library(PHYSX3_LIB_PROFILE
-	NAMES PhysX3PROFILE${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(PHYSX3EXTENSIONS_LIB_PROFILE
-	NAMES PhysX3ExtensionsPROFILE${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(PHYSX3CHARACTERKINEMATIC_LIB_PROFILE
-	NAMES PhysX3CharacterKinematicPROFILE${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(PHYSX3COMMON_LIB_PROFILE
-	NAMES PhysX3CommonPROFILE${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(PHYSX3COOKING_LIB_PROFILE
-	NAMES PhysX3CookingPROFILE${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(LOWLEVEL_LIB_PROFILE
-	NAMES LowLevelPROFILE${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(LOWLEVELAABB_LIB_PROFILE
-	NAMES LowLevelAABBPROFILE${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(LOWLEVELCLOTH_LIB_PROFILE
-	NAMES LowLevelClothPROFILE${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(LOWLEVELDYNAMICS_LIB_PROFILE
-	NAMES LowLevelDynamicsPROFILE${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(LOWLEVELPARTICLES_LIB_PROFILE
-	NAMES LowLevelParticlesPROFILE${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(SCENEQUERY_LIB_PROFILE
-	NAMES SceneQueryPROFILE${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(SIMULATIONCONTROLLER_LIB_PROFILE
-	NAMES SimulationControllerPROFILE${PHYSX_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-
-if (TARGET_BUILD_PLATFORM STREQUAL "Windows")
-
-	find_library(PHYSX3GPU_LIB
-		NAMES PhysX3Gpu${PHYSX_ARCH_FILE}
-		PATHS ${LIB_PATH}
-	)
-	find_library(PHYSX3GPU_LIB_DEBUG
-		NAMES PhysX3GpuDEBUG${PHYSX_ARCH_FILE}
-		PATHS ${LIB_PATH}
-	)
-
-
-	SET(DLL_PATH ${PHYSXSDK_PATH}/bin/${VS_STR}${PHYSX_ARCH_FOLDER}-cmake${PHYSX_CRT_SUFFIX})
-
-	find_library(PHYSX3_DLL
-		NAMES PhysX3${PHYSX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	find_library(PHYSX3CHARACTERKINEMATIC_DLL
-		NAMES PhysX3CharacterKinematic${PHYSX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	find_library(PHYSX3COMMON_DLL
-		NAMES PhysX3Common${PHYSX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	find_library(PHYSX3COOKING_DLL
-		NAMES PhysX3Cooking${PHYSX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	find_library(PHYSX3GPU_DLL
-		NAMES PhysX3Gpu${PHYSX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-
-	
-	find_library(PHYSX3_DLL_DEBUG
-		NAMES PhysX3DEBUG${PHYSX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	find_library(PHYSX3CHARACTERKINEMATIC_DLL_DEBUG
-		NAMES PhysX3CharacterKinematicDEBUG${PHYSX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	find_library(PHYSX3COMMON_DLL_DEBUG
-		NAMES PhysX3CommonDEBUG${PHYSX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	find_library(PHYSX3COOKING_DLL_DEBUG
-		NAMES PhysX3CookingDEBUG${PHYSX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	# NOTE - GPU dlls not included in required dlls or libs as they're optional.
-	find_library(PHYSX3GPU_DLL_DEBUG
-		NAMES PhysX3GpuDEBUG${PHYSX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	
-	find_library(PHYSX3_DLL_PROFILE
-		NAMES PhysX3PROFILE${PHYSX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	find_library(PHYSX3CHARACTERKINEMATIC_DLL_PROFILE
-		NAMES PhysX3CharacterKinematicPROFILE${PHYSX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	find_library(PHYSX3COMMON_DLL_PROFILE
-		NAMES PhysX3CommonPROFILE${PHYSX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	find_library(PHYSX3COOKING_DLL_PROFILE
-		NAMES PhysX3CookingPROFILE${PHYSX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	# NOTE - GPU dlls not included in required dlls or libs as they're optional.
-	find_library(PHYSX3GPU_DLL_PROFILE
-		NAMES PhysX3GpuPROFILE${PHYSX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	
-	find_library(PHYSX3_DLL_CHECKED
-		NAMES PhysX3CHECKED${PHYSX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	find_library(PHYSX3CHARACTERKINEMATIC_DLL_CHECKED
-		NAMES PhysX3CharacterKinematicCHECKED${PHYSX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	find_library(PHYSX3COMMON_DLL_CHECKED
-		NAMES PhysX3CommonCHECKED${PHYSX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	find_library(PHYSX3COOKING_DLL_CHECKED
-		NAMES PhysX3CookingCHECKED${PHYSX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	# NOTE - GPU dlls not included in required dlls or libs as they're optional.
-	find_library(PHYSX3GPU_DLL_CHECKED
-		NAMES PhysX3GpuCHECKED${PHYSX_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	
-	# Create this list to check for found dlls below
-	SET(DLL_VAR_LIST 
-		PHYSX3_DLL 
-		PHYSX3CHARACTERKINEMATIC_DLL 
-		PHYSX3COMMON_DLL 
-		PHYSX3COOKING_DLL 
-
-		PHYSX3_DLL_DEBUG 
-		PHYSX3CHARACTERKINEMATIC_DLL_DEBUG 
-		PHYSX3COMMON_DLL_DEBUG 
-		PHYSX3COOKING_DLL_DEBUG
-
-		PHYSX3_DLL_PROFILE 
-		PHYSX3CHARACTERKINEMATIC_DLL_PROFILE 
-		PHYSX3COMMON_DLL_PROFILE 
-		PHYSX3COOKING_DLL_PROFILE
-
-		PHYSX3_DLL_CHECKED 
-		PHYSX3CHARACTERKINEMATIC_DLL_CHECKED 
-		PHYSX3COMMON_DLL_CHECKED 
-		PHYSX3COOKING_DLL_CHECKED
-
-	)
-endif()
-
-if (TARGET_BUILD_PLATFORM STREQUAL "linux")
-	SET(BIN_PATH ${PHYSXSDK_PATH}/bin/linux64-cmake)
-	SET(CMAKE_FIND_LIBRARY_SUFFIXES ".so")
-
-    find_library(PHYSX3_LIB
-        NAMES PhysX3${PHYSX_ARCH_FILE}
-        PATHS ${BIN_PATH}
-    )
-    find_library(PHYSX3COOKING_LIB
-        NAMES PhysX3Cooking${PHYSX_ARCH_FILE}
-        PATHS ${BIN_PATH}
-    )
-    find_library(PHYSX3CHARACTERKINEMATIC_LIB
-        NAMES PhysX3CharacterKinematic${PHYSX_ARCH_FILE}
-        PATHS ${BIN_PATH}
-    )
-    find_library(PHYSX3COMMON_LIB
-        NAMES PhysX3Common${PHYSX_ARCH_FILE}
-        PATHS ${BIN_PATH}
-    )
-
-    find_library(PHYSX3_LIB_DEBUG
-        NAMES PhysX3DEBUG${PHYSX_ARCH_FILE}
-        PATHS ${BIN_PATH}
-    )
-    find_library(PHYSX3COOKING_LIB_DEBUG
-        NAMES PhysX3CookingDEBUG${PHYSX_ARCH_FILE}
-        PATHS ${BIN_PATH}
-    )
-    find_library(PHYSX3CHARACTERKINEMATIC_LIB_DEBUG
-        NAMES PhysX3CharacterKinematicDEBUG${PHYSX_ARCH_FILE}
-        PATHS ${BIN_PATH}
-    )
-    find_library(PHYSX3COMMON_LIB_DEBUG
-        NAMES PhysX3CommonDEBUG${PHYSX_ARCH_FILE}
-        PATHS ${BIN_PATH}
-    )
-
-    find_library(PHYSX3_LIB_CHECKED
-        NAMES PhysX3CHECKED${PHYSX_ARCH_FILE}
-        PATHS ${BIN_PATH}
-    )
-    find_library(PHYSX3COOKING_LIB_CHECKED
-        NAMES PhysX3CookingCHECKED${PHYSX_ARCH_FILE}
-        PATHS ${BIN_PATH}
-    )
-    find_library(PHYSX3CHARACTERKINEMATIC_LIB_CHECKED
-        NAMES PhysX3CharacterKinematicCHECKED${PHYSX_ARCH_FILE}
-        PATHS ${BIN_PATH}
-    )
-    find_library(PHYSX3COMMON_LIB_CHECKED
-        NAMES PhysX3CommonCHECKED${PHYSX_ARCH_FILE}
-        PATHS ${BIN_PATH}
-    )
-    
-    find_library(PHYSX3_LIB_PROFILE
-        NAMES PhysX3PROFILE${PHYSX_ARCH_FILE}
-        PATHS ${BIN_PATH}
-    )
-    find_library(PHYSX3COOKING_LIB_PROFILE
-        NAMES PhysX3CookingPROFILE${PHYSX_ARCH_FILE}
-        PATHS ${BIN_PATH}
-    )
-    find_library(PHYSX3CHARACTERKINEMATIC_LIB_PROFILE
-        NAMES PhysX3CharacterKinematicPROFILE${PHYSX_ARCH_FILE}
-        PATHS ${BIN_PATH}
-    )
-    find_library(PHYSX3COMMON_LIB_PROFILE
-        NAMES PhysX3CommonPROFILE${PHYSX_ARCH_FILE}
-        PATHS ${BIN_PATH}
-    )
-    
-endif()
-
-
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(PHYSXSDK
-	DEFAULT_MSG
-	PHYSXSDK_PATH
-	
-	PHYSX3_LIB
-	PHYSX3EXTENSIONS_LIB
-	PHYSX3CHARACTERKINEMATIC_LIB
-	PHYSX3COMMON_LIB
-	PHYSX3COOKING_LIB
-	LOWLEVEL_LIB
-	LOWLEVELAABB_LIB
-	LOWLEVELCLOTH_LIB
-	LOWLEVELDYNAMICS_LIB
-	LOWLEVELPARTICLES_LIB
-	SCENEQUERY_LIB
-	SIMULATIONCONTROLLER_LIB
-
-	PHYSX3_LIB_DEBUG
-	PHYSX3EXTENSIONS_LIB_DEBUG
-	PHYSX3CHARACTERKINEMATIC_LIB_DEBUG
-	PHYSX3COMMON_LIB_DEBUG
-	PHYSX3COOKING_LIB_DEBUG
-	LOWLEVEL_LIB_DEBUG
-	LOWLEVELAABB_LIB_DEBUG
-	LOWLEVELCLOTH_LIB_DEBUG
-	LOWLEVELDYNAMICS_LIB_DEBUG
-	LOWLEVELPARTICLES_LIB_DEBUG
-	SCENEQUERY_LIB_DEBUG
-	SIMULATIONCONTROLLER_LIB_DEBUG
-
-#	PHYSX3_LIB_CHECKED
-#	PHYSX3EXTENSIONS_LIB_CHECKED
-#	PHYSX3CHARACTERKINEMATIC_LIB_CHECKED
-#	PHYSX3COMMON_LIB_CHECKED
-#	PHYSX3COOKING_LIB_CHECKED
-#	LOWLEVEL_LIB_CHECKED
-#	LOWLEVELAABB_LIB_CHECKED
-#	LOWLEVELCLOTH_LIB_CHECKED
-#	LOWLEVELDYNAMICS_LIB_CHECKED
-#	LOWLEVELPARTICLES_LIB_CHECKED
-#	SCENEQUERY_LIB_CHECKED
-#	SIMULATIONCONTROLLER_LIB_CHECKED
-#
-#	PHYSX3_LIB_PROFILE
-#	PHYSX3EXTENSIONS_LIB_PROFILE
-#	PHYSX3CHARACTERKINEMATIC_LIB_PROFILE
-#	PHYSX3COMMON_LIB_PROFILE
-#	PHYSX3COOKING_LIB_PROFILE
-#	LOWLEVEL_LIB_PROFILE
-#	LOWLEVELAABB_LIB_PROFILE
-#	LOWLEVELCLOTH_LIB_PROFILE
-#	LOWLEVELDYNAMICS_LIB_PROFILE
-#	LOWLEVELPARTICLES_LIB_PROFILE
-#	SCENEQUERY_LIB_PROFILE
-#	SIMULATIONCONTROLLER_LIB_PROFILE
-	
-	${DLL_VAR_LIST}
-)
-
-if (PHYSXSDK_FOUND)
-	
-	SET(PHYSXSDK_INCLUDE_DIRS 
-		${PHYSXSDK_PATH}/Include 
-		${PHYSXSDK_PATH}/Include/common 
-		${PHYSXSDK_PATH}/Include/cooking
-		${PHYSXSDK_PATH}/Include/extensions 
-		${PHYSXSDK_PATH}/Include/geometry
-		${PHYSXSDK_PATH}/Include/gpu
-		${PHYSXSDK_PATH}/Include/deformable
-		${PHYSXSDK_PATH}/Include/particles
-		${PHYSXSDK_PATH}/Include/characterkinematic
-		${PHYSXSDK_PATH}/Include/characterdynamic
-		${PHYSXSDK_PATH}/Include/vehicle
-	)
-	
-	SET(PHYSXSDK_LIBS_RELEASE ${PHYSX3_LIB} ${PHYSX3EXTENSIONS_LIB} ${PHYSX3CHARACTERKINEMATIC_LIB} ${PHYSX3COMMON_LIB} ${PHYSX3COOKING_LIB} ${PHYSX3GPU_LIB} ${LOWLEVEL_LIB} ${LOWLEVELAABB_LIB} ${LOWLEVELCLOTH_LIB} ${LOWLEVELDYNAMICS_LIB} ${LOWLEVELPARTICLES_LIB} ${SCENEQUERY_LIB} ${SIMULATIONCONTROLLER_LIB}
-		CACHE STRING ""
-	)
-	SET(PHYSXSDK_LIBS_DEBUG ${PHYSX3_LIB_DEBUG} ${PHYSX3EXTENSIONS_LIB_DEBUG} ${PHYSX3CHARACTERKINEMATIC_LIB_DEBUG} ${PHYSX3COMMON_LIB_DEBUG} ${PHYSX3COOKING_LIB_DEBUG} ${PHYSX3GPU_LIB_DEBUG} ${LOWLEVEL_LIB_DEBUG} ${LOWLEVELAABB_LIB_DEBUG} ${LOWLEVELCLOTH_LIB_DEBUG} ${LOWLEVELDYNAMICS_LIB_DEBUG} ${LOWLEVELPARTICLES_LIB_DEBUG} ${SCENEQUERY_LIB_DEBUG} ${SIMULATIONCONTROLLER_LIB_DEBUG}
-		CACHE STRING ""
-	)
-	SET(PHYSXSDK_LIBS_CHECKED ${PHYSX3_LIB_CHECKED} ${PHYSX3EXTENSIONS_LIB_CHECKED} ${PHYSX3CHARACTERKINEMATIC_LIB_CHECKED} ${PHYSX3COMMON_LIB_CHECKED} ${PHYSX3COOKING_LIB_CHECKED} ${PHYSX3GPU_LIB_CHECKED} ${LOWLEVEL_LIB_CHECKED} ${LOWLEVELAABB_LIB_CHECKED} ${LOWLEVELCLOTH_LIB_CHECKED} ${LOWLEVELDYNAMICS_LIB_CHECKED} ${LOWLEVELPARTICLES_LIB_CHECKED} ${SCENEQUERY_LIB_CHECKED} ${SIMULATIONCONTROLLER_LIB_CHECKED}
-		CACHE STRING ""
-	)
-	SET(PHYSXSDK_LIBS_PROFILE ${PHYSX3_LIB_PROFILE} ${PHYSX3EXTENSIONS_LIB_PROFILE} ${PHYSX3CHARACTERKINEMATIC_LIB_PROFILE} ${PHYSX3COMMON_LIB_PROFILE} ${PHYSX3COOKING_LIB_PROFILE} ${PHYSX3GPU_LIB_PROFILE} ${LOWLEVEL_LIB_PROFILE} ${LOWLEVELAABB_LIB_PROFILE} ${LOWLEVELCLOTH_LIB_PROFILE} ${LOWLEVELDYNAMICS_LIB_PROFILE} ${LOWLEVELPARTICLES_LIB_PROFILE} ${SCENEQUERY_LIB_PROFILE} ${SIMULATIONCONTROLLER_LIB_PROFILE}
-		CACHE STRING ""
-	)
-
-	#NOTE: This is all dll configs, might need to be split.
-	SET(PHYSXSDK_DLLS 
-		${PHYSX3_DLL} ${PHYSX3CHARACTERKINEMATIC_DLL} ${PHYSX3COMMON_DLL} ${PHYSX3COOKING_DLL} ${PHYSX3GPU_DLL} 
-		${PHYSX3_DLL_DEBUG} ${PHYSX3CHARACTERKINEMATIC_DLL_DEBUG} ${PHYSX3COMMON_DLL_DEBUG} ${PHYSX3COOKING_DLL_DEBUG} ${PHYSX3GPU_DLL_DEBUG} 
-		${PHYSX3_DLL_PROFILE} ${PHYSX3CHARACTERKINEMATIC_DLL_PROFILE} ${PHYSX3COMMON_DLL_PROFILE} ${PHYSX3COOKING_DLL_PROFILE} ${PHYSX3GPU_DLL_PROFILE} 
-		${PHYSX3_DLL_CHECKED} ${PHYSX3CHARACTERKINEMATIC_DLL_CHECKED} ${PHYSX3COMMON_DLL_CHECKED} ${PHYSX3COOKING_DLL_CHECKED} ${PHYSX3GPU_DLL_CHECKED} 
-	)
-	
-	SET(PHYSXSDK_LIBRARIES "" CACHE STRING "")
-	
-	foreach(x ${PHYSXSDK_LIBS_RELEASE})
-		list(APPEND PHYSXSDK_LIBRARIES optimized ${x})
-	endforeach()
-	
-	foreach(x ${PHYSXSDK_LIBS_DEBUG})
-		list(APPEND PHYSXSDK_LIBRARIES debug ${x})
-	endforeach()
-endif()
diff --git a/NvBlast/sdk/compiler/cmake/modules/FindPxSharedSDK.cmake b/NvBlast/sdk/compiler/cmake/modules/FindPxSharedSDK.cmake
deleted file mode 100644
index 0f67f5c..0000000
--- a/NvBlast/sdk/compiler/cmake/modules/FindPxSharedSDK.cmake
+++ /dev/null
@@ -1,293 +0,0 @@
-# - Try to find PxShared binary SDK
-# - Sets PXSHAREDSDK_LIBS_DEBUG and PXSHAREDSDK_LIBS_RELEASE - lists of the libraries found
-# - Sets PXSHAREDSDK_INCLUDE_DIRS 
-# - Sets PXSHAREDSDK_DLLS - List of the DLLs to copy to the bin directory of projects that depend on this
-
-include(FindPackageHandleStandardArgs)
-
-# Find the includes
-
-# TODO: Do the version stuff properly!
-find_path(PXSHAREDSDK_PATH include/foundation/Px.h
-	PATHS 
-	${GW_DEPS_ROOT}/$ENV{PM_PxShared_NAME}/${PxSharedSDK_FIND_VERSION}
-	${GW_DEPS_ROOT}/PxShared/${PxSharedSDK_FIND_VERSION}
-)
-
-if (TARGET_BUILD_PLATFORM STREQUAL "Windows")
-	# If the project pulling in this dependency needs the static crt, then append that to the path.
-	if (STATIC_WINCRT)
-		SET(PXSHARED_CRT_SUFFIX "-staticcrt")
-	else()
-		SET(PXSHARED_CRT_SUFFIX "")
-	endif()
-
-	if (CMAKE_CL_64)
-		SET(PXSHARED_ARCH_FOLDER "win64")
-		SET(PXSHARED_ARCH_FILE "_x64")
-	else()
-		SET(PXSHARED_ARCH_FOLDER "win32")
-		SET(PXSHARED_ARCH_FILE "_x86")
-	endif()
-
-	# What compiler version do we want?
-
-	if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 18.0.0.0 AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.0.0.0)
-		SET(VS_STR "vc12")
-	elseif(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 19.0.0.0)
-		SET(VS_STR "vc14")
-	else()
-		MESSAGE(FATAL_ERROR "Failed to find compatible PxSharedSDK - Only supporting VS2013 and VS2015")
-	endif()
-	
-	SET(LIB_PATH ${PXSHAREDSDK_PATH}/lib/${VS_STR}${PXSHARED_ARCH_FOLDER}-cmake${PXSHARED_CRT_SUFFIX})
-	SET(CMAKE_FIND_LIBRARY_SUFFIXES ".lib" ".dll")
-
-elseif(TARGET_BUILD_PLATFORM STREQUAL "PS4")
-	SET(LIB_PATH ${PXSHAREDSDK_PATH}/lib/vc14ps4-cmake)
-	SET(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
-	SET(CMAKE_FIND_LIBRARY_PREFIXES "lib")
-elseif(TARGET_BUILD_PLATFORM STREQUAL "XboxOne")
-	SET(LIB_PATH ${PXSHAREDSDK_PATH}/lib/vc14xboxone-cmake)
-	SET(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
-	SET(CMAKE_FIND_LIBRARY_PREFIXES "lib")
-elseif(TARGET_BUILD_PLATFORM STREQUAL "linux")
-	SET(LIB_PATH ${PXSHAREDSDK_PATH}/lib/linux64-cmake)
-	SET(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
-	SET(CMAKE_FIND_LIBRARY_PREFIXES "lib")
-	SET(PXSHARED_ARCH_FILE "_x64")
-endif()
-
-
-# Now find all of the PhysX libs in the lib directory
-
-
-find_library(PSFASTXML_LIB
-	NAMES PsFastXml${PXSHARED_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(PXFOUNDATION_LIB
-	NAMES PxFoundation${PXSHARED_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(PXPVDSDK_LIB
-	NAMES PxPvdSDK${PXSHARED_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(PXTASK_LIB
-	NAMES PxTask${PXSHARED_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-
-find_library(PSFASTXML_LIB_DEBUG
-	NAMES PsFastXmlDEBUG${PXSHARED_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(PXFOUNDATION_LIB_DEBUG
-	NAMES PxFoundationDEBUG${PXSHARED_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(PXPVDSDK_LIB_DEBUG
-	NAMES PxPvdSDKDEBUG${PXSHARED_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(PXTASK_LIB_DEBUG
-	NAMES PxTaskDEBUG${PXSHARED_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-
-find_library(PSFASTXML_LIB_CHECKED
-	NAMES PsFastXmlCHECKED${PXSHARED_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(PXFOUNDATION_LIB_CHECKED
-	NAMES PxFoundationCHECKED${PXSHARED_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(PXPVDSDK_LIB_CHECKED
-	NAMES PxPvdSDKCHECKED${PXSHARED_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(PXTASK_LIB_CHECKED
-	NAMES PxTaskCHECKED${PXSHARED_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-
-find_library(PSFASTXML_LIB_PROFILE
-	NAMES PsFastXmlPROFILE${PXSHARED_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(PXFOUNDATION_LIB_PROFILE
-	NAMES PxFoundationPROFILE${PXSHARED_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(PXPVDSDK_LIB_PROFILE
-	NAMES PxPvdSDKPROFILE${PXSHARED_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-find_library(PXTASK_LIB_PROFILE
-	NAMES PxTaskPROFILE${PXSHARED_ARCH_FILE}
-	PATHS ${LIB_PATH}
-)
-
-if (TARGET_BUILD_PLATFORM STREQUAL "Windows")
-	SET(DLL_PATH ${PXSHAREDSDK_PATH}/bin/${VS_STR}${PXSHARED_ARCH_FOLDER}-cmake${PXSHARED_CRT_SUFFIX})
-
-	find_library(PXFOUNDATION_DLL
-		NAMES PxFoundation${PXSHARED_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	find_library(PXPVDSDK_DLL
-		NAMES PxPvdSDK${PXSHARED_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-
-	find_library(PXFOUNDATION_DLL_DEBUG
-		NAMES PxFoundationDEBUG${PXSHARED_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	find_library(PXPVDSDK_DLL_DEBUG
-		NAMES PxPvdSDKDEBUG${PXSHARED_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-
-	find_library(PXFOUNDATION_DLL_CHECKED
-		NAMES PxFoundationCHECKED${PXSHARED_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	find_library(PXPVDSDK_DLL_CHECKED
-		NAMES PxPvdSDKCHECKED${PXSHARED_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-
-	find_library(PXFOUNDATION_DLL_PROFILE
-		NAMES PxFoundationPROFILE${PXSHARED_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	find_library(PXPVDSDK_DLL_PROFILE
-		NAMES PxPvdSDKPROFILE${PXSHARED_ARCH_FILE}
-		PATHS ${DLL_PATH}
-	)
-	
-	#Put the found dll variables in a list if we actually looked for them (windows)
-	SET(DLL_VAR_LIST 
-		PXFOUNDATION_DLL 
-		PXPVDSDK_DLL 
-
-		PXFOUNDATION_DLL_DEBUG 
-		PXPVDSDK_DLL_DEBUG 
-		
-		PXFOUNDATION_DLL_CHECKED 
-		PXPVDSDK_DLL_CHECKED 
-
-		PXFOUNDATION_DLL_PROFILE 
-		PXPVDSDK_DLL_PROFILE 
-		
-	)
-endif()
-
-if (TARGET_BUILD_PLATFORM STREQUAL "linux")
-	SET(BIN_PATH ${PXSHAREDSDK_PATH}/bin/linux64-cmake)
-	SET(CMAKE_FIND_LIBRARY_SUFFIXES ".so")
-
-    find_library(PXFOUNDATION_LIB
-        NAMES PxFoundation${PXSHARED_ARCH_FILE}
-        PATHS ${BIN_PATH}
-    )
-    find_library(PXPVDSDK_LIB
-        NAMES PxPvdSDK${PXSHARED_ARCH_FILE}
-        PATHS ${BIN_PATH}
-    )
-
-    find_library(PXFOUNDATION_LIB_DEBUG
-        NAMES PxFoundationDEBUG${PXSHARED_ARCH_FILE}
-        PATHS ${BIN_PATH}
-    )
-    find_library(PXPVDSDK_LIB_DEBUG
-        NAMES PxPvdSDKDEBUG${PXSHARED_ARCH_FILE}
-        PATHS ${BIN_PATH}
-    )
-endif()
-
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(PXSHAREDSDK
-	DEFAULT_MSG
-	PXSHAREDSDK_PATH
-
-	PSFASTXML_LIB
-	PXFOUNDATION_LIB
-	PXPVDSDK_LIB
-	PXTASK_LIB
-	
-	PSFASTXML_LIB_DEBUG
-	PXFOUNDATION_LIB_DEBUG
-	PXPVDSDK_LIB_DEBUG
-	PXTASK_LIB_DEBUG
-
-#	PSFASTXML_LIB_CHECKED
-#	PXFOUNDATION_LIB_CHECKED
-#	PXPVDSDK_LIB_CHECKED
-#	PXTASK_LIB_CHECKED
-#
-#	PSFASTXML_LIB_PROFILE
-#	PXFOUNDATION_LIB_PROFILE
-#	PXPVDSDK_LIB_PROFILE
-#	PXTASK_LIB_PROFILE
-
-	
-	${DLL_VAR_LIST}
-)
-
-if (PXSHAREDSDK_FOUND)
-
-	# NOTE: This include list is way too long and reaches into too many internals.
-	# Also may not be good enough for all users.
-	SET(PXSHAREDSDK_INCLUDE_DIRS 
-		${PXSHAREDSDK_PATH}/include 
-		${PXSHAREDSDK_PATH}/include/pvd
-		${PXSHAREDSDK_PATH}/include/task
-		${PXSHAREDSDK_PATH}/include/filebuf
-		${PXSHAREDSDK_PATH}/include/foundation
-		${PXSHAREDSDK_PATH}/src/foundation/include
-		${PXSHAREDSDK_PATH}/src/filebuf/include
-		${PXSHAREDSDK_PATH}/src/fastxml/include
-	)
-	
-	SET(PXSHAREDSDK_LIBS_RELEASE ${PSFASTXML_LIB} ${PXFOUNDATION_LIB} ${PXPVDSDK_LIB} ${PXTASK_LIB}
-		CACHE STRING ""
-	)
-	SET(PXSHAREDSDK_LIBS_DEBUG ${PSFASTXML_LIB_DEBUG} ${PXFOUNDATION_LIB_DEBUG} ${PXPVDSDK_LIB_DEBUG} ${PXTASK_LIB_DEBUG}
-		CACHE STRING ""
-	)
-	
-	SET(PXSHAREDSDK_LIBS_CHECKED ${PSFASTXML_LIB_CHECKED} ${PXFOUNDATION_LIB_CHECKED} ${PXPVDSDK_LIB_CHECKED} ${PXTASK_LIB_CHECKED}
-		CACHE STRING ""
-	)
-
-	SET(PXSHAREDSDK_LIBS_PROFILE ${PSFASTXML_LIB_PROFILE} ${PXFOUNDATION_LIB_PROFILE} ${PXPVDSDK_LIB_PROFILE} ${PXTASK_LIB_PROFILE}
-		CACHE STRING ""
-	)
-
-	SET(PXSHAREDSDK_DLLS 
-		${PXFOUNDATION_DLL} 
-		${PXPVDSDK_DLL} 
-
-		${PXFOUNDATION_DLL_DEBUG} 
-		${PXPVDSDK_DLL_DEBUG}
-	
-		${PXFOUNDATION_DLL_CHECKED} 
-		${PXPVDSDK_DLL_CHECKED}
-
-		${PXFOUNDATION_DLL_PROFILE} 
-		${PXPVDSDK_DLL_PROFILE}
-	)
-	
-	SET(PXSHAREDSDK_LIBRARIES "" CACHE STRING "")
-	
-	foreach(x ${PXSHAREDSDK_LIBS_RELEASE})
-		list(APPEND PXSHAREDSDK_LIBRARIES optimized ${x})
-	endforeach()
-	
-	foreach(x ${PXSHAREDSDK_LIBS_DEBUG})
-		list(APPEND PXSHAREDSDK_LIBRARIES debug ${x})
-	endforeach()
-endif()
diff --git a/NvBlast/sdk/compiler/cmake/modules/FindXDK.cmake b/NvBlast/sdk/compiler/cmake/modules/FindXDK.cmake
deleted file mode 100644
index 601dd8f..0000000
--- a/NvBlast/sdk/compiler/cmake/modules/FindXDK.cmake
+++ /dev/null
@@ -1,257 +0,0 @@
-# - Try to find XDLK
-# - Sets XDK_LIBRARIES - list of the libraries found
-# - Sets XDK_INCLUDE_DIRS 
-
-include(FindPackageHandleStandardArgs)
-
-# Find the includes
-
-# TODO: Do the version stuff properly!
-# TODO: Handle a binary dep version of the XDK
-find_path(XDK_PATH include/winrt/Windows.Xbox.UI.h
-	PATHS 
-	$ENV{XboxOneXDKLatest}/xdk
-)
-
-SET(LIB_PATH ${XDK_PATH}/Lib/amd64/)
-SET(CMAKE_FIND_LIBRARY_PREFIXES "")
-SET(CMAKE_FIND_LIBRARY_SUFFIXES ".lib")
-
-MESSAGE("XDK LIB PATH: ${LIB_PATH}")
-
-find_library(ACPHAL_LIB
-	NAMES acphal
-	PATHS ${LIB_PATH}
-)
-
-find_library(APPMODEL_LIB
-	NAMES appmodel
-	PATHS ${LIB_PATH}
-)
-
-find_library(BCRYPT_LIB
-	NAMES bcrypt
-	PATHS ${LIB_PATH}
-)
-
-find_library(COMBASE_LIB
-	NAMES combase
-	PATHS ${LIB_PATH}
-)
-
-find_library(CONSOLEID_LIB
-	NAMES consoleid
-	PATHS ${LIB_PATH}
-)
-
-find_library(D3D11_X_LIB
-	NAMES d3d11_x
-	PATHS ${LIB_PATH}
-)
-
-find_library(D3D12_X_LIB
-	NAMES d3d12_x
-	PATHS ${LIB_PATH}
-)
-
-find_library(D3DCOMPILER_LIB
-	NAMES d3dcompiler
-	PATHS ${LIB_PATH}
-)
-
-find_library(DXGUID_LIB
-	NAMES dxguid
-	PATHS ${LIB_PATH}
-)
-
-find_library(ETWPLUS_LIB
-	NAMES etwplus
-	PATHS ${LIB_PATH}
-)
-
-find_library(IXMLHTTPREQUEST2_LIB
-	NAMES ixmlhttprequest2
-	PATHS ${LIB_PATH}
-)
-
-find_library(KERNELX_LIB
-	NAMES kernelx
-	PATHS ${LIB_PATH}
-)
-
-find_library(KSTUDIOCLIENT_LIB
-	NAMES kstudioclient
-	PATHS ${LIB_PATH}
-)
-
-find_library(MFPLAT_LIB
-	NAMES mfplat
-	PATHS ${LIB_PATH}
-)
-
-find_library(MFREADWRITE_LIB
-	NAMES mfreadwrite
-	PATHS ${LIB_PATH}
-)
-
-find_library(MFUUID_LIB
-	NAMES mfuuid
-	PATHS ${LIB_PATH}
-)
-
-find_library(MMDEVAPI_LIB
-	NAMES mmdevapi
-	PATHS ${LIB_PATH}
-)
-
-find_library(PIXEVT_LIB
-	NAMES PIXEvt
-	PATHS ${LIB_PATH}
-)
-
-find_library(RPCRT4_LIB
-	NAMES rpcrt4
-	PATHS ${LIB_PATH}
-)
-
-find_library(SMARTGLASSINTEROP_LIB
-	NAMES smartglassinterop
-	PATHS ${LIB_PATH}
-)
-
-find_library(STRMIIDS_LIB
-	NAMES strmiids
-	PATHS ${LIB_PATH}
-)
-
-find_library(TOOLHELPX_LIB
-	NAMES toolhelpx
-	PATHS ${LIB_PATH}
-)
-
-find_library(UUID_LIB
-	NAMES uuid
-	PATHS ${LIB_PATH}
-)
-
-find_library(WINDOWSCODECS_LIB
-	NAMES windowscodecs
-	PATHS ${LIB_PATH}
-)
-
-find_library(WMCODECDSPUUID_LIB
-	NAMES wmcodecdspuuid
-	PATHS ${LIB_PATH}
-)
-
-find_library(WS2_32_LIB
-	NAMES ws2_32
-	PATHS ${LIB_PATH}
-)
-
-find_library(XAPOBASE_LIB
-	NAMES xapobase
-	PATHS ${LIB_PATH}
-)
-
-find_library(XAUDIO2_LIB
-	NAMES xaudio2
-	PATHS ${LIB_PATH}
-)
-
-find_library(XG_X_LIB
-	NAMES xg_x
-	PATHS ${LIB_PATH}
-)
-
-find_library(XI_LIB
-	NAMES xi
-	PATHS ${LIB_PATH}
-)
-
-find_library(XSTUDIOCLIENT_LIB
-	NAMES xstudioclient
-	PATHS ${LIB_PATH}
-)
-
-
-
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(XDK
-	DEFAULT_MSG
-	XDK_PATH
-
-	ACPHAL_LIB
-	APPMODEL_LIB
-	BCRYPT_LIB
-	COMBASE_LIB
-	CONSOLEID_LIB
-	D3D11_X_LIB
-	D3D12_X_LIB
-	D3DCOMPILER_LIB
-	DXGUID_LIB
-	ETWPLUS_LIB
-	IXMLHTTPREQUEST2_LIB
-	KERNELX_LIB
-	KSTUDIOCLIENT_LIB
-	MFPLAT_LIB
-	MFREADWRITE_LIB
-	MFUUID_LIB
-	MMDEVAPI_LIB
-	PIXEVT_LIB
-	RPCRT4_LIB
-	SMARTGLASSINTEROP_LIB
-	STRMIIDS_LIB
-	TOOLHELPX_LIB
-	UUID_LIB
-	WINDOWSCODECS_LIB
-	WMCODECDSPUUID_LIB
-	WS2_32_LIB
-	XAPOBASE_LIB
-	XAUDIO2_LIB
-	XG_X_LIB
-	XI_LIB
-	XSTUDIOCLIENT_LIB
-)
-
-if (XDK_FOUND)
-	SET(XDK_INCLUDE_DIRS 
-		${XDK_PATH}/Include 
-		${XDK_PATH}/Include/shared
-		${XDK_PATH}/Include/um
-		${XDK_PATH}/Include/winrt
-	)
-	
-	SET(XDK_LIBRARIES 
-		${ACPHAL_LIB}
-		${APPMODEL_LIB}
-		${BCRYPT_LIB}
-		${COMBASE_LIB}
-		${CONSOLEID_LIB}
-		${D3D11_X_LIB}
-		${D3D12_X_LIB}
-		${D3DCOMPILER_LIB}
-		${DXGUID_LIB}
-		${ETWPLUS_LIB}
-		${IXMLHTTPREQUEST2_LIB}
-		${KERNELX_LIB}
-		${KSTUDIOCLIENT_LIB}
-		${MFPLAT_LIB}
-		${MFREADWRITE_LIB}
-		${MFUUID_LIB}
-		${MMDEVAPI_LIB}
-		${PIXEVT_LIB}
-		${RPCRT4_LIB}
-		${SMARTGLASSINTEROP_LIB}
-		${STRMIIDS_LIB}
-		${TOOLHELPX_LIB}
-		${UUID_LIB}
-		${WINDOWSCODECS_LIB}
-		${WMCODECDSPUUID_LIB}
-		${WS2_32_LIB}
-		${XAPOBASE_LIB}
-		${XAUDIO2_LIB}
-		${XG_X_LIB}
-		${XI_LIB}
-		${XSTUDIOCLIENT_LIB}
-	)
-endif()
diff --git a/NvBlast/sdk/compiler/cmake/windows/CMakeLists.txt b/NvBlast/sdk/compiler/cmake/windows/CMakeLists.txt
deleted file mode 100644
index ac8b186..0000000
--- a/NvBlast/sdk/compiler/cmake/windows/CMakeLists.txt
+++ /dev/null
@@ -1,67 +0,0 @@
-#Platform specific compile flags and project includes
-
-SET(CMAKE_CXX_FLAGS "/GR- /GF /MP /Gy /d2Zi+ /errorReport:prompt /fp:fast /Gd /Gm- /GS- /nologo /W4 /WX /Zc:forScope /Zc:inline /Zc:wchar_t /Zi")
-
-OPTION(STATIC_WINCRT "Use static WinCRT" OFF)
-
-# Are we using the static or dynamic RT library? Whatever we use, it needs to be the same in any dependencies
-#  we pull in or we're potentially having mismatch issues.
-IF(STATIC_WINCRT)
-	SET(WINCRT_NDEBUG "/MT")
-	SET(WINCRT_DEBUG "/MTd")
-ELSE()
-	SET(WINCRT_NDEBUG "/MD")
-	SET(WINCRT_DEBUG "/MDd")
-ENDIF()
-
-SET(CMAKE_CXX_FLAGS_DEBUG "/Od /RTCsu ${WINCRT_DEBUG}")
-SET(CMAKE_CXX_FLAGS_CHECKED "/Ox ${WINCRT_NDEBUG}")
-SET(CMAKE_CXX_FLAGS_PROFILE "/Ox ${WINCRT_NDEBUG}")
-SET(CMAKE_CXX_FLAGS_RELEASE "/Ox ${WINCRT_NDEBUG}")
-
-MESSAGE("STATIC OR DYN: ${WINCRT_DEBUG}")
-
-# Build PDBs for all configurations
-SET(CMAKE_SHARED_LINKER_FLAGS "/DEBUG")
-
-IF(CMAKE_CL_64)
-	ADD_DEFINITIONS(-DWIN64)
-ENDIF(CMAKE_CL_64)				
-
-SET(BLAST_SLN_COMPILE_DEFS _HAS_EXCEPTIONS=0;WIN32;WIN64;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;)
-#NvBlastExt doesn't have the _CONSOLE flag
-
-SET(BLAST_SLN_DEBUG_COMPILE_DEFS _DEBUG;NV_DEBUG=1;)
-SET(BLAST_SLN_CHECKED_COMPILE_DEFS NDEBUG;NV_CHECKED=1;)
-SET(BLAST_SLN_PROFILE_COMPILE_DEFS NDEBUG;NV_PROFILE=1;)
-SET(BLAST_SLN_RELEASE_COMPILE_DEFS NDEBUG;)
-
-IF(CMAKE_CL_64)
-	SET(LIBPATH_SUFFIX "x64")
-ELSE(CMAKE_CL_64)
-	SET(LIBPATH_SUFFIX "x86")
-ENDIF(CMAKE_CL_64)				
-
-SET(CMAKE_DEBUG_POSTFIX "${CMAKE_DEBUG_POSTFIX}_${LIBPATH_SUFFIX}")
-SET(CMAKE_PROFILE_POSTFIX "${CMAKE_PROFILE_POSTFIX}_${LIBPATH_SUFFIX}")
-SET(CMAKE_CHECKED_POSTFIX "${CMAKE_CHECKED_POSTFIX}_${LIBPATH_SUFFIX}")
-SET(CMAKE_RELEASE_POSTFIX "${CMAKE_RELEASE_POSTFIX}_${LIBPATH_SUFFIX}")
-
-
-# Include all of the projects
-INCLUDE(${PROJECT_CMAKE_FILES_DIR}/NvBlast.cmake)
-INCLUDE(${PROJECT_CMAKE_FILES_DIR}/NvBlastTk.cmake)
-INCLUDE(${PROJECT_CMAKE_FILES_DIR}/NvBlastExtConverterLL.cmake)
-INCLUDE(${PROJECT_CMAKE_FILES_DIR}/NvBlastExtShaders.cmake)
-INCLUDE(${PROJECT_CMAKE_FILES_DIR}/NvBlastExtPhysX.cmake)
-INCLUDE(${PROJECT_CMAKE_FILES_DIR}/NvBlastExtAuthoring.cmake)
-INCLUDE(${PROJECT_CMAKE_FILES_DIR}/NvBlastExtImport.cmake)
-
-#Sadly, CapnProto won't compile on anything less than VS2015.
-if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 19.0.0.0)
-	SET(SERIALIZATION_INCLUDED 1 PARENT_SCOPE)
-	INCLUDE(${PROJECT_CMAKE_FILES_DIR}/NvBlastExtSerialization.cmake)
-	INCLUDE(${PROJECT_CMAKE_FILES_DIR}/NvBlastExtSerializationLL.cmake)
-else()
-	SET(SERIALIZATION_INCLUDED 0)
-endif()
diff --git a/NvBlast/sdk/compiler/cmake/windows/NvBlast.cmake b/NvBlast/sdk/compiler/cmake/windows/NvBlast.cmake
deleted file mode 100644
index 64b6b02..0000000
--- a/NvBlast/sdk/compiler/cmake/windows/NvBlast.cmake
+++ /dev/null
@@ -1,22 +0,0 @@
-#
-# Build NvBlast Windows
-#
-
-SET(BLAST_PLATFORM_COMMON_FILES
-	${COMMON_SOURCE_DIR}/NvBlastIncludeWindows.h
-)
-
-SET(BLAST_PLATFORM_INCLUDES
-)
-
-SET(BLAST_COMPILE_DEFS
-	# Common to all configurations
-	${BLAST_SLN_COMPILE_DEFS};_CONSOLE
-	
-	$<$<CONFIG:debug>:${BLAST_SLN_DEBUG_COMPILE_DEFS}>
-	$<$<CONFIG:checked>:${BLAST_SLN_CHECKED_COMPILE_DEFS}>
-	$<$<CONFIG:profile>:${BLAST_SLN_PROFILE_COMPILE_DEFS}>
-	$<$<CONFIG:release>:${BLAST_SLN_RELEASE_COMPILE_DEFS}>
-)
-
-SET(BLAST_LIB_TYPE SHARED)
diff --git a/NvBlast/sdk/compiler/cmake/windows/NvBlastExtAuthoring.cmake b/NvBlast/sdk/compiler/cmake/windows/NvBlastExtAuthoring.cmake
deleted file mode 100644
index 7406d74..0000000
--- a/NvBlast/sdk/compiler/cmake/windows/NvBlastExtAuthoring.cmake
+++ /dev/null
@@ -1,24 +0,0 @@
-#
-# Build NvBlastExt Windows
-#
-
-SET(BLASTEXT_PLATFORM_COMMON_FILES
-	${COMMON_SOURCE_DIR}/NvBlastIncludeWindows.h
-)
-
-SET(BLASTEXT_PLATFORM_INCLUDES
-)
-
-SET(BLASTEXT_COMPILE_DEFS
-	# Common to all configurations
-	${BLAST_SLN_COMPILE_DEFS};_CONSOLE;
-	
-	$<$<CONFIG:debug>:${BLAST_SLN_DEBUG_COMPILE_DEFS}>
-	$<$<CONFIG:checked>:${BLAST_SLN_CHECKED_COMPILE_DEFS}>
-	$<$<CONFIG:profile>:${BLAST_SLN_PROFILE_COMPILE_DEFS}>
-	$<$<CONFIG:release>:${BLAST_SLN_RELEASE_COMPILE_DEFS}>
-)
-
-SET(BLAST_EXT_SHARED_LIB_TYPE SHARED)
-
-SET(BLASTEXT_PLATFORM_COMPILE_OPTIONS "/wd4100;/wd4239;/wd4244;/wd4245;/wd4267;/EHsc")
diff --git a/NvBlast/sdk/compiler/cmake/windows/NvBlastExtConverterLL.cmake b/NvBlast/sdk/compiler/cmake/windows/NvBlastExtConverterLL.cmake
deleted file mode 100644
index 7406d74..0000000
--- a/NvBlast/sdk/compiler/cmake/windows/NvBlastExtConverterLL.cmake
+++ /dev/null
@@ -1,24 +0,0 @@
-#
-# Build NvBlastExt Windows
-#
-
-SET(BLASTEXT_PLATFORM_COMMON_FILES
-	${COMMON_SOURCE_DIR}/NvBlastIncludeWindows.h
-)
-
-SET(BLASTEXT_PLATFORM_INCLUDES
-)
-
-SET(BLASTEXT_COMPILE_DEFS
-	# Common to all configurations
-	${BLAST_SLN_COMPILE_DEFS};_CONSOLE;
-	
-	$<$<CONFIG:debug>:${BLAST_SLN_DEBUG_COMPILE_DEFS}>
-	$<$<CONFIG:checked>:${BLAST_SLN_CHECKED_COMPILE_DEFS}>
-	$<$<CONFIG:profile>:${BLAST_SLN_PROFILE_COMPILE_DEFS}>
-	$<$<CONFIG:release>:${BLAST_SLN_RELEASE_COMPILE_DEFS}>
-)
-
-SET(BLAST_EXT_SHARED_LIB_TYPE SHARED)
-
-SET(BLASTEXT_PLATFORM_COMPILE_OPTIONS "/wd4100;/wd4239;/wd4244;/wd4245;/wd4267;/EHsc")
diff --git a/NvBlast/sdk/compiler/cmake/windows/NvBlastExtImport.cmake b/NvBlast/sdk/compiler/cmake/windows/NvBlastExtImport.cmake
deleted file mode 100644
index 7406d74..0000000
--- a/NvBlast/sdk/compiler/cmake/windows/NvBlastExtImport.cmake
+++ /dev/null
@@ -1,24 +0,0 @@
-#
-# Build NvBlastExt Windows
-#
-
-SET(BLASTEXT_PLATFORM_COMMON_FILES
-	${COMMON_SOURCE_DIR}/NvBlastIncludeWindows.h
-)
-
-SET(BLASTEXT_PLATFORM_INCLUDES
-)
-
-SET(BLASTEXT_COMPILE_DEFS
-	# Common to all configurations
-	${BLAST_SLN_COMPILE_DEFS};_CONSOLE;
-	
-	$<$<CONFIG:debug>:${BLAST_SLN_DEBUG_COMPILE_DEFS}>
-	$<$<CONFIG:checked>:${BLAST_SLN_CHECKED_COMPILE_DEFS}>
-	$<$<CONFIG:profile>:${BLAST_SLN_PROFILE_COMPILE_DEFS}>
-	$<$<CONFIG:release>:${BLAST_SLN_RELEASE_COMPILE_DEFS}>
-)
-
-SET(BLAST_EXT_SHARED_LIB_TYPE SHARED)
-
-SET(BLASTEXT_PLATFORM_COMPILE_OPTIONS "/wd4100;/wd4239;/wd4244;/wd4245;/wd4267;/EHsc")
diff --git a/NvBlast/sdk/compiler/cmake/windows/NvBlastExtPhysX.cmake b/NvBlast/sdk/compiler/cmake/windows/NvBlastExtPhysX.cmake
deleted file mode 100644
index 9bf7614..0000000
--- a/NvBlast/sdk/compiler/cmake/windows/NvBlastExtPhysX.cmake
+++ /dev/null
@@ -1,24 +0,0 @@
-#
-# Build NvBlastExt Windows
-#
-
-SET(BLASTEXT_PLATFORM_COMMON_FILES
-	${COMMON_SOURCE_DIR}/NvBlastIncludeWindows.h
-)
-
-SET(BLASTEXT_PLATFORM_INCLUDES
-)
-
-SET(BLASTEXT_COMPILE_DEFS
-	# Common to all configurations
-	${BLAST_SLN_COMPILE_DEFS};_CONSOLE;
-	
-	$<$<CONFIG:debug>:${BLAST_SLN_DEBUG_COMPILE_DEFS}>
-	$<$<CONFIG:checked>:${BLAST_SLN_CHECKED_COMPILE_DEFS}>
-	$<$<CONFIG:profile>:${BLAST_SLN_PROFILE_COMPILE_DEFS}>
-	$<$<CONFIG:release>:${BLAST_SLN_RELEASE_COMPILE_DEFS}>
-)
-
-SET(BLASTEXT_PHYSX_LIBTYPE SHARED)
-
-SET(BLASTEXT_PLATFORM_COMPILE_OPTIONS "/wd4100;/wd4239;/wd4244;/wd4245;/wd4267;/EHsc")
diff --git a/NvBlast/sdk/compiler/cmake/windows/NvBlastExtSerialization.cmake b/NvBlast/sdk/compiler/cmake/windows/NvBlastExtSerialization.cmake
deleted file mode 100644
index 20910be..0000000
--- a/NvBlast/sdk/compiler/cmake/windows/NvBlastExtSerialization.cmake
+++ /dev/null
@@ -1,26 +0,0 @@
-#
-# Build NvBlastExtSerialization Windows
-#
-
-SET(BLASTEXTSERIALIZATION_PLATFORM_COMMON_FILES
-	${COMMON_SOURCE_DIR}/NvBlastIncludeWindows.h
-)
-
-SET(BLASTEXTSERIALIZATION_PLATFORM_INCLUDES
-)
-
-SET(BLASTEXTSERIALIZATION_COMPILE_DEFS
-	# Common to all configurations
-	${BLAST_SLN_COMPILE_DEFS};_CONSOLE;
-	
-	$<$<CONFIG:debug>:${BLAST_SLN_DEBUG_COMPILE_DEFS}>
-	$<$<CONFIG:checked>:${BLAST_SLN_CHECKED_COMPILE_DEFS}>
-	$<$<CONFIG:profile>:${BLAST_SLN_PROFILE_COMPILE_DEFS}>
-	$<$<CONFIG:release>:${BLAST_SLN_RELEASE_COMPILE_DEFS}>
-)
-
-SET(BLASTEXTSERIALIZATION_LIB_TYPE SHARED)
-
-
-SET(BLASTEXTSERIALIZATION_COMPILE_OPTIONS "/wd4100;/wd4239;/wd4244;/wd4245;/wd4267;/EHsc")
-
diff --git a/NvBlast/sdk/compiler/cmake/windows/NvBlastExtSerializationLL.cmake b/NvBlast/sdk/compiler/cmake/windows/NvBlastExtSerializationLL.cmake
deleted file mode 100644
index 20910be..0000000
--- a/NvBlast/sdk/compiler/cmake/windows/NvBlastExtSerializationLL.cmake
+++ /dev/null
@@ -1,26 +0,0 @@
-#
-# Build NvBlastExtSerialization Windows
-#
-
-SET(BLASTEXTSERIALIZATION_PLATFORM_COMMON_FILES
-	${COMMON_SOURCE_DIR}/NvBlastIncludeWindows.h
-)
-
-SET(BLASTEXTSERIALIZATION_PLATFORM_INCLUDES
-)
-
-SET(BLASTEXTSERIALIZATION_COMPILE_DEFS
-	# Common to all configurations
-	${BLAST_SLN_COMPILE_DEFS};_CONSOLE;
-	
-	$<$<CONFIG:debug>:${BLAST_SLN_DEBUG_COMPILE_DEFS}>
-	$<$<CONFIG:checked>:${BLAST_SLN_CHECKED_COMPILE_DEFS}>
-	$<$<CONFIG:profile>:${BLAST_SLN_PROFILE_COMPILE_DEFS}>
-	$<$<CONFIG:release>:${BLAST_SLN_RELEASE_COMPILE_DEFS}>
-)
-
-SET(BLASTEXTSERIALIZATION_LIB_TYPE SHARED)
-
-
-SET(BLASTEXTSERIALIZATION_COMPILE_OPTIONS "/wd4100;/wd4239;/wd4244;/wd4245;/wd4267;/EHsc")
-
diff --git a/NvBlast/sdk/compiler/cmake/windows/NvBlastExtShaders.cmake b/NvBlast/sdk/compiler/cmake/windows/NvBlastExtShaders.cmake
deleted file mode 100644
index 7406d74..0000000
--- a/NvBlast/sdk/compiler/cmake/windows/NvBlastExtShaders.cmake
+++ /dev/null
@@ -1,24 +0,0 @@
-#
-# Build NvBlastExt Windows
-#
-
-SET(BLASTEXT_PLATFORM_COMMON_FILES
-	${COMMON_SOURCE_DIR}/NvBlastIncludeWindows.h
-)
-
-SET(BLASTEXT_PLATFORM_INCLUDES
-)
-
-SET(BLASTEXT_COMPILE_DEFS
-	# Common to all configurations
-	${BLAST_SLN_COMPILE_DEFS};_CONSOLE;
-	
-	$<$<CONFIG:debug>:${BLAST_SLN_DEBUG_COMPILE_DEFS}>
-	$<$<CONFIG:checked>:${BLAST_SLN_CHECKED_COMPILE_DEFS}>
-	$<$<CONFIG:profile>:${BLAST_SLN_PROFILE_COMPILE_DEFS}>
-	$<$<CONFIG:release>:${BLAST_SLN_RELEASE_COMPILE_DEFS}>
-)
-
-SET(BLAST_EXT_SHARED_LIB_TYPE SHARED)
-
-SET(BLASTEXT_PLATFORM_COMPILE_OPTIONS "/wd4100;/wd4239;/wd4244;/wd4245;/wd4267;/EHsc")
diff --git a/NvBlast/sdk/compiler/cmake/windows/NvBlastTk.cmake b/NvBlast/sdk/compiler/cmake/windows/NvBlastTk.cmake
deleted file mode 100644
index d12f78f..0000000
--- a/NvBlast/sdk/compiler/cmake/windows/NvBlastTk.cmake
+++ /dev/null
@@ -1,27 +0,0 @@
-#
-# Build NvBlastTk Windows
-#
-
-FIND_PACKAGE(nvToolsExt $ENV{PM_nvToolsExt_VERSION} REQUIRED)
-
-SET(BLASTTK_PLATFORM_COMMON_FILES
-	${COMMON_SOURCE_DIR}/NvBlastIncludeWindows.h
-)
-
-SET(BLASTTK_PLATFORM_INCLUDES
-	PRIVATE $<$<OR:$<CONFIG:debug>,$<CONFIG:checked>,$<CONFIG:profile>>:${NVTOOLSEXT_INCLUDE_DIRS}>
-)
-
-SET(BLASTTK_COMPILE_DEFS
-	# Common to all configurations
-	${BLAST_SLN_COMPILE_DEFS};_CONSOLE
-	
-	$<$<CONFIG:debug>:${BLAST_SLN_DEBUG_COMPILE_DEFS}>
-	$<$<CONFIG:checked>:${BLAST_SLN_CHECKED_COMPILE_DEFS}>
-	$<$<CONFIG:profile>:${BLAST_SLN_PROFILE_COMPILE_DEFS}>
-	$<$<CONFIG:release>:${BLAST_SLN_RELEASE_COMPILE_DEFS}>
-)
-
-SET(BLASTTK_LIBTYPE "SHARED")
-
-SET(BLASTTK_PLATFORM_LINKED_LIBS Rpcrt4 $<$<OR:$<CONFIG:debug>,$<CONFIG:checked>,$<CONFIG:profile>>:${NVTOOLSEXT_LIB}>)
diff --git a/NvBlast/sdk/extensions/authoring/include/NvBlastExtAuthoringBondGenerator.h b/NvBlast/sdk/extensions/authoring/include/NvBlastExtAuthoringBondGenerator.h
deleted file mode 100644
index 68767eb..0000000
--- a/NvBlast/sdk/extensions/authoring/include/NvBlastExtAuthoringBondGenerator.h
+++ /dev/null
@@ -1,136 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTAUTHORINGBONDGENERATOR_H
-#define NVBLASTEXTAUTHORINGBONDGENERATOR_H
-
-#include "NvBlastExtAuthoringTypes.h"
-#include "NvBlastExtAuthoringFractureTool.h"
-#include "NvBlastTypes.h"
-#include "../cooking/PxCooking.h"
-#include <PxPlane.h>
-#include <NvBlastExtAuthoringCollisionBuilder.h>
-struct NvBlastBondDesc;
-struct NvBlastChunkDesc;
-struct NvBlastBond;
-
-using namespace physx;
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-// Forward declarations
-class TriangleProcessor;
-struct PlaneChunkIndexer;
-
-/**
-	Bond interface generation configuration
-	EXACT - common surface will be searched
-	AVERAGE - Inerface is approximated by projections or intersecitons with midplane
-*/
-struct BondGenerationConfig
-{
-	enum BondGenMode { EXACT, AVERAGE };
-	BondGenMode bondMode;
-};
-
-
-struct PlaneChunkIndexer
-{
-	PlaneChunkIndexer(int32_t chunkId, int32_t trId, physx::PxPlane pl) : chunkId(chunkId), trId(trId), plane(pl) {}
-	int32_t chunkId;
-	int32_t trId;
-	physx::PxPlane plane;
-};
-
-
-/**
-	Tool for gathering bond information from provided mesh geometry
-*/
-
-class BlastBondGenerator
-{
-public:
-				
-	BlastBondGenerator(physx::PxCooking* cooking, physx::PxPhysicsInsertionCallback* insertionCallback) : mPxCooking(cooking), mPxInsertionCallback(insertionCallback){};
-
-	/**
-		This method based on marking triangles during fracture process, so can be used only with internally fractured meshes.
-		\param[in] tool				FractureTool which contains chunks representation, tool->finalizeFracturing() should be called before.
-		\param[in] chunkIsSupport	Array of flags, if true - chunk is support. Array size should be equal to chunk count in tool.
-		\param[out] resultBondDescs	Array of created bond descriptors.
-		\param[out] resultChunkDescriptors	Array of created chunk descriptors.
-		\return 0 if success
-	*/
-	int32_t	buildDescFromInternalFracture(FractureTool* tool, const std::vector<bool>& chunkIsSupport, std::vector<NvBlastBondDesc>& resultBondDescs, std::vector<NvBlastChunkDesc>& resultChunkDescriptors);
-
-
-	/**
-		Creates bond description between two meshes
-		\param[in] meshA	Array of triangles of mesh A.
-		\param[in] meshB	Array of triangles of mesh B.
-		\param[out] resultBond	Result bond description.
-		\param[in] conf	Bond creation mode.
-		\return 0 if success
-	*/
-	int32_t	createBondBetweenMeshes(const std::vector<Triangle>& meshA, const std::vector<Triangle>& meshB, NvBlastBond& resultBond, BondGenerationConfig conf = BondGenerationConfig());
-
-	/**
-		Creates bond description between number of meshes
-		\param[in] geometry	Array of arrays of triangles for each chunk.
-		\param[out] resultBond	Array of result bonds.
-		\param[in] overlaps	Array of pairs - indexes of chunks, for which bond should be created.
-		\param[in] cfg	Bond creation mode.
-		\return 0 if success
-	*/
-	int32_t	createBondBetweenMeshes(const std::vector<std::vector<Triangle> >& geometry, std::vector<NvBlastBondDesc>& resultBond, const std::vector<std::pair<uint32_t, uint32_t> >& overlaps, BondGenerationConfig cfg);
-
-
-	/**
-		Creates bond description for prefractured meshes, when there is no info about which chunks should be connected with bond.
-		\param[in] geometry	Array of arrays of triangles for each chunk.
-		\param[in] chunkIsSupport Array of flags, if true - chunk is support. Array size should be equal to chunk count in tool.
-		\param[out] resultBondDescs	Array of result bonds.
-		\param[in] conf	Bond creation mode.
-		\return 0 if success
-	*/
-	int32_t	bondsFromPrefractured(const std::vector<std::vector<Triangle>>& geometry, const std::vector<bool>& chunkIsSupport, std::vector<NvBlastBondDesc>& resultBondDescs, BondGenerationConfig conf = BondGenerationConfig());
-				
-private:
-	float	processWithMidplanes(TriangleProcessor* trProcessor, const std::vector<physx::PxVec3>& chunk1Points, const std::vector<physx::PxVec3>& chunk2Points,
-								 const std::vector<physx::PxVec3>& hull1p,const std::vector<physx::PxVec3>& hull2p, physx::PxVec3& normal, physx::PxVec3& centroid);
-
-	int32_t	createFullBondListAveraged(const std::vector<std::vector<Triangle>>& chunksGeometry, const std::vector<bool>& supportFlags, std::vector<NvBlastBondDesc>& mResultBondDescs, BondGenerationConfig conf);
-	int32_t	createFullBondListExact(const std::vector<std::vector<Triangle>>& chunksGeometry, const std::vector<bool>& supportFlags, std::vector<NvBlastBondDesc>& mResultBondDescs, BondGenerationConfig conf);
-	int32_t	createFullBondListExactInternal(const std::vector<std::vector<Triangle>>& chunksGeometry, std::vector < PlaneChunkIndexer >& planeTriangleMapping , std::vector<NvBlastBondDesc>& mResultBondDescs);
-	int32_t	createBondForcedInternal(const std::vector<PxVec3>& hull0, const std::vector<PxVec3>& hull1,const CollisionHull& cHull0, const CollisionHull& cHull1,PxBounds3 bound0, PxBounds3 bound1, NvBlastBond& resultBond, float overlapping);
-
-	void	buildGeometryCache(const std::vector<std::vector<Triangle> >& geometry);
-	void	resetGeometryCache();
-
-	physx::PxCooking*							mPxCooking;
-	physx::PxPhysicsInsertionCallback*			mPxInsertionCallback;
-
-
-	std::vector<std::vector<Triangle> >			mGeometryCache;
-
-	std::vector<PlaneChunkIndexer>				mPlaneCache;
-	std::vector<CollisionHull>					mCHullCache;
-	std::vector<std::vector<physx::PxVec3> >	mHullsPointsCache;
-	std::vector<physx::PxBounds3 >				mBoundsCache;
-};
-
-}	// namespace Blast
-}	// namespace Nv
-
-#endif // NVBLASTEXTAUTHORINGBONDGENERATOR_H
\ No newline at end of file
diff --git a/NvBlast/sdk/extensions/authoring/include/NvBlastExtAuthoringCollisionBuilder.h b/NvBlast/sdk/extensions/authoring/include/NvBlastExtAuthoringCollisionBuilder.h
deleted file mode 100644
index b3e143a..0000000
--- a/NvBlast/sdk/extensions/authoring/include/NvBlastExtAuthoringCollisionBuilder.h
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTAUTHORINGCOLLISIONBUILDER_H
-#define NVBLASTEXTAUTHORINGCOLLISIONBUILDER_H
-
-#include "NvBlastTypes.h"
-#include <vector>
-#include <PxVec3.h>
-
-namespace physx
-{
-	class PxCooking;
-	class PxPhysicsInsertionCallback;
-	class PxVec3;
-	class PxConvexMesh;
-}
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-/**
-	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;
-	};
-	///**
-
-	CollisionHull(){};
-
-	std::vector<physx::PxVec3>	points;
-	std::vector<uint32_t>		indices;
-	std::vector<HullPolygon>	polygonData;
-};
-
-
-/**
-	ConvexMeshBuilder provides routine to build collision hulls from array of vertices.
-	Collision hull is built as convex hull of provided point set.
-	If due to some reason building of convex hull is failed, collision hull is built as bounding box of vertex set.
-*/
-class ConvexMeshBuilder
-{
-public:
-
-	/**
-		Constructor should be provided with PxCoocking and PxPhysicsInsertionCallback objects.
-	*/
-	ConvexMeshBuilder(physx::PxCooking* cooking, physx::PxPhysicsInsertionCallback* insertionCallback) : mInsertionCallback(insertionCallback), mCooking(cooking) {}
-
-	/**
-		Method creates CollisionHull from provided array of vertices.
-		\param[in]	vertexData		Vertex array of some object, for which collision geometry should be built
-		\param[out] output			Reference on CollisionHull object in which generated geometry should be saved
-	*/
-	void					buildCollisionGeometry(const std::vector<physx::PxVec3>& vertexData, CollisionHull& output);
-
-	/**
-	Method creates PxConvexMesh from provided array of vertices.
-	\param[in]	vertexData		Vertex array of some object, for which collision geometry should be built
-
-	\return pointer to the PxConvexMesh object if it was built successfully, 'nullptr' otherwise.
-	*/
-	physx::PxConvexMesh*	buildConvexMesh(std::vector<physx::PxVec3>& vertexData);
-
-
-	/**
-		Method creates PxConvexMesh from provided ConvexHull geometry
-		\param[in]	hull ConvexHull geometry
-
-		\return pointer to the PxConvexMesh object if it was built successfully, 'nullptr' otherwise.
-	*/
-	physx::PxConvexMesh*	buildConvexMesh(CollisionHull& hull);
-
-
-	/**
-		Convex geometry trimming. 
-		Using slicing with noised slicing surface can result in intersecting collision geometry.
-		It leads to unstable behaviour of rigid body simulation. 
-		This method trims all intersecting parts of collision geometry.
-		As a drawback, trimming collision geometry can lead to penetrating render meshes during simulation.
-
-
-		\param[in]	in ConvexHull geometry which should be clipped. 
-		\param[in]	chunkDepth Array of depth levels of convex hulls corresponding chunks.
-
-	*/
-	
-	void					trimCollisionGeometry(std::vector<CollisionHull>& in, const std::vector<uint32_t>& chunkDepth);
-
-
-private:
-	physx::PxPhysicsInsertionCallback*	mInsertionCallback;
-	physx::PxCooking*					mCooking;
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTEXTAUTHORINGCOLLISIONBUILDER_H
diff --git a/NvBlast/sdk/extensions/authoring/include/NvBlastExtAuthoringFractureTool.h b/NvBlast/sdk/extensions/authoring/include/NvBlastExtAuthoringFractureTool.h
deleted file mode 100644
index 528ffbc..0000000
--- a/NvBlast/sdk/extensions/authoring/include/NvBlastExtAuthoringFractureTool.h
+++ /dev/null
@@ -1,435 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTAUTHORINGFRACTURETOOL_H
-#define NVBLASTAUTHORINGFRACTURETOOL_H
-
-#include "NvBlastExtAuthoringMesh.h"
-#include "NvBlastTypes.h"
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-class SpatialAccelerator;
-class ChunkPostProcessor;
-
-
-/*
-	Chunk data, chunk with chunkId == 0 is always source mesh.
-*/
-struct ChunkInfo
-{
-	Mesh*	meshData;
-	int32_t	parent;
-	int32_t	chunkId;
-	bool	isLeaf;
-};
-
-
-/*
-	Slicing fracturing configuration
-
-
-	default:
-	x_slices = 1;
-	y_slices = 1;
-	z_slices = 1;
-
-	offset_variations	= 0.f;
-	angle_variations	= 0.f;
-	noiseAmplitude		= 0.f;
-	noiseFrequency		= 1.f;
-	noiseOctaveNumber	= 1;
-	surfaceResolution	= 1;
-*/
-struct SlicingConfiguration
-{
-	/** 
-		Number of slices in each direction
-	*/
-	int32_t	x_slices, y_slices, z_slices;
-	
-	/** 
-		Offset variation, value in [0, 1]
-	*/
-	float	offset_variations;
-	/** 
-		Angle variation, value in [0, 1]
-	*/
-	float	angle_variations;
-
-
-	/**
-		Noisy slicing configutaion:
-
-		Amplitude of cutting surface noise. If it is 0 - noise is disabled.
-	*/
-	float noiseAmplitude;
-	/**
-		Frequencey of cutting surface noise. 
-	*/
-	float noiseFrequency;
-	/**
-		Octave number in slicing surface noise.
-	*/
-	uint32_t noiseOctaveNumber;
-	/**
-		Cutting surface resolution.
-	*/
-	int32_t surfaceResolution;
-
-
-	SlicingConfiguration()
-	{
-		reset();
-	}
-	/**
-		Set default params.
-	*/
-	void reset()
-	{
-		x_slices = 1;
-		y_slices = 1;
-		z_slices = 1;
-
-		offset_variations	= 0.f;
-		angle_variations	= 0.f;
-		noiseAmplitude		= 0.f;
-		noiseFrequency		= 1.f;
-		noiseOctaveNumber	= 1;
-		surfaceResolution	= 1;
-	}
-
-};
-
-
-
-/**
-	Class for voronoi sites generation inside supplied mesh.
-*/
-class VoronoiSitesGenerator
-{
-public:
-	
-	/** 
-		Voronoi sites should not be generated outside of the fractured mesh, so VoronoiSitesGenerator
-		should be supplied with fracture mesh.
-		\param[in] mesh			Fracture mesh
-		\param[in] rnd			User supplied random value generator.
-		\return
-	*/
-	VoronoiSitesGenerator(Mesh* mesh, RandomGeneratorBase* rnd);
-	~VoronoiSitesGenerator();
-
-	/**
-		Set base fracture mesh
-	*/
-	void						setBaseMesh(Mesh* m);
-
-	/**
-		Returns reference on vector of generated voronoi sites.
-	*/
-	std::vector<physx::PxVec3>& getVoronoiSites();
-	
-	/**
-		Add site in particular point
-		\param[in] site		Site coordinates
-	*/
-	void						addSite(const physx::PxVec3& site);
-	/**
-		Uniformly generate sites inside the mesh
-		\param[in] numberOfSites	Number of generated sites
-	*/
-	void						uniformlyGenerateSitesInMesh(const uint32_t numberOfSites);
-
-	/**
-		Generate sites in clustered fashion
-		\param[in] numberOfClusters	Number of generated clusters
-		\param[in] sitesPerCluster	Number of sites in each cluster
-		\param[in] clusterRadius	Voronoi cells cluster radius
-	*/
-	void						clusteredSitesGeneration(const uint32_t numberOfClusters, const uint32_t sitesPerCluster, float clusterRadius);
-
-	/**
-		Radial pattern of sites generation
-		\param[in] center		Center of generated pattern
-		\param[in] normal		Normal to plane in which sites are generated
-		\param[in] radius		Pattern radius
-		\param[in] angularSteps	Number of angular steps
-		\param[in] radialSteps	Number of radial steps
-		\param[in] angleOffset	Angle offset at each radial step
-		\param[in] variability	Randomness of sites distribution 
-	*/
-	void						radialPattern(const physx::PxVec3& center, const physx::PxVec3& normal, float radius, int32_t angularSteps, int32_t radialSteps, float angleOffset = 0.0f, float variability = 0.0f);
-
-	/**
-		Generate sites inside sphere
-		\param[in] count		Count of generated sites
-		\param[in] radius		Radius of sphere
-		\param[in] center		Center of sphere
-	*/
-	void						generateInSphere(const uint32_t count, const float radius, const physx::PxVec3& center);
-	/**
-		Set stencil mesh. With stencil mesh sites are generated only inside both of fracture and stencil meshes. 
-		\param[in] stencil		Stencil mesh.
-	*/
-	void						setStencil(Mesh* stencil);
-	/**
-		Removes stencil mesh
-	*/
-	void						clearStencil();
-
-	/** 
-		Deletes sites inside supplied sphere
-		\param[in] radius				Radius of sphere
-		\param[in] center				Center of sphere
-		\param[in] eraserProbability	Probability of removing some particular site
-	*/
-	void						deleteInSphere(const float radius, const physx::PxVec3& center, const float eraserProbability = 1);
-
-private:
-	std::vector<physx::PxVec3>	mGeneratedSites;
-	Mesh*						mMesh;
-	Mesh*						mStencil;
-	RandomGeneratorBase*		mRnd;
-	SpatialAccelerator*			mAccelerator;
-};
-
-
-
-/**
-	FractureTool class provides methods to fracture provided mesh and generate Blast asset data
-*/
-class FractureTool
-{
-
-public:
-
-	/**
-		FractureTool can log asset creation info if logCallback is provided.
-	*/
-	FractureTool(NvBlastLog logCallback = nullptr)
-	{
-		mPlaneIndexerOffset = 1;
-		mChunkIdCounter = 0;
-		mRemoveIslands = false;
-		mLoggingCallback = logCallback;
-	}
-
-	~FractureTool()
-	{
-		reset();
-	}
-
-	/**
-		Reset FractureTool state.
-	*/
-	void									reset();
-	
-	
-	/**
-		Set input mesh wich will be fractured, FractureTool will be reseted.
-	*/
-	void									setSourceMesh(Mesh* mesh);
-
-	/**
-		Get chunk mesh in polygonal representation
-	*/
-	Mesh									getChunkMesh(int32_t chunkId);
-
-	/**
-		Input mesh is scaled and transformed internally to fit unit cube centered in origin.
-		Method provides offset vector and scale parameter;
-	*/
-	void									getTransformation(physx::PxVec3& offset, float& scale);
-
-
-	/**
-		Fractures specified chunk with voronoi method.
-		\param[in] chunkId				Chunk to fracture
-		\param[in] cellPoints			Array of voronoi sites
-		\param[in] replaceChunk			if 'true', newly generated chunks will replace source chunk, if 'false', newly generated chunks will be at next depth level, source chunk will be parent for them.
-										Case replaceChunk == true && chunkId == 0 considered as wrong input parameters
-		\return   If 0, fracturing is successful.
-	*/
-	int32_t									voronoiFracturing(uint32_t chunkId, const std::vector<physx::PxVec3>& cellPoints, bool replaceChunk);
-
-	/**
-		Fractures specified chunk with voronoi method. Cells can be scaled along x,y,z axes.
-		\param[in] chunkId				Chunk to fracture
-		\param[in] cellPoints			Array of voronoi sites
-		\param[in] cellPoints			Array of voronoi sites
-		\param[in] scale				Voronoi cells scaling factor
-		\param[in] replaceChunk			if 'true', newly generated chunks will replace source chunk, if 'false', newly generated chunks will be at next depth level, source chunk will be parent for them.
-									    Case replaceChunk == true && chunkId == 0 considered as wrong input parameters
-		\return   If 0, fracturing is successful.
-	*/
-	int32_t									voronoiFracturing(uint32_t chunkId, const std::vector<physx::PxVec3>& cellPoints, const physx::PxVec3& scale, bool replaceChunk);
-
-
-	/**
-		Fractures specified chunk with slicing method.
-		\param[in] chunkId				Chunk to fracture
-		\param[in] conf					Slicing parameters, see SlicingConfiguration.
-		\param[in] replaceChunk			if 'true', newly generated chunks will replace source chunk, if 'false', newly generated chunks will be at next depth level, source chunk will be parent for them.
-										Case replaceChunk == true && chunkId == 0 considered as wrong input parameters
-		\param[in] rnd					User supplied random number generator
-
-		\return   If 0, fracturing is successful.
-	*/
-	int32_t									slicing(uint32_t chunkId, SlicingConfiguration conf, bool replaceChunk, RandomGeneratorBase* rnd);
-
-
-	/**
-		Creates resulting fractured mesh geometry from intermediate format
-	*/
-	void									finalizeFracturing();
-	
-	/**
-		Get chunk information
-	*/
-	const std::vector<ChunkInfo>&    		getChunkList();
-
-
-	/**
-		Tesselate interior surfaces
-		\param[in] averageEdgeLength - Average length of edge on internal surface.
-	*/
-	void									tesselate(float averageEdgeLength);
-	
-	/**
-		Apply noise to interior surfaces. Must be called only after tesselation!
-		\param[in] amplitude Amplitude of noise
-		\param[in] frequency Frequency of noise
-		\param[in] octaves Number of noise octaves
-		\param[in] falloff - damping of noise around of external surface
-		\param[in] relaxIterations - number of smoothing iterations before applying noise
-		\param[in] relaxFactor - amount of smoothing before applying noise.
-		\param[in] seed Random seed value
-	*/
-	void									applyNoise(float amplitude, float frequency, int32_t octaves, float falloff, int32_t relaxIterations, float relaxFactor, int32_t seed = 0);
-
-	/**
-		Get percentage of mesh overlap.
-		percentage computed as volume(intersection(meshA , meshB)) / volume (meshA) 
-		\param[in] meshA Mesh A
-		\param[in] meshB Mesh B
-		\return mesh overlap percentage
-	*/
-	static float							getMeshOverlap(Mesh& meshA, Mesh& meshB);
-
-	/**
-		Get chunk base mesh
-		\param[in] chunkIndex Chunk index
-		\param[out] output Array of triangles to be filled
-	*/
-	void									getBaseMesh(int32_t chunkIndex, std::vector<Triangle>& output);
-
-	/**
-		Get chunk mesh with noise
-		\param[in] chunkIndex Chunk index
-		\param[out] output Array of triangles to be filled
-	*/
-	void									getNoisedMesh(int32_t chunkIndex, std::vector<Triangle>& output);
-
-
-	/**
-		Return index of chunk with specified chunkId
-		\param[in] chunkId Chunk ID
-		\return Chunk index in internal buffer, if not exist -1 is returned.
-	*/
-	int32_t									getChunkIndex(int32_t chunkId);
-
-	/**
-		Return id of chunk with specified index.
-		\param[in] chunkIndex Chunk index
-		\return Chunk id or -1 if there is no such chunk.
-	*/
-	int32_t									getChunkId(int32_t chunkIndex);
-
-	/**
-		Return depth level of the given chunk
-		\param[in] chunkId Chunk ID
-		\return Chunk depth or -1 if there is no such chunk.
-	*/
-	int32_t									getChunkDepth(int32_t chunkId);
-
-	/**
-		Return array of chunks IDs with given depth.
-		\param[in] depth Chunk depth
-		\return Array of chunk IDs
-	*/
-	std::vector<int32_t>					getChunksIdAtDepth(uint32_t depth);
-
-
-	/**
-		Get result geometry without noise as vertex and index buffers, where index buffers contain series of triplets
-		which represent triangles.
-		\param[out] vertexBuffer Array of vertices to be filled
-		\param[out] indexBuffer Array of arrays of indices to be filled
-	*/
-	void									getBufferedBaseMeshes(std::vector<Vertex>& vertexBuffer, std::vector<std::vector<uint32_t> >& indexBuffer);
-
-	/**
-		Get result geometry after tesselation and application of noise as vertex and index buffers, where index buffers contain series of triplets
-		which represent triangles.
-		\param[out] vertexBuffer Array of vertices to be filled
-		\param[out] indexBuffer Array of arrays of indices to be filled
-	*/
-	void									getBufferedNoiseMeshes(std::vector<Vertex>& vertexBuffer, std::vector<std::vector<uint32_t> >& indexBuffer);
-
-	/**
-		Set automatic islands removing. May cause instabilities.
-		\param[in] isRemoveIslands Flag whether remove or not islands.
-	*/
-	void									setRemoveIslands(bool isRemoveIslands);
-
-	/**
-		Try find islands and remove them on some specifical chunk. If chunk has childs, island removing can lead to wrong results! Apply it before further chunk splitting.
-		\param[in] chunkId Chunk ID which should be checked for islands
-		\return Number of found islands is returned
-	*/
-	int32_t									islandDetectionAndRemoving(int32_t chunkId);
-
-private:	
-	void									eraseChunk(int32_t chunkId);	
-	bool									isAncestorForChunk(int32_t ancestorId, int32_t chunkId);
-	void									deleteAllChildsOfChunk(int32_t chunkId);
-	int32_t									slicingNoisy(uint32_t chunkId, SlicingConfiguration conf, bool replaceChunk, RandomGeneratorBase* rnd);
-
-protected:
-	/**
-	Mesh scaled to unite-cube and translated to the origin
-	*/
-	float								mScaleFactor;
-	physx::PxVec3						mOffset;
-
-	/* Chunk mesh wrappers */
-	std::vector<ChunkPostProcessor*>	mChunkPostprocessors;
-
-
-	
-	int32_t								mPlaneIndexerOffset;
-	int32_t								mChunkIdCounter;
-	std::vector<ChunkInfo>				mChunkData;
-
-	bool								mRemoveIslands;
-
-	NvBlastLog							mLoggingCallback;
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTAUTHORINGFRACTURETOOL_H
diff --git a/NvBlast/sdk/extensions/authoring/include/NvBlastExtAuthoringMesh.h b/NvBlast/sdk/extensions/authoring/include/NvBlastExtAuthoringMesh.h
deleted file mode 100644
index 2b1806a..0000000
--- a/NvBlast/sdk/extensions/authoring/include/NvBlastExtAuthoringMesh.h
+++ /dev/null
@@ -1,174 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTAUTHORINGMESH_H
-#define NVBLASTAUTHORINGMESH_H
-
-#include "NvBlastExtAuthoringTypes.h"
-#include <vector>
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-/**
-	Class for internal mesh representation
-*/
-class Mesh
-{
-public:
-
-	/**
-		Constructs mesh object from array of triangles.
-		\param[in] position			Array of vertex positions
-		\param[in] normals			Array of vertex normals
-		\param[in] uv				Array of vertex uv coordinates
-		\param[in] verticesCount	Vertices count
-		\param[in] indices			Array of vertex indices. Indices contain vertex index triplets which form a mesh triangle. 
-		\param[in] indicesCount		Indices count (should be equal to numberOfTriangles * 3)
-	*/
-	Mesh(physx::PxVec3* position, physx::PxVec3* normals, physx::PxVec2* uv, uint32_t verticesCount, uint32_t* indices, uint32_t indicesCount);
-
-	/**
-		Constructs mesh object from array of facets.
-		\param[in] vertices		Array of vertices
-		\param[in] edges		Array of edges
-		\param[in] facets		Array of facets
-		\param[in] posCount		Vertices count
-		\param[in] edgesCount	Edges count
-		\param[in] facetsCount	Facets count
-	*/
-	Mesh(Vertex* vertices, Edge* edges, Facet* facets, uint32_t posCount, uint32_t edgesCount, uint32_t facetsCount);
-
-	~Mesh();
-
-	/**
-		Return true if mesh is valid
-	*/
-	bool				isValid();
-
-	/**
-		Return pointer on vertices array
-	*/
-	Vertex*				getVertices();
-
-	/**
-		Return pointer on edges array
-	*/
-	Edge*				getEdges();
-
-	/**
-		Return pointer on facets array
-	*/
-	Facet*				getFacetsBuffer();
-
-	/**
-		Return pointer on specified facet
-	*/
-	Facet*				getFacet(int32_t facet);
-
-	/**
-		Return edges count
-	*/
-	uint32_t			getEdgesCount();
-
-	/**
-		Return vertices count
-	*/
-	uint32_t			getVerticesCount();
-
-	/**
-		Return facet count
-	*/
-	uint32_t			getFacetCount();
-
-	/**
-		Return reference on mesh bounding box.
-	*/
-	physx::PxBounds3&	getBoundingBox();
-
-	/**
-		Recalculate bounding box
-	*/
-	void				recalculateBoundingBox();
-
-	/**
-		Compute mesh volume. Can be used only for triangulated meshes.
-		Return mesh volume. If mesh is not triangulated return 0.
-	*/
-	float				getMeshVolume();
-
-private:
-	std::vector<Vertex>	mVertices;
-	std::vector<Edge>	mEdges;
-	std::vector<Facet>	mFacets;
-	physx::PxBounds3	mBounds;
-};
-
-
-/**
-	Helper functions
-*/
-
-/**
-	Set cutting box at some particular position.
-	\param[in] point	Cutting face center
-	\param[in] normal	Cutting face normal
-	\param[in] mesh		Cutting box mesh
-	\param[in] size		Cutting box size
-	\param[in] id	Cutting box ID
-*/
-void	setCuttingBox(const physx::PxVec3& point, const physx::PxVec3& normal, Mesh* mesh, float size, int32_t id);
-/**
-	Create cutting box at some particular position.
-	\param[in] point	Cutting face center
-	\param[in] normal	Cutting face normal
-	\param[in] size		Cutting box size
-	\param[in] id	Cutting box ID
-*/
-Mesh*	getCuttingBox(const physx::PxVec3& point, const physx::PxVec3& normal, float size, int32_t id);
-
-/**
-	Create box at some particular position.
-	\param[in] point	Cutting face center
-	\param[in] size		Cutting box size
-*/
-Mesh*	getBigBox(const physx::PxVec3& point, float size);
-
-/**
-	Create slicing box with noisy cutting surface.
-	\param[in] point			Cutting face center
-	\param[in] normal			Cutting face normal
-	\param[in] size				Cutting box size
-	\param[in] jaggedPlaneSize	Noisy surface size
-	\param[in] resolution		Noisy surface resolution
-	\param[in] id				Cutting box ID
-	\param[in] amplitude		Noise amplitude
-	\param[in] frequency		Noise frequency
-	\param[in] octaves			Noise octaves
-	\param[in] seed				Random generator seed, used for noise generation.	
-*/
-Mesh* getNoisyCuttingBoxPair(const physx::PxVec3& point, const physx::PxVec3& normal, float size, float jaggedPlaneSize, uint32_t resolution, int32_t id, float amplitude, float frequency, int32_t octaves, int32_t seed);
-
-
-/**
-	Inverses normals of cutting box and sets indices. 
-	\param[in] mesh		Cutting box mesh
-	\param[in] id	Cutting box ID
-*/
-void inverseNormalAndSetIndices(Mesh* mesh, int32_t id);
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTAUTHORINGMESH_H
diff --git a/NvBlast/sdk/extensions/authoring/include/NvBlastExtAuthoringTypes.h b/NvBlast/sdk/extensions/authoring/include/NvBlastExtAuthoringTypes.h
deleted file mode 100644
index de28866..0000000
--- a/NvBlast/sdk/extensions/authoring/include/NvBlastExtAuthoringTypes.h
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTAUTHORINGTYPES_H
-#define NVBLASTAUTHORINGTYPES_H
-
-#include <PxVec3.h>
-#include <PxVec2.h>
-#include <PxBounds3.h>
-#include <algorithm>
-#include "NvBlastTypes.h"
-
-#define NOT_VALID_VERTEX INT32_MAX
-
-namespace Nv
-{
-namespace Blast
-{
-
-/**
-	Edge representation
-*/
-struct Edge
-{
-	uint32_t s, e;
-	Edge() : s(NOT_VALID_VERTEX), e(NOT_VALID_VERTEX){}
-	Edge(int s, int e) : s(s), e(e) {}
-	bool operator<(const Edge& b) const
-	{
-		if (s == b.s)
-			return e < b.e;
-		else
-			return s < b.s;
-	}
-};
-
-/**
-	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.
-};
-
-/**
-	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 userInfo;
-	physx::PxVec3 getNormal()
-	{
-		return ((b.p - a.p).cross(c.p - a.p));
-	}
-};
-
-
-/**
-	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);
-	}
-
-	uint32_t ea, eb, ec;
-	int32_t userInfo;
-};
-
-/**
-	Mesh facet representation
-*/
-struct Facet
-{
-	int32_t		firstEdgeNumber;
-	uint32_t	edgesCount;
-	int32_t		userData;
-	Facet(int32_t fEdge = 0, uint32_t eCount = 0, int32_t userData = 0) : firstEdgeNumber(fEdge), edgesCount(eCount), userData(userData) {}
-};
-
-/**
-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() {};
-};
-
-
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTAUTHORINGTYPES_H
diff --git a/NvBlast/sdk/extensions/authoring/source/NvBlastExtApexSharedParts.cpp b/NvBlast/sdk/extensions/authoring/source/NvBlastExtApexSharedParts.cpp
deleted file mode 100644
index 73c59b8..0000000
--- a/NvBlast/sdk/extensions/authoring/source/NvBlastExtApexSharedParts.cpp
+++ /dev/null
@@ -1,1004 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastExtApexSharedParts.h"
-
-#include "PxMat44.h"
-#include "PxBounds3.h"
-#include "PxFoundation.h"
-#include "PxPhysics.h"
-#include "PsVecMath.h"
-#include <vector>
-
-using namespace physx;
-using namespace physx::shdfnd::aos;
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-PX_NOALIAS PX_FORCE_INLINE BoolV PointOutsideOfPlane4(const Vec3VArg _a, const Vec3VArg _b, const Vec3VArg _c, const Vec3VArg _d)
-{
-	// this is not 0 because of the following scenario:
-	// All the points lie on the same plane and the plane goes through the origin (0,0,0).
-	// On the Wii U, the math below has the problem that when point A gets projected on the
-	// plane cumputed by A, B, C, the distance to the plane might not be 0 for the mentioned
-	// scenario but a small positive or negative value. This can lead to the wrong boolean
-	// results. Using a small negative value as threshold is more conservative but safer.
-	const Vec4V zero = V4Load(-1e-6);
-
-	const Vec3V ab = V3Sub(_b, _a);
-	const Vec3V ac = V3Sub(_c, _a);
-	const Vec3V ad = V3Sub(_d, _a);
-	const Vec3V bd = V3Sub(_d, _b);
-	const Vec3V bc = V3Sub(_c, _b);
-
-	const Vec3V v0 = V3Cross(ab, ac);
-	const Vec3V v1 = V3Cross(ac, ad);
-	const Vec3V v2 = V3Cross(ad, ab);
-	const Vec3V v3 = V3Cross(bd, bc);
-
-	const FloatV signa0 = V3Dot(v0, _a);
-	const FloatV signa1 = V3Dot(v1, _a);
-	const FloatV signa2 = V3Dot(v2, _a);
-	const FloatV signd3 = V3Dot(v3, _a);
-
-	const FloatV signd0 = V3Dot(v0, _d);
-	const FloatV signd1 = V3Dot(v1, _b);
-	const FloatV signd2 = V3Dot(v2, _c);
-	const FloatV signa3 = V3Dot(v3, _b);
-
-	const Vec4V signa = V4Merge(signa0, signa1, signa2, signa3);
-	const Vec4V signd = V4Merge(signd0, signd1, signd2, signd3);
-	return V4IsGrtrOrEq(V4Mul(signa, signd), zero);//same side, outside of the plane
-}
-
-PX_NOALIAS PX_FORCE_INLINE Vec3V closestPtPointSegment(const Vec3VArg a, const Vec3VArg b)
-{
-	const FloatV zero = FZero();
-	const FloatV one = FOne();
-
-	//Test degenerated case
-	const Vec3V ab = V3Sub(b, a);
-	const FloatV denom = V3Dot(ab, ab);
-	const Vec3V ap = V3Neg(a);//V3Sub(origin, a);
-	const FloatV nom = V3Dot(ap, ab);
-	const BoolV con = FIsEq(denom, zero);
-	const FloatV tValue = FClamp(FDiv(nom, denom), zero, one);
-	const FloatV t = FSel(con, zero, tValue);
-
-	return V3Sel(con, a, V3ScaleAdd(ab, t, a));
-}
-
-PX_NOALIAS PX_FORCE_INLINE Vec3V closestPtPointSegment(const Vec3VArg Q0, const Vec3VArg Q1, const Vec3VArg A0, const Vec3VArg A1,
-	const Vec3VArg B0, const Vec3VArg B1, PxU32& size, Vec3V& closestA, Vec3V& closestB)
-{
-	const Vec3V a = Q0;
-	const Vec3V b = Q1;
-
-	const BoolV bTrue = BTTTT();
-	const FloatV zero = FZero();
-	const FloatV one = FOne();
-
-	//Test degenerated case
-	const Vec3V ab = V3Sub(b, a);
-	const FloatV denom = V3Dot(ab, ab);
-	const Vec3V ap = V3Neg(a);//V3Sub(origin, a);
-	const FloatV nom = V3Dot(ap, ab);
-	const BoolV con = FIsEq(denom, zero);
-
-	if (BAllEq(con, bTrue))
-	{
-		size = 1;
-		closestA = A0;
-		closestB = B0;
-		return Q0;
-	}
-
-	const Vec3V v = V3Sub(A1, A0);
-	const Vec3V w = V3Sub(B1, B0);
-	const FloatV tValue = FClamp(FDiv(nom, denom), zero, one);
-	const FloatV t = FSel(con, zero, tValue);
-
-	const Vec3V tempClosestA = V3ScaleAdd(v, t, A0);
-	const Vec3V tempClosestB = V3ScaleAdd(w, t, B0);
-	closestA = tempClosestA;
-	closestB = tempClosestB;
-	return V3Sub(tempClosestA, tempClosestB);
-}
-
-PX_NOALIAS Vec3V closestPtPointSegmentTesselation(const Vec3VArg Q0, const Vec3VArg Q1, const Vec3VArg A0, const Vec3VArg A1,
-	const Vec3VArg B0, const Vec3VArg B1, PxU32& size, Vec3V& closestA, Vec3V& closestB)
-{
-	const FloatV half = FHalf();
-
-	const FloatV targetSegmentLengthSq = FLoad(10000.f);//100 unit
-
-	Vec3V q0 = Q0;
-	Vec3V q1 = Q1;
-	Vec3V a0 = A0;
-	Vec3V a1 = A1;
-	Vec3V b0 = B0;
-	Vec3V b1 = B1;
-
-	for (;;)
-	{
-		const Vec3V midPoint = V3Scale(V3Add(q0, q1), half);
-		const Vec3V midA = V3Scale(V3Add(a0, a1), half);
-		const Vec3V midB = V3Scale(V3Add(b0, b1), half);
-
-		const Vec3V v = V3Sub(midPoint, q0);
-		const FloatV sqV = V3Dot(v, v);
-		if (FAllGrtr(targetSegmentLengthSq, sqV))
-			break;
-		//split the segment into half
-		const Vec3V tClos0 = closestPtPointSegment(q0, midPoint);
-		const FloatV sqDist0 = V3Dot(tClos0, tClos0);
-
-		const Vec3V tClos1 = closestPtPointSegment(q1, midPoint);
-		const FloatV sqDist1 = V3Dot(tClos1, tClos1);
-		//const BoolV con = FIsGrtr(sqDist0, sqDist1);
-		if (FAllGrtr(sqDist0, sqDist1))
-		{
-			//segment [m, q1]
-			q0 = midPoint;
-			a0 = midA;
-			b0 = midB;
-		}
-		else
-		{
-			//segment [q0, m]
-			q1 = midPoint;
-			a1 = midA;
-			b1 = midB;
-		}
-
-	}
-
-	return closestPtPointSegment(q0, q1, a0, a1, b0, b1, size, closestA, closestB);
-}
-
-PX_NOALIAS Vec3V closestPtPointTriangleTesselation(const Vec3V* PX_RESTRICT Q, const Vec3V* PX_RESTRICT A, const Vec3V* PX_RESTRICT B, const PxU32* PX_RESTRICT indices, PxU32& size, Vec3V& closestA, Vec3V& closestB)
-{
-	size = 3;
-	const FloatV zero = FZero();
-	const FloatV eps = FEps();
-	const FloatV half = FHalf();
-	const BoolV bTrue = BTTTT();
-	const FloatV four = FLoad(4.f);
-	const FloatV sixty = FLoad(100.f);
-
-	const PxU32 ind0 = indices[0];
-	const PxU32 ind1 = indices[1];
-	const PxU32 ind2 = indices[2];
-
-	const Vec3V a = Q[ind0];
-	const Vec3V b = Q[ind1];
-	const Vec3V c = Q[ind2];
-
-	Vec3V ab_ = V3Sub(b, a);
-	Vec3V ac_ = V3Sub(c, a);
-	Vec3V bc_ = V3Sub(b, c);
-
-	const FloatV dac_ = V3Dot(ac_, ac_);
-	const FloatV dbc_ = V3Dot(bc_, bc_);
-	if (FAllGrtrOrEq(eps, FMin(dac_, dbc_)))
-	{
-		//degenerate
-		size = 2;
-		return closestPtPointSegment(Q[ind0], Q[ind1], A[ind0], A[ind1], B[ind0], B[ind1], size, closestA, closestB);
-	}
-
-	Vec3V ap = V3Neg(a);
-	Vec3V bp = V3Neg(b);
-	Vec3V cp = V3Neg(c);
-
-	FloatV d1 = V3Dot(ab_, ap); //  snom
-	FloatV d2 = V3Dot(ac_, ap); //  tnom
-	FloatV d3 = V3Dot(ab_, bp); // -sdenom
-	FloatV d4 = V3Dot(ac_, bp); //  unom = d4 - d3
-	FloatV d5 = V3Dot(ab_, cp); //  udenom = d5 - d6
-	FloatV d6 = V3Dot(ac_, cp); // -tdenom
-	/*	FloatV unom = FSub(d4, d3);
-	FloatV udenom = FSub(d5, d6);*/
-
-	FloatV va = FNegScaleSub(d5, d4, FMul(d3, d6));//edge region of BC
-	FloatV vb = FNegScaleSub(d1, d6, FMul(d5, d2));//edge region of AC
-	FloatV vc = FNegScaleSub(d3, d2, FMul(d1, d4));//edge region of AB
-
-	//check if p in vertex region outside a
-	const BoolV con00 = FIsGrtrOrEq(zero, d1); // snom <= 0
-	const BoolV con01 = FIsGrtrOrEq(zero, d2); // tnom <= 0
-	const BoolV con0 = BAnd(con00, con01); // vertex region a
-	if (BAllEq(con0, bTrue))
-	{
-		//size = 1;
-		closestA = A[ind0];
-		closestB = B[ind0];
-		return Q[ind0];
-	}
-
-	//check if p in vertex region outside b
-	const BoolV con10 = FIsGrtrOrEq(d3, zero);
-	const BoolV con11 = FIsGrtrOrEq(d3, d4);
-	const BoolV con1 = BAnd(con10, con11); // vertex region b
-	if (BAllEq(con1, bTrue))
-	{
-		/*size = 1;
-		indices[0] = ind1;*/
-		closestA = A[ind1];
-		closestB = B[ind1];
-		return Q[ind1];
-	}
-
-
-	//check if p in vertex region outside of c
-	const BoolV con20 = FIsGrtrOrEq(d6, zero);
-	const BoolV con21 = FIsGrtrOrEq(d6, d5);
-	const BoolV con2 = BAnd(con20, con21); // vertex region c
-	if (BAllEq(con2, bTrue))
-	{
-		closestA = A[ind2];
-		closestB = B[ind2];
-		return Q[ind2];
-	}
-
-	//check if p in edge region of AB
-	const BoolV con30 = FIsGrtrOrEq(zero, vc);
-	const BoolV con31 = FIsGrtrOrEq(d1, zero);
-	const BoolV con32 = FIsGrtrOrEq(zero, d3);
-	const BoolV con3 = BAnd(con30, BAnd(con31, con32));
-
-	if (BAllEq(con3, bTrue))
-	{
-		//size = 2;
-		//p in edge region of AB, split AB
-		return closestPtPointSegmentTesselation(Q[ind0], Q[ind1], A[ind0], A[ind1], B[ind0], B[ind1], size, closestA, closestB);
-	}
-
-	//check if p in edge region of BC
-	const BoolV con40 = FIsGrtrOrEq(zero, va);
-	const BoolV con41 = FIsGrtrOrEq(d4, d3);
-	const BoolV con42 = FIsGrtrOrEq(d5, d6);
-	const BoolV con4 = BAnd(con40, BAnd(con41, con42));
-
-	if (BAllEq(con4, bTrue))
-	{
-		//p in edge region of BC, split BC
-		return closestPtPointSegmentTesselation(Q[ind1], Q[ind2], A[ind1], A[ind2], B[ind1], B[ind2], size, closestA, closestB);
-	}
-
-	//check if p in edge region of AC
-	const BoolV con50 = FIsGrtrOrEq(zero, vb);
-	const BoolV con51 = FIsGrtrOrEq(d2, zero);
-	const BoolV con52 = FIsGrtrOrEq(zero, d6);
-	const BoolV con5 = BAnd(con50, BAnd(con51, con52));
-
-	if (BAllEq(con5, bTrue))
-	{
-		//p in edge region of AC, split AC
-		return closestPtPointSegmentTesselation(Q[ind0], Q[ind2], A[ind0], A[ind2], B[ind0], B[ind2], size, closestA, closestB);
-	}
-
-	size = 3;
-
-	Vec3V q0 = Q[ind0];
-	Vec3V q1 = Q[ind1];
-	Vec3V q2 = Q[ind2];
-	Vec3V a0 = A[ind0];
-	Vec3V a1 = A[ind1];
-	Vec3V a2 = A[ind2];
-	Vec3V b0 = B[ind0];
-	Vec3V b1 = B[ind1];
-	Vec3V b2 = B[ind2];
-
-	for (;;)
-	{
-
-		const Vec3V ab = V3Sub(q1, q0);
-		const Vec3V ac = V3Sub(q2, q0);
-		const Vec3V bc = V3Sub(q2, q1);
-
-		const FloatV dab = V3Dot(ab, ab);
-		const FloatV dac = V3Dot(ac, ac);
-		const FloatV dbc = V3Dot(bc, bc);
-
-		const FloatV fMax = FMax(dab, FMax(dac, dbc));
-		const FloatV fMin = FMin(dab, FMin(dac, dbc));
-
-		const Vec3V w = V3Cross(ab, ac);
-
-		const FloatV area = V3Length(w);
-		const FloatV ratio = FDiv(FSqrt(fMax), FSqrt(fMin));
-		if (FAllGrtr(four, ratio) && FAllGrtr(sixty, area))
-			break;
-
-		//calculate the triangle normal
-		const Vec3V triNormal = V3Normalize(w);
-
-		PX_ASSERT(V3AllEq(triNormal, V3Zero()) == 0);
-
-
-		//split the longest edge
-		if (FAllGrtrOrEq(dab, dac) && FAllGrtrOrEq(dab, dbc))
-		{
-			//split edge q0q1
-			const Vec3V midPoint = V3Scale(V3Add(q0, q1), half);
-			const Vec3V midA = V3Scale(V3Add(a0, a1), half);
-			const Vec3V midB = V3Scale(V3Add(b0, b1), half);
-
-			const Vec3V v = V3Sub(midPoint, q2);
-			const Vec3V n = V3Normalize(V3Cross(v, triNormal));
-
-			const FloatV d = FNeg(V3Dot(n, midPoint));
-			const FloatV dp = FAdd(V3Dot(n, q0), d);
-			const FloatV sum = FMul(d, dp);
-
-			if (FAllGrtr(sum, zero))
-			{
-				//q0 and origin at the same side, split triangle[q0, m, q2]
-				q1 = midPoint;
-				a1 = midA;
-				b1 = midB;
-			}
-			else
-			{
-				//q1 and origin at the same side, split triangle[m, q1, q2]
-				q0 = midPoint;
-				a0 = midA;
-				b0 = midB;
-			}
-
-		}
-		else if (FAllGrtrOrEq(dac, dbc))
-		{
-			//split edge q0q2
-			const Vec3V midPoint = V3Scale(V3Add(q0, q2), half);
-			const Vec3V midA = V3Scale(V3Add(a0, a2), half);
-			const Vec3V midB = V3Scale(V3Add(b0, b2), half);
-
-			const Vec3V v = V3Sub(midPoint, q1);
-			const Vec3V n = V3Normalize(V3Cross(v, triNormal));
-
-			const FloatV d = FNeg(V3Dot(n, midPoint));
-			const FloatV dp = FAdd(V3Dot(n, q0), d);
-			const FloatV sum = FMul(d, dp);
-
-			if (FAllGrtr(sum, zero))
-			{
-				//q0 and origin at the same side, split triangle[q0, q1, m]
-				q2 = midPoint;
-				a2 = midA;
-				b2 = midB;
-			}
-			else
-			{
-				//q2 and origin at the same side, split triangle[m, q1, q2]
-				q0 = midPoint;
-				a0 = midA;
-				b0 = midB;
-			}
-		}
-		else
-		{
-			//split edge q1q2
-			const Vec3V midPoint = V3Scale(V3Add(q1, q2), half);
-			const Vec3V midA = V3Scale(V3Add(a1, a2), half);
-			const Vec3V midB = V3Scale(V3Add(b1, b2), half);
-
-			const Vec3V v = V3Sub(midPoint, q0);
-			const Vec3V n = V3Normalize(V3Cross(v, triNormal));
-
-			const FloatV d = FNeg(V3Dot(n, midPoint));
-			const FloatV dp = FAdd(V3Dot(n, q1), d);
-			const FloatV sum = FMul(d, dp);
-
-			if (FAllGrtr(sum, zero))
-			{
-				//q1 and origin at the same side, split triangle[q0, q1, m]
-				q2 = midPoint;
-				a2 = midA;
-				b2 = midB;
-			}
-			else
-			{
-				//q2 and origin at the same side, split triangle[q0, m, q2]
-				q1 = midPoint;
-				a1 = midA;
-				b1 = midB;
-			}
-
-
-		}
-	}
-
-	//P must project inside face region. Compute Q using Barycentric coordinates
-	ab_ = V3Sub(q1, q0);
-	ac_ = V3Sub(q2, q0);
-	ap = V3Neg(q0);
-	bp = V3Neg(q1);
-	cp = V3Neg(q2);
-
-	d1 = V3Dot(ab_, ap); //  snom
-	d2 = V3Dot(ac_, ap); //  tnom
-	d3 = V3Dot(ab_, bp); // -sdenom
-	d4 = V3Dot(ac_, bp); //  unom = d4 - d3
-	d5 = V3Dot(ab_, cp); //  udenom = d5 - d6
-	d6 = V3Dot(ac_, cp); // -tdenom
-
-	va = FNegScaleSub(d5, d4, FMul(d3, d6));//edge region of BC
-	vb = FNegScaleSub(d1, d6, FMul(d5, d2));//edge region of AC
-	vc = FNegScaleSub(d3, d2, FMul(d1, d4));//edge region of AB
-
-	const FloatV toRecipD = FAdd(va, FAdd(vb, vc));
-	const FloatV denom = FRecip(toRecipD);//V4GetW(recipTmp);
-	const Vec3V v0 = V3Sub(a1, a0);
-	const Vec3V v1 = V3Sub(a2, a0);
-	const Vec3V w0 = V3Sub(b1, b0);
-	const Vec3V w1 = V3Sub(b2, b0);
-
-	const FloatV t = FMul(vb, denom);
-	const FloatV w = FMul(vc, denom);
-	const Vec3V vA1 = V3Scale(v1, w);
-	const Vec3V vB1 = V3Scale(w1, w);
-	const Vec3V tempClosestA = V3Add(a0, V3ScaleAdd(v0, t, vA1));
-	const Vec3V tempClosestB = V3Add(b0, V3ScaleAdd(w0, t, vB1));
-	closestA = tempClosestA;
-	closestB = tempClosestB;
-	return V3Sub(tempClosestA, tempClosestB);
-}
-
-PX_NOALIAS Vec3V closestPtPointTetrahedronTesselation(Vec3V* PX_RESTRICT Q, Vec3V* PX_RESTRICT A, Vec3V* PX_RESTRICT B, PxU32& size, Vec3V& closestA, Vec3V& closestB)
-{
-	const FloatV eps = FEps();
-	const Vec3V zeroV = V3Zero();
-	PxU32 tempSize = size;
-
-	FloatV bestSqDist = FLoad(PX_MAX_REAL);
-	const Vec3V a = Q[0];
-	const Vec3V b = Q[1];
-	const Vec3V c = Q[2];
-	const Vec3V d = Q[3];
-	const BoolV bTrue = BTTTT();
-	const BoolV bFalse = BFFFF();
-
-	//degenerated
-	const Vec3V ad = V3Sub(d, a);
-	const Vec3V bd = V3Sub(d, b);
-	const Vec3V cd = V3Sub(d, c);
-	const FloatV dad = V3Dot(ad, ad);
-	const FloatV dbd = V3Dot(bd, bd);
-	const FloatV dcd = V3Dot(cd, cd);
-	const FloatV fMin = FMin(dad, FMin(dbd, dcd));
-	if (FAllGrtr(eps, fMin))
-	{
-		size = 3;
-		PxU32 tempIndices[] = { 0, 1, 2 };
-		return closestPtPointTriangleTesselation(Q, A, B, tempIndices, size, closestA, closestB);
-	}
-
-	Vec3V _Q[] = { Q[0], Q[1], Q[2], Q[3] };
-	Vec3V _A[] = { A[0], A[1], A[2], A[3] };
-	Vec3V _B[] = { B[0], B[1], B[2], B[3] };
-
-	PxU32 indices[3] = { 0, 1, 2 };
-
-	const BoolV bIsOutside4 = PointOutsideOfPlane4(a, b, c, d);
-
-	if (BAllEq(bIsOutside4, bFalse))
-	{
-		//origin is inside the tetrahedron, we are done
-		return zeroV;
-	}
-
-	Vec3V result = zeroV;
-	Vec3V tempClosestA, tempClosestB;
-
-	if (BAllEq(BGetX(bIsOutside4), bTrue))
-	{
-
-		PxU32 tempIndices[] = { 0, 1, 2 };
-		PxU32 _size = 3;
-
-		result = closestPtPointTriangleTesselation(_Q, _A, _B, tempIndices, _size, tempClosestA, tempClosestB);
-
-		const FloatV sqDist = V3Dot(result, result);
-		bestSqDist = sqDist;
-
-		indices[0] = tempIndices[0];
-		indices[1] = tempIndices[1];
-		indices[2] = tempIndices[2];
-
-		tempSize = _size;
-		closestA = tempClosestA;
-		closestB = tempClosestB;
-	}
-
-	if (BAllEq(BGetY(bIsOutside4), bTrue))
-	{
-
-		PxU32 tempIndices[] = { 0, 2, 3 };
-
-		PxU32 _size = 3;
-
-		const Vec3V q = closestPtPointTriangleTesselation(_Q, _A, _B, tempIndices, _size, tempClosestA, tempClosestB);
-
-		const FloatV sqDist = V3Dot(q, q);
-		const BoolV con = FIsGrtr(bestSqDist, sqDist);
-		if (BAllEq(con, bTrue))
-		{
-			result = q;
-			bestSqDist = sqDist;
-			indices[0] = tempIndices[0];
-			indices[1] = tempIndices[1];
-			indices[2] = tempIndices[2];
-
-			tempSize = _size;
-			closestA = tempClosestA;
-			closestB = tempClosestB;
-		}
-	}
-
-	if (BAllEq(BGetZ(bIsOutside4), bTrue))
-	{
-
-		PxU32 tempIndices[] = { 0, 3, 1 };
-		PxU32 _size = 3;
-
-		const Vec3V q = closestPtPointTriangleTesselation(_Q, _A, _B, tempIndices, _size, tempClosestA, tempClosestB);
-
-		const FloatV sqDist = V3Dot(q, q);
-		const BoolV con = FIsGrtr(bestSqDist, sqDist);
-		if (BAllEq(con, bTrue))
-		{
-			result = q;
-			bestSqDist = sqDist;
-			indices[0] = tempIndices[0];
-			indices[1] = tempIndices[1];
-			indices[2] = tempIndices[2];
-			tempSize = _size;
-			closestA = tempClosestA;
-			closestB = tempClosestB;
-		}
-
-	}
-
-	if (BAllEq(BGetW(bIsOutside4), bTrue))
-	{
-
-		PxU32 tempIndices[] = { 1, 3, 2 };
-		PxU32 _size = 3;
-
-		const Vec3V q = closestPtPointTriangleTesselation(_Q, _A, _B, tempIndices, _size, tempClosestA, tempClosestB);
-
-		const FloatV sqDist = V3Dot(q, q);
-		const BoolV con = FIsGrtr(bestSqDist, sqDist);
-
-		if (BAllEq(con, bTrue))
-		{
-			result = q;
-			bestSqDist = sqDist;
-
-			indices[0] = tempIndices[0];
-			indices[1] = tempIndices[1];
-			indices[2] = tempIndices[2];
-
-			tempSize = _size;
-			closestA = tempClosestA;
-			closestB = tempClosestB;
-		}
-	}
-
-	A[0] = _A[indices[0]]; A[1] = _A[indices[1]]; A[2] = _A[indices[2]];
-	B[0] = _B[indices[0]]; B[1] = _B[indices[1]]; B[2] = _B[indices[2]];
-	Q[0] = _Q[indices[0]]; Q[1] = _Q[indices[1]]; Q[2] = _Q[indices[2]];
-
-
-	size = tempSize;
-	return result;
-}
-
-PX_NOALIAS PX_FORCE_INLINE Vec3V doTesselation(Vec3V* PX_RESTRICT Q, Vec3V* PX_RESTRICT A, Vec3V* PX_RESTRICT B,
-	const Vec3VArg support, const Vec3VArg supportA, const Vec3VArg supportB, PxU32& size, Vec3V& closestA, Vec3V& closestB)
-{
-	switch (size)
-	{
-	case 1:
-	{
-		closestA = supportA;
-		closestB = supportB;
-		return support;
-	}
-	case 2:
-	{
-		return closestPtPointSegmentTesselation(Q[0], support, A[0], supportA, B[0], supportB, size, closestA, closestB);
-	}
-	case 3:
-	{
-
-		PxU32 tempIndices[3] = { 0, 1, 2 };
-		return closestPtPointTriangleTesselation(Q, A, B, tempIndices, size, closestA, closestB);
-	}
-	case 4:
-	{
-		return closestPtPointTetrahedronTesselation(Q, A, B, size, closestA, closestB);
-	}
-	default:
-		PX_ASSERT(0);
-	}
-	return support;
-}
-
-
-
-
-enum Status
-{
-	STATUS_NON_INTERSECT,
-	STATUS_CONTACT,
-	STATUS_DEGENERATE,
-};
-
-struct Output
-{
-	/// Get the normal to push apart in direction from A to B
-	PX_FORCE_INLINE Vec3V getNormal() const { return V3Normalize(V3Sub(mClosestB, mClosestA)); }
-	Vec3V mClosestA;				///< Closest point on A
-	Vec3V mClosestB;				///< Closest point on B
-	FloatV mDistSq;
-};
-
-struct ConvexV
-{
-	void calcExtent(const Vec3V& dir, PxF32& minOut, PxF32& maxOut) const
-	{
-		// Expand 
-		const Vec4V x = Vec4V_From_FloatV(V3GetX(dir));
-		const Vec4V y = Vec4V_From_FloatV(V3GetY(dir));
-		const Vec4V z = Vec4V_From_FloatV(V3GetZ(dir));
-
-		const Vec4V* src = mAovVertices;
-		const Vec4V* end = src + mNumAovVertices * 3;
-
-		// Do first step
-		Vec4V max = V4MulAdd(x, src[0], V4MulAdd(y, src[1], V4Mul(z, src[2])));
-		Vec4V min = max;
-		src += 3;
-		// Do the rest
-		for (; src < end; src += 3)
-		{
-			const Vec4V dot = V4MulAdd(x, src[0], V4MulAdd(y, src[1], V4Mul(z, src[2])));
-			max = V4Max(dot, max);
-			min = V4Min(dot, min);
-		}
-		FStore(V4ExtractMax(max), &maxOut);
-		FStore(V4ExtractMin(min), &minOut);
-	}
-	Vec3V calcSupport(const Vec3V& dir) const
-	{
-		// Expand 
-		const Vec4V x = Vec4V_From_FloatV(V3GetX(dir));
-		const Vec4V y = Vec4V_From_FloatV(V3GetY(dir));
-		const Vec4V z = Vec4V_From_FloatV(V3GetZ(dir));
-
-		PX_ALIGN(16, static const PxF32 index4const[]) = { 0.0f, 1.0f, 2.0f, 3.0f };
-		Vec4V index4 = *(const Vec4V*)index4const;
-		PX_ALIGN(16, static const PxF32 delta4const[]) = { 4.0f, 4.0f, 4.0f, 4.0f };
-		const Vec4V delta4 = *(const Vec4V*)delta4const;
-
-		const Vec4V* src = mAovVertices;
-		const Vec4V* end = src + mNumAovVertices * 3;
-
-		// Do first step
-		Vec4V max = V4MulAdd(x, src[0], V4MulAdd(y, src[1], V4Mul(z, src[2])));
-		Vec4V maxIndex = index4;
-		index4 = V4Add(index4, delta4);
-		src += 3;
-		// Do the rest
-		for (; src < end; src += 3)
-		{
-			const Vec4V dot = V4MulAdd(x, src[0], V4MulAdd(y, src[1], V4Mul(z, src[2])));
-			const BoolV cmp = V4IsGrtr(dot, max);
-			max = V4Max(dot, max);
-			maxIndex = V4Sel(cmp, index4, maxIndex);
-			index4 = V4Add(index4, delta4);
-		}
-		Vec4V horiMax = Vec4V_From_FloatV(V4ExtractMax(max));
-		PxU32 mask = BGetBitMask(V4IsEq(horiMax, max));
-		const PxU32 simdIndex = (0x12131210 >> (mask + mask)) & PxU32(3);
-
-		/// NOTE! Could be load hit store
-		/// Would be better to have all simd. 
-		PX_ALIGN(16, PxF32 f[4]);
-		V4StoreA(maxIndex, f);
-		PxU32 index = PxU32(PxI32(f[simdIndex]));
-
-		const Vec4V* aovIndex = (mAovVertices + (index >> 2) * 3);
-		const PxF32* aovOffset = ((const PxF32*)aovIndex) + (index & 3);
-
-		return Vec3V_From_Vec4V(V4LoadXYZW(aovOffset[0], aovOffset[4], aovOffset[8], 1.0f));
-	}
-
-	const Vec4V* mAovVertices;			///< Vertices storex x,x,x,x, y,y,y,y, z,z,z,z
-	PxU32 mNumAovVertices;			///< Number of groups of 4 of vertices
-};
-
-Status Collide(const Vec3V& initialDir, const ConvexV& convexA, const Mat34V& bToA, const ConvexV& convexB, Output& out)
-{
-	Vec3V Q[4];
-	Vec3V A[4];
-	Vec3V B[4];
-
-	Mat33V aToB = M34Trnsps33(bToA);
-
-	PxU32 size = 0;
-
-	const Vec3V zeroV = V3Zero();
-	const BoolV bTrue = BTTTT();
-
-	//Vec3V v = V3UnitX();
-	Vec3V v = V3Sel(FIsGrtr(V3Dot(initialDir, initialDir), FZero()), initialDir, V3UnitX());
-
-	//const FloatV minMargin = zero;
-	//const FloatV eps2 = FMul(minMargin, FLoad(0.01f));
-	//FloatV eps2 = zero;
-	FloatV eps2 = FLoad(1e-6f);
-	const FloatV epsRel = FLoad(0.000225f);
-
-	Vec3V closA(zeroV), closB(zeroV);
-	FloatV sDist = FMax();
-	FloatV minDist = sDist;
-	Vec3V closAA = zeroV;
-	Vec3V closBB = zeroV;
-
-	BoolV bNotTerminated = bTrue;
-	BoolV bCon = bTrue;
-
-	do
-	{
-		minDist = sDist;
-		closAA = closA;
-		closBB = closB;
-
-		PxU32 index = size++;
-		PX_ASSERT(index < 4);
-
-		const Vec3V supportA = convexA.calcSupport(V3Neg(v));
-		const Vec3V supportB = M34MulV3(bToA, convexB.calcSupport(M33MulV3(aToB, v)));
-		const Vec3V support = Vec3V_From_Vec4V(Vec4V_From_Vec3V(V3Sub(supportA, supportB)));
-
-		A[index] = supportA;
-		B[index] = supportB;
-		Q[index] = support;
-
-		const FloatV signDist = V3Dot(v, support);
-		const FloatV tmp0 = FSub(sDist, signDist);
-		if (FAllGrtr(FMul(epsRel, sDist), tmp0))
-		{
-			out.mClosestA = closA;
-			out.mClosestB = closB;
-			out.mDistSq = sDist;
-			return STATUS_NON_INTERSECT;
-		}
-
-		//calculate the closest point between two convex hull
-		v = doTesselation(Q, A, B, support, supportA, supportB, size, closA, closB);
-		sDist = V3Dot(v, v);
-		bCon = FIsGrtr(minDist, sDist);
-
-		bNotTerminated = BAnd(FIsGrtr(sDist, eps2), bCon);
-	} while (BAllEq(bNotTerminated, bTrue));
-
-	out.mClosestA = V3Sel(bCon, closA, closAA);
-	out.mClosestB = V3Sel(bCon, closB, closBB);
-	out.mDistSq = FSel(bCon, sDist, minDist);
-	return Status(BAllEq(bCon, bTrue) == 1 ? STATUS_CONTACT : STATUS_DEGENERATE);
-}
-
-static void _calcSeparation(const ConvexV& convexA, const physx::PxTransform& aToWorldIn, const Mat34V& bToA, ConvexV& convexB, Output& out, Separation& sep)
-{
-	
-	Mat33V aToB = M34Trnsps33(bToA);
-	Vec3V normalA = out.getNormal();
-
-	convexA.calcExtent(normalA, sep.min0, sep.max0);
-	Vec3V normalB = M33MulV3(aToB, normalA);
-	convexB.calcExtent(normalB, sep.min1, sep.max1);
-
-	{
-		// Offset the min max taking into account transform
-		// Distance of origin from B's space in As space in direction of the normal in As space should fix it...
-		PxF32 fix;
-		FStore(V3Dot(bToA.col3, normalA), &fix);
-		sep.min1 += fix;
-		sep.max1 += fix;
-	}
-
-	// Looks like it's the plane at the midpoint
-	Vec3V center = V3Scale(V3Add(out.mClosestA, out.mClosestB), FLoad(0.5f));
-	// Transform to world space
-	Mat34V aToWorld;
-	*(PxMat44*)&aToWorld = aToWorldIn;
-	// Put the normal in world space
-	Vec3V worldCenter = M34MulV3(aToWorld, center);
-	Vec3V worldNormal = M34Mul33V3(aToWorld, normalA);
-
-	FloatV dist = V3Dot(worldNormal, worldCenter);
-	V3StoreU(worldNormal, sep.plane.n);
-	FStore(dist, &sep.plane.d);
-	sep.plane.d = -sep.plane.d;
-}
-
-static void _arrayVec3ToVec4(const PxVec3* src, Vec4V* dst, PxU32 num)
-{
-	const PxU32 num4 = num >> 2;
-	for (PxU32 i = 0; i < num4; i++, dst += 3, src += 4)
-	{
-		Vec3V v0 = V3LoadU(&src[0].x);
-		Vec3V v1 = V3LoadU(&src[1].x);
-		Vec3V v2 = V3LoadU(&src[2].x);
-		Vec3V v3 = V3LoadU(&src[3].x);
-		// Transpose
-		V4Transpose(v0, v1, v2, v3);
-		// Save 
-		dst[0] = v0;
-		dst[1] = v1;
-		dst[2] = v2;
-	}
-	const PxU32 remain = num & 3;
-	if (remain)
-	{
-		Vec3V work[4];
-		PxU32 i = 0;
-		for (; i < remain; i++) work[i] = V3LoadU(&src[i].x);
-		for (; i < 4; i++) work[i] = work[remain - 1];
-		V4Transpose(work[0], work[1], work[2], work[3]);
-		dst[0] = work[0];
-		dst[1] = work[1];
-		dst[2] = work[2];
-	}
-}
-
-
-static void _arrayVec3ToVec4(const PxVec3* src, const Vec3V& scale, Vec4V* dst, PxU32 num)
-{
-	// If no scale - use the faster version
-	if (V3AllEq(scale, V3One()))
-	{
-		return _arrayVec3ToVec4(src, dst, num);
-	}
-
-	const PxU32 num4 = num >> 2;
-	for (PxU32 i = 0; i < num4; i++, dst += 3, src += 4)
-	{
-		Vec3V v0 = V3Mul(scale, V3LoadU(&src[0].x));
-		Vec3V v1 = V3Mul(scale, V3LoadU(&src[1].x));
-		Vec3V v2 = V3Mul(scale, V3LoadU(&src[2].x));
-		Vec3V v3 = V3Mul(scale, V3LoadU(&src[3].x));
-		// Transpose
-		V4Transpose(v0, v1, v2, v3);
-		// Save 
-		dst[0] = v0;
-		dst[1] = v1;
-		dst[2] = v2;
-	}
-	const PxU32 remain = num & 3;
-	if (remain)
-	{
-		Vec3V work[4];
-		PxU32 i = 0;
-		for (; i < remain; i++) work[i] = V3Mul(scale, V3LoadU(&src[i].x));
-		for (; i < 4; i++) work[i] = work[remain - 1];
-		V4Transpose(work[0], work[1], work[2], work[3]);
-		dst[0] = work[0];
-		dst[1] = work[1];
-		dst[2] = work[2];
-	}
-}
-
-
-bool importerHullsInProximityApexFree(const std::vector<PxVec3>& hull0, PxBounds3& hull0Bounds, const physx::PxTransform& localToWorldRT0In, const physx::PxVec3& scale0In,
-	const std::vector<PxVec3>& hull1, PxBounds3& hull1Bounds, const physx::PxTransform& localToWorldRT1In, const physx::PxVec3& scale1In,
-	physx::PxF32 maxDistance, Separation* separation)
-{
-
-
-	const PxU32 numVerts0 = static_cast<PxU32>(hull0.size());
-	const PxU32 numVerts1 = static_cast<PxU32>(hull1.size());
-	const PxU32 numAov0 = (numVerts0 + 3) >> 2;
-	const PxU32 numAov1 = (numVerts1 + 3) >> 2;
-	Vec4V* verts0 = (Vec4V*)alloca((numAov0 + numAov1) * sizeof(Vec4V) * 3);
-
-	// Make sure it's aligned
-	PX_ASSERT((size_t(verts0) & 0xf) == 0);
-
-	Vec4V* verts1 = verts0 + (numAov0 * 3);
-
-	const Vec3V scale0 = V3LoadU(&scale0In.x);
-	const Vec3V scale1 = V3LoadU(&scale1In.x);
-	std::vector<PxVec3> vert0(numVerts0);
-	for (uint32_t i = 0; i < numVerts0; ++i)
-	{
-		vert0[i] = hull0[i];
-	}
-	std::vector<PxVec3> vert1(numVerts1);
-	for (uint32_t i = 0; i < numVerts1; ++i)
-	{
-		vert1[i] = hull1[i];
-	}
-
-	_arrayVec3ToVec4(&vert0[0], scale0, verts0, numVerts0);
-	_arrayVec3ToVec4(&vert1[0], scale1, verts1, numVerts1);
-
-	const PxTransform trans1To0 = localToWorldRT0In.transformInv(localToWorldRT1In);
-
-	// Load into simd mat
-	Mat34V bToA;
-	*(PxMat44*)&bToA = trans1To0;
-	(*(PxMat44*)&bToA).column3.w = 0.0f; // AOS wants the 4th component of Vec3V to be 0 to work properly
-
-	ConvexV convexA;
-	ConvexV convexB;
-
-	convexA.mNumAovVertices = numAov0;
-	convexA.mAovVertices = verts0;
-
-	convexB.mNumAovVertices = numAov1;
-	convexB.mAovVertices = verts1;
-
-	// Take the origin of B in As space as the inital direction as it is 'the difference in transform origins B-A in A's space'
-	// Should be a good first guess
-	const Vec3V initialDir = bToA.col3;
-	Output output;
-	Status status = Collide(initialDir, convexA, bToA, convexB, output);
-
-	if (status == STATUS_DEGENERATE)
-	{
-		// Calculate the tolerance from the extents
-		const PxVec3 extents0 = hull0Bounds.getExtents();
-		const PxVec3 extents1 = hull1Bounds.getExtents();
-
-		const FloatV tolerance0 = V3ExtractMin(V3Mul(V3LoadU(&extents0.x), scale0));
-		const FloatV tolerance1 = V3ExtractMin(V3Mul(V3LoadU(&extents1.x), scale1));
-
-		const FloatV tolerance = FMul(FAdd(tolerance0, tolerance1), FLoad(0.01f));
-		const FloatV sqTolerance = FMul(tolerance, tolerance);
-
-		status = FAllGrtr(sqTolerance, output.mDistSq) ? STATUS_CONTACT : STATUS_NON_INTERSECT;
-	}
-
-	switch (status)
-	{
-	case STATUS_CONTACT:
-	{
-		if (separation)
-		{
-			_calcSeparation(convexA, localToWorldRT0In, bToA, convexB, output, *separation);
-		}
-		return true;
-	}
-	default:
-	case STATUS_NON_INTERSECT:
-	{
-		if (separation)
-		{
-			_calcSeparation(convexA, localToWorldRT0In, bToA, convexB, output, *separation);
-		}
-		PxF32 val;
-		FStore(output.mDistSq, &val);
-		return val < (maxDistance * maxDistance);
-	}
-	}
-}
-
-} // namespace Blast
-} // namespace Nv
diff --git a/NvBlast/sdk/extensions/authoring/source/NvBlastExtApexSharedParts.h b/NvBlast/sdk/extensions/authoring/source/NvBlastExtApexSharedParts.h
deleted file mode 100644
index 68e0412..0000000
--- a/NvBlast/sdk/extensions/authoring/source/NvBlastExtApexSharedParts.h
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTAPEXSHAREDPARTS_H
-#define NVBLASTEXTAPEXSHAREDPARTS_H
-
-#include "NvBlast.h"
-#include <vector>
-#include <PxPlane.h>
-namespace physx
-{
-	class PxVec3;
-	class PxTransform;
-	class PxBounds3;
-}
-
-namespace Nv
-{
-namespace Blast
-{
-
-struct Separation
-{
-	physx::PxPlane	plane;
-	float	min0, max0, min1, max1;
-
-	float getDistance()
-	{
-		return physx::PxMax(min0 - max1, min1 - max0);
-	}
-};
-
-/**
-	Function to compute midplane between two convex hulls. Is copied from APEX.
-*/
-bool importerHullsInProximityApexFree(const std::vector<physx::PxVec3>& hull0, physx::PxBounds3& hull0Bounds, const physx::PxTransform& localToWorldRT0In, const physx::PxVec3& scale0In,
-	const std::vector<physx::PxVec3>& hull1, physx::PxBounds3& hull1Bounds, const physx::PxTransform& localToWorldRT1In, const physx::PxVec3& scale1In,
-	physx::PxF32 maxDistance, Separation* separation);
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // NVBLASTEXTAPEXSHAREDPARTS_H
diff --git a/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringAccelerator.cpp b/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringAccelerator.cpp
deleted file mode 100644
index 075bce9..0000000
--- a/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringAccelerator.cpp
+++ /dev/null
@@ -1,629 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastExtAuthoringAccelerator.h"
-#include "NvBlastExtAuthoringMesh.h"
-#include "NvBlastExtAuthoringInternalCommon.h"
-
-
-using namespace physx;
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-DummyAccelerator::DummyAccelerator(int32_t count) :count(count)
-{
-	current = 0;
-}
-void DummyAccelerator::setState(Vertex* pos, Edge* ed, Facet& fc)
-{
-	current = 0;
-	(void)pos;
-	(void)ed;
-	(void)fc;
-}
-void DummyAccelerator::setState(const physx::PxVec3& point) {
-	current = 0;
-	(void)point;
-}
-int32_t DummyAccelerator::getNextFacet()
-{
-	if (current < count)
-	{
-		++current;
-		return current - 1;
-	}
-	else
-		return -1;
-}
-
-
-
-BBoxBasedAccelerator::BBoxBasedAccelerator(Mesh* mesh, int32_t resolution) : mResolution(resolution), alreadyGotValue(1)
-{
-	mBounds = mesh->getBoundingBox();
-	mSpatialMap.resize(resolution * resolution * resolution);
-	mCells.resize(resolution * resolution * resolution);
-	int32_t currentCell = 0;
-	PxVec3 incr = (mBounds.maximum - mBounds.minimum) * (1.0f / mResolution);
-	for (int32_t z = 0; z < resolution; ++z)
-	{
-		for (int32_t y = 0; y < resolution; ++y)
-		{
-			for (int32_t x = 0; x < resolution; ++x)
-			{
-				mCells[currentCell].minimum.x = mBounds.minimum.x + x * incr.x;
-				mCells[currentCell].minimum.y = mBounds.minimum.y + y * incr.y;
-				mCells[currentCell].minimum.z = mBounds.minimum.z + z * incr.z;
-
-				mCells[currentCell].maximum.x = mBounds.minimum.x + (x + 1) * incr.x;
-				mCells[currentCell].maximum.y = mBounds.minimum.y + (y + 1) * incr.y;
-				mCells[currentCell].maximum.z = mBounds.minimum.z + (z + 1) * incr.z;
-
-				++currentCell;
-			}
-		}
-	}
-
-	buildAccelStructure(mesh->getVertices(), mesh->getEdges(), mesh->getFacetsBuffer(), mesh->getFacetCount());
-}
-
-
-BBoxBasedAccelerator::~BBoxBasedAccelerator()
-{
-	mResolution = 0;
-	mBounds.setEmpty();
-	mSpatialMap.clear();
-	mCells.clear();
-}
-
-int32_t BBoxBasedAccelerator::getNextFacet()
-{
-	int32_t facetId = -1;
-
-	while (mIteratorCell != -1)
-	{
-		if (mIteratorFacet >= (int32_t)mSpatialMap[mIteratorCell].size())
-		{
-			if (!cellList.empty())
-			{
-				mIteratorCell = cellList.back();
-				cellList.pop_back();
-				mIteratorFacet = 0;
-			}
-			else
-			{
-				mIteratorCell = -1;
-				break;
-			}
-		}
-		if (alreadyGotFlag[mSpatialMap[mIteratorCell][mIteratorFacet]] != alreadyGotValue)
-		{
-			facetId = mSpatialMap[mIteratorCell][mIteratorFacet];
-			mIteratorFacet++;
-			break;
-		}
-		else
-		{
-			mIteratorFacet++;
-		}
-	}
-	if (facetId != -1)
-	{
-		alreadyGotFlag[facetId] = alreadyGotValue;
-	}
-	return facetId;
-}
-void BBoxBasedAccelerator::setState(Vertex* pos, Edge* ed, Facet& fc)
-{
-	alreadyGotValue++;
-	mIteratorCell = -1;
-	mIteratorFacet = -1;
-	cellList.clear();
-	facetBox.setEmpty();
-	Edge* edge = ed + fc.firstEdgeNumber;
-	uint32_t count = fc.edgesCount;
-	for (uint32_t ec = 0; ec < count; ++ec)
-	{
-		facetBox.include(pos[edge->s].p);
-		facetBox.include(pos[edge->e].p);
-		edge++;
-	}
-	for (uint32_t i = 0; i < mCells.size(); ++i)
-	{
-		if (testCellPolygonIntersection(i, facetBox))
-		{
-			if (!mSpatialMap[i].empty())
-				cellList.push_back(i);
-		}
-	}
-	if (!cellList.empty())
-	{
-		mIteratorFacet = 0;
-		mIteratorCell = cellList.back();
-		cellList.pop_back();
-	}
-}
-
-
-void BBoxBasedAccelerator::setState(const PxVec3& p)
-{
-	alreadyGotValue++;
-	mIteratorCell = -1;
-	mIteratorFacet = -1;
-	cellList.clear();
-	int32_t perSlice = mResolution * mResolution;
-	for (uint32_t i = 0; i < mCells.size(); ++i)
-	{
-		if (mCells[i].contains(p))
-		{
-			int32_t xyCellId = i % perSlice;
-			for (int32_t zCell = 0; zCell < mResolution; ++zCell)
-			{
-				int32_t cell = zCell * perSlice + xyCellId;
-				if (!mSpatialMap[cell].empty())
-					cellList.push_back(cell);
-			}
-		}
-	}
-	if (!cellList.empty())
-	{
-		mIteratorFacet = 0;
-		mIteratorCell = cellList.back();
-		cellList.pop_back();
-	}
-}
-
-
-bool BBoxBasedAccelerator::testCellPolygonIntersection(int32_t cellId, PxBounds3& facetBB)
-{
-	if (weakBoundingBoxIntersection(mCells[cellId], facetBB))
-	{
-		return true;
-	}
-	else
-		return false;
-}
-
-void BBoxBasedAccelerator::buildAccelStructure(Vertex* pos, Edge* edges, Facet* fc, int32_t facetCount)
-{
-	for (int32_t facet = 0; facet < facetCount; ++facet)
-	{
-		PxBounds3 bBox;
-		bBox.setEmpty();
-		Edge* edge = &edges[0] + fc->firstEdgeNumber;
-		int32_t count = fc->edgesCount;
-		for (int32_t ec = 0; ec < count; ++ec)
-		{
-			bBox.include(pos[edge->s].p);
-			bBox.include(pos[edge->e].p);
-			edge++;
-		}
-
-		for (uint32_t i = 0; i < mCells.size(); ++i)
-		{
-			if (testCellPolygonIntersection(i, bBox))
-			{
-				mSpatialMap[i].push_back(facet);
-			}
-		}
-		fc++;
-	}
-	alreadyGotFlag.resize(facetCount, 0);
-	cellList.resize(mCells.size());
-}
-
-int32_t testEdgeAgainstCube(PxVec3& p1, PxVec3& p2)
-{
-	PxVec3 vec = p2 - p1;
-	PxVec3 vecSigns;
-	for (int32_t i = 0; i < 3; ++i)
-	{
-		vecSigns[i] = (vec[i] < 0) ? -1 : 1;
-	}
-	for (int32_t i = 0; i < 3; ++i)
-	{
-		if (p1[i] * vecSigns[i] > 0.5f) return 0;
-		if (p2[i] * vecSigns[i] < -0.5f) return 0;
-	}
-
-	for (int32_t i = 0; i < 3; ++i)
-	{
-		int32_t ip1 = (i + 1) % 3;
-		int32_t ip2 = (i + 2) % 3;
-
-		float vl1 = vec[ip2] * p1[ip1] - vec[ip1] * p1[ip2];
-		float vl2 = 0.5f * (vec[ip2] * vecSigns[ip1] + vec[ip1] * vecSigns[ip2]);
-		if (vl1 * vl1 > vl2 * vl2)
-		{
-			return 0;
-		}
-	}
-	return 1;
-}
-
-NV_INLINE int32_t isInSegm(float a, float b, float c)
-{
-	return (b >= c) - (a >= c);
-}
-
-NV_INLINE int32_t edgeIsAbovePoint(PxVec2& p1, PxVec2& p2, PxVec2& p)
-{
-	int32_t direction = isInSegm(p1.x, p2.x, p.x);
-	if (direction != 0)
-	{
-		if (isInSegm(p1.y, p2.y, p.y))
-		{
-			if (direction * (p.x - p1.x) * (p2.y - p1.y) >= direction * (p.y - p1.y) * (p2.x - p1.x))
-			{
-				return direction;
-			}
-		}
-		else
-		{
-			if (p1.y > p.y)
-				return direction;
-		}		
-	}
-	return 0;
-}
-
-int32_t pointInPolygon(PxVec3* vertices, PxVec3& diagPoint, int32_t edgeCount, PxVec3& normal)
-{
-	std::vector<PxVec2> projectedVertices(edgeCount * 2);
-	ProjectionDirections pDir = getProjectionDirection(normal);
-	PxVec2 projectedDiagPoint = getProjectedPoint(diagPoint, pDir);
-	PxVec2* saveVert = projectedVertices.data();
-	PxVec3* p = vertices;
-	for (int32_t i = 0; i < edgeCount * 2; ++i)
-	{
-		*saveVert = getProjectedPoint(*p, pDir);
-		++saveVert;
-		++p;
-	}	
-	int32_t counter = 0;
-	PxVec2* v = projectedVertices.data();
-	for (int32_t i = 0; i < edgeCount; ++i)
-	{
-		PxVec2& p1 = *v;
-		PxVec2& p2 = *(v + 1);
-		counter += edgeIsAbovePoint(p1, p2, projectedDiagPoint);
-		v += 2;
-	}
-	return counter != 0;
-}
-
-
-
-int32_t testFacetUnitCubeIntersectionInternal(PxVec3* vertices,PxVec3& facetNormal, int32_t edgeCount)
-{
-	PxVec3* pnt_p = vertices;
-	for (int32_t i = 0; i < edgeCount; ++i)
-	{
-		if (testEdgeAgainstCube(*pnt_p, *(pnt_p + 1)) == 1)
-		{
-			return 1;
-		}
-		pnt_p += 2;
-	}
-
-	PxVec3 cubeDiag(0, 0, 0);
-	for (int32_t i = 0; i < 3; ++i)
-		cubeDiag[i] = (facetNormal[i] < 0) ? -1 : 1;
-	float t = vertices->dot(facetNormal) / (cubeDiag.dot(facetNormal));
-	if (t > 0.5 || t < -0.5)
-		return 0;
-	
-	PxVec3 intersPoint = cubeDiag * t;
-	int trs = pointInPolygon(vertices, intersPoint, edgeCount, facetNormal);
-	return trs;
-}
-
-enum TrivialFlags
-{
-	HAS_POINT_BELOW_HIGH_X = ~(1 << 0),
-	HAS_POINT_ABOVE_LOW_X = ~(1 << 1),
-
-	HAS_POINT_BELOW_HIGH_Y = ~(1 << 2),
-	HAS_POINT_ABOVE_LOW_Y = ~(1 << 3),
-
-	HAS_POINT_BELOW_HIGH_Z = ~(1 << 4),
-	HAS_POINT_ABOVE_LOW_Z = ~(1 << 5),
-
-
-
-	ALL_ONE = (1 << 6) - 1
-};
-
-
-
-
-
-int32_t testFacetUnitCubeIntersection(Vertex* vertices, Edge* edges, Facet& fc, PxBounds3 cube, float fattening)
-{
-	Edge* ed = edges + fc.firstEdgeNumber;
-	int32_t trivialFlags = ALL_ONE;
-	cube.fattenFast(fattening);
-	for (uint32_t i = 0; i < fc.edgesCount; ++i)
-	{
-		{
-			PxVec3& p = vertices[ed->s].p;
-			if (cube.contains(p))
-				return 1;
-			if (p.x < cube.getCenter().x + 0.5)
-				trivialFlags &= HAS_POINT_BELOW_HIGH_X;
-			if (p.x > cube.getCenter().x - 0.5)
-				trivialFlags &= HAS_POINT_ABOVE_LOW_X;
-
-			if (p.y < cube.getCenter().y + 0.5)
-				trivialFlags &= HAS_POINT_BELOW_HIGH_Y;
-			if (p.y > cube.getCenter().y - 0.5)
-				trivialFlags &= HAS_POINT_ABOVE_LOW_Y;
-
-			if (p.z < cube.getCenter().z + 0.5)
-				trivialFlags &= HAS_POINT_BELOW_HIGH_Z;
-			if (p.z > cube.getCenter().z - 0.5)
-				trivialFlags &= HAS_POINT_ABOVE_LOW_Z;
-		}
-		{
-			PxVec3& p = vertices[ed->e].p;
-			if (cube.contains(p))
-				return 1;
-			if (p.x < cube.getCenter().x + 0.5)
-				trivialFlags &= HAS_POINT_BELOW_HIGH_X;
-			if (p.x > cube.getCenter().x - 0.5)
-				trivialFlags &= HAS_POINT_ABOVE_LOW_X;
-
-			if (p.y < cube.getCenter().y + 0.5)
-				trivialFlags &= HAS_POINT_BELOW_HIGH_Y;
-			if (p.y > cube.getCenter().y - 0.5)
-				trivialFlags &= HAS_POINT_ABOVE_LOW_Y;
-
-			if (p.z < cube.getCenter().z + 0.5)
-				trivialFlags &= HAS_POINT_BELOW_HIGH_Z;
-			if (p.z > cube.getCenter().z - 0.5)
-				trivialFlags &= HAS_POINT_ABOVE_LOW_Z;
-		}
-
-		++ed;
-	}
-	if (trivialFlags != 0)
-	{
-		return 0;
-	}
-	std::vector<PxVec3> verticesRescaled(fc.edgesCount * 2);
-	
-	int32_t vrt = 0;
-	ed = edges + fc.firstEdgeNumber;
-	PxVec3 offset = cube.getCenter();
-	PxVec3 normal(1, 1, 1);
-	
-	/**
-		Compute normal
-	*/
-	PxVec3& v1 = vertices[ed->s].p;
-	PxVec3* v2 = nullptr;
-	PxVec3* v3 = nullptr;
-	
-	for (uint32_t i = 0; i < fc.edgesCount; ++i)
-	{
-		if (v1 != vertices[ed->s].p)
-		{
-			v2 = &vertices[ed->s].p;
-			break;
-		}
-		if (v1 != vertices[ed->e].p)
-		{
-			v2 = &vertices[ed->e].p;
-			break;
-		}
-		ed++;
-	}
-	ed = edges + fc.firstEdgeNumber;
-	for (uint32_t i = 0; i < fc.edgesCount; ++i)
-	{
-		if (v1 != vertices[ed->s].p && *v2 != vertices[ed->s].p)
-		{
-			v3 = &vertices[ed->s].p;
-			break;
-		}
-		if (v1 != vertices[ed->e].p && *v2 != vertices[ed->e].p)
-		{
-			v3 = &vertices[ed->e].p;
-			break;
-		}
-		ed++;
-	}
-	ed = edges + fc.firstEdgeNumber;
-	if (v2 != nullptr && v3 != nullptr)
-	{
-		normal = (*v2 - v1).cross(*v3 - v1); 
-	}
-	else
-	{
-		return true; // If cant find normal, assume it intersects box.
-	}
-
-	
-	normal.normalize();
-
-	PxVec3 rescale(.5f / (cube.getExtents().x), .5f / (cube.getExtents().y), 0.5f / (cube.getExtents().z));
-	for (uint32_t i = 0; i < fc.edgesCount; ++i)
-	{
-		verticesRescaled[vrt] = vertices[ed->s].p - offset;
-		verticesRescaled[vrt].x *= rescale.x;
-		verticesRescaled[vrt].y *= rescale.y;
-		verticesRescaled[vrt].z *= rescale.z;
-		++vrt;
-		verticesRescaled[vrt] = vertices[ed->e].p - offset;
-		verticesRescaled[vrt].x *= rescale.x;
-		verticesRescaled[vrt].y *= rescale.y;
-		verticesRescaled[vrt].z *= rescale.z;
-		++ed;
-		++vrt;
-	}
-	return testFacetUnitCubeIntersectionInternal(verticesRescaled.data(), normal, fc.edgesCount);
-}
-
-
-IntersectionTestingAccelerator::IntersectionTestingAccelerator(Mesh* in, int32_t resolution)
-{
-
-
-	alreadyGotFlag.resize(in->getFacetCount(), 0);
-	alreadyGotValue = 0;
-	mResolution = resolution;
-
-	float cubeSize = 1.0f / resolution;
-	PxVec3 cubeMinimal(-0.5, -0.5, -0.5);
-	PxVec3 extents(cubeSize, cubeSize, cubeSize);
-	mCubes.resize(mResolution * mResolution * mResolution);
-	mSpatialMap.resize(mCubes.size());
-	int32_t cubeId = 0;
-
-	// Build unit cube partition
-	for (int32_t i = 0; i < mResolution; ++i)
-	{				
-		cubeMinimal.y = -0.5;
-		cubeMinimal.z = -0.5;
-		for (int32_t j = 0; j < mResolution; ++j)
-		{
-			cubeMinimal.z = -0.5;			
-			for (int32_t k = 0; k < mResolution; ++k)
-			{				
-				mCubes[cubeId].minimum = cubeMinimal;
-				mCubes[cubeId].maximum = cubeMinimal + extents;
-				cubeMinimal.z += cubeSize;
-				++cubeId;
-			}
-			cubeMinimal.y += cubeSize;
-		}
-		cubeMinimal.x += cubeSize;
-	}
-	
-
-	for (uint32_t i = 0; i < in->getFacetCount(); ++i)
-	{
-		for (uint32_t c = 0; c < mCubes.size(); ++c)
-		{
-			if (testFacetUnitCubeIntersection(in->getVertices(), in->getEdges(), *in->getFacet(i), mCubes[c], 0.001))
-			{
-				mSpatialMap[c].push_back(i);
-			}
-		}
-	}
-}
-
-
-int32_t IntersectionTestingAccelerator::getNextFacet()
-{
-	int32_t facetId = -1;
-
-	while (mIteratorCell != -1)
-	{
-		if (mIteratorFacet >= (int32_t)mSpatialMap[mIteratorCell].size())
-		{
-			if (!cellList.empty())
-			{
-				mIteratorCell = cellList.back();
-				cellList.pop_back();
-				mIteratorFacet = 0;
-			}
-			else
-			{
-				mIteratorCell = -1;
-				break;
-			}
-		}
-		if (alreadyGotFlag[mSpatialMap[mIteratorCell][mIteratorFacet]] != alreadyGotValue)
-		{
-			facetId = mSpatialMap[mIteratorCell][mIteratorFacet];
-			mIteratorFacet++;
-			break;
-		}
-		else
-		{
-			mIteratorFacet++;
-		}
-	}
-	if (facetId != -1)
-	{
-		alreadyGotFlag[facetId] = alreadyGotValue;
-	}
-	return facetId;
-}
-
-void IntersectionTestingAccelerator::setState(Vertex* pos, Edge* ed, Facet& fc)
-{
-	alreadyGotValue++;
-	mIteratorCell = -1;
-	mIteratorFacet = -1;
-	cellList.clear();
-	PxBounds3 bigBox(PxVec3(-0.5, -0.5, -0.5), PxVec3(0.5, 0.5, 0.5));
-	if (!testFacetUnitCubeIntersection(pos, ed, fc, bigBox, 0.001f))
-	{
-		return;
-	}
-	for (uint32_t i = 0; i < mCubes.size(); ++i)
-	{
-		if (testFacetUnitCubeIntersection(pos, ed, fc, mCubes[i], 0.001f))
-		{
-			if (!mSpatialMap[i].empty())
-				cellList.push_back(i);
-		}
-	}
-	if (!cellList.empty())
-	{
-		mIteratorFacet = 0;
-		mIteratorCell = cellList.back();
-		cellList.pop_back();
-	}
-}
-
-void IntersectionTestingAccelerator::setState(const PxVec3& p)
-{
-	alreadyGotValue++;
-	mIteratorCell = -1;
-	mIteratorFacet = -1;
-	cellList.clear();
-	
-	
-	for (uint32_t i = 0; i < mCubes.size(); ++i)
-	{		
-		PxBounds3 tmp = mCubes[i];
-		tmp.fattenFast(0.001);
-		if (tmp.contains(p))
-		{
-			int32_t xyCellId = (((int)((float)i / mResolution)) * mResolution);
-			for (int32_t zCell = 0; zCell < mResolution; ++zCell)
-			{
-				int32_t cell = zCell + xyCellId;
-				if (!mSpatialMap[cell].empty())
-				{
-					cellList.push_back(cell);
-				}
-					
-			}
-		}
-	}
-	if (!cellList.empty())
-	{
-		mIteratorFacet = 0;
-		mIteratorCell = cellList.back();
-		cellList.pop_back();
-	}
-}
-
-
-} // namespace Blast
-} // namespace Nv
diff --git a/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringAccelerator.h b/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringAccelerator.h
deleted file mode 100644
index 8284cd7..0000000
--- a/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringAccelerator.h
+++ /dev/null
@@ -1,147 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef 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.
-		\param[in] pos Vertex buffer
-		\param[in] ed Edge buffer
-		\param[in] fc Facet which should be tested.
-	*/
-	virtual void	setState(Vertex* pos, Edge* ed, 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 ~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(Vertex* pos, Edge* ed, Facet& fc);
-	virtual void setState(const physx::PxVec3& point);
-	virtual int32_t getNextFacet();
-
-private:
-	int32_t count;
-	int32_t current;
-};
-
-/**
-	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(Mesh* mesh, int32_t resolution);
-	virtual ~BBoxBasedAccelerator();
-	int32_t getNextFacet();
-	void setState(Vertex* pos, Edge* ed, Facet& fc);
-	void setState(const physx::PxVec3& p);
-private:
-
-	bool testCellPolygonIntersection(int32_t cellId, physx::PxBounds3& facetBB);
-	void buildAccelStructure(Vertex* pos, Edge* edges, Facet* fc, int32_t facetCount);
-
-	int32_t mResolution;
-	physx::PxBounds3 mBounds;
-	physx::PxBounds3 facetBox;
-	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 mIteratorCell;
-	int32_t mIteratorFacet;
-};
-
-
-
-/**
-	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 are intersected by 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.
-
-	In difference with BBoxBasedAccelerator this accelerator computes actual intersection of cube with polygon. It is more precise and omits much more intersections but slower.
-*/
-
-class IntersectionTestingAccelerator : public SpatialAccelerator
-{
-public:
-	IntersectionTestingAccelerator(Mesh* mesh, int32_t resolution);
-	int32_t getNextFacet();
-	void setState(Vertex* pos, Edge* ed, Facet& fc);
-	void setState(const physx::PxVec3& p);
-
-
-private:
-	std::vector< std::vector<int32_t> > mSpatialMap;
-	std::vector<physx::PxBounds3> mCubes;
-	int32_t mResolution;
-
-	// Iterator data
-	std::vector<uint32_t> alreadyGotFlag;
-	uint32_t alreadyGotValue;
-	std::vector<int32_t> cellList;
-	int32_t mIteratorCell;
-	int32_t mIteratorFacet;
-};
-
-} // namespace Blast
-} // namsepace Nv
-
-
-#endif // ifndef NVBLASTEXTAUTHORINGACCELERATOR_H
diff --git a/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringBondGenerator.cpp b/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringBondGenerator.cpp
deleted file mode 100644
index b2c3883..0000000
--- a/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringBondGenerator.cpp
+++ /dev/null
@@ -1,991 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-// This warning arises when using some stl containers with older versions of VC
-// c:\program files (x86)\microsoft visual studio 12.0\vc\include\xtree(1826): warning C4702: unreachable code
-#include "NvPreprocessor.h"
-#if NV_VC && NV_VC < 14
-#pragma warning(disable : 4702)
-#endif
-
-#include <NvBlastExtAuthoringBondGenerator.h>
-#include <NvBlastTypes.h>
-#include <NvBlast.h>
-#include "NvBlastExtTriangleProcessor.h"
-#include "NvBlastExtApexSharedParts.h"
-#include "NvBlastExtAuthoringCollisionBuilder.h"
-#include "NvBlastExtAuthoringInternalCommon.h"
-#include <vector>
-#include <map>
-#include <PxPlane.h>
-#include <algorithm>
-#include <cmath>
-
-using physx::PxVec3;
-using physx::PxBounds3;
-
-//#define DEBUG_OUTPUT
-#ifdef DEBUG_OUTPUT
-
-void saveGeometryToObj(std::vector<PxVec3>& triangles, const char* filepath)
-{
-	
-	FILE* outStream = fopen(filepath, "w");
-
-	for (uint32_t i = 0; i < triangles.size(); ++i)
-	{
-		fprintf(outStream, "v %lf %lf %lf\n", triangles[i].x, triangles[i].y, triangles[i].z);
-		++i;
-		fprintf(outStream, "v %lf %lf %lf\n", triangles[i].x, triangles[i].y, triangles[i].z);
-		++i;
-		fprintf(outStream, "v %lf %lf %lf\n", triangles[i].x, triangles[i].y, triangles[i].z);
-	}
-	for (uint32_t i = 0; i < triangles.size() / 3; ++i)
-	{
-		PxVec3 normal = (triangles[3 * i + 2] - triangles[3 * i]).cross((triangles[3 * i + 1] - triangles[3 * i])).getNormalized();
-		fprintf(outStream, "vn %lf %lf %lf\n", normal.x, normal.y, normal.z);
-		fprintf(outStream, "vn %lf %lf %lf\n", normal.x, normal.y, normal.z);
-		fprintf(outStream, "vn %lf %lf %lf\n", normal.x, normal.y, normal.z);
-	}
-	int indx = 1;
-	for (uint32_t i = 0; i < triangles.size() / 3; ++i)
-	{
-		fprintf(outStream, "f %d//%d  ", indx, indx);
-		indx++;
-		fprintf(outStream, "%d//%d  ", indx, indx);
-		indx++;
-		fprintf(outStream, "%d//%d \n", indx, indx);
-		indx++;
-	}
-
-	fclose(outStream);
-
-}
-
-
-std::vector<PxVec3> intersectionBuffer;
-std::vector<PxVec3> meshBuffer;
-#endif 
-
-namespace Nv
-{
-	namespace Blast
-	{
-
-		#define EPS_PLANE 0.0001f
-				
-		bool planeComparer(const PlaneChunkIndexer& as, const PlaneChunkIndexer& bs)
-			{
-				const PxPlane& a = as.plane;
-				const PxPlane& b = bs.plane;
-
-				if (a.d + EPS_PLANE < b.d)		return true;
-				if (a.d - EPS_PLANE > b.d)		return false;
-				if (a.n.x + EPS_PLANE < b.n.x) return true;
-				if (a.n.x - EPS_PLANE > b.n.x) return false;
-				if (a.n.y + EPS_PLANE < b.n.y) return true;
-				if (a.n.y - EPS_PLANE > b.n.y) return false;
-				return a.n.z + EPS_PLANE < b.n.z;
-			}
-
-
-		struct Bond
-		{
-			int32_t m_chunkId;
-			int32_t m_planeIndex;
-			int32_t triangleIndex;
-
-			bool operator<(const Bond& inp) const
-			{
-				if (abs(m_planeIndex) == abs(inp.m_planeIndex))
-				{
-					return m_chunkId < inp.m_chunkId;
-				}
-				else
-				{
-					return abs(m_planeIndex) < abs(inp.m_planeIndex);
-				}
-			}
-		};
-
-
-		struct BondInfo
-		{
-			float area;
-			physx::PxBounds3 m_bb;
-			physx::PxVec3 centroid;
-			physx::PxVec3 normal;
-			int32_t m_chunkId;
-		};
-
-
-		float BlastBondGenerator::processWithMidplanes(TriangleProcessor* trProcessor, const std::vector<PxVec3>& chunk1Points, const std::vector<PxVec3>& chunk2Points,
-			const std::vector<PxVec3>& hull1p, const std::vector<PxVec3>& hull2p, PxVec3& normal, PxVec3& centroid)
-		{
-			PxBounds3 bounds;
-			PxBounds3 aBounds;
-			PxBounds3 bBounds;
-			bounds.setEmpty();
-			aBounds.setEmpty();
-			bBounds.setEmpty();
-
-			PxVec3 chunk1Centroid(0, 0, 0);
-			PxVec3 chunk2Centroid(0, 0, 0);
-
-			///////////////////////////////////////////////////////////////////////////////////
-			if (chunk1Points.size() < 4 || chunk2Points.size() < 4)
-			{
-				return 0.0;
-			}
-
-			for (uint32_t i = 0; i < chunk1Points.size(); ++i)
-			{
-				chunk1Centroid += chunk1Points[i];
-				bounds.include(chunk1Points[i]);
-				aBounds.include(chunk1Points[i]);
-			}
-			for (uint32_t i = 0; i < chunk2Points.size(); ++i)
-			{
-				chunk2Centroid += chunk2Points[i];
-				bounds.include(chunk2Points[i]);
-				bBounds.include(chunk2Points[i]);
-			}
-
-
-			chunk1Centroid *= (1.0f / chunk1Points.size());
-			chunk2Centroid *= (1.0f / chunk2Points.size());
-
-			Separation separation;
-			if (!importerHullsInProximityApexFree(hull1p, aBounds, PxTransform(PxIdentity), PxVec3(1, 1, 1), hull2p, bBounds, PxTransform(PxIdentity), PxVec3(1, 1, 1), 0.000, &separation))
-			{
-				return 0.0;
-			}
-
-			// Build first plane interface
-			PxPlane midplane = separation.plane;
-			if (!midplane.n.isFinite())
-			{
-				return 0.0;
-			}
-			std::vector<PxVec3> interfacePoints;
-
-			float firstCentroidSide = midplane.distance(chunk1Centroid);
-			float secondCentroidSide = midplane.distance(chunk2Centroid);
-
-			for (uint32_t i = 0; i < chunk1Points.size(); ++i)
-			{
-				float dst = midplane.distance(chunk1Points[i]);
-				if (dst * firstCentroidSide < 0)
-				{
-					interfacePoints.push_back(chunk1Points[i]);
-				}
-			}
-
-			for (uint32_t i = 0; i < chunk2Points.size(); ++i)
-			{
-				float dst = midplane.distance(chunk2Points[i]);
-				if (dst * secondCentroidSide < 0)
-				{
-					interfacePoints.push_back(chunk2Points[i]);
-				}
-			}
-			std::vector<PxVec3> convexHull;
-			trProcessor->buildConvexHull(interfacePoints, convexHull, midplane.n);
-			float area = 0;
-			PxVec3 centroidLocal(0, 0, 0);
-			if (convexHull.size() < 3)
-			{
-				return 0.0;
-			}
-			for (uint32_t i = 0; i < convexHull.size() - 1; ++i)
-			{
-				centroidLocal += convexHull[i];
-				area += (convexHull[i] - convexHull[0]).cross((convexHull[i + 1] - convexHull[0])).magnitude();
-			}
-			centroidLocal += convexHull.back();
-			centroidLocal *= (1.0f / convexHull.size());
-			float direction = midplane.n.dot(chunk2Centroid - chunk1Centroid);
-			if (direction < 0)
-			{
-				normal = -1.0f * normal;
-			}
-			normal = midplane.n;
-			centroid = centroidLocal;
-			return area * 0.5f;
-		}
-
-
-		int32_t BlastBondGenerator::bondsFromPrefractured(const std::vector<std::vector<Triangle>>& geometry, const std::vector<bool>& chunkIsSupport, std::vector<NvBlastBondDesc>& resultBondDescs, BondGenerationConfig conf)
-		{
-			int32_t ret_val = 0;
-			switch (conf.bondMode)
-			{
-			case BondGenerationConfig::AVERAGE:
-				ret_val = createFullBondListAveraged(geometry, chunkIsSupport, resultBondDescs, conf);
-				break;
-			case BondGenerationConfig::EXACT:
-				ret_val = createFullBondListExact(geometry, chunkIsSupport, resultBondDescs, conf);
-				break;
-			}
-			return ret_val;
-		}
-
-		int32_t BlastBondGenerator::createFullBondListAveraged(const std::vector<std::vector<Triangle>>& chunksGeometry, const std::vector<bool>& supportFlags, std::vector<NvBlastBondDesc>& mResultBondDescs, BondGenerationConfig conf)
-		{
-			NV_UNUSED(conf);
-
-			std::vector<std::vector<PxVec3> > chunksPoints(chunksGeometry.size());
-
-			for (uint32_t i = 0; i < chunksGeometry.size(); ++i)
-			{
-				if (!supportFlags[i])
-				{
-					continue;
-				}
-				for (uint32_t j = 0; j < chunksGeometry[i].size(); ++j)
-				{
-					chunksPoints[i].push_back(chunksGeometry[i][j].a.p);
-					chunksPoints[i].push_back(chunksGeometry[i][j].b.p);
-					chunksPoints[i].push_back(chunksGeometry[i][j].c.p);
-				}
-			}
-
-			Nv::Blast::ConvexMeshBuilder builder(mPxCooking, mPxInsertionCallback);
-
-			std::vector<CollisionHull> cHulls(chunksGeometry.size());
-
-			for (uint32_t i = 0; i < chunksGeometry.size(); ++i)
-			{
-				if (!supportFlags[i])
-				{
-					continue;
-				}
-				builder.buildCollisionGeometry(chunksPoints[i], cHulls[i]);
-			}
-
-			std::vector<std::vector<PxVec3> > hullPoints(cHulls.size());
-
-			for (uint32_t chunk = 0; chunk < cHulls.size(); ++chunk)
-			{
-				if (!supportFlags[chunk])
-				{
-					continue;
-				}
-
-				hullPoints[chunk].resize(cHulls[chunk].points.size());
-				for (uint32_t i = 0; i < cHulls[chunk].points.size(); ++i)
-				{
-					hullPoints[chunk][i].x = cHulls[chunk].points[i].x;
-					hullPoints[chunk][i].y = cHulls[chunk].points[i].y;
-					hullPoints[chunk][i].z = cHulls[chunk].points[i].z;
-				}
-			}
-
-			TriangleProcessor trProcessor;
-
-			for (uint32_t i = 0; i < chunksGeometry.size(); ++i)
-			{
-				if (!supportFlags[i])
-				{
-					continue;
-				}
-				for (uint32_t j = i + 1; j < chunksGeometry.size(); ++j)
-				{
-					if (!supportFlags[i])
-					{
-						continue;
-					}
-					PxVec3 normal;
-					PxVec3 centroid;
-
-					float area = processWithMidplanes(&trProcessor, chunksPoints[i], chunksPoints[j], hullPoints[i], hullPoints[j], normal, centroid);
-
-					if (area > 0)
-					{
-						NvBlastBondDesc bDesc;
-						bDesc.chunkIndices[0] = i;
-						bDesc.chunkIndices[1] = j;
-						bDesc.bond.area = area;
-						bDesc.bond.centroid[0] = centroid.x;
-						bDesc.bond.centroid[1] = centroid.y;
-						bDesc.bond.centroid[2] = centroid.z;
-
-						bDesc.bond.normal[0] = normal.x;
-						bDesc.bond.normal[1] = normal.y;
-						bDesc.bond.normal[2] = normal.z;
-
-
-						mResultBondDescs.push_back(bDesc);
-					}
-
-				}
-			}
-
-			return 0;
-		}
-
-		uint32_t isSamePlane(PxPlane& a, PxPlane& b)
-		{
-			if (PxAbs(a.d - b.d) > EPS_PLANE) return 0;
-			if (PxAbs(a.n.x - b.n.x) > EPS_PLANE) return 0;
-			if (PxAbs(a.n.y - b.n.y) > EPS_PLANE) return 0;
-			if (PxAbs(a.n.z - b.n.z) > EPS_PLANE) return 0;
-			return 1;
-		}
-
-		int32_t BlastBondGenerator::createFullBondListExact(const std::vector<std::vector<Triangle>>& chunksGeometry, const std::vector<bool>& supportFlags, std::vector<NvBlastBondDesc>& mResultBondDescs, BondGenerationConfig conf)
-		{		
-			std::vector < PlaneChunkIndexer > planeTriangleMapping;
-			NV_UNUSED(conf);
-			for (uint32_t i = 0; i < chunksGeometry.size(); ++i)
-			{
-				if (!supportFlags[i])
-				{
-					continue;
-				}
-				for (uint32_t j = 0; j < chunksGeometry[i].size(); ++j)
-				{
-#ifdef DEBUG_OUTPUT
-					meshBuffer.push_back(chunksGeometry[i][j].a.p );
-					meshBuffer.push_back(chunksGeometry[i][j].b.p);
-					meshBuffer.push_back(chunksGeometry[i][j].c.p );
-#endif
-
-					PxPlane nPlane = PxPlane(chunksGeometry[i][j].a.p, chunksGeometry[i][j].b.p, chunksGeometry[i][j].c.p);
-					planeTriangleMapping.push_back(PlaneChunkIndexer(i, j, nPlane));
-				}
-			}
-
-			std::sort(planeTriangleMapping.begin(), planeTriangleMapping.end(), planeComparer);
-			return createFullBondListExactInternal(chunksGeometry, planeTriangleMapping, mResultBondDescs);
-		}
-
-		void BlastBondGenerator::buildGeometryCache(const std::vector<std::vector<Triangle> >& geometry)
-		{
-			mGeometryCache = geometry;
-			mHullsPointsCache.resize(geometry.size());
-			mBoundsCache.resize(geometry.size());
-			mCHullCache.resize(geometry.size());
-			for (uint32_t i = 0; i < mGeometryCache.size(); ++i)
-			{
-				for (uint32_t j = 0; j < mGeometryCache[i].size(); ++j)
-				{
-
-					PxPlane nPlane = PxPlane(mGeometryCache[i][j].a.p, mGeometryCache[i][j].b.p, mGeometryCache[i][j].c.p);
-					mPlaneCache.push_back(PlaneChunkIndexer(i, j, nPlane));
-				}
-			}
-
-			for (uint32_t ch = 0; ch < mGeometryCache.size(); ++ch)
-			{
-				std::vector<PxVec3>  chunksPoints(mGeometryCache[ch].size() * 3);
-
-				int32_t sp = 0;
-				for (uint32_t i = 0; i < mGeometryCache[ch].size(); ++i)
-				{
-					chunksPoints[sp++] = mGeometryCache[ch][i].a.p;
-					chunksPoints[sp++] = mGeometryCache[ch][i].b.p;
-					chunksPoints[sp++] = mGeometryCache[ch][i].c.p;
-				}
-
-				Nv::Blast::ConvexMeshBuilder builder(mPxCooking, mPxInsertionCallback);
-
-				CollisionHull& cHull = mCHullCache[ch];
-
-				builder.buildCollisionGeometry(chunksPoints, cHull);
-
-				mHullsPointsCache[ch].resize(cHull.points.size());
-
-				mBoundsCache[ch].setEmpty();
-				for (uint32_t i = 0; i < cHull.points.size(); ++i)
-				{
-					mHullsPointsCache[ch][i].x = cHull.points[i].x;
-					mHullsPointsCache[ch][i].y = cHull.points[i].y;
-					mHullsPointsCache[ch][i].z = cHull.points[i].z;
-					mBoundsCache[ch].include(mHullsPointsCache[ch][i]);
-				}
-			}
-		}
-
-		void BlastBondGenerator::resetGeometryCache()
-		{			
-			mGeometryCache.clear();
-			mPlaneCache.clear();
-			mHullsPointsCache.clear();
-			mCHullCache.clear();
-			mBoundsCache.clear();
-		}
-
-		int32_t BlastBondGenerator::createFullBondListExactInternal(const std::vector<std::vector<Triangle>>& chunksGeometry, std::vector < PlaneChunkIndexer >& planeTriangleMapping, std::vector<NvBlastBondDesc>& mResultBondDescs)
-		{
-			std::map<std::pair<int32_t, int32_t>, std::pair<NvBlastBondDesc, int32_t> > bonds;
-
-			TriangleProcessor trPrc;
-			std::vector<PxVec3> intersectionBufferLocal;
-
-			NvBlastBondDesc cleanBond;
-			memset(&cleanBond, 0, sizeof(NvBlastBondDesc));
-			for (uint32_t tIndex = 0; tIndex < planeTriangleMapping.size(); ++tIndex)
-			{
-				
-				PlaneChunkIndexer opp = planeTriangleMapping[tIndex];
-
-				opp.plane.d *= -1;
-				opp.plane.n *= -1;
-
-				uint32_t startIndex = (uint32_t)(std::lower_bound(planeTriangleMapping.begin(), planeTriangleMapping.end(), opp, planeComparer) - planeTriangleMapping.begin());
-				uint32_t endIndex = (uint32_t)(std::upper_bound(planeTriangleMapping.begin(), planeTriangleMapping.end(), opp, planeComparer) - planeTriangleMapping.begin());
-				//	uint32_t startIndex = 0;
-				//	uint32_t endIndex = (uint32_t)planeTriangleMapping.size();
-
-				PlaneChunkIndexer& mappedTr = planeTriangleMapping[tIndex];
-				const Triangle& trl = chunksGeometry[mappedTr.chunkId][mappedTr.trId];
-				PxPlane pln = mappedTr.plane;
-				TrPrcTriangle trp(trl.a.p, trl.b.p, trl.c.p);
-				PxVec3 trCentroid = (trl.a.p + trl.b.p + trl.c.p) * (1.0f / 3.0f);
-				trp.points[0] -= trCentroid;
-				trp.points[1] -= trCentroid;
-				trp.points[2] -= trCentroid;
-				ProjectionDirections pDir = getProjectionDirection(pln.n);
-				TrPrcTriangle2d trp2d;
-				trp2d.points[0] = getProjectedPointWithWinding(trp.points[0], pDir);
-				trp2d.points[1] = getProjectedPointWithWinding(trp.points[1], pDir);
-				trp2d.points[2] = getProjectedPointWithWinding(trp.points[2], pDir);
-
-				for (uint32_t i = startIndex; i <= endIndex && i < planeTriangleMapping.size(); ++i)
-				{
-					PlaneChunkIndexer& mappedTr2 = planeTriangleMapping[i];
-					if (mappedTr2.trId == opp.chunkId)
-					{
-						continue;
-					}
-
-					if (!isSamePlane(opp.plane, mappedTr2.plane))
-					{
-						continue;
-					}
-					
-					if (mappedTr.chunkId == mappedTr2.chunkId)
-					{
-						continue;
-					}
-					std::pair<int32_t, int32_t> bondEndPoints = std::make_pair(mappedTr.chunkId, mappedTr2.chunkId);
-					if (bondEndPoints.second < bondEndPoints.first) continue;
-					std::pair<int32_t, int32_t> bondEndPointsSwapped = std::make_pair(mappedTr2.chunkId, mappedTr.chunkId);
-					if (bonds.find(bondEndPoints) == bonds.end() && bonds.find(bondEndPointsSwapped) != bonds.end())
-					{
-						continue; // We do not need account interface surface twice
-					}
-					if (bonds.find(bondEndPoints) == bonds.end())
-					{
-						bonds[bondEndPoints].second = 0;
-						bonds[bondEndPoints].first = cleanBond;
-						bonds[bondEndPoints].first.chunkIndices[0] = bondEndPoints.first;
-						bonds[bondEndPoints].first.chunkIndices[1] = bondEndPoints.second;
-						bonds[bondEndPoints].first.bond.normal[0] = pln.n[0];
-						bonds[bondEndPoints].first.bond.normal[1] = pln.n[1];
-						bonds[bondEndPoints].first.bond.normal[2] = pln.n[2];
-					}
-
-					const Triangle& trl2 = chunksGeometry[mappedTr2.chunkId][mappedTr2.trId];
-
-					TrPrcTriangle trp2(trl2.a.p, trl2.b.p, trl2.c.p);
-
-					intersectionBufferLocal.clear();
-					intersectionBufferLocal.reserve(32);
-					trPrc.getTriangleIntersection(trp, trp2d, trp2, trCentroid, intersectionBufferLocal, pln.n);
-					PxVec3 centroidPoint(0, 0, 0);
-					int32_t collectedVerticesCount = 0;
-					float area = 0;
-					if (intersectionBufferLocal.size() >= 3)
-					{
-#ifdef DEBUG_OUTPUT
-						for (uint32_t p = 1; p < intersectionBufferLocal.size() - 1; ++p)
-						{
-							intersectionBuffer.push_back(intersectionBufferLocal[0]);
-							intersectionBuffer.push_back(intersectionBufferLocal[p]);
-							intersectionBuffer.push_back(intersectionBufferLocal[p + 1]);
-						}
-#endif
-						centroidPoint = intersectionBufferLocal[0] + intersectionBufferLocal.back();
-						collectedVerticesCount = 2;
-
-						for (uint32_t j = 1; j < intersectionBufferLocal.size() - 1; ++j)
-						{
-							++collectedVerticesCount;
-							centroidPoint += intersectionBufferLocal[j];
-							area += (intersectionBufferLocal[j + 1] - intersectionBufferLocal[0]).cross(intersectionBufferLocal[j] - intersectionBufferLocal[0]).magnitude();
-						}
-					}
-					if (area > 0.00001f)
-					{
-						bonds[bondEndPoints].second += collectedVerticesCount;
-
-						bonds[bondEndPoints].first.bond.area += area * 0.5f;
-						bonds[bondEndPoints].first.bond.centroid[0] += (centroidPoint.x);
-						bonds[bondEndPoints].first.bond.centroid[1] += (centroidPoint.y);
-						bonds[bondEndPoints].first.bond.centroid[2] += (centroidPoint.z);
-					}
-				}
-			}
-
-			for (auto it : bonds)
-			{
-				if (it.second.first.bond.area > 0)
-				{
-					float mlt = 1.0f / (it.second.second);
-					it.second.first.bond.centroid[0] *= mlt;
-					it.second.first.bond.centroid[1] *= mlt;
-					it.second.first.bond.centroid[2] *= mlt;
-
-					mResultBondDescs.push_back(it.second.first);
-				}
-
-			}
-#ifdef DEBUG_OUTPUT
-			saveGeometryToObj(meshBuffer, "Mesh.obj");
-			saveGeometryToObj(intersectionBuffer, "inter.obj");
-#endif
-			return 0;
-		}
-
-		int32_t BlastBondGenerator::createBondForcedInternal(const std::vector<PxVec3>& hull0, const std::vector<PxVec3>& hull1,
-															const CollisionHull& cHull0,const CollisionHull& cHull1,
-															PxBounds3 bound0, PxBounds3 bound1, NvBlastBond& resultBond, float overlapping)
-		{
-
-			TriangleProcessor trProcessor;
-			Separation separation;
-			importerHullsInProximityApexFree(hull0, bound0, PxTransform(PxIdentity), PxVec3(1, 1, 1), hull1, bound1, PxTransform(PxIdentity), PxVec3(1, 1, 1), 0.000, &separation);
-
-			if (std::isnan(separation.plane.d))
-			{				
-				importerHullsInProximityApexFree(hull0, bound0, PxTransform(PxVec3(0.000001f, 0.000001f, 0.000001f)), PxVec3(1, 1, 1), hull1, bound1, PxTransform(PxIdentity), PxVec3(1, 1, 1), 0.000, &separation);
-				if (std::isnan(separation.plane.d))
-				{
-					return 1;
-				}
-			}
-
-			PxPlane pl = separation.plane;
-			std::vector<PxVec3> ifsPoints[2];
-
-			float dst[2][2];
-
-			dst[0][0] = 0;
-			dst[0][1] = MAXIMUM_EXTENT;
-			for (uint32_t p = 0; p < cHull0.points.size(); ++p)
-			{
-				float d = pl.distance(PxVec3(cHull0.points[p].x, cHull0.points[p].y, cHull0.points[p].z));
-				if (PxAbs(d) > PxAbs(dst[0][0]))
-				{
-					dst[0][0] = d;
-				}
-				if (PxAbs(d) < PxAbs(dst[0][1]))
-				{
-					dst[0][1] = d;
-				}
-			}
-
-			dst[1][0] = 0;
-			dst[1][1] = MAXIMUM_EXTENT;
-			for (uint32_t p = 0; p < cHull1.points.size(); ++p)
-			{
-				float d = pl.distance(PxVec3(cHull1.points[p].x, cHull1.points[p].y, cHull1.points[p].z));
-				if (PxAbs(d) > PxAbs(dst[1][0]))
-				{
-					dst[1][0] = d;
-				}
-				if (PxAbs(d) < PxAbs(dst[1][1]))
-				{
-					dst[1][1] = d;
-				}
-			}
-
-		
-			float cvOffset[2] = { dst[0][1] + (dst[0][0] - dst[0][1]) * overlapping, dst[1][1] + (dst[1][0] - dst[1][1]) * overlapping };
-
-			for (uint32_t i = 0; i < cHull0.polygonData.size(); ++i)
-			{
-				uint32_t offset = cHull0.polygonData[i].mIndexBase;
-				PxVec3 result;
-				for (uint32_t j = 0; j < cHull0.polygonData[i].mNbVerts; ++j)
-				{
-					uint32_t nxj = (j + 1) % cHull0.polygonData[i].mNbVerts;
-					const uint32_t* ind = &cHull0.indices[0];
-					PxVec3 a = hull0[ind[j + offset]] - pl.n * cvOffset[0];
-					PxVec3 b = hull0[ind[nxj + offset]] - pl.n * cvOffset[0];
-
-					if (getPlaneSegmentIntersection(pl, a, b, result))
-					{
-						ifsPoints[0].push_back(result);
-					}
-				}
-			}
-
-			for (uint32_t i = 0; i < cHull1.polygonData.size(); ++i)
-			{
-				uint32_t offset = cHull1.polygonData[i].mIndexBase;
-				PxVec3 result;
-				for (uint32_t j = 0; j < cHull1.polygonData[i].mNbVerts; ++j)
-				{
-					uint32_t nxj = (j + 1) % cHull1.polygonData[i].mNbVerts;
-					const uint32_t* ind = &cHull1.indices[0];
-					PxVec3 a = hull1[ind[j + offset]] - pl.n * cvOffset[1];
-					PxVec3 b = hull1[ind[nxj + offset]] - pl.n * cvOffset[1];
-
-					if (getPlaneSegmentIntersection(pl, a, b, result))
-					{
-						ifsPoints[1].push_back(result);
-					}
-				}
-			}
-
-
-			std::vector<PxVec3> convexes[2];
-
-			trProcessor.buildConvexHull(ifsPoints[0], convexes[0], pl.n);
-			trProcessor.buildConvexHull(ifsPoints[1], convexes[1], pl.n);
-
-			float areas[2] = { 0, 0 };
-			PxVec3 centroids[2] = { PxVec3(0, 0, 0), PxVec3(0, 0, 0) };
-
-			for (uint32_t cv = 0; cv < 2; ++cv)
-			{
-				if (convexes[cv].size() == 0)
-				{
-					continue;
-				}
-				centroids[cv] = convexes[cv][0] + convexes[cv].back();
-				for (uint32_t i = 1; i < convexes[cv].size() - 1; ++i)
-				{
-					centroids[cv] += convexes[cv][i];
-					areas[cv] += (convexes[cv][i + 1] - convexes[cv][0]).cross(convexes[cv][i] - convexes[cv][0]).magnitude();
-#ifdef DEBUG_OUTPUT
-					intersectionBuffer.push_back(convexes[cv][0]);
-					intersectionBuffer.push_back(convexes[cv][i]);
-					intersectionBuffer.push_back(convexes[cv][i + 1]);
-#endif
-
-				}
-				centroids[cv] *= (1.0f / convexes[cv].size());
-				areas[cv] = PxAbs(areas[cv]);
-			}
-
-			resultBond.area = (areas[0] + areas[1]) * 0.5f;
-			resultBond.centroid[0] = (centroids[0][0] + centroids[1][0]) * 0.5f;
-			resultBond.centroid[1] = (centroids[0][1] + centroids[1][1]) * 0.5f;
-			resultBond.centroid[2] = (centroids[0][2] + centroids[1][2]) * 0.5f;
-			resultBond.normal[0] = pl.n[0];
-			resultBond.normal[1] = pl.n[1];
-			resultBond.normal[2] = pl.n[2];
-
-#ifdef DEBUG_OUTPUT
-			saveGeometryToObj(meshBuffer, "ArbitMeshes.obj");
-			saveGeometryToObj(intersectionBuffer, "inter.obj");
-#endif
-
-
-			return 0;				
-		}
-
-
-		int32_t BlastBondGenerator::buildDescFromInternalFracture(FractureTool* tool, const std::vector<bool>& chunkIsSupport, std::vector<NvBlastBondDesc>& mResultBondDescs, std::vector<NvBlastChunkDesc>& mResultChunkDescriptors)
-		{
-			const std::vector<ChunkInfo>& chunkData = tool->getChunkList();
-			std::vector<std::vector<Triangle> > trianglesBuffer(chunkData.size());
-
-			for (uint32_t i = 0; i < trianglesBuffer.size(); ++i)
-			{
-				tool->getBaseMesh(i, trianglesBuffer[i]);
-			}
-
-			if (chunkData.empty() || trianglesBuffer.empty())
-			{
-				return 1;
-			}
-			mResultChunkDescriptors.resize(trianglesBuffer.size());
-			std::vector<Bond>	bondDescriptors;
-			mResultChunkDescriptors[0].parentChunkIndex = UINT32_MAX;
-			mResultChunkDescriptors[0].userData = 0;
-
-			{
-				PxVec3 chunkCentroid(0, 0, 0);
-				for (uint32_t tr = 0; tr < trianglesBuffer[0].size(); ++tr)
-				{
-					chunkCentroid += trianglesBuffer[0][tr].a.p;
-					chunkCentroid += trianglesBuffer[0][tr].b.p;
-					chunkCentroid += trianglesBuffer[0][tr].c.p;
-				}
-				chunkCentroid *= (1.0f / (3 * trianglesBuffer[0].size()));
-				mResultChunkDescriptors[0].centroid[0] = chunkCentroid[0];
-				mResultChunkDescriptors[0].centroid[1] = chunkCentroid[1];
-				mResultChunkDescriptors[0].centroid[2] = chunkCentroid[2];
-			}
-
-			for (uint32_t i = 1; i < chunkData.size(); ++i)
-			{
-
-				mResultChunkDescriptors[i].userData = i;
-				mResultChunkDescriptors[i].parentChunkIndex = tool->getChunkIndex(chunkData[i].parent);
-				if (chunkIsSupport[i])
-					mResultChunkDescriptors[i].flags = NvBlastChunkDesc::SupportFlag;
-				PxVec3 chunkCentroid(0, 0, 0);
-				for (uint32_t tr = 0; tr < trianglesBuffer[i].size(); ++tr)
-				{
-					chunkCentroid += trianglesBuffer[i][tr].a.p;
-					chunkCentroid += trianglesBuffer[i][tr].b.p;
-					chunkCentroid += trianglesBuffer[i][tr].c.p;
-
-					Triangle& trRef = trianglesBuffer[i][tr];
-					int32_t id = trRef.userInfo;
-					if (id == 0)
-						continue;
-					bondDescriptors.push_back(Bond());
-					Bond& bond = bondDescriptors.back();
-					bond.m_chunkId = i;
-					bond.m_planeIndex = id;
-					bond.triangleIndex = tr;
-				}
-				chunkCentroid *= (1.0f / (3 * trianglesBuffer[i].size()));
-				mResultChunkDescriptors[i].centroid[0] = chunkCentroid[0];
-				mResultChunkDescriptors[i].centroid[1] = chunkCentroid[1];
-				mResultChunkDescriptors[i].centroid[2] = chunkCentroid[2];
-			}
-			std::sort(bondDescriptors.begin(), bondDescriptors.end());
-			if (bondDescriptors.empty())
-			{
-				return 0;
-			}
-			int32_t chunkId, planeId;
-			chunkId = bondDescriptors[0].m_chunkId;
-			planeId = bondDescriptors[0].m_planeIndex;
-			std::vector<BondInfo> forwardChunks;
-			std::vector<BondInfo> backwardChunks;
-
-			float area = 0;
-			PxVec3 normal(0, 0, 0);
-			PxVec3 centroid(0, 0, 0);
-			int32_t collected = 0;
-			PxBounds3 bb = PxBounds3::empty();
-
-			chunkId = -1;
-			planeId = bondDescriptors[0].m_planeIndex;
-			for (uint32_t i = 0; i <= bondDescriptors.size(); ++i)
-			{
-				if (i == bondDescriptors.size() || (chunkId != bondDescriptors[i].m_chunkId || abs(planeId) != abs(bondDescriptors[i].m_planeIndex)))
-				{
-					if (chunkId != -1)
-					{
-						if (bondDescriptors[i - 1].m_planeIndex > 0) {
-							forwardChunks.push_back(BondInfo());
-							forwardChunks.back().area = area;
-							forwardChunks.back().normal = normal;
-							forwardChunks.back().centroid = centroid * (1.0f / 3.0f / collected);
-							forwardChunks.back().m_chunkId = chunkId;
-							forwardChunks.back().m_bb = bb;
-
-						}
-						else
-						{
-							backwardChunks.push_back(BondInfo());
-							backwardChunks.back().area = area;
-							backwardChunks.back().normal = normal;
-							backwardChunks.back().centroid = centroid * (1.0f / 3.0f / collected);
-							backwardChunks.back().m_chunkId = chunkId;
-							backwardChunks.back().m_bb = bb;
-						}
-					}
-					bb.setEmpty();
-					collected = 0;
-					area = 0;
-					normal = PxVec3(0, 0, 0);
-					centroid = PxVec3(0, 0, 0);
-					if (i != bondDescriptors.size())
-						chunkId = bondDescriptors[i].m_chunkId;
-				}
-				if (i == bondDescriptors.size() || abs(planeId) != abs(bondDescriptors[i].m_planeIndex))
-				{
-					for (uint32_t fchunk = 0; fchunk < forwardChunks.size(); ++fchunk)
-					{
-						for (uint32_t bchunk = 0; bchunk < backwardChunks.size(); ++bchunk)
-						{
-							if (weakBoundingBoxIntersection(forwardChunks[fchunk].m_bb, backwardChunks[bchunk].m_bb) == 0)
-							{
-								continue;
-							}
-							if (chunkIsSupport[forwardChunks[fchunk].m_chunkId] == false || chunkIsSupport[backwardChunks[bchunk].m_chunkId] == false)
-							{
-								continue;
-							}
-							mResultBondDescs.push_back(NvBlastBondDesc());
-							mResultBondDescs.back().bond.area = std::min(forwardChunks[fchunk].area, backwardChunks[bchunk].area);
-							mResultBondDescs.back().bond.normal[0] = forwardChunks[fchunk].normal.x;
-							mResultBondDescs.back().bond.normal[1] = forwardChunks[fchunk].normal.y;
-							mResultBondDescs.back().bond.normal[2] = forwardChunks[fchunk].normal.z;
-
-							mResultBondDescs.back().bond.centroid[0] = (forwardChunks[fchunk].centroid.x + backwardChunks[bchunk].centroid.x ) * 0.5;
-							mResultBondDescs.back().bond.centroid[1] = (forwardChunks[fchunk].centroid.y + backwardChunks[bchunk].centroid.y) * 0.5;
-							mResultBondDescs.back().bond.centroid[2] = (forwardChunks[fchunk].centroid.z + backwardChunks[bchunk].centroid.z) * 0.5;
-
-
-							mResultBondDescs.back().chunkIndices[0] = forwardChunks[fchunk].m_chunkId;
-							mResultBondDescs.back().chunkIndices[1] = backwardChunks[bchunk].m_chunkId;
-						}
-					}
-					forwardChunks.clear();
-					backwardChunks.clear();
-					if (i != bondDescriptors.size())
-					{
-						planeId = bondDescriptors[i].m_planeIndex;
-					}
-					else
-					{
-						break;
-					}
-				}
-
-				collected++;
-				int32_t tr = bondDescriptors[i].triangleIndex;
-				PxVec3 n = trianglesBuffer[chunkId][tr].getNormal();
-				area += n.magnitude();
-				normal = n.getNormalized();
-				centroid += trianglesBuffer[chunkId][tr].a.p;
-				centroid += trianglesBuffer[chunkId][tr].b.p;
-				centroid += trianglesBuffer[chunkId][tr].c.p;
-
-				bb.include(trianglesBuffer[chunkId][tr].a.p);
-				bb.include(trianglesBuffer[chunkId][tr].b.p);
-				bb.include(trianglesBuffer[chunkId][tr].c.p);
-			}
-
-			return 0;
-		}
-
-		int32_t BlastBondGenerator::createBondBetweenMeshes(const std::vector<std::vector<Triangle> >& geometry, std::vector<NvBlastBondDesc>& resultBond,const std::vector<std::pair<uint32_t, uint32_t> >& overlaps, BondGenerationConfig cfg)
-		{
-			if (cfg.bondMode == BondGenerationConfig::AVERAGE)
-			{
-				resetGeometryCache();
-				buildGeometryCache(geometry);
-			}
-			resultBond.clear();
-			resultBond.resize(overlaps.size());
-		
-			if (cfg.bondMode == BondGenerationConfig::EXACT)
-			{
-				for (uint32_t i = 0; i < overlaps.size(); ++i)
-				{
-					resultBond[i].chunkIndices[0] = overlaps[i].first;
-					resultBond[i].chunkIndices[1] = overlaps[i].second;					
-					createBondBetweenMeshes(geometry[overlaps[i].first], geometry[overlaps[i].second], resultBond[i].bond, cfg);
-				}
-			}
-			else
-			{
-				for (uint32_t i = 0; i < overlaps.size(); ++i)
-				{
-					resultBond[i].chunkIndices[0] = overlaps[i].first;
-					resultBond[i].chunkIndices[1] = overlaps[i].second;
-					createBondForcedInternal(mHullsPointsCache[overlaps[i].first], mHullsPointsCache[overlaps[i].second], mCHullCache[overlaps[i].first], mCHullCache[overlaps[i].second],
-						mBoundsCache[overlaps[i].first], mBoundsCache[overlaps[i].second], resultBond[i].bond, 0.3f);
-				}
-			}
-		
-			return 0;
-		}
-
-
-		int32_t BlastBondGenerator::createBondBetweenMeshes(const std::vector<Triangle>& meshA, const std::vector<Triangle>& meshB, NvBlastBond& resultBond, BondGenerationConfig conf)
-		{
-			float overlapping = 0.3;
-			if (conf.bondMode == BondGenerationConfig::EXACT)
-			{
-				std::vector<std::vector<Triangle> > chunks;
-				chunks.push_back(meshA);
-				chunks.push_back(meshB);
-				std::vector<bool> isSupport(2, true);
-				std::vector<NvBlastBondDesc> desc;
-				createFullBondListExact(chunks, isSupport, desc, conf);
-				if (desc.size() > 0)
-				{
-					resultBond = desc.back().bond; 
-				}
-				else
-				{
-					return 1;
-				}
-				return 0;
-			}
-		
-			std::vector<PxVec3>  chunksPoints1(meshA.size() * 3);
-			std::vector<PxVec3>  chunksPoints2(meshB.size() * 3);
-
-			int32_t sp = 0;
-			for (uint32_t i = 0; i < meshA.size(); ++i)
-			{
-				chunksPoints1[sp++] = meshA[i].a.p;
-				chunksPoints1[sp++] = meshA[i].b.p;
-				chunksPoints1[sp++] = meshA[i].c.p;
-#ifdef DEBUG_OUTPUT
-				meshBuffer.push_back(meshA[i].a.p);
-				meshBuffer.push_back(meshA[i].b.p);
-				meshBuffer.push_back(meshA[i].c.p);
-#endif
-
-
-			}
-			sp = 0;
-			for (uint32_t i = 0; i < meshB.size(); ++i)
-			{
-				chunksPoints2[sp++] = meshB[i].a.p;
-				chunksPoints2[sp++] = meshB[i].b.p;
-				chunksPoints2[sp++] = meshB[i].c.p;
-#ifdef DEBUG_OUTPUT
-				meshBuffer.push_back(meshB[i].a.p);
-				meshBuffer.push_back(meshB[i].b.p);
-				meshBuffer.push_back(meshB[i].c.p);
-#endif
-			}
-
-
-			Nv::Blast::ConvexMeshBuilder builder(mPxCooking, mPxInsertionCallback);
-
-			CollisionHull cHull[2];
-
-			builder.buildCollisionGeometry(chunksPoints1, cHull[0]);
-			builder.buildCollisionGeometry(chunksPoints2, cHull[1]);
-
-			std::vector<PxVec3> hullPoints[2];
-			hullPoints[0].resize(cHull[0].points.size());
-			hullPoints[1].resize(cHull[1].points.size());
-
-
-			PxBounds3 bb[2];
-			bb[0].setEmpty();
-			bb[1].setEmpty();
-
-			for (uint32_t cv = 0; cv < 2; ++cv)
-			{
-				for (uint32_t i = 0; i < cHull[cv].points.size(); ++i)
-				{
-					hullPoints[cv][i].x = cHull[cv].points[i].x;
-					hullPoints[cv][i].y = cHull[cv].points[i].y;
-					hullPoints[cv][i].z = cHull[cv].points[i].z;
-					bb[cv].include(hullPoints[cv][i]);
-				}
-			}		
-			return createBondForcedInternal(hullPoints[0], hullPoints[1], cHull[0], cHull[1], bb[0], bb[1], resultBond, overlapping);
-		}
-
-
-
-	}
-}
diff --git a/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringBooleanTool.cpp b/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringBooleanTool.cpp
deleted file mode 100644
index b5030d7..0000000
--- a/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringBooleanTool.cpp
+++ /dev/null
@@ -1,1351 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastExtAuthoringBooleanTool.h"
-#include "NvBlastExtAuthoringMesh.h"
-#include "NvBlastExtAuthoringAccelerator.h"
-
-#include <math.h>
-#include <set>
-#include <algorithm>
-
-using physx::PxVec3;
-using physx::PxVec2;
-using physx::PxBounds3;
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-/* Linear interpolation of vectors */
-
-NV_FORCE_INLINE void vec3Lerp(const PxVec3& a, const PxVec3& b, PxVec3& out, float t)
-{
-	out.x = (b.x - a.x) * t + a.x;
-	out.y = (b.y - a.y) * t + a.y;
-	out.z = (b.z - a.z) * t + a.z;
-}
-
-NV_FORCE_INLINE void vec2Lerp(const PxVec2& a, const PxVec2& b, PxVec2& out, float t)
-{
-	out.x = (b.x - a.x) * t + a.x;
-	out.y = (b.y - a.y) * t + a.y;
-}
-
-
-NV_FORCE_INLINE int32_t BooleanEvaluator::addIfNotExist(Vertex& p)
-{
-	mVerticesAggregate.push_back(p);
-	return static_cast<int32_t>(mVerticesAggregate.size()) - 1;
-}
-
-NV_FORCE_INLINE void BooleanEvaluator::addEdgeIfValid(EdgeWithParent& ed)
-{
-	mEdgeAggregate.push_back(ed);
-}
-
-/**
-Vertex level shadowing functions
-*/
-NV_FORCE_INLINE int32_t vertexShadowing(const PxVec3& a, const PxVec3& b)
-{
-	return (b.x >= a.x) ? 1 : 0;
-}
-/**
-Vertex-edge status functions
-*/
-NV_FORCE_INLINE int32_t veStatus01(const PxVec3& sEdge, const PxVec3& eEdge, const PxVec3& p)
-{
-	return vertexShadowing(p, eEdge) - vertexShadowing(p, sEdge);
-}
-
-NV_FORCE_INLINE int32_t veStatus10(const PxVec3& sEdge, const PxVec3& eEdge, const PxVec3& p)
-{
-	return -vertexShadowing(eEdge, p) + vertexShadowing(sEdge, p);
-}
-
-/**
-Vertex-edge shadowing functions
-*/
-int32_t shadowing01(const Vertex& sEdge, const Vertex& eEdge, const PxVec3& p, Vertex& onEdgePoint, bool& hasOnEdge)
-{
-	int32_t winding = veStatus01(sEdge.p, eEdge.p, p);
-	if (winding != 0)
-	{
-		float t = (p.x - sEdge.p.x) / (eEdge.p.x - sEdge.p.x);
-		if (t >= 1)
-		{
-			onEdgePoint = eEdge;
-		}
-		else if (t <= 0)
-		{
-			onEdgePoint = sEdge;
-		}
-		else
-		{
-			vec3Lerp(sEdge.p, eEdge.p, onEdgePoint.p, t);
-			vec3Lerp(sEdge.n, eEdge.n, onEdgePoint.n, t);
-			vec2Lerp(sEdge.uv[0], eEdge.uv[0], onEdgePoint.uv[0], t);
-		}
-		hasOnEdge = true;
-		if (onEdgePoint.p.y >= p.y)
-		{
-			return winding;
-		}
-	}
-	else
-	{
-		hasOnEdge = false;
-	}
-	return 0;
-}
-int32_t shadowing10(const Vertex& sEdge, const Vertex& eEdge, const PxVec3& p, Vertex& onEdgePoint, bool& hasOnEdge)
-{
-	int32_t winding = veStatus10(sEdge.p, eEdge.p, p);
-	if (winding != 0)
-	{
-		float t = (p.x - sEdge.p.x) / (eEdge.p.x - sEdge.p.x);
-		if (t >= 1)
-		{
-			onEdgePoint = eEdge;
-		}
-		else if (t <= 0)
-		{
-			onEdgePoint = sEdge;
-		}
-		else
-		{
-			vec3Lerp(sEdge.p, eEdge.p, onEdgePoint.p, t);
-			vec3Lerp(sEdge.n, eEdge.n, onEdgePoint.n, t);
-			vec2Lerp(sEdge.uv[0], eEdge.uv[0], onEdgePoint.uv[0], t);
-		}
-		hasOnEdge = true;
-		if (onEdgePoint.p.y < p.y)
-		{
-			return winding;
-		}
-	}
-	else
-	{
-		hasOnEdge = false;
-	}
-	return 0;
-}
-
-int32_t shadowing01(const PxVec3& sEdge, const PxVec3& eEdge, const PxVec3& p)
-{
-	int32_t winding = veStatus01(sEdge, eEdge, p);
-	if (winding != 0)
-	{
-		float t = ((p.x - sEdge.x) / (eEdge.x - sEdge.x));
-		PxVec3 onEdgePoint;
-		if (t >= 1)
-			onEdgePoint = eEdge;
-		else if (t <= 0)
-			onEdgePoint = sEdge;
-		else
-			vec3Lerp(sEdge, eEdge, onEdgePoint, t);
-		if (onEdgePoint.y >= p.y)
-		{
-			return winding;
-		}
-	}
-	return 0;
-}
-
-int32_t shadowing10(const PxVec3& sEdge, const PxVec3& eEdge, const PxVec3& p)
-{
-	int32_t winding = veStatus10(sEdge, eEdge, p);
-	if (winding != 0)
-	{
-		float t = ((p.x - sEdge.x) / (eEdge.x - sEdge.x));
-		PxVec3 onEdgePoint;
-		if (t >= 1)
-			onEdgePoint = eEdge;
-		else if (t <= 0)
-			onEdgePoint = sEdge;
-		else
-			vec3Lerp(sEdge, eEdge, onEdgePoint, t);
-		if (onEdgePoint.y < p.y)
-		{
-			return winding;
-		}
-	}
-	return 0;
-}
-
-/**
-Vertex-facet shadowing functions
-*/
-
-int32_t vfStatus02(const PxVec3& p, const Vertex* points, const Edge* edges, int32_t edgesCount, Vertex& out1, Vertex& out2)
-{
-	int32_t val = 0;
-	Vertex pnt;
-	bool hasOnEdge = false;
-	for (int32_t i = 0; i < edgesCount; ++i)
-	{
-		val -= shadowing01(points[edges->s], points[edges->e], p, pnt, hasOnEdge);
-		if (hasOnEdge != 0)
-		{
-			out2 = out1;
-			out1 = pnt;
-		}
-		++edges;
-	}
-	return val;
-}
-
-
-int32_t shadowing02(const PxVec3& p, const Vertex* points, const Edge* edges, int edgesCount, bool& hasOnFacetPoint, Vertex& onFacetPoint)
-{
-	Vertex p1, p2;
-	int32_t stat = vfStatus02(p, points, edges, edgesCount, p1, p2);
-	float z = 0;
-	hasOnFacetPoint = false;
-	if (stat != 0)
-	{
-		PxVec3 vc = p2.p - p1.p;
-		float t = 0;
-		t = (abs(vc.x) > abs(vc.y)) ? (p.x - p1.p.x) / vc.x : (p.y - p1.p.y) / vc.y;
-		t = (t < 0) ? 0 : t;
-		t = (t > 1) ? 1 : t;
-		z = t * vc.z + p1.p.z;
-
-		hasOnFacetPoint = true;
-		onFacetPoint.p.x = p.x;
-		onFacetPoint.p.y = p.y;
-		onFacetPoint.p.z = z;
-
-		vec2Lerp(p1.uv[0], p2.uv[0], onFacetPoint.uv[0], t);
-		vec3Lerp(p1.n, p2.n, onFacetPoint.n, t);
-
-		if (z >= p.z)
-		{
-			return stat;
-		}
-	}
-	return 0;
-}
-
-int32_t vfStatus20(const PxVec3& p, const Vertex* points, const Edge* edges, int32_t edgesCount, Vertex& out1, Vertex& out2)
-{
-	int32_t val = 0;
-	Vertex pnt;
-	bool hasOnEdge = false;
-	for (int32_t i = 0; i < edgesCount; ++i)
-	{
-		val += shadowing10(points[edges->s], points[edges->e], p, pnt, hasOnEdge);
-		if (hasOnEdge != 0)
-		{
-			out2 = out1;
-			out1 = pnt;
-		}
-		++edges;
-	}
-	return val;
-}
-
-int32_t shadowing20(const PxVec3& p, const Vertex* points, const Edge* edges, int edgesCount, bool& hasOnFacetPoint, Vertex& onFacetPoint)
-{
-	Vertex p1, p2;
-	int32_t stat = vfStatus20(p, points, edges, edgesCount, p1, p2);
-	hasOnFacetPoint = false;
-	if (stat != 0)
-	{
-		PxVec3 vc = p2.p - p1.p;
-		float t = 0;
-		t = (abs(vc.x) > abs(vc.y)) ? (p.x - p1.p.x) / vc.x : (p.y - p1.p.y) / vc.y;
-		t = (t < 0) ? 0 : t;
-		t = (t > 1) ? 1 : t;
-
-		hasOnFacetPoint = true;
-		onFacetPoint.p.x = p.x;
-		onFacetPoint.p.y = p.y;
-
-		onFacetPoint.p.z = t * vc.z + p1.p.z;
-		
-		vec2Lerp(p1.uv[0], p2.uv[0], onFacetPoint.uv[0], t);
-		vec3Lerp(p1.n, p2.n, onFacetPoint.n, t);
-
-		if (onFacetPoint.p.z < p.z)
-		{
-			return stat;
-		}
-	}
-	return 0;
-}
-
-
-NV_FORCE_INLINE int32_t edgesCrossCheck(const PxVec3& eAs, const PxVec3& eAe, const PxVec3& eBs, const PxVec3& eBe)
-{
-	return shadowing01(eBs, eBe, eAe) - shadowing01(eBs, eBe, eAs) + shadowing10(eAs, eAe, eBe) - shadowing10(eAs, eAe, eBs);
-}
-
-int32_t edgesIntersection(const Vertex& eAs, const Vertex& eAe, const Vertex& eBs, const Vertex& eBe, Vertex& intersectionA, Vertex& intersectionB, bool& hasPoints)
-{
-	int32_t status = edgesCrossCheck(eAs.p, eAe.p, eBs.p, eBe.p);
-	hasPoints = false;
-	if (status == 0)
-		return 0;
-	Vertex tempPoint;
-
-	Vertex bShadowingPair[2];
-	Vertex aShadowingPair[2];
-	bool hasOnEdge = false;
-	int32_t shadowingType = shadowing10(eAs, eAe, eBs.p, tempPoint, hasOnEdge);
-
-	bool aShadowing = false;
-	bool bShadowing = false;
-
-
-	if (shadowingType == 0 && hasOnEdge)
-	{
-		aShadowing = true;
-		aShadowingPair[0] = eBs;
-		aShadowingPair[1] = tempPoint;
-	}
-	else
-	{
-		if (shadowingType == 1 || shadowingType == -1)
-		{
-			bShadowing = true;
-			bShadowingPair[0] = eBs;
-			bShadowingPair[1] = tempPoint;
-		}
-	}
-
-	shadowingType = shadowing10(eAs, eAe, eBe.p, tempPoint, hasOnEdge);
-
-	if (shadowingType == 0 && !aShadowing && hasOnEdge)
-	{
-		aShadowing = true;
-		aShadowingPair[0] = eBe;
-		aShadowingPair[1] = tempPoint;
-	}
-	else
-	{
-		if ((shadowingType == 1 || shadowingType == -1) && !bShadowing)
-		{
-			bShadowing = true;
-			bShadowingPair[0] = eBe;
-			bShadowingPair[1] = tempPoint;
-		}
-	}
-	shadowingType = shadowing01(eBs, eBe, eAe.p, tempPoint, hasOnEdge);
-
-	if (shadowingType == 0 && !aShadowing && hasOnEdge)
-	{
-		aShadowing = true;
-		aShadowingPair[1] = eAe;
-		aShadowingPair[0] = tempPoint;
-	}
-	else
-	{
-		if ((shadowingType == 1 || shadowingType == -1) && !bShadowing)
-		{
-			bShadowing = true;
-			bShadowingPair[1] = eAe;
-			bShadowingPair[0] = tempPoint;
-		}
-	}
-
-	shadowingType = shadowing01(eBs, eBe, eAs.p, tempPoint, hasOnEdge);
-
-	if (shadowingType == 0 && !aShadowing && hasOnEdge)
-	{
-		aShadowing = true;
-		aShadowingPair[1] = eAs;
-		aShadowingPair[0] = tempPoint;
-	}
-	else
-	{
-		if ((shadowingType == 1 || shadowingType == -1) && !bShadowing)
-		{
-			bShadowing = true;
-			bShadowingPair[1] = eAs;
-			bShadowingPair[0] = tempPoint;
-		}
-	}
-	float deltaPlus = bShadowingPair[0].p.y - bShadowingPair[1].p.y;
-	float deltaMinus = aShadowingPair[0].p.y - aShadowingPair[1].p.y;
-	float div = 0;
-	if (deltaPlus > 0)
-		div = deltaPlus / (deltaPlus - deltaMinus);
-	else
-		div = 0;
-
-	intersectionA.p = bShadowingPair[1].p - div * (bShadowingPair[1].p - aShadowingPair[1].p);
-	intersectionA.n = bShadowingPair[1].n - div * (bShadowingPair[1].n - aShadowingPair[1].n);
-	intersectionA.uv[0] = bShadowingPair[1].uv[0] - (bShadowingPair[1].uv[0] - aShadowingPair[1].uv[0]) * div;
-	intersectionB.p = intersectionA.p;
-	intersectionB.p.z = bShadowingPair[0].p.z - div * (bShadowingPair[0].p.z - aShadowingPair[0].p.z);
-	intersectionB.n = bShadowingPair[0].n - div * (bShadowingPair[0].n - aShadowingPair[0].n);
-	intersectionB.uv[0] = bShadowingPair[0].uv[0] - (bShadowingPair[0].uv[0] - aShadowingPair[0].uv[0]) * div;
-
-	hasPoints = true;
-	return status;
-}
-
-NV_FORCE_INLINE int32_t edgeEdgeShadowing(const Vertex& eAs, const Vertex& eAe, const Vertex& eBs, const Vertex& eBe, Vertex& intersectionA, Vertex& intersectionB, bool& hasPoints)
-{
-	int32_t status = edgesIntersection(eAs, eAe, eBs, eBe, intersectionA, intersectionB, hasPoints);
-	if (intersectionB.p.z >= intersectionA.p.z)
-	{
-		return status;
-	}
-	return 0;
-}
-
-int32_t edgeFacetIntersection12(const Vertex& edSt, const Vertex& edEnd, const Vertex* points, const Edge* edges, int edgesCount, Vertex& intersectionA, Vertex& intersectionB)
-{
-	int32_t status = 0;
-	Vertex p1, p2;
-	Vertex bShadowingPair[2];
-	Vertex aShadowingPair[2];
-	bool hasPoint = false;
-	int32_t shadowingType = shadowing02(edEnd.p, points, edges, edgesCount, hasPoint, p1);
-	status -= shadowingType;
-	bool aShadowing = false;
-	bool bShadowing = false;
-
-	if (shadowingType == 0 && hasPoint)
-	{
-		aShadowing = true;
-		aShadowingPair[0] = p1;
-		aShadowingPair[1] = edEnd;
-	}
-	else
-	{
-		if (shadowingType == 1 || shadowingType == -1)
-		{
-			bShadowing = true;
-			bShadowingPair[0] = p1;
-			bShadowingPair[1] = edEnd;
-		}
-	}
-
-	shadowingType = shadowing02(edSt.p, points, edges, edgesCount, hasPoint, p1);
-	status += shadowingType;
-	if (shadowingType == 0 && !aShadowing && hasPoint)
-	{
-		aShadowing = true;
-		aShadowingPair[0] = p1;
-		aShadowingPair[1] = edSt;
-	}
-	else
-	{
-		if ((shadowingType == 1 || shadowingType == -1) && !bShadowing)
-		{
-			bShadowing = true;
-			bShadowingPair[0] = p1;
-			bShadowingPair[1] = edSt;
-		}
-	}
-
-	for (int32_t ed = 0; ed < edgesCount; ++ed)
-	{
-		shadowingType = edgeEdgeShadowing(edSt, edEnd, points[edges[ed].s], points[edges[ed].e], p1, p2, hasPoint);
-		status -= shadowingType;
-		if (shadowingType == 0 && !aShadowing && hasPoint)
-		{
-			aShadowing = true;
-			aShadowingPair[0] = p2;
-			aShadowingPair[1] = p1;
-		}
-		else
-		{
-			if ((shadowingType == 1 || shadowingType == -1) && !bShadowing)
-			{
-				bShadowing = true;
-				bShadowingPair[0] = p2;
-				bShadowingPair[1] = p1;
-			}
-		}
-	}
-	if (status == 0)
-	{
-		return 0;
-	}
-	if (!bShadowing || !aShadowing)
-	{
-		return 0;
-	}
-	float deltaPlus = bShadowingPair[0].p.z - bShadowingPair[1].p.z;
-	float div = 0;
-	if (deltaPlus != 0)
-	{
-		float deltaMinus = aShadowingPair[0].p.z - aShadowingPair[1].p.z;
-		div = deltaPlus / (deltaPlus - deltaMinus);
-	}
-	intersectionA.p = bShadowingPair[1].p - div * (bShadowingPair[1].p - aShadowingPair[1].p);
-	intersectionA.n = bShadowingPair[1].n - div * (bShadowingPair[1].n - aShadowingPair[1].n);
-	intersectionA.uv[0] = bShadowingPair[1].uv[0] - (bShadowingPair[1].uv[0] - aShadowingPair[1].uv[0]) * div;
-
-	intersectionB.p = intersectionA.p;
-	intersectionB.n = bShadowingPair[0].n - div * (bShadowingPair[0].n - aShadowingPair[0].n);
-	intersectionB.uv[0] = bShadowingPair[0].uv[0] - (bShadowingPair[0].uv[0] - aShadowingPair[0].uv[0]) * div;
-
-
-	return status;
-}
-
-
-int32_t edgeFacetIntersection21(const Vertex& edSt, const Vertex& edEnd, const Vertex* points, const Edge* edges, int edgesCount, Vertex& intersectionA, Vertex& intersectionB)
-{
-	int32_t status = 0;
-	Vertex p1, p2;
-
-	Vertex bShadowingPair[2];
-	Vertex aShadowingPair[2];
-	bool hasPoint = false;
-	int32_t shadowingType = shadowing20(edEnd.p, points, edges, edgesCount, hasPoint, p1);
-	status = shadowingType;
-	bool aShadowing = false;
-	bool bShadowing = false;
-	if (shadowingType == 0 && hasPoint)
-	{
-		aShadowing = true;
-		aShadowingPair[0] = edEnd;
-		aShadowingPair[1] = p1;
-	}
-	else
-	{
-		if (shadowingType == 1 || shadowingType == -1)
-		{
-			bShadowing = true;
-			bShadowingPair[0] = edEnd;
-			bShadowingPair[1] = p1;
-		}
-	}
-
-	shadowingType = shadowing20(edSt.p, points, edges, edgesCount, hasPoint, p1);
-	status -= shadowingType;
-	if (shadowingType == 0 && !aShadowing && hasPoint)
-	{
-		aShadowing = true;
-		aShadowingPair[0] = edSt;
-		aShadowingPair[1] = p1;
-	}
-	else
-	{
-		if ((shadowingType == 1 || shadowingType == -1) && !bShadowing)
-		{
-			bShadowing = true;
-			bShadowingPair[0] = edSt;
-			bShadowingPair[1] = p1;
-		}
-	}
-
-	for (int32_t ed = 0; ed < edgesCount; ++ed)
-	{
-		shadowingType = edgeEdgeShadowing(points[edges[ed].s], points[edges[ed].e], edSt, edEnd, p1, p2, hasPoint);
-		status -= shadowingType;
-		if (shadowingType == 0)
-		{
-			if (!aShadowing && hasPoint)
-			{
-				aShadowing = true;
-				aShadowingPair[0] = p2;
-				aShadowingPair[1] = p1;
-			}
-		}
-		else
-		{
-			if ((shadowingType == 1 || shadowingType == -1) && !bShadowing)
-			{
-				bShadowing = true;
-				bShadowingPair[0] = p2;
-				bShadowingPair[1] = p1;
-			}
-		}
-	}
-	if (status == 0)
-	{
-		return 0;
-	}
-	if (!bShadowing || !aShadowing)
-	{
-		return 0;
-	}
-	float deltaPlus = bShadowingPair[0].p.z - bShadowingPair[1].p.z;
-	float div = 0;
-	if (deltaPlus != 0)
-	{
-		float deltaMinus = aShadowingPair[0].p.z - aShadowingPair[1].p.z;
-		div = deltaPlus / (deltaPlus - deltaMinus);
-	}
-	intersectionA.p = bShadowingPair[1].p - div * (bShadowingPair[1].p - aShadowingPair[1].p);
-	intersectionA.n = bShadowingPair[1].n - div * (bShadowingPair[1].n - aShadowingPair[1].n);
-	intersectionA.uv[0] = bShadowingPair[1].uv[0] - (bShadowingPair[1].uv[0] - aShadowingPair[1].uv[0]) * div;
-
-	intersectionB.p = intersectionA.p;
-	intersectionB.n = bShadowingPair[0].n - div * (bShadowingPair[0].n - aShadowingPair[0].n);
-	intersectionB.uv[0] = bShadowingPair[0].uv[0] - (bShadowingPair[0].uv[0] - aShadowingPair[0].uv[0]) * div;
-
-	return status;
-}
-
-int32_t BooleanEvaluator::vertexMeshStatus03(const PxVec3& p, Mesh* mesh)
-{
-	int32_t status = 0;
-	Vertex pnt;
-	bool hasPoint = false;
-	mAcceleratorB->setState(p);
-	int32_t facet = mAcceleratorB->getNextFacet();
-	while (facet != -1)
-	{
-		Edge* ed = mesh->getEdges() + mesh->getFacet(facet)->firstEdgeNumber;
-		status += shadowing02(p, mesh->getVertices(), ed, mesh->getFacet(facet)->edgesCount, hasPoint, pnt);
-		facet = mAcceleratorB->getNextFacet();
-	}
-
-	//for (int32_t facet = 0; facet < mesh->getFacetCount(); ++facet) 
-	//{
-	//	Edge* ed = mesh->getEdges() + mesh->getFacet(facet)->firstEdgeNumber;
-	//	status += shadowing02(p, mesh->getVertices(), ed, mesh->getFacet(facet)->edgesCount, hasPoint, pnt);
-	//}
-
-	return status;
-}
-
-int32_t BooleanEvaluator::vertexMeshStatus30(const PxVec3& p, Mesh* mesh)
-{
-	int32_t status = 0;
-	bool hasPoints = false;
-	Vertex point;
-	mAcceleratorA->setState(p);
-	int32_t facet = mAcceleratorA->getNextFacet();
-	while ( facet != -1)
-	{
-		Edge* ed = mesh->getEdges() + mesh->getFacet(facet)->firstEdgeNumber;
-		status -= shadowing20(p, mesh->getVertices(), ed, mesh->getFacet(facet)->edgesCount, hasPoints, point);
-		facet = mAcceleratorA->getNextFacet();
-	}
-
-	//for (int32_t facet = 0; facet < mesh->getFacetCount(); ++facet)
-	//{
-	//	Edge* ed = mesh->getEdges() + mesh->getFacet(facet)->firstEdgeNumber;
-	//	status -= shadowing20(p, mesh->getVertices(), ed, mesh->getFacet(facet)->edgesCount, hasPoints, point);
-	//}
-	return status;
-}
-
-NV_FORCE_INLINE int32_t inclusionValue03(BooleanConf& conf, int32_t xValue)
-{
-	return conf.ca + conf.ci * xValue;
-}
-
-NV_FORCE_INLINE int32_t inclusionValueEdgeFace(BooleanConf& conf, int32_t xValue)
-{
-	return conf.ci * xValue;
-}
-
-NV_FORCE_INLINE int32_t inclusionValue30(BooleanConf& conf, int32_t xValue)
-{
-	return conf.cb + conf.ci * xValue;
-}
-
-struct VertexComparator
-{
-	VertexComparator(PxVec3 base = PxVec3()) : basePoint(base) {};
-	PxVec3 basePoint;
-	bool operator()(const Vertex& a, const Vertex& b)
-	{
-		return (b.p - a.p).dot(basePoint) > 0.0;
-	}
-};
-
-struct VertexPairComparator
-{
-	VertexPairComparator(PxVec3 base = PxVec3()) : basePoint(base) {};
-	PxVec3 basePoint;
-	bool operator()(const std::pair<Vertex, Vertex>& a, const std::pair<Vertex, Vertex>& b)
-	{
-		return (b.first.p - a.first.p).dot(basePoint) > 0.0;
-	}
-};
-
-int32_t BooleanEvaluator::isPointContainedInMesh(Mesh* msh, const PxVec3& point)
-{
-	if (msh == nullptr)
-	{
-		return 0;
-	}
-	DummyAccelerator dmAccel(msh->getFacetCount());
-	mAcceleratorA = &dmAccel;
-	return vertexMeshStatus30(point, msh);
-
-}
-
-int32_t BooleanEvaluator::isPointContainedInMesh(Mesh* msh, SpatialAccelerator* spAccel, const PxVec3& point)
-{
-	if (msh == nullptr)
-	{
-		return 0;
-	}
-	mAcceleratorA = spAccel;
-	return vertexMeshStatus30(point, msh);
-}
-
-
-bool shouldSwap(const PxVec3& a, const PxVec3& b)
-{
-	if (a.x < b.x) return false;
-	if (a.x > b.x) return true;
-
-	if (a.y < b.y) return false;
-	if (a.y > b.y) return true;
-
-	if (a.z < b.z) return false;
-	if (a.z > b.z) return true;
-
-	return false;
-}
-
-void BooleanEvaluator::buildFaceFaceIntersections(BooleanConf mode)
-{
-	int32_t statusValue = 0;
-	int32_t inclusionValue = 0;
-
-	std::vector<std::pair<Vertex, Vertex> > retainedStarts;
-	std::vector<std::pair<Vertex, Vertex>> retainedEnds;
-	VertexPairComparator comp;
-
-	Vertex newPointA;
-	Vertex newPointB;
-
-	Vertex* meshAPoints = mMeshA->getVertices();
-	Vertex* meshBPoints = mMeshB->getVertices();
-	EdgeWithParent newEdge;
-	mEdgeFacetIntersectionData12.clear();
-	mEdgeFacetIntersectionData21.clear();
-	
-	mEdgeFacetIntersectionData12.resize(mMeshA->getFacetCount());
-	mEdgeFacetIntersectionData21.resize(mMeshB->getFacetCount());
-
-	for (uint32_t facetB = 0; facetB < mMeshB->getFacetCount(); ++facetB)
-	{
-		mAcceleratorA->setState(mMeshB->getVertices(), mMeshB->getEdges(), *mMeshB->getFacet(facetB));
-		int32_t facetA = mAcceleratorA->getNextFacet();
-		while (facetA != -1)
-		{
-			Edge* facetBEdges = mMeshB->getEdges() + mMeshB->getFacet(facetB)->firstEdgeNumber;
-			Edge* facetAEdges = mMeshA->getEdges() + mMeshA->getFacet(facetA)->firstEdgeNumber;
-			Edge* fbe = facetBEdges;
-			Edge* fae = facetAEdges;
-			retainedStarts.clear();
-			retainedEnds.clear();
-			PxVec3 compositeEndPoint(0, 0, 0);
-			PxVec3 compositeStartPoint(0, 0, 0);
-			uint32_t facetAEdgeCount = mMeshA->getFacet(facetA)->edgesCount;
-			uint32_t facetBEdgeCount = mMeshB->getFacet(facetB)->edgesCount;
-			int32_t ic = 0;
-			for (uint32_t i = 0; i < facetAEdgeCount; ++i)
-			{
-				if (shouldSwap(meshAPoints[fae->e].p, meshAPoints[fae->s].p))
-				{
-					statusValue = -edgeFacetIntersection12(meshAPoints[fae->e], meshAPoints[fae->s], mMeshB->getVertices(), facetBEdges, facetBEdgeCount, newPointA, newPointB);
-				}
-				else
-				{
-					statusValue = edgeFacetIntersection12(meshAPoints[fae->s], meshAPoints[fae->e], mMeshB->getVertices(), facetBEdges, facetBEdgeCount, newPointA, newPointB);
-				}
-				inclusionValue = -inclusionValueEdgeFace(mode, statusValue);
-				if (inclusionValue > 0)
-				{
-					for (ic = 0; ic < inclusionValue; ++ic)
-					{
-						retainedEnds.push_back(std::make_pair(newPointA, newPointB));
-						compositeEndPoint += newPointA.p;
-					}
-					mEdgeFacetIntersectionData12[facetA].push_back(EdgeFacetIntersectionData(i, statusValue, newPointA));
-				}
-				if (inclusionValue < 0)
-				{
-					for (ic = 0; ic < -inclusionValue; ++ic)
-					{
-						retainedStarts.push_back(std::make_pair(newPointA, newPointB));
-						compositeStartPoint += newPointA.p;
-					}
-					mEdgeFacetIntersectionData12[facetA].push_back(EdgeFacetIntersectionData(i, statusValue, newPointA));
-				}
-				fae++;
-			}
-			for (uint32_t i = 0; i < facetBEdgeCount; ++i)
-			{
-				if (shouldSwap(meshBPoints[fbe->e].p, meshBPoints[fbe->s].p))
-				{
-					statusValue = -edgeFacetIntersection21(meshBPoints[(fbe)->e], meshBPoints[(fbe)->s], mMeshA->getVertices(), facetAEdges, facetAEdgeCount, newPointA, newPointB);
-				}
-				else
-				{
-					statusValue = edgeFacetIntersection21(meshBPoints[(fbe)->s], meshBPoints[(fbe)->e], mMeshA->getVertices(), facetAEdges, facetAEdgeCount, newPointA, newPointB);
-				}
-				inclusionValue = inclusionValueEdgeFace(mode, statusValue);
-				if (inclusionValue > 0)
-				{
-					for (ic = 0; ic < inclusionValue; ++ic)
-					{
-						retainedEnds.push_back(std::make_pair(newPointA, newPointB));
-						compositeEndPoint += newPointB.p;
-					}
-					mEdgeFacetIntersectionData21[facetB].push_back(EdgeFacetIntersectionData( i, statusValue, newPointB));
-				}
-				if (inclusionValue < 0)
-				{
-					for (ic = 0; ic < -inclusionValue; ++ic)
-					{
-						retainedStarts.push_back(std::make_pair(newPointA, newPointB));
-						compositeStartPoint += newPointB.p;
-					}
-					mEdgeFacetIntersectionData21[facetB].push_back(EdgeFacetIntersectionData(i, statusValue, newPointB));
-				}
-				fbe++;
-			}
-			if (retainedStarts.size() != retainedEnds.size())
-			{
-				NVBLAST_LOG_ERROR(mLoggingCallback, "Not equal number of starting and ending vertices! Probably input mesh has open edges.");
-				return;
-			}
-			if (retainedStarts.size() > 1)
-			{
-				comp.basePoint = compositeEndPoint - compositeStartPoint;
-				std::sort(retainedStarts.begin(), retainedStarts.end(), comp);
-				std::sort(retainedEnds.begin(), retainedEnds.end(), comp);
-			}
-			for (uint32_t rv = 0; rv < retainedStarts.size(); ++rv)
-			{
-				newEdge.s = addIfNotExist(retainedStarts[rv].first);
-				newEdge.e = addIfNotExist(retainedEnds[rv].first);
-				newEdge.parent = facetA;
-				addEdgeIfValid(newEdge);
-				newEdge.parent = facetB + mMeshA->getFacetCount();
-				newEdge.e = addIfNotExist(retainedStarts[rv].second);
-				newEdge.s = addIfNotExist(retainedEnds[rv].second);
-				addEdgeIfValid(newEdge);
-			}
-			facetA = mAcceleratorA->getNextFacet();
-		} // while (*iter != -1)
-
-	} // for (uint32_t facetB = 0; facetB < mMeshB->getFacetCount(); ++facetB)
-
-
-
-}
-
-
-void BooleanEvaluator::buildFastFaceFaceIntersection(BooleanConf mode)
-{
-	int32_t statusValue = 0;
-	int32_t inclusionValue = 0;
-
-	std::vector<std::pair<Vertex, Vertex> > retainedStarts;
-	std::vector<std::pair<Vertex, Vertex>> retainedEnds;
-	VertexPairComparator comp;
-
-	Vertex newPointA;
-	Vertex newPointB;
-
-	Vertex* meshAPoints = mMeshA->getVertices();
-	EdgeWithParent newEdge;
-
-	mEdgeFacetIntersectionData12.clear();
-	mEdgeFacetIntersectionData21.clear();
-
-	mEdgeFacetIntersectionData12.resize(mMeshA->getFacetCount());
-	mEdgeFacetIntersectionData21.resize(mMeshB->getFacetCount());
-
-	for (uint32_t facetA = 0; facetA < mMeshA->getFacetCount(); ++facetA)
-	{
-		Edge* facetAEdges = mMeshA->getEdges() + mMeshA->getFacet(facetA)->firstEdgeNumber;
-		int32_t facetB = 0;
-			Edge* facetBEdges = mMeshB->getEdges() + mMeshB->getFacet(facetB)->firstEdgeNumber;
-			Edge* fae = facetAEdges;
-			retainedStarts.clear();
-			retainedEnds.clear();
-			PxVec3 compositeEndPoint(0, 0, 0);
-			PxVec3 compositeStartPoint(0, 0, 0);
-			uint32_t facetAEdgeCount = mMeshA->getFacet(facetA)->edgesCount;
-			uint32_t facetBEdgeCount = mMeshB->getFacet(facetB)->edgesCount;
-			int32_t ic = 0;
-			for (uint32_t i = 0; i < facetAEdgeCount; ++i)
-			{
-				if (shouldSwap(meshAPoints[fae->e].p, meshAPoints[fae->s].p))
-				{
-					statusValue = -edgeFacetIntersection12(meshAPoints[fae->e], meshAPoints[fae->s], mMeshB->getVertices(), facetBEdges, facetBEdgeCount, newPointA, newPointB);
-				}
-				else
-				{
-					statusValue = edgeFacetIntersection12(meshAPoints[fae->s], meshAPoints[fae->e], mMeshB->getVertices(), facetBEdges, facetBEdgeCount, newPointA, newPointB);
-				}
-				inclusionValue = -inclusionValueEdgeFace(mode, statusValue);
-				if (inclusionValue > 0)
-				{
-					for (ic = 0; ic < inclusionValue; ++ic)
-					{
-						retainedEnds.push_back(std::make_pair(newPointA, newPointB));
-						compositeEndPoint += newPointA.p;
-					}
-					mEdgeFacetIntersectionData12[facetA].push_back(EdgeFacetIntersectionData(i, statusValue, newPointA));
-				}
-				if (inclusionValue < 0)
-				{
-					for (ic = 0; ic < -inclusionValue; ++ic)
-					{
-						retainedStarts.push_back(std::make_pair(newPointA, newPointB));
-						compositeStartPoint += newPointA.p;
-					}
-					mEdgeFacetIntersectionData12[facetA].push_back(EdgeFacetIntersectionData(i, statusValue, newPointA));
-				}
-				fae++;
-			}
-			if (retainedStarts.size() != retainedEnds.size())
-			{
-				NVBLAST_LOG_ERROR(mLoggingCallback, "Not equal number of starting and ending vertices! Probably input mesh has open edges.");
-				return;
-			}
-			if (retainedStarts.size() > 1)
-			{
-				comp.basePoint = compositeEndPoint - compositeStartPoint;
-				std::sort(retainedStarts.begin(), retainedStarts.end(), comp);
-				std::sort(retainedEnds.begin(), retainedEnds.end(), comp);
-			}
-			for (uint32_t rv = 0; rv < retainedStarts.size(); ++rv)
-			{
-				newEdge.s = addIfNotExist(retainedStarts[rv].first);
-				newEdge.e = addIfNotExist(retainedEnds[rv].first);
-				newEdge.parent = facetA;
-				addEdgeIfValid(newEdge);
-				newEdge.parent = facetB + mMeshA->getFacetCount();
-				newEdge.e = addIfNotExist(retainedStarts[rv].second);
-				newEdge.s = addIfNotExist(retainedEnds[rv].second);
-				addEdgeIfValid(newEdge);
-			}
-	}
-
-}
-
-
-
-void BooleanEvaluator::collectRetainedPartsFromA(BooleanConf mode)
-{
-
-	int32_t statusValue = 0;
-	int32_t inclusionValue = 0;
-	Vertex* vertices = mMeshA->getVertices();
-	Vertex newPoint;
-	VertexComparator comp;
-	PxBounds3& bMeshBoudning = mMeshB->getBoundingBox();
-	Edge* facetEdges = mMeshA->getEdges();
-	std::vector<Vertex> retainedStartVertices;
-	std::vector<Vertex> retainedEndVertices;
-	retainedStartVertices.reserve(255);
-	retainedEndVertices.reserve(255);
-	int32_t ic = 0;
-	for (uint32_t facetId = 0; facetId < mMeshA->getFacetCount(); ++facetId)
-	{
-		retainedStartVertices.clear();
-		retainedEndVertices.clear();
-		for (uint32_t i = 0; i < mMeshA->getFacet(facetId)->edgesCount; ++i)
-		{
-			PxVec3 compositeEndPoint(0, 0, 0);
-			PxVec3 compositeStartPoint(0, 0, 0);
-
-			int32_t lastPos = static_cast<int32_t>(retainedEndVertices.size());
-			/* Test start and end point of edge against mesh */
-			if (bMeshBoudning.contains(vertices[facetEdges->s].p))
-			{
-				statusValue = vertexMeshStatus03(vertices[facetEdges->s].p, mMeshB);
-			}
-			else
-			{
-				statusValue = 0;
-			}
-			inclusionValue = -inclusionValue03(mode, statusValue);
-
-			if (inclusionValue > 0)
-			{
-				for (ic = 0; ic < inclusionValue; ++ic)
-				{
-					retainedEndVertices.push_back(vertices[facetEdges->s]);
-					compositeEndPoint += vertices[facetEdges->s].p;
-				}
-			}
-			else
-			{
-				if (inclusionValue < 0)
-				{
-					for (ic = 0; ic < -inclusionValue; ++ic)
-					{
-						retainedStartVertices.push_back(vertices[facetEdges->s]);
-						compositeStartPoint += vertices[facetEdges->s].p;
-					}
-				}
-			}
-
-			if (bMeshBoudning.contains(vertices[facetEdges->e].p))
-			{
-				statusValue = vertexMeshStatus03(vertices[facetEdges->e].p, mMeshB);
-			}
-			else
-			{
-				statusValue = 0;
-			}
-			inclusionValue = inclusionValue03(mode, statusValue);
-			if (inclusionValue > 0)
-			{
-				for (ic = 0; ic < inclusionValue; ++ic)
-				{
-					retainedEndVertices.push_back(vertices[facetEdges->e]);
-					compositeEndPoint += vertices[facetEdges->e].p;
-				}
-			}
-			else
-			{
-				if (inclusionValue < 0)
-				{
-					for (ic = 0; ic < -inclusionValue; ++ic)
-					{
-						retainedStartVertices.push_back(vertices[facetEdges->e]);
-						compositeStartPoint += vertices[facetEdges->e].p;
-					}
-				}
-			}
-			/* Test edge intersection with mesh*/
-			for (uint32_t intrs = 0; intrs < mEdgeFacetIntersectionData12[facetId].size(); ++intrs)
-			{
-				EdgeFacetIntersectionData& intr = mEdgeFacetIntersectionData12[facetId][intrs];
-				if (intr.edId != (int32_t)i)
-					continue;
-				newPoint = intr.intersectionPoint;
-				inclusionValue = inclusionValueEdgeFace(mode, intr.intersectionType);
-
-				if (inclusionValue > 0)
-				{
-					for (ic = 0; ic < inclusionValue; ++ic)
-					{
-						retainedEndVertices.push_back(newPoint);
-						compositeEndPoint += newPoint.p;
-					}
-				}
-				else
-				{
-					if (inclusionValue < 0)
-					{
-						for (ic = 0; ic < -inclusionValue; ++ic)
-						{
-							retainedStartVertices.push_back(newPoint);
-							compositeStartPoint += newPoint.p;
-						}
-					}
-				}
-			}
-			facetEdges++;
-			if (retainedStartVertices.size() != retainedEndVertices.size())
-			{
-				NVBLAST_LOG_ERROR(mLoggingCallback, "Not equal number of starting and ending vertices! Probably input mesh has open edges.");
-				return;
-			}
-			if (retainedEndVertices.size() > 1)
-			{
-				comp.basePoint = compositeEndPoint - compositeStartPoint;
-				std::sort(retainedStartVertices.begin() + lastPos, retainedStartVertices.end(), comp);
-				std::sort(retainedEndVertices.begin() + lastPos, retainedEndVertices.end(), comp);
-			}
-		}
-
-
-		EdgeWithParent newEdge;
-		for (uint32_t rv = 0; rv < retainedStartVertices.size(); ++rv)
-		{
-			newEdge.s = addIfNotExist(retainedStartVertices[rv]);
-			newEdge.e = addIfNotExist(retainedEndVertices[rv]);
-			newEdge.parent = facetId;
-			addEdgeIfValid(newEdge);
-		}
-	}
-
-	return;
-}
-
-void BooleanEvaluator::collectRetainedPartsFromB(BooleanConf mode)
-{
-	int32_t statusValue = 0;
-	int32_t inclusionValue = 0;
-	Vertex* vertices = mMeshB->getVertices();
-	Vertex newPoint;
-	VertexComparator comp;
-	PxBounds3& aMeshBoudning = mMeshA->getBoundingBox();
-	Edge* facetEdges = mMeshB->getEdges();
-	std::vector<Vertex> retainedStartVertices;
-	std::vector<Vertex> retainedEndVertices;
-	retainedStartVertices.reserve(255);
-	retainedEndVertices.reserve(255);
-	int32_t ic = 0;
-	for (uint32_t facetId = 0; facetId < mMeshB->getFacetCount(); ++facetId)
-	{
-		retainedStartVertices.clear();
-		retainedEndVertices.clear();
-		for (uint32_t i = 0; i < mMeshB->getFacet(facetId)->edgesCount; ++i)
-		{
-			PxVec3 compositeEndPoint(0, 0, 0);
-			PxVec3 compositeStartPoint(0, 0, 0);
-			int32_t lastPos = static_cast<int32_t>(retainedEndVertices.size());
-			if (aMeshBoudning.contains(vertices[facetEdges->s].p))
-			{
-				statusValue = vertexMeshStatus30(vertices[facetEdges->s].p, mMeshA);
-			}
-			else
-			{
-				statusValue = 0;
-			}
-			inclusionValue = -inclusionValue30(mode, statusValue);
-
-			if (inclusionValue > 0)
-			{
-				for (ic = 0; ic < inclusionValue; ++ic)
-				{
-					retainedEndVertices.push_back(vertices[facetEdges->s]);
-					compositeEndPoint += vertices[facetEdges->s].p;
-				}
-
-			}
-			else
-			{
-				if (inclusionValue < 0)
-				{
-					for (ic = 0; ic < -inclusionValue; ++ic)
-					{
-						retainedStartVertices.push_back(vertices[facetEdges->s]);
-						compositeStartPoint += vertices[facetEdges->s].p;
-					}
-
-				}
-			}
-
-			if (aMeshBoudning.contains(vertices[facetEdges->e].p))
-			{
-				statusValue = vertexMeshStatus30(vertices[facetEdges->e].p, mMeshA);
-			}
-			else
-			{
-				statusValue = 0;
-			}
-			inclusionValue = inclusionValue30(mode, statusValue);
-			if (inclusionValue > 0)
-			{
-				for (ic = 0; ic < inclusionValue; ++ic)
-				{
-					retainedEndVertices.push_back(vertices[facetEdges->e]);
-					compositeEndPoint += vertices[facetEdges->e].p;
-				}
-
-			}
-			else
-			{
-				if (inclusionValue < 0)
-				{
-					for (ic = 0; ic < -inclusionValue; ++ic)
-					{
-						retainedStartVertices.push_back(vertices[facetEdges->e]);
-						compositeStartPoint += vertices[facetEdges->e].p;
-					}
-
-				}
-			}
-			for (uint32_t intrs = 0; intrs < mEdgeFacetIntersectionData21[facetId].size(); ++intrs)
-			{
-				EdgeFacetIntersectionData& intr = mEdgeFacetIntersectionData21[facetId][intrs];
-				if (intr.edId != (int32_t)i)
-					continue;
-				newPoint = intr.intersectionPoint;
-				inclusionValue = inclusionValueEdgeFace(mode, intr.intersectionType);
-
-				if (inclusionValue > 0)
-				{
-					for (ic = 0; ic < inclusionValue; ++ic)
-					{
-						retainedEndVertices.push_back(newPoint);
-						compositeEndPoint += newPoint.p;
-					}
-				}
-				else
-				{
-					if (inclusionValue < 0)
-					{
-						for (ic = 0; ic < -inclusionValue; ++ic)
-						{
-							retainedStartVertices.push_back(newPoint);
-							compositeStartPoint += newPoint.p;
-						}
-					}
-				}
-			}
-			facetEdges++;
-			if (retainedStartVertices.size() != retainedEndVertices.size())
-			{
-				NVBLAST_LOG_ERROR(mLoggingCallback, "Not equal number of starting and ending vertices! Probably input mesh has open edges.");
-				return;
-			}
-			if (retainedEndVertices.size() - lastPos > 1)
-			{
-				comp.basePoint = compositeEndPoint - compositeStartPoint;
-				std::sort(retainedStartVertices.begin() + lastPos, retainedStartVertices.end(), comp);
-				std::sort(retainedEndVertices.begin() + lastPos, retainedEndVertices.end(), comp);
-			}
-		}
-		EdgeWithParent newEdge;
-		for (uint32_t rv = 0; rv < retainedStartVertices.size(); ++rv)
-		{
-			newEdge.s = addIfNotExist(retainedStartVertices[rv]);
-			newEdge.e = addIfNotExist(retainedEndVertices[rv]);
-			newEdge.parent = facetId + mMeshA->getFacetCount();
-			addEdgeIfValid(newEdge);
-		}
-	}
-	return;
-}
-
-bool EdgeWithParentSortComp(const EdgeWithParent& a, const EdgeWithParent& b)
-{
-	return a.parent < b.parent;
-}
-
-
-void BooleanEvaluator::performBoolean(Mesh* meshA, Mesh* meshB, SpatialAccelerator* spAccelA, SpatialAccelerator* spAccelB, BooleanConf mode)
-{
-	reset();
-	mMeshA = meshA;
-	mMeshB = meshB;
-	mAcceleratorA = spAccelA;
-	mAcceleratorB = spAccelB;
-	buildFaceFaceIntersections(mode);
-	collectRetainedPartsFromA(mode);
-	collectRetainedPartsFromB(mode);
-	mAcceleratorA = nullptr;
-	mAcceleratorB = nullptr;
-}
-
-void BooleanEvaluator::performBoolean(Mesh* meshA, Mesh* meshB, BooleanConf mode)
-{
-	reset();
-	mMeshA = meshA;
-	mMeshB = meshB;
-	DummyAccelerator ac = DummyAccelerator(mMeshA->getFacetCount());
-	DummyAccelerator bc = DummyAccelerator(mMeshB->getFacetCount());
-	performBoolean(meshA, meshB, &ac, &bc, mode);
-}
-
-
-void BooleanEvaluator::performFastCutting(Mesh* meshA, Mesh* meshB, SpatialAccelerator* spAccelA, SpatialAccelerator* spAccelB, BooleanConf mode)
-{
-	reset();
-	mMeshA = meshA;
-	mMeshB = meshB;
-	mAcceleratorA = spAccelA;
-	mAcceleratorB = spAccelB;
-	buildFastFaceFaceIntersection(mode);
-	collectRetainedPartsFromA(mode);
-	mAcceleratorA = nullptr;
-	mAcceleratorB = nullptr;
-}
-
-void BooleanEvaluator::performFastCutting(Mesh* meshA, Mesh* meshB, BooleanConf mode)
-{
-	reset();
-	mMeshA = meshA;
-	mMeshB = meshB;
-	DummyAccelerator ac = DummyAccelerator(mMeshA->getFacetCount());
-	DummyAccelerator bc = DummyAccelerator(mMeshB->getFacetCount());
-	performFastCutting(meshA, meshB, &ac, &bc, mode);
-}
-
-
-
-
-BooleanEvaluator::BooleanEvaluator(NvBlastLog loggingCallback)
-{
-	mMeshA = nullptr;
-	mMeshB = nullptr;
-	mAcceleratorA = nullptr;
-	mAcceleratorB = nullptr;
-	mLoggingCallback = loggingCallback;
-}
-BooleanEvaluator::~BooleanEvaluator()
-{
-	reset();
-}
-
-
-
-Mesh* BooleanEvaluator::createNewMesh()
-{
-	if (mEdgeAggregate.size() == 0)
-	{
-		return nullptr;
-	}
-	std::sort(mEdgeAggregate.begin(), mEdgeAggregate.end(), EdgeWithParentSortComp);
-	std::vector<Facet> newFacets;
-	std::vector<Edge>  newEdges(mEdgeAggregate.size());
-	int32_t lastPos = 0;
-	int32_t lastParent = mEdgeAggregate[0].parent;
-	uint32_t collected = 0;
-	int32_t userData = 0;
-	for (uint32_t i = 0; i < mEdgeAggregate.size(); ++i)
-	{
-		if (mEdgeAggregate[i].parent != lastParent)
-		{			
-			if (lastParent < (int32_t)mMeshA->getFacetCount())
-			{
-				userData = mMeshA->getFacet(lastParent)->userData;
-			}
-			else
-			{
-				userData = mMeshB->getFacet(lastParent - mMeshA->getFacetCount())->userData;
-			}
-			newFacets.push_back(Facet(lastPos, collected, userData));
-			lastPos = i;
-			lastParent = mEdgeAggregate[i].parent;
-			collected = 0;
-		}
-		collected++;
-		newEdges[i].s = mEdgeAggregate[i].s;
-		newEdges[i].e = mEdgeAggregate[i].e;
-	}
-	int32_t pr = lastParent - mMeshA->getFacetCount();
-	if (lastParent < (int32_t)mMeshA->getFacetCount())
-	{
-		userData = mMeshA->getFacet(lastParent)->userData;
-	}
-	else
-	{
-		userData = mMeshB->getFacet(pr)->userData;
-	}
-	newFacets.push_back(Facet(lastPos, collected, userData));
-	return new Mesh(&mVerticesAggregate[0], &newEdges[0], &newFacets[0], static_cast<uint32_t>(mVerticesAggregate.size()), static_cast<uint32_t>(mEdgeAggregate.size()), static_cast<uint32_t>(newFacets.size()));
-}
-
-void BooleanEvaluator::reset()
-{
-	mMeshA			= nullptr;
-	mMeshB			= nullptr;
-	mAcceleratorA	= nullptr;
-	mAcceleratorB	= nullptr;
-	mEdgeAggregate.clear();
-	mVerticesAggregate.clear();
-	mEdgeFacetIntersectionData12.clear();
-	mEdgeFacetIntersectionData21.clear();
-}
-
-} // namespace Blast
-} // namespace Nv
diff --git a/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringBooleanTool.h b/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringBooleanTool.h
deleted file mode 100644
index 0b0b73a..0000000
--- a/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringBooleanTool.h
+++ /dev/null
@@ -1,197 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTAUTHORINGBOOLEANTOOL_H
-#define NVBLASTEXTAUTHORINGBOOLEANTOOL_H
-
-#include "NvBlastExtAuthoringTypes.h"
-#include "NvBlastExtAuthoringInternalCommon.h"
-#include <vector>
-#include <map>
-#include "NvBlastTypes.h"
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-class Mesh;
-
-/**
-	Boolean tool config, used to perform different operations: UNION, INTERSECTION, DIFFERENCE
-*/
-struct BooleanConf
-{
-	int32_t ca, cb, ci;
-	BooleanConf(int32_t a, int32_t b, int32_t c) : ca(a), cb(b), ci(c)
-	{
-	}
-};
-
-
-namespace BooleanConfigurations
-{
-	/**
-		Creates boolean tool configuration to perform intersection of meshes A and B.
-	*/
-inline BooleanConf BOOLEAN_INTERSECION()
-{
-	return BooleanConf(0, 0, 1);
-}
-
-/**
-	Creates boolean tool configuration to perform union of meshes A and B.
-*/
-inline BooleanConf BOOLEAN_UNION()
-{
-	return BooleanConf(1, 1, -1);
-}
-/**
-	Creates boolean tool configuration to perform difference of meshes(A - B).
-*/
-inline BooleanConf BOOLEAN_DIFFERENCE()
-{
-	return BooleanConf(1, 0, -1);
-}
-}
-
-/**
-	Structure which holds information about intersection facet with edge.
-*/
-struct EdgeFacetIntersectionData
-{
-	int32_t	edId;
-	int32_t	intersectionType;
-	Vertex	intersectionPoint;
-	EdgeFacetIntersectionData(int32_t edId, int32_t intersType, Vertex& inters) : edId(edId), intersectionType(intersType), intersectionPoint(inters)
-	{	}
-	EdgeFacetIntersectionData(int32_t edId) : edId(edId)
-	{	}
-	bool operator<(const EdgeFacetIntersectionData& b) const
-	{
-		return edId < b.edId;
-	}
-};
-
-
-class SpatialAccelerator;
-
-/**
-	Tool for performing boolean operations on polygonal meshes.
-	Tool supports only closed meshes. Performing boolean on meshes with holes can lead to unexpected behavior, e.g. holes in result geometry.
-*/
-class BooleanEvaluator
-{
-
-public:
-	BooleanEvaluator(NvBlastLog logCallback = nullptr);
-	~BooleanEvaluator();
-
-	/**
-		Perform boolean operation on two polygonal meshes (A and B).
-		\param[in] meshA	Mesh A 
-		\param[in] meshB	Mesh B
-		\param[in] spAccelA Acceleration structure for mesh A
-		\param[in] spAccelB Acceleration structure for mesh B
-		\param[in] mode		Boolean operation type
-	*/
-	void	performBoolean(Mesh* meshA, Mesh* meshB, SpatialAccelerator* spAccelA, SpatialAccelerator* spAccelB, BooleanConf mode);
-
-	/**
-		Perform boolean operation on two polygonal meshes (A and B).
-		\param[in] meshA	Mesh A
-		\param[in] meshB	Mesh B
-		\param[in] mode		Boolean operation type
-	*/
-	void	performBoolean(Mesh* meshA, Mesh* meshB, BooleanConf mode);
-
-	/**
-		Perform cutting of mesh with some large box, which represents cutting plane. This method skips part of intersetion computations, so
-		should be used ONLY with cutting box, received from getBigBox(...) method from NvBlastExtAuthoringMesh.h. For cutting use only BOOLEAN_INTERSECTION or BOOLEAN_DIFFERENCE mode.
-		\param[in] meshA	Mesh A
-		\param[in] meshB	Cutting box
-		\param[in] spAccelA Acceleration structure for mesh A
-		\param[in] spAccelB Acceleration structure for cutting box
-		\param[in] mode		Boolean operation type
-	*/
-	void	performFastCutting(Mesh* meshA, Mesh* meshB, SpatialAccelerator* spAccelA, SpatialAccelerator* spAccelB, BooleanConf mode);
-
-	/**
-		Perform cutting of mesh with some large box, which represents cutting plane. This method skips part of intersetion computations, so
-		should be used ONLY with cutting box, received from getBigBox(...) method from NvBlastExtAuthoringMesh.h. For cutting use only BOOLEAN_INTERSECTION or BOOLEAN_DIFFERENCE mode.
-		\param[in] meshA	Mesh A
-		\param[in] meshB	Cutting box
-		\param[in] mode		Boolean operation type
-	*/
-	void	performFastCutting(Mesh* meshA, Mesh* meshB, BooleanConf mode);
-
-	/**
-		Test whether point contained in mesh.
-		\param[in] mesh		Mesh geometry
-		\param[in] point	Point which should be tested
-		\return not 0 if point is inside of mesh
-	*/
-	int32_t	isPointContainedInMesh(Mesh* mesh, const physx::PxVec3& point);
-	/**
-		Test whether point contained in mesh.
-		\param[in] mesh		Mesh geometry
-		\param[in] spAccel	Acceleration structure for mesh
-		\param[in] point	Point which should be tested
-		\return not 0 if point is inside of mesh
-	*/
-	int32_t	isPointContainedInMesh(Mesh* mesh, SpatialAccelerator* spAccel, const physx::PxVec3& point);
-
-
-	/**
-		Generates result polygon mesh after performing boolean operation.
-		\return If not nullptr - result mesh geometry.
-	*/
-	Mesh*	createNewMesh();
-
-	/**
-		Reset tool state.
-	*/
-	void	reset();
-
-private:
-
-	void	buildFaceFaceIntersections(BooleanConf);
-	void	buildFastFaceFaceIntersection(BooleanConf);
-	void	collectRetainedPartsFromA(BooleanConf mode);
-	void	collectRetainedPartsFromB(BooleanConf mode);
-
-	int32_t	addIfNotExist(Vertex& p);
-	void	addEdgeIfValid(EdgeWithParent& ed);
-private:
-
-	int32_t	vertexMeshStatus03(const physx::PxVec3& p, Mesh* mesh);
-	int32_t	vertexMeshStatus30(const physx::PxVec3& p, Mesh* mesh);
-
-	Mesh*													mMeshA;
-	Mesh*													mMeshB;
-
-	SpatialAccelerator*										mAcceleratorA;
-	SpatialAccelerator*										mAcceleratorB;
-
-	std::vector<EdgeWithParent>								mEdgeAggregate;
-	std::vector<Vertex>										mVerticesAggregate;
-
-	std::vector<std::vector<EdgeFacetIntersectionData> >	mEdgeFacetIntersectionData12;
-	std::vector<std::vector<EdgeFacetIntersectionData> >	mEdgeFacetIntersectionData21;
-
-	NvBlastLog	mLoggingCallback;
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTEXTAUTHORINGBOOLEANTOOL_H
diff --git a/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringCollisionBuilder.cpp b/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringCollisionBuilder.cpp
deleted file mode 100644
index becdce9..0000000
--- a/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringCollisionBuilder.cpp
+++ /dev/null
@@ -1,279 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastExtAuthoringCollisionBuilder.h"
-#include <PxConvexMesh.h>
-#include <PxVec3.h>
-#include <PxBounds3.h>
-#include "PxPhysics.h"
-#include "cooking/PxCooking.h"
-#include  <NvBlastExtApexSharedParts.h>
-#include <NvBlastExtAuthoringInternalCommon.h>
-
-#include <NvBlastExtAuthoringBooleanTool.h>
-#include <NvBlastExtAuthoringMesh.h>
-
-using namespace physx;
-
-namespace Nv
-{
-namespace Blast
-{
-
-void ConvexMeshBuilder::buildCollisionGeometry(const std::vector<PxVec3>& vData, CollisionHull& output)
-{
-	std::vector<physx::PxVec3> vertexData = vData;
-
-	PxConvexMeshDesc convexMeshDescr;
-	PxConvexMesh* resultConvexMesh;
-	PxBounds3 bounds;
-	// Scale chunk to unit cube size, to avoid numerical errors
-	bounds.setEmpty();
-	for (uint32_t i = 0; i < vertexData.size(); ++i)
-	{
-		bounds.include(vertexData[i]);
-	}
-	PxVec3 bbCenter = bounds.getCenter();
-	float scale = PxMax(PxAbs(bounds.getExtents(0)), PxMax(PxAbs(bounds.getExtents(1)), PxAbs(bounds.getExtents(2))));
-	for (uint32_t i = 0; i < vertexData.size(); ++i)
-	{
-		vertexData[i] = vertexData[i] - bbCenter;
-		vertexData[i] *= (1.0f / scale);
-	}
-	bounds.setEmpty();
-	for (uint32_t i = 0; i < vertexData.size(); ++i)
-	{
-		bounds.include(vertexData[i]);
-	}
-	convexMeshDescr.points.data = vertexData.data();
-	convexMeshDescr.points.stride = sizeof(PxVec3);
-	convexMeshDescr.points.count = (uint32_t)vertexData.size();
-	convexMeshDescr.flags = PxConvexFlag::eCOMPUTE_CONVEX;
-	resultConvexMesh = mCooking->createConvexMesh(convexMeshDescr, *mInsertionCallback);
-	if (!resultConvexMesh)
-	{
-		vertexData.clear();
-		vertexData.push_back(bounds.minimum);
-		vertexData.push_back(PxVec3(bounds.minimum.x, bounds.maximum.y, bounds.minimum.z));
-		vertexData.push_back(PxVec3(bounds.maximum.x, bounds.maximum.y, bounds.minimum.z));
-		vertexData.push_back(PxVec3(bounds.maximum.x, bounds.minimum.y, bounds.minimum.z));
-		vertexData.push_back(PxVec3(bounds.minimum.x, bounds.minimum.y, bounds.maximum.z));
-		vertexData.push_back(PxVec3(bounds.minimum.x, bounds.maximum.y, bounds.maximum.z));
-		vertexData.push_back(PxVec3(bounds.maximum.x, bounds.maximum.y, bounds.maximum.z));
-		vertexData.push_back(PxVec3(bounds.maximum.x, bounds.minimum.y, bounds.maximum.z));
-		convexMeshDescr.points.data = vertexData.data();
-		convexMeshDescr.points.count = (uint32_t)vertexData.size();
-		resultConvexMesh = mCooking->createConvexMesh(convexMeshDescr, *mInsertionCallback);
-	}
-	output.polygonData.resize(resultConvexMesh->getNbPolygons());
-	output.points.resize(resultConvexMesh->getNbVertices());
-	int32_t indicesCount = 0;
-	PxHullPolygon hPoly;
-	for (uint32_t i = 0; i < resultConvexMesh->getNbPolygons(); ++i)
-	{
-		CollisionHull::HullPolygon& pd = output.polygonData[i];
-		resultConvexMesh->getPolygonData(i, hPoly);
-		pd.mIndexBase = hPoly.mIndexBase;
-		pd.mNbVerts = hPoly.mNbVerts;
-		pd.mPlane[0] = hPoly.mPlane[0];
-		pd.mPlane[1] = hPoly.mPlane[1];
-		pd.mPlane[2] = hPoly.mPlane[2];
-		pd.mPlane[3] = hPoly.mPlane[3];
-
-		pd.mPlane[0] /= scale;
-		pd.mPlane[1] /= scale;
-		pd.mPlane[2] /= scale;
-		pd.mPlane[3] -= (pd.mPlane[0] * bbCenter.x + pd.mPlane[1] * bbCenter.y + pd.mPlane[2] * bbCenter.z);
-		float length = sqrt(pd.mPlane[0] * pd.mPlane[0] + pd.mPlane[1] * pd.mPlane[1] + pd.mPlane[2] * pd.mPlane[2]);
-		pd.mPlane[0] /= length;
-		pd.mPlane[1] /= length;
-		pd.mPlane[2] /= length;
-		pd.mPlane[3] /= length;
-		indicesCount = PxMax(indicesCount, pd.mIndexBase + pd.mNbVerts);
-	}
-	output.indices.resize(indicesCount);
-	for (uint32_t i = 0; i < resultConvexMesh->getNbVertices(); ++i)
-	{
-		PxVec3 p = resultConvexMesh->getVertices()[i] * scale + bbCenter;
-		output.points[i] = p;
-	}
-	for (int32_t i = 0; i < indicesCount; ++i)
-	{
-		output.indices[i] = resultConvexMesh->getIndexBuffer()[i];
-	}
-	resultConvexMesh->release();
-}
-
-void ConvexMeshBuilder::trimCollisionGeometry(std::vector<CollisionHull>& in, const std::vector<uint32_t>& chunkDepth)
-{
-	std::vector<std::vector<PxPlane> > chunkMidplanes(in.size());
-	std::vector<PxVec3> centers(in.size());
-	std::vector<PxBounds3> hullsBounds(in.size());
-	for (uint32_t i = 0; i < in.size(); ++i)
-	{
-		hullsBounds[i].setEmpty();
-		centers[i] = PxVec3(0, 0, 0);
-		for (uint32_t p = 0; p < in[i].points.size(); ++p)
-		{
-			centers[i] += in[i].points[p];
-			hullsBounds[i].include(in[i].points[p]);
-		}
-		centers[i] = hullsBounds[i].getCenter();
-	}
-
-	Separation params;
-	for (uint32_t hull = 0; hull < in.size(); ++hull)
-	{
-		for (uint32_t hull2 = hull + 1; hull2 < in.size(); ++hull2)
-		{
-			if (chunkDepth[hull] != chunkDepth[hull2])
-			{
-				continue;
-			}
-			if (importerHullsInProximityApexFree(in[hull].points, hullsBounds[hull], PxTransform(PxIdentity), PxVec3(1, 1, 1),
-				in[hull2].points, hullsBounds[hull2], PxTransform(PxIdentity), PxVec3(1, 1, 1), 0.0, &params) == false)
-			{
-				continue;
-			}
-			PxVec3 c1 = centers[hull];
-			PxVec3 c2 = centers[hull2];
-			float d = FLT_MAX;
-			PxVec3 n1;
-			PxVec3 n2;
-			for (uint32_t p = 0; p < in[hull].points.size(); ++p)
-			{
-				float ld = (in[hull].points[p] - c2).magnitude();
-				if (ld < d)
-				{
-					n1 = in[hull].points[p];
-					d = ld;
-				}
-			}
-			d = FLT_MAX;
-			for (uint32_t p = 0; p < in[hull2].points.size(); ++p)
-			{
-				float ld = (in[hull2].points[p] - c1).magnitude();
-				if (ld < d)
-				{
-					n2 = in[hull2].points[p];
-					d = ld;
-				}
-			}
-
-			PxVec3 dir = c2 - c1;
-
-			PxPlane pl = PxPlane((n1 + n2) * 0.5, dir.getNormalized());
-			chunkMidplanes[hull].push_back(pl);
-			PxPlane pl2 = PxPlane((n1 + n2) * 0.5, -dir.getNormalized());
-			chunkMidplanes[hull2].push_back(pl2);		
-		}
-	}
-	std::vector<PxVec3> hPoints;
-	for (uint32_t i = 0; i < in.size(); ++i)
-	{
-		std::vector<Facet> facets;
-		std::vector<Vertex> vertices;
-		std::vector<Edge> edges;
-		for (uint32_t fc = 0; fc < in[i].polygonData.size(); ++fc)
-		{
-			Facet nFc;
-			nFc.firstEdgeNumber = edges.size();
-			uint32_t n = in[i].polygonData[fc].mNbVerts;
-			for (uint32_t ed = 0; ed < n; ++ed)
-			{
-				uint32_t vr1 = in[i].indices[(ed) + in[i].polygonData[fc].mIndexBase];
-				uint32_t vr2 = in[i].indices[(ed + 1) % n + in[i].polygonData[fc].mIndexBase];
-				edges.push_back(Edge(vr1, vr2));
-			}
-			nFc.edgesCount = n;
-			facets.push_back(nFc);
-		}
-		vertices.resize(in[i].points.size());
-		for (uint32_t vr = 0; vr < in[i].points.size(); ++vr)
-		{
-			vertices[vr].p = in[i].points[vr];
-		}
-		Mesh* hullMesh = new Mesh(vertices.data(), edges.data(), facets.data(), vertices.size(), edges.size(), facets.size());
-		BooleanEvaluator evl;
-		Mesh* cuttingMesh = getCuttingBox(PxVec3(0, 0, 0), PxVec3(0, 0, 1), 40, 0);
-		for (uint32_t p = 0; p < chunkMidplanes[i].size(); ++p)
-		{
-			PxPlane& pl = chunkMidplanes[i][p];
-			setCuttingBox(pl.pointInPlane(), pl.n.getNormalized(), cuttingMesh, 60, 0);
-			evl.performFastCutting(hullMesh, cuttingMesh, BooleanConfigurations::BOOLEAN_DIFFERENCE());
-			Mesh* result = evl.createNewMesh();
-			if (result == nullptr)
-			{
-				break;
-			}
-			delete hullMesh;
-			hullMesh = result;
-		}
-		delete cuttingMesh;
-		if (hullMesh == nullptr)
-		{
-			continue;
-		}
-		hPoints.clear();
-		hPoints.resize(hullMesh->getVerticesCount());
-		for (uint32_t v = 0; v < hullMesh->getVerticesCount(); ++v)
-		{
-			hPoints[v] = hullMesh->getVertices()[v].p;
-		}
-		delete hullMesh;
-		buildCollisionGeometry(hPoints, in[i]);
-	}
-}
-
-
-PxConvexMesh* ConvexMeshBuilder::buildConvexMesh(std::vector<PxVec3>& vertexData)
-{
-	CollisionHull hull;
-	buildCollisionGeometry(vertexData, hull);
-
-	PxConvexMeshDesc convexMeshDescr;
-	convexMeshDescr.indices.data = hull.indices.data();
-	convexMeshDescr.indices.count = (uint32_t)hull.indices.size();
-	convexMeshDescr.indices.stride = sizeof(uint32_t);
-
-	convexMeshDescr.points.data = hull.points.data();
-	convexMeshDescr.points.count = (uint32_t)hull.points.size();
-	convexMeshDescr.points.stride = sizeof(PxVec3);
-
-	convexMeshDescr.polygons.data = hull.polygonData.data();
-	convexMeshDescr.polygons.count = (uint32_t)hull.polygonData.size();
-	convexMeshDescr.polygons.stride = sizeof(PxHullPolygon);
-
-	PxConvexMesh* convexMesh = mCooking->createConvexMesh(convexMeshDescr, *mInsertionCallback);
-	return convexMesh;
-}
-
-PxConvexMesh* ConvexMeshBuilder::buildConvexMesh(CollisionHull& hull)
-{	
-	PxConvexMeshDesc convexMeshDescr;
-	convexMeshDescr.indices.data = hull.indices.data();
-	convexMeshDescr.indices.count = (uint32_t)hull.indices.size();
-	convexMeshDescr.indices.stride = sizeof(uint32_t);
-
-	convexMeshDescr.points.data = hull.points.data();
-	convexMeshDescr.points.count = (uint32_t)hull.points.size();
-	convexMeshDescr.points.stride = sizeof(PxVec3);
-
-	convexMeshDescr.polygons.data = hull.polygonData.data();
-	convexMeshDescr.polygons.count = (uint32_t)hull.polygonData.size();
-	convexMeshDescr.polygons.stride = sizeof(PxHullPolygon);
-
-	PxConvexMesh* convexMesh = mCooking->createConvexMesh(convexMeshDescr, *mInsertionCallback);
-	return convexMesh;
-}
-
-
-} // namespace Blast
-} // namespace Nv
diff --git a/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringFractureTool.cpp b/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringFractureTool.cpp
deleted file mode 100644
index 48830fe..0000000
--- a/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringFractureTool.cpp
+++ /dev/null
@@ -1,1510 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastExtAuthoringFractureTool.h"
-// This warning arises when using some stl containers with older versions of VC
-// c:\program files (x86)\microsoft visual studio 12.0\vc\include\xtree(1826): warning C4702: unreachable code
-#if NV_VC && NV_VC < 14
-#pragma warning(disable : 4702)
-#endif
-#include <queue>
-#include <vector>
-#include "NvBlastExtAuthoringVSA.h"
-#include <float.h>
-#include "NvBlastExtAuthoringTriangulator.h"
-#include "NvBlastExtAuthoringBooleanTool.h"
-#include "NvBlastExtAuthoringAccelerator.h"
-#include "NvBlast.h"
-#include "NvBlastExtAuthoringPerlinNoise.h"
-#include <NvBlastAssert.h>
-using namespace physx;
-
-#define DEFAULT_BB_ACCELARATOR_RES 10
-
-namespace Nv
-{
-namespace Blast
-{
-
-struct Halfspace_partitioning : public VSA::VS3D_Halfspace_Set
-{
-	std::vector<physx::PxPlane> planes;
-	VSA::real farthest_halfspace(VSA::real plane[4], const VSA::real point[4])
-	{
-		float biggest_d = -FLT_MAX;
-		for (uint32_t i = 0; i < planes.size(); ++i)
-		{
-			float d = planes[i].n.x * point[0] + planes[i].n.y * point[1] + planes[i].n.z * point[2] + planes[i].d * point[3];
-			if (d > biggest_d)
-			{
-				biggest_d = d;
-				plane[0] = planes[i].n.x;
-				plane[1] = planes[i].n.y;
-				plane[2] = planes[i].n.z;
-				plane[3] = planes[i].d;
-			}
-		}
-		return biggest_d;
-	};
-};
-
-
-void findCellBasePlanes(const std::vector<PxVec3>& sites, std::vector<std::vector<int32_t> >& neighboors)
-{
-	Halfspace_partitioning prt;
-	std::vector<physx::PxPlane>& planes = prt.planes;
-	neighboors.resize(sites.size());
-	for (uint32_t cellId = 0; cellId + 1 < sites.size(); ++cellId)
-	{
-		planes.clear();
-		planes.resize(sites.size() - 1 - cellId);
-		std::vector<PxVec3> midpoints(sites.size() - 1);
-		int32_t collected = 0;
-
-		for (uint32_t i = cellId + 1; i < sites.size(); ++i)
-		{
-			PxVec3 midpoint = 0.5 * (sites[i] + sites[cellId]);
-			PxVec3 direction = (sites[i] - sites[cellId]).getNormalized();
-			planes[collected].n = direction;
-			planes[collected].d = -direction.dot(midpoint);
-			midpoints[collected] = midpoint;
-			++collected;
-		}
-		for (uint32_t i = 0; i < planes.size(); ++i)
-		{
-			planes[i].n = -planes[i].n;
-			planes[i].d = -planes[i].d;
-
-			if (VSA::vs3d_test(prt))
-			{
-				neighboors[cellId].push_back(i + cellId + 1);
-				neighboors[i + cellId + 1].push_back(cellId);
-			};
-			planes[i].n = -planes[i].n;
-			planes[i].d = -planes[i].d;
-		}
-	}
-}
-
-
-#define SITE_BOX_SIZE 4
-#define CUTTING_BOX_SIZE 40
-
-Mesh* getCellMesh(BooleanEvaluator& eval, int32_t planeIndexerOffset, int32_t cellId, const std::vector<PxVec3>& sites, std::vector < std::vector<int32_t> >& neighboors)
-{
-	Mesh* cell = getBigBox(sites[cellId], SITE_BOX_SIZE);
-	Mesh* cuttingMesh = getCuttingBox(PxVec3(0, 0, 0), PxVec3(1, 1, 1), CUTTING_BOX_SIZE, 0);
-
-	for (uint32_t i = 0; i < neighboors[cellId].size(); ++i)
-	{
-		int32_t nCell = neighboors[cellId][i];
-		PxVec3 midpoint = 0.5 * (sites[nCell] + sites[cellId]);
-		PxVec3 direction = (sites[nCell] - sites[cellId]).getNormalized();
-		int32_t planeIndex = static_cast<int32_t>(sites.size()) * std::min(cellId, nCell) + std::max(cellId, nCell) + planeIndexerOffset;
-		if (nCell < cellId)
-			planeIndex = -planeIndex;
-		setCuttingBox(midpoint, -direction, cuttingMesh, CUTTING_BOX_SIZE, planeIndex);
-		eval.performFastCutting(cell, cuttingMesh, BooleanConfigurations::BOOLEAN_INTERSECION());
-		Mesh* newCell = eval.createNewMesh();
-		delete cell;
-		cell = newCell;
-		if (cell == nullptr)
-			break;
-	}
-	return cell;
-}
-
-
-bool blastBondComparator(const NvBlastBondDesc& a, const NvBlastBondDesc& b)
-{
-	if (a.chunkIndices[0] == b.chunkIndices[0])
-		return a.chunkIndices[1] < b.chunkIndices[1];
-	else
-		return a.chunkIndices[0] < b.chunkIndices[0];
-}
-
-
-#define MAX_VORONOI_ATTEMPT_NUMBER 450
-
-VoronoiSitesGenerator::VoronoiSitesGenerator(Mesh* mesh, RandomGeneratorBase* rnd)
-{
-	mMesh = mesh;
-	mRnd = rnd;
-	mAccelerator = new BBoxBasedAccelerator(mMesh, DEFAULT_BB_ACCELARATOR_RES);
-	mStencil = nullptr;
-}
-
-void VoronoiSitesGenerator::setBaseMesh(Mesh* m)
-{
-	mGeneratedSites.clear();
-	delete mAccelerator;
-	mMesh = m;
-	mAccelerator = new BBoxBasedAccelerator(mMesh, DEFAULT_BB_ACCELARATOR_RES);
-}
-
-VoronoiSitesGenerator::~VoronoiSitesGenerator()
-{
-	delete mAccelerator;
-	mAccelerator = nullptr;
-}
-
-
-void VoronoiSitesGenerator::setStencil(Mesh* stencil)
-{
-	mStencil = stencil;
-}
-
-
-void VoronoiSitesGenerator::clearStencil()
-{
-	mStencil = nullptr;
-}
-
-
-void VoronoiSitesGenerator::uniformlyGenerateSitesInMesh(const uint32_t sitesCount)
-{
-	BooleanEvaluator voronoiMeshEval(nullptr);
-	PxVec3 mn = mMesh->getBoundingBox().minimum;
-	PxVec3 mx = mMesh->getBoundingBox().maximum;
-	PxVec3 vc = mx - mn;
-	uint32_t attemptNumber = 0;
-	uint32_t generatedSites = 0;
-	while (generatedSites < sitesCount && attemptNumber < MAX_VORONOI_ATTEMPT_NUMBER)
-	{
-		float rn1 = mRnd->getRandomValue() * vc.x;
-		float rn2 = mRnd->getRandomValue() * vc.y;
-		float rn3 = mRnd->getRandomValue() * vc.z;
-		if (voronoiMeshEval.isPointContainedInMesh(mMesh, PxVec3(rn1, rn2, rn3) + mn) && (mStencil == nullptr
-			|| voronoiMeshEval.isPointContainedInMesh(mStencil, PxVec3(rn1, rn2, rn3) + mn)))
-		{
-			generatedSites++;
-			mGeneratedSites.push_back(PxVec3(rn1, rn2, rn3) + mn);
-			attemptNumber = 0;
-		}
-		else
-		{
-			attemptNumber++;
-			if (attemptNumber > MAX_VORONOI_ATTEMPT_NUMBER)
-				break;
-		}
-	}
-}
-
-
-void VoronoiSitesGenerator::clusteredSitesGeneration(const uint32_t numberOfClusters, const uint32_t sitesPerCluster, float clusterRadius)
-{
-	BooleanEvaluator voronoiMeshEval(nullptr);
-	PxVec3 mn = mMesh->getBoundingBox().minimum;
-	PxVec3 mx = mMesh->getBoundingBox().maximum;
-	PxVec3 middle = (mx + mn) * 0.5;
-	PxVec3 vc = (mx - mn) * 0.5;
-	uint32_t attemptNumber = 0;
-	uint32_t generatedSites = 0;
-	std::vector<PxVec3> tempPoints;
-	while (generatedSites < numberOfClusters)
-	{
-		float rn1 = mRnd->getRandomValue() * 2 - 1;
-		float rn2 = mRnd->getRandomValue() * 2 - 1;
-		float rn3 = mRnd->getRandomValue() * 2 - 1;
-		PxVec3 p = PxVec3(middle.x + rn1 * vc.x, middle.y + rn2 * vc.y, middle.z + rn3 * vc.z);
-
-		if (voronoiMeshEval.isPointContainedInMesh(mMesh, p) && (mStencil == nullptr
-			|| voronoiMeshEval.isPointContainedInMesh(mStencil, p)))
-		{
-			generatedSites++;
-			tempPoints.push_back(p);
-			attemptNumber = 0;
-		}
-		else
-		{
-			attemptNumber++;
-			if (attemptNumber > MAX_VORONOI_ATTEMPT_NUMBER)
-				break;
-		}
-	}
-	int32_t totalCount = 0;
-	for (; tempPoints.size() > 0; tempPoints.pop_back())
-	{
-		uint32_t unif = sitesPerCluster;
-		generatedSites = 0;
-		while (generatedSites < unif)
-		{
-			PxVec3 p = tempPoints.back() + PxVec3(mRnd->getRandomValue() * 2 - 1, mRnd->getRandomValue() * 2 - 1, mRnd->getRandomValue() * 2 - 1).getNormalized() * (mRnd->getRandomValue() + 0.001f) * clusterRadius;
-			if (voronoiMeshEval.isPointContainedInMesh(mMesh, p) && (mStencil == nullptr
-				|| voronoiMeshEval.isPointContainedInMesh(mStencil, p)))
-			{
-				totalCount++;
-				generatedSites++;
-				mGeneratedSites.push_back(p);
-				attemptNumber = 0;
-			}
-			else
-			{
-				attemptNumber++;
-				if (attemptNumber > MAX_VORONOI_ATTEMPT_NUMBER)
-					break;
-			}
-		}
-
-	}
-
-}
-
-
-#define IN_SPHERE_ATTEMPT_NUMBER 20
-
-void VoronoiSitesGenerator::addSite(const physx::PxVec3& site)
-{
-	mGeneratedSites.push_back(site);
-}
-
-
-void VoronoiSitesGenerator::generateInSphere(const uint32_t count, const float radius, const physx::PxVec3& center)
-{
-	BooleanEvaluator voronoiMeshEval(nullptr);
-	uint32_t attemptNumber = 0;
-	uint32_t generatedSites = 0;
-	std::vector<PxVec3> tempPoints;
-
-	while (generatedSites < count && attemptNumber < MAX_VORONOI_ATTEMPT_NUMBER)
-	{
-		float rn1 = mRnd->getRandomValue() * radius;
-		float rn2 = mRnd->getRandomValue() * radius;
-		float rn3 = mRnd->getRandomValue() * radius;
-		if (voronoiMeshEval.isPointContainedInMesh(mMesh, PxVec3(rn1, rn2, rn3) + center) && (mStencil == nullptr
-			|| voronoiMeshEval.isPointContainedInMesh(mStencil, PxVec3(rn1, rn2, rn3) + center)))
-		{
-			generatedSites++;
-			mGeneratedSites.push_back(PxVec3(rn1, rn2, rn3) + center);
-			attemptNumber = 0;
-		}
-		else
-		{
-			attemptNumber++;
-			if (attemptNumber > MAX_VORONOI_ATTEMPT_NUMBER)
-				break;
-		}
-	}
-}
-
-
-void VoronoiSitesGenerator::deleteInSphere(const float radius, const physx::PxVec3& center, float deleteProbability)
-{
-	float r2 = radius * radius;
-	for (uint32_t i = 0; i < mGeneratedSites.size(); ++i)
-	{
-		if ((mGeneratedSites[i] - center).magnitudeSquared() < r2 && mRnd->getRandomValue() <= deleteProbability)
-		{
-			std::swap(mGeneratedSites[i], mGeneratedSites.back());
-			mGeneratedSites.pop_back();
-			--i;
-		}
-	}
-}
-
-
-void VoronoiSitesGenerator::radialPattern(const physx::PxVec3& center, const physx::PxVec3& normal, float radius, int32_t angularSteps, int32_t radialSteps, float angleOffset, float variability)
-{
-//	mGeneratedSites.push_back(center);
-	physx::PxVec3 t1, t2;
-	if (abs(normal.z) < 0.9)
-	{
-		t1 = normal.cross(PxVec3(0, 0, 1));
-	}
-	else
-	{
-		t1 = normal.cross(PxVec3(1, 0, 0));
-	}
-	t2 = t1.cross(normal);
-	t1.normalize();
-	t2.normalize();
-
-	float radStep = radius / radialSteps;
-	int32_t cCr = 0;
-
-	float angleStep = PxPi * 2 / angularSteps;
-	for (float cRadius = radStep; cRadius < radius; cRadius += radStep)
-	{
-		float cAngle = angleOffset * cCr;
-		for (int32_t i = 0; i < angularSteps; ++i)
-		{
-			float angVars = mRnd->getRandomValue() * variability + (1.0f - 0.5f * variability);
-			float radVars = mRnd->getRandomValue() * variability + (1.0f - 0.5f * variability);
-
-			PxVec3 nPos = (PxCos(cAngle * angVars) * t1 + PxSin(cAngle * angVars) * t2) * cRadius * radVars + center;
-			mGeneratedSites.push_back(nPos);
-			cAngle += angleStep;
-		}
-		++cCr;
-	}
-}
-
-
-std::vector<PxVec3>& VoronoiSitesGenerator::getVoronoiSites()
-{
-	return mGeneratedSites;
-}
-
-
-int32_t FractureTool::voronoiFracturing(uint32_t chunkId, const std::vector<physx::PxVec3>& cellPointsIn, bool replaceChunk)
-{
-	if (chunkId == 0 && replaceChunk)
-	{
-		return 1;
-	}
-
-	int32_t chunkIndex = getChunkIndex(chunkId);
-	if (chunkIndex == -1 || cellPointsIn.size() < 2)
-	{
-		return 1;
-	}
-	if (!mChunkData[chunkIndex].isLeaf)
-	{
-		deleteAllChildsOfChunk(chunkId);
-	}
-	chunkIndex = getChunkIndex(chunkId);
-
-	Mesh* mesh = mChunkData[chunkIndex].meshData;
-
-	std::vector<PxVec3> cellPoints(cellPointsIn.size());
-	for (uint32_t i = 0; i < cellPointsIn.size(); ++i)
-	{
-		cellPoints[i] = (cellPointsIn[i] - mOffset) * (1.0f / mScaleFactor);
-	}
-
-	/**
-	Prebuild accelerator structure
-	*/
-	BooleanEvaluator eval(mLoggingCallback);
-	BooleanEvaluator voronoiMeshEval(mLoggingCallback);
-
-	BBoxBasedAccelerator spAccel = BBoxBasedAccelerator(mesh, DEFAULT_BB_ACCELARATOR_RES);
-
-	std::vector<std::vector<int32_t> > neighboors;
-	findCellBasePlanes(cellPoints, neighboors);
-
-	/**
-	Fracture
-	*/
-	int32_t parentChunk = replaceChunk ? mChunkData[chunkIndex].parent : chunkId;
-	std::vector<uint32_t> newlyCreatedChunksIds;
-	for (uint32_t i = 0; i < cellPoints.size(); ++i)
-	{
-		Mesh* cell = getCellMesh(eval, mPlaneIndexerOffset, i, cellPoints, neighboors);
-
-		if (cell == nullptr)
-		{
-			continue;
-		}
-		DummyAccelerator dmAccel(cell->getFacetCount());
-		voronoiMeshEval.performBoolean(mesh, cell, &spAccel, &dmAccel, BooleanConfigurations::BOOLEAN_INTERSECION());
-		Mesh* resultMesh = voronoiMeshEval.createNewMesh();
-		if (resultMesh)
-		{
-			mChunkData.push_back(ChunkInfo());
-			mChunkData.back().isLeaf = true;
-			mChunkData.back().meshData = resultMesh;
-			mChunkData.back().parent = parentChunk;
-			mChunkData.back().chunkId = mChunkIdCounter++;
-			newlyCreatedChunksIds.push_back(mChunkData.back().chunkId);
-		}
-		eval.reset();
-		delete cell;
-	}
-	mChunkData[chunkIndex].isLeaf = false;
-	if (replaceChunk)
-	{
-		eraseChunk(chunkId);
-	}
-	mPlaneIndexerOffset += static_cast<int32_t>(cellPoints.size() * cellPoints.size());
-
-
-	if (mRemoveIslands)
-	{
-		for (auto chunkToCheck : newlyCreatedChunksIds)
-		{
-			islandDetectionAndRemoving(chunkToCheck);
-		}
-	}
-	return 0;
-}
-
-Mesh FractureTool::getChunkMesh(int32_t chunkId)
-{
-	Mesh temp = *mChunkData[getChunkIndex(chunkId)].meshData;
-	for (uint32_t i = 0; i < temp.getVerticesCount(); ++i)
-	{
-		temp.getVertices()[i].p = temp.getVertices()[i].p * mScaleFactor + mOffset;
-	}
-	temp.recalculateBoundingBox();
-
-	return temp;
-}
-
-
-int32_t FractureTool::voronoiFracturing(uint32_t chunkId, const std::vector<physx::PxVec3>& cellPointsIn, const physx::PxVec3& scale, bool replaceChunk)
-{
-	if (chunkId == 0 && replaceChunk)
-	{
-		return 1;
-	}
-
-	int32_t chunkIndex = getChunkIndex(chunkId);
-	if (chunkIndex == -1 || cellPointsIn.size() < 2)
-	{
-		return 1;
-	}
-	if (!mChunkData[chunkIndex].isLeaf)
-	{
-		deleteAllChildsOfChunk(chunkId);
-	}
-	chunkIndex = getChunkIndex(chunkId);
-
-	Mesh* mesh = mChunkData[chunkIndex].meshData;
-
-	std::vector<PxVec3> cellPoints(cellPointsIn.size());
-	for (uint32_t i = 0; i < cellPointsIn.size(); ++i)
-	{
-		cellPoints[i] = (cellPointsIn[i] - mOffset) * (1.0f / mScaleFactor);
-	
-		cellPoints[i].x *= (1.0f / scale.x);
-		cellPoints[i].y *= (1.0f / scale.y);
-		cellPoints[i].z *= (1.0f / scale.z);
-	}
-
-	/**
-	Prebuild accelerator structure
-	*/
-	BooleanEvaluator eval(mLoggingCallback);
-	BooleanEvaluator voronoiMeshEval(mLoggingCallback);
-
-	BBoxBasedAccelerator spAccel = BBoxBasedAccelerator(mesh, DEFAULT_BB_ACCELARATOR_RES);
-
-	std::vector<std::vector<int32_t> > neighboors;
-	findCellBasePlanes(cellPoints, neighboors);
-
-	/**
-	Fracture
-	*/
-	int32_t parentChunk = replaceChunk ? mChunkData[chunkIndex].parent : chunkId;
-	std::vector<uint32_t> newlyCreatedChunksIds;
-
-	for (uint32_t i = 0; i < cellPoints.size(); ++i)
-	{
-		Mesh* cell = getCellMesh(eval, mPlaneIndexerOffset, i, cellPoints, neighboors);
-				
-		if (cell == nullptr)
-		{
-			continue;
-		}
-
-		for (uint32_t v = 0; v < cell->getVerticesCount(); ++v)
-		{
-			cell->getVertices()[v].p.x *= scale.x;
-			cell->getVertices()[v].p.y *= scale.y;
-			cell->getVertices()[v].p.z *= scale.z;
-		}
-		cell->recalculateBoundingBox();
-		DummyAccelerator dmAccel(cell->getFacetCount());
-		voronoiMeshEval.performBoolean(mesh, cell, &spAccel, &dmAccel, BooleanConfigurations::BOOLEAN_INTERSECION());
-		Mesh* resultMesh = voronoiMeshEval.createNewMesh();
-		if (resultMesh)
-		{
-			mChunkData.push_back(ChunkInfo());
-			mChunkData.back().isLeaf = true;
-			mChunkData.back().meshData = resultMesh;
-			mChunkData.back().parent = parentChunk;
-			mChunkData.back().chunkId = mChunkIdCounter++;
-			newlyCreatedChunksIds.push_back(mChunkData.back().chunkId);
-		}
-		eval.reset();
-		delete cell;
-	}
-	mChunkData[chunkIndex].isLeaf = false;
-	if (replaceChunk)
-	{
-		eraseChunk(chunkId);
-	}
-	mPlaneIndexerOffset += static_cast<int32_t>(cellPoints.size() * cellPoints.size());
-
-	if (mRemoveIslands)
-	{
-		for (auto chunkToCheck : newlyCreatedChunksIds)
-		{
-			islandDetectionAndRemoving(chunkToCheck);
-		}
-	}
-
-	return 0;
-}
-
-
-int32_t FractureTool::slicing(uint32_t chunkId, SlicingConfiguration conf, bool replaceChunk, RandomGeneratorBase* rnd)
-{
-	if (conf.noiseAmplitude != 0)
-	{
-		return slicingNoisy(chunkId, conf, replaceChunk, rnd);
-	}
-
-	if (replaceChunk && chunkId == 0)
-	{
-		return 1;
-	}
-
-	int32_t chunkIndex = getChunkIndex(chunkId);
-	if (chunkIndex == -1)
-	{
-		return 1;
-	}
-	if (!mChunkData[chunkIndex].isLeaf)
-	{
-		deleteAllChildsOfChunk(chunkId);
-	}
-	chunkIndex = getChunkIndex(chunkId);
-	
-
-	Mesh* mesh = new Mesh(*mChunkData[chunkIndex].meshData);
-	
-	BooleanEvaluator bTool(mLoggingCallback);
-
-	int32_t x_slices = conf.x_slices;
-	int32_t y_slices = conf.y_slices;
-	int32_t z_slices = conf.z_slices;
-
-	const PxBounds3 sourceBBox = mesh->getBoundingBox();
-
-	PxVec3 center = PxVec3(mesh->getBoundingBox().minimum.x, 0, 0);
-
-
-	float x_offset = (sourceBBox.maximum.x - sourceBBox.minimum.x) * (1.0f / (x_slices + 1));
-	float y_offset = (sourceBBox.maximum.y - sourceBBox.minimum.y) * (1.0f / (y_slices + 1));
-	float z_offset = (sourceBBox.maximum.z - sourceBBox.minimum.z) * (1.0f / (z_slices + 1));
-
-	center.x += x_offset;
-
-	PxVec3 dir(1, 0, 0);
-
-	Mesh* slBox = getCuttingBox(center, dir, 20, 0);
-
-	ChunkInfo ch;
-	ch.isLeaf = true;
-	ch.parent = replaceChunk ? mChunkData[chunkIndex].parent : chunkId;
-	std::vector<ChunkInfo> xSlicedChunks;
-	std::vector<ChunkInfo> ySlicedChunks;
-	std::vector<uint32_t> newlyCreatedChunksIds;
-	/**
-	Slice along x direction
-	*/
-	for (int32_t slice = 0; slice < x_slices; ++slice)
-	{
-		PxVec3 randVect = PxVec3(2 * rnd->getRandomValue() - 1, 2 * rnd->getRandomValue() - 1, 2 * rnd->getRandomValue() - 1);
-		PxVec3 lDir = dir + randVect * conf.angle_variations;
-
-		setCuttingBox(center, lDir, slBox, 20, mPlaneIndexerOffset);
-		bTool.performFastCutting(mesh, slBox, BooleanConfigurations::BOOLEAN_DIFFERENCE());
-		ch.meshData = bTool.createNewMesh();
-
-		if (ch.meshData != 0)
-		{
-			xSlicedChunks.push_back(ch);
-		}
-		inverseNormalAndSetIndices(slBox, -mPlaneIndexerOffset);
-		++mPlaneIndexerOffset;
-		bTool.performFastCutting(mesh, slBox, BooleanConfigurations::BOOLEAN_INTERSECION());
-		Mesh* result = bTool.createNewMesh();
-		delete mesh;
-		mesh = result;
-		if (mesh == nullptr)
-		{
-			break;
-		}
-		center.x += x_offset + (rnd->getRandomValue()) * conf.offset_variations * x_offset;
-	}
-	if (mesh != 0)
-	{
-		ch.meshData = mesh;
-		xSlicedChunks.push_back(ch);
-	}
-
-
-	for (uint32_t chunk = 0; chunk < xSlicedChunks.size(); ++chunk)
-	{
-		center = PxVec3(0, sourceBBox.minimum.y, 0);
-		center.y += y_offset;
-		dir = PxVec3(0, 1, 0);
-		mesh = xSlicedChunks[chunk].meshData;
-
-		for (int32_t slice = 0; slice < y_slices; ++slice)
-		{
-			PxVec3 randVect = PxVec3(2 * rnd->getRandomValue() - 1, 2 * rnd->getRandomValue() - 1, 2 * rnd->getRandomValue() - 1);
-			PxVec3 lDir = dir + randVect * conf.angle_variations;
-
-			
-			setCuttingBox(center, lDir, slBox, 20, mPlaneIndexerOffset);
-			bTool.performFastCutting(mesh, slBox, BooleanConfigurations::BOOLEAN_DIFFERENCE());
-			ch.meshData = bTool.createNewMesh();
-			if (ch.meshData != 0)
-			{
-				ySlicedChunks.push_back(ch);
-			}
-			inverseNormalAndSetIndices(slBox, -mPlaneIndexerOffset);
-			++mPlaneIndexerOffset;
-			bTool.performFastCutting(mesh, slBox, BooleanConfigurations::BOOLEAN_INTERSECION());
-			Mesh* result = bTool.createNewMesh();
-			delete mesh;
-			mesh = result;
-			if (mesh == nullptr)
-			{
-				break;
-			}
-			center.y += y_offset + (rnd->getRandomValue()) * conf.offset_variations * y_offset;
-		}
-		if (mesh != 0)
-		{
-			ch.meshData = mesh;
-			ySlicedChunks.push_back(ch);
-		}
-	}
-
-
-	for (uint32_t chunk = 0; chunk < ySlicedChunks.size(); ++chunk)
-	{
-		center = PxVec3(0, 0, sourceBBox.minimum.z);
-		center.z += z_offset;
-		dir = PxVec3(0, 0, 1);
-		mesh = ySlicedChunks[chunk].meshData;
-
-		for (int32_t slice = 0; slice < z_slices; ++slice)
-		{
-			PxVec3 randVect = PxVec3(2 * rnd->getRandomValue() - 1, 2 * rnd->getRandomValue() - 1, 2 * rnd->getRandomValue() - 1);
-			PxVec3 lDir = dir + randVect * conf.angle_variations;
-			setCuttingBox(center, lDir, slBox, 20, mPlaneIndexerOffset);
-			bTool.performFastCutting(mesh, slBox, BooleanConfigurations::BOOLEAN_DIFFERENCE());
-			ch.meshData = bTool.createNewMesh();
-			if (ch.meshData != 0)
-			{
-				ch.chunkId = mChunkIdCounter++;
-				newlyCreatedChunksIds.push_back(ch.chunkId);
-				mChunkData.push_back(ch);
-			}
-			inverseNormalAndSetIndices(slBox, -mPlaneIndexerOffset);
-			++mPlaneIndexerOffset;
-			bTool.performFastCutting(mesh, slBox, BooleanConfigurations::BOOLEAN_INTERSECION());
-			Mesh* result = bTool.createNewMesh();
-			delete mesh;
-			mesh = result;
-			if (mesh == nullptr)
-			{
-				break;
-			}
-			center.z += z_offset + (rnd->getRandomValue()) * conf.offset_variations * z_offset;
-		}
-		if (mesh != 0)
-		{
-			ch.chunkId = mChunkIdCounter++;
-			ch.meshData = mesh;
-			mChunkData.push_back(ch);
-			newlyCreatedChunksIds.push_back(ch.chunkId);
-		}
-	}
-
-
-	delete slBox;
-
-	mChunkData[chunkIndex].isLeaf = false;
-	if (replaceChunk)
-	{
-		eraseChunk(chunkId);
-	}
-
-	if (mRemoveIslands)
-	{
-		for (auto chunkToCheck : newlyCreatedChunksIds)
-		{
-			islandDetectionAndRemoving(chunkToCheck);
-		}
-	}
-
-	return 0;
-}
-
-int32_t FractureTool::slicingNoisy(uint32_t chunkId, SlicingConfiguration conf, bool replaceChunk, RandomGeneratorBase* rnd)
-{
-	if (replaceChunk && chunkId == 0)
-	{
-		return 1;
-	}
-
-	int32_t chunkIndex = getChunkIndex(chunkId);
-	if (chunkIndex == -1)
-	{
-		return 1;
-	}
-	if (!mChunkData[chunkIndex].isLeaf)
-	{
-		deleteAllChildsOfChunk(chunkId);
-	}
-	chunkIndex = getChunkIndex(chunkId);
-
-
-	Mesh* mesh = new Mesh(*mChunkData[chunkIndex].meshData);
-
-	BooleanEvaluator bTool(mLoggingCallback);
-
-	int32_t x_slices = conf.x_slices;
-	int32_t y_slices = conf.y_slices;
-	int32_t z_slices = conf.z_slices;
-
-	const PxBounds3 sourceBBox = mesh->getBoundingBox();
-
-	PxVec3 center = PxVec3(mesh->getBoundingBox().minimum.x, 0, 0);
-
-
-	float x_offset = (sourceBBox.maximum.x - sourceBBox.minimum.x) * (1.0f / (x_slices + 1));
-	float y_offset = (sourceBBox.maximum.y - sourceBBox.minimum.y) * (1.0f / (y_slices + 1));
-	float z_offset = (sourceBBox.maximum.z - sourceBBox.minimum.z) * (1.0f / (z_slices + 1));
-
-	center.x += x_offset;
-
-	PxVec3 dir(1, 0, 0);
-
-	Mesh* slBox = nullptr;
-
-	ChunkInfo ch;
-	ch.isLeaf = true;
-	ch.parent = replaceChunk ? mChunkData[chunkIndex].parent : chunkId;
-	std::vector<ChunkInfo> xSlicedChunks;
-	std::vector<ChunkInfo> ySlicedChunks;
-	std::vector<uint32_t> newlyCreatedChunksIds;
-	float noisyPartSize = 1.8f;
-	int32_t acceleratorRes = 5;
-	/**
-		Slice along x direction
-	*/
-	for (int32_t slice = 0; slice < x_slices; ++slice)
-	{
-		PxVec3 randVect = PxVec3(2 * rnd->getRandomValue() - 1, 2 * rnd->getRandomValue() - 1, 2 * rnd->getRandomValue() - 1);
-		PxVec3 lDir = dir + randVect * conf.angle_variations;
-		slBox = getNoisyCuttingBoxPair(center, lDir, 40, noisyPartSize, conf.surfaceResolution, mPlaneIndexerOffset, conf.noiseAmplitude, conf.noiseFrequency, conf.noiseOctaveNumber, rnd->getRandomValue());
-	//	DummyAccelerator accel(mesh->getFacetCount());
-		IntersectionTestingAccelerator accel(mesh, acceleratorRes);
-		DummyAccelerator dummy(slBox->getFacetCount());
-		bTool.performBoolean(mesh, slBox, &accel, &dummy, BooleanConfigurations::BOOLEAN_DIFFERENCE());
-		ch.meshData = bTool.createNewMesh();
-		if (ch.meshData != 0)
-		{
-			xSlicedChunks.push_back(ch);
-		}
-		inverseNormalAndSetIndices(slBox, -mPlaneIndexerOffset);
-		++mPlaneIndexerOffset;
-		bTool.performBoolean(mesh, slBox, &accel, &dummy, BooleanConfigurations::BOOLEAN_INTERSECION());
-		Mesh* result = bTool.createNewMesh();
-		delete slBox;
-		delete mesh;
-		mesh = result;
-		if (mesh == nullptr)
-		{
-			break;
-		}
-		center.x += x_offset + (rnd->getRandomValue()) * conf.offset_variations * x_offset;
-	}
-	if (mesh != 0)
-	{
-		ch.meshData = mesh;
-		xSlicedChunks.push_back(ch);
-	}
-	slBox = getCuttingBox(center, dir, 20, 0);
-	uint32_t slicedChunkSize = xSlicedChunks.size();
-	for (uint32_t chunk = 0; chunk < slicedChunkSize; ++chunk)
-	{
-		center = PxVec3(0, sourceBBox.minimum.y, 0);
-		center.y += y_offset;
-		dir = PxVec3(0, 1, 0);
-		mesh = xSlicedChunks[chunk].meshData;
-
-		for (int32_t slice = 0; slice < y_slices; ++slice)
-		{
-			PxVec3 randVect = PxVec3(2 * rnd->getRandomValue() - 1, 2 * rnd->getRandomValue() - 1, 2 * rnd->getRandomValue() - 1);
-			PxVec3 lDir = dir + randVect * conf.angle_variations;
-
-			slBox = getNoisyCuttingBoxPair(center, lDir, 40, noisyPartSize, conf.surfaceResolution, mPlaneIndexerOffset, conf.noiseAmplitude, conf.noiseFrequency, conf.noiseOctaveNumber, rnd->getRandomValue());
-		//	DummyAccelerator accel(mesh->getFacetCount());
-			IntersectionTestingAccelerator accel(mesh, acceleratorRes);
-			DummyAccelerator dummy(slBox->getFacetCount());
-			bTool.performBoolean(mesh, slBox, &accel, &dummy, BooleanConfigurations::BOOLEAN_DIFFERENCE());
-			ch.meshData = bTool.createNewMesh();
-			if (ch.meshData != 0)
-			{
-				ySlicedChunks.push_back(ch);
-			}
-			inverseNormalAndSetIndices(slBox, -mPlaneIndexerOffset);
-			++mPlaneIndexerOffset;
-			bTool.performBoolean(mesh, slBox, &accel, &dummy, BooleanConfigurations::BOOLEAN_INTERSECION());
-			Mesh* result = bTool.createNewMesh();
-			delete slBox;
-			delete mesh;
-			mesh = result;
-			if (mesh == nullptr)
-			{
-				break;
-			}
-			center.y += y_offset + (rnd->getRandomValue()) * conf.offset_variations * y_offset;
-		}
-		if (mesh != 0)
-		{
-			ch.meshData = mesh;
-			ySlicedChunks.push_back(ch);
-		}
-	}
-
-	for (uint32_t chunk = 0; chunk < ySlicedChunks.size(); ++chunk)
-	{
-		center = PxVec3(0, 0, sourceBBox.minimum.z);
-		center.z += z_offset;
-		dir = PxVec3(0, 0, 1);
-		mesh = ySlicedChunks[chunk].meshData;
-
-		for (int32_t slice = 0; slice < z_slices; ++slice)
-		{
-			PxVec3 randVect = PxVec3(2 * rnd->getRandomValue() - 1, 2 * rnd->getRandomValue() - 1, 2 * rnd->getRandomValue() - 1);
-			PxVec3 lDir = dir + randVect * conf.angle_variations;
-			slBox = getNoisyCuttingBoxPair(center, lDir, 40, noisyPartSize, conf.surfaceResolution, mPlaneIndexerOffset, conf.noiseAmplitude, conf.noiseFrequency, conf.noiseOctaveNumber, rnd->getRandomValue());
-	//		DummyAccelerator accel(mesh->getFacetCount());
-			IntersectionTestingAccelerator accel(mesh, acceleratorRes);
-			DummyAccelerator dummy(slBox->getFacetCount());
-			bTool.performBoolean(mesh, slBox, &accel, &dummy, BooleanConfigurations::BOOLEAN_DIFFERENCE());
-			ch.meshData = bTool.createNewMesh();
-			if (ch.meshData != 0)
-			{
-				ch.chunkId = mChunkIdCounter++;
-				mChunkData.push_back(ch);
-				newlyCreatedChunksIds.push_back(ch.chunkId);
-			}
-			inverseNormalAndSetIndices(slBox, -mPlaneIndexerOffset);
-			++mPlaneIndexerOffset;
-			bTool.performBoolean(mesh, slBox, &accel, &dummy, BooleanConfigurations::BOOLEAN_INTERSECION());
-			Mesh* result = bTool.createNewMesh();
-			delete mesh;
-			delete slBox;
-			mesh = result;
-			if (mesh == nullptr)
-			{
-				break;
-			}
-			center.z += z_offset + (rnd->getRandomValue()) * conf.offset_variations * z_offset;
-		}
-		if (mesh != 0)
-		{
-			ch.chunkId = mChunkIdCounter++;
-			ch.meshData = mesh;
-			mChunkData.push_back(ch);
-			newlyCreatedChunksIds.push_back(ch.chunkId);
-		}
-	}
-
-//	delete slBox;
-
-	mChunkData[chunkIndex].isLeaf = false;
-	if (replaceChunk)
-	{
-		eraseChunk(chunkId);
-	}
-
-	if (mRemoveIslands)
-	{
-		for (auto chunkToCheck : newlyCreatedChunksIds)
-		{
-			islandDetectionAndRemoving(chunkToCheck);
-		}
-	}
-
-	return 0;
-}
-
-
-
-int32_t FractureTool::getChunkIndex(int32_t chunkId)
-{
-	for (uint32_t i = 0; i < mChunkData.size(); ++i)
-	{
-		if (mChunkData[i].chunkId == chunkId)
-		{
-			return i;
-		}
-	}
-	return -1;
-}
-
-int32_t FractureTool::getChunkDepth(int32_t chunkId)
-{
-	int32_t chunkIndex = getChunkIndex(chunkId);
-	if (chunkIndex == -1)
-	{
-		return -1;
-	}
-
-	int32_t depth = 0;
-
-	while (mChunkData[chunkIndex].parent != -1)
-	{
-		++depth;
-		chunkIndex = getChunkIndex(mChunkData[chunkIndex].parent);
-	}
-	return depth;	
-}
-
-std::vector<int32_t> FractureTool::getChunksIdAtDepth(uint32_t depth)
-{
-	std::vector<int32_t> chunkIds;
-
-	for (uint32_t i = 0; i < mChunkData.size(); ++i)
-	{
-		if (getChunkDepth(mChunkData[i].chunkId) == (int32_t)depth)
-		{
-			chunkIds.push_back(mChunkData[i].chunkId);
-		}
-	}
-	return chunkIds;
-}
-
-
-void FractureTool::getTransformation(PxVec3& offset, float& scale)
-{
-	offset = mOffset;
-	scale = mScaleFactor;
-}
-
-void FractureTool::setSourceMesh(Mesh* mesh)
-{
-	if (mesh == nullptr)
-	{
-		return;
-	}
-	reset();
-
-	mChunkData.resize(1);
-	mChunkData[0].meshData = new Mesh(*mesh);
-	mChunkData[0].parent = -1;
-	mChunkData[0].isLeaf = true;
-	mChunkData[0].chunkId = mChunkIdCounter++;
-	mesh = mChunkData[0].meshData;
-
-	/**
-	Move to origin and scale to unit cube
-	*/
-
-	mOffset = (mesh->getBoundingBox().maximum + mesh->getBoundingBox().minimum) * 0.5f;
-	PxVec3 bbSizes = (mesh->getBoundingBox().maximum - mesh->getBoundingBox().minimum);
-
-	mScaleFactor = std::max(bbSizes.x, std::max(bbSizes.y, bbSizes.z));
-
-	Vertex* verticesBuffer = mesh->getVertices();
-	for (uint32_t i = 0; i < mesh->getVerticesCount(); ++i)
-	{
-		verticesBuffer[i].p = (verticesBuffer[i].p - mOffset) * (1.0f / mScaleFactor);
-	}
-
-	mesh->getBoundingBox().minimum = (mesh->getBoundingBox().minimum - mOffset) * (1.0f / mScaleFactor);
-	mesh->getBoundingBox().maximum = (mesh->getBoundingBox().maximum - mOffset) * (1.0f / mScaleFactor);
-
-
-	for (uint32_t i = 0; i < mesh->getFacetCount(); ++i)
-	{
-		mesh->getFacet(i)->userData = 0; // Mark facet as initial boundary facet
-	}
-}
-
-
-void FractureTool::reset()
-{
-	mChunkPostprocessors.clear();
-	for (uint32_t i = 0; i < mChunkData.size(); ++i)
-	{
-		delete mChunkData[i].meshData;
-	}
-	mChunkData.clear();
-	mPlaneIndexerOffset = 1;
-	mChunkIdCounter = 0;
-}
-
-
-
-
-bool FractureTool::isAncestorForChunk(int32_t ancestorId, int32_t chunkId)
-{
-	if (ancestorId == chunkId)
-	{
-		return false;
-	}
-	while (chunkId != -1)
-	{
-		if (ancestorId == chunkId)
-		{
-			return true;
-		}
-		chunkId = getChunkIndex(chunkId);
-		if (chunkId == -1)
-		{
-			return false;
-		}
-		chunkId = mChunkData[chunkId].parent;
-	}
-	return false;
-}
-
-void FractureTool::eraseChunk(int32_t chunkId)
-{
-	deleteAllChildsOfChunk(chunkId);
-	int32_t index = getChunkIndex(chunkId);
-	if (index != -1)
-	{
-		delete mChunkData[index].meshData;
-		std::swap(mChunkData.back(), mChunkData[index]);
-		mChunkData.pop_back();
-	}
-}
-
-
-void FractureTool::deleteAllChildsOfChunk(int32_t chunkId)
-{
-	std::vector<int32_t> chunkToDelete;
-	for (uint32_t i = 0; i < mChunkData.size(); ++i)
-	{
-		if (isAncestorForChunk(chunkId, mChunkData[i].chunkId))
-		{
-			chunkToDelete.push_back(i);
-		}
-	}
-	for (int32_t i = (int32_t)chunkToDelete.size() - 1; i >= 0; --i)
-	{
-		int32_t m = chunkToDelete[i];
-		delete mChunkData[m].meshData;
-		std::swap(mChunkData.back(), mChunkData[m]);
-		mChunkData.pop_back();
-	}
-}
-
-void FractureTool::finalizeFracturing()
-{
-	for (uint32_t i = 0; i < mChunkPostprocessors.size(); ++i)
-	{
-		delete mChunkPostprocessors[i];
-	}
-	mChunkPostprocessors.resize(mChunkData.size());
-	for (uint32_t i = 0; i < mChunkPostprocessors.size(); ++i)
-	{
-		mChunkPostprocessors[i] = new ChunkPostProcessor();
-	}
-	
-	for (uint32_t i = 0; i < mChunkPostprocessors.size(); ++i)
-	{
-		mChunkPostprocessors[i]->triangulate(mChunkData[i].meshData);
-	}
-	std::vector<int32_t> badOnes;
-	for (uint32_t i = 0; i < mChunkPostprocessors.size(); ++i)
-	{
-		if (mChunkPostprocessors[i]->getBaseMesh().empty())
-		{
-			badOnes.push_back(i);
-		}
-	}
-	for (int32_t i = (int32_t)badOnes.size() - 1; i >= 0; --i)
-	{
-		int32_t chunkId = mChunkData[badOnes[i]].chunkId;
-		for (uint32_t j = 0; j < mChunkData.size(); ++j)
-		{
-			if (mChunkData[j].parent == chunkId)
-				mChunkData[j].parent = mChunkData[badOnes[i]].parent;
-		}
-		std::swap(mChunkPostprocessors[badOnes[i]], mChunkPostprocessors.back());
-		mChunkPostprocessors.pop_back();
-		std::swap(mChunkData[badOnes[i]], mChunkData.back());
-		mChunkData.pop_back();
-	}
-
-}
-
-const std::vector<ChunkInfo>& FractureTool::getChunkList()
-{
-	return mChunkData;
-}
-
-void FractureTool::getBaseMesh(int32_t chunkIndex, std::vector<Triangle>& output)
-{
-	NVBLAST_ASSERT(mChunkPostprocessors.size() > 0);
-	if (mChunkPostprocessors.size() == 0)
-	{		
-		return; // finalizeFracturing() should be called before getting mesh!
-	}
-	output = mChunkPostprocessors[chunkIndex]->getBaseMesh();
-
-	/* Scale mesh back */
-
-	for (uint32_t i = 0; i < output.size(); ++i)
-	{
-		output[i].a.p = output[i].a.p * mScaleFactor + mOffset;
-		output[i].b.p = output[i].b.p * mScaleFactor + mOffset;
-		output[i].c.p = output[i].c.p * mScaleFactor + mOffset;
-	}
-}
-
-void FractureTool::getNoisedMesh(int32_t chunkIndex, std::vector<Triangle>& output)
-{
-	NVBLAST_ASSERT(mChunkPostprocessors.size() > 0);
-	if (mChunkPostprocessors.size() == 0)
-	{
-		return; // finalizeFracturing() should be called before getting mesh!
-	}
-
-	if (mChunkData[chunkIndex].chunkId == 0)
-	{
-		output = mChunkPostprocessors[chunkIndex]->getBaseMesh();
-	}
-	else
-	{
-		output = mChunkPostprocessors[chunkIndex]->getNoisyMesh();
-	}
-
-	for (uint32_t i = 0; i < output.size(); ++i)
-	{
-		output[i].a.p = output[i].a.p * mScaleFactor + mOffset;
-		output[i].b.p = output[i].b.p * mScaleFactor + mOffset;
-		output[i].c.p = output[i].c.p * mScaleFactor + mOffset;
-	}
-}
-
-void FractureTool::tesselate(float averateEdgeLength)
-{
-	NVBLAST_ASSERT(mChunkPostprocessors.size() > 0);
-	if (mChunkPostprocessors.size() == 0)
-	{
-		return; // finalizeFracturing() should be called before tesselation!
-	}
-
-	for (uint32_t i = 0; i < mChunkPostprocessors.size(); ++i)
-	{
-		if (mChunkData[i].chunkId == 0) // skip source mesh
-		{
-			continue;
-		}
-		mChunkPostprocessors[i]->tesselateInternalSurface(averateEdgeLength / mScaleFactor);
-	}
-}
-
-void FractureTool::applyNoise(float amplitude, float frequency, int32_t octaves, float falloff, int32_t relaxIterations, float relaxFactor, int32_t seed)
-{
-	octaves = octaves <= 0 ? 1 : octaves;
-	if (mChunkPostprocessors.empty())
-	{
-		return;
-	}
-	SimplexNoise noise(amplitude / mScaleFactor, frequency * mScaleFactor, octaves, seed);
-	for (uint32_t i = 0; i < mChunkPostprocessors.size(); ++i)
-	{
-		if (mChunkData[i].chunkId == 0) // skip source mesh
-		{
-			continue;
-		}
-		mChunkPostprocessors[i]->applyNoise(noise, falloff, relaxIterations, relaxFactor);
-	}
-}
-
-float getVolume(std::vector<Triangle>& triangles)
-{
-	float volume = 0.0f;
-
-	for (uint32_t i = 0; i < triangles.size(); ++i)
-	{
-		PxVec3& a = triangles[i].a.p;
-		PxVec3& b = triangles[i].b.p;
-		PxVec3& c = triangles[i].c.p;
-		volume += (a.x * b.y * c.z - a.x * b.z * c.y - a.y * b.x * c.z + a.y * b.z * c.x + a.z * b.x * c.y - a.z * b.y * c.x);
-	}
-	return (1.0f / 6.0f) * PxAbs(volume);
-}
-
-float FractureTool::getMeshOverlap(Mesh& meshA, Mesh& meshB)
-{
-	BooleanEvaluator bTool;
-	bTool.performBoolean(&meshA, &meshB, BooleanConfigurations::BOOLEAN_INTERSECION());
-	Mesh* result = bTool.createNewMesh();
-	if (result == nullptr)
-	{
-		return 0.0f;
-	}
-
-	ChunkPostProcessor postProcessor;
-	postProcessor.triangulate(&meshA);
-
-	float baseVolume = getVolume(postProcessor.getBaseMesh());
-	if (baseVolume == 0)
-	{
-		return 0.0f;
-	}
-	postProcessor.triangulate(result);
-	float intrsVolume = getVolume(postProcessor.getBaseMesh());
-
-	delete result;
-
-	return intrsVolume / baseVolume;
-}
-
-void weldVertices(std::map<Vertex, uint32_t, VrtComp>& vertexMapping, std::vector<Vertex>& vertexBuffer, std::vector<uint32_t>& indexBuffer, std::vector<Triangle>& trb)
-{
-	for (uint32_t i = 0; i < trb.size(); ++i)
-	{
-		auto it = vertexMapping.find(trb[i].a);
-		if (it == vertexMapping.end())
-		{
-			indexBuffer.push_back(static_cast<uint32_t>(vertexBuffer.size()));
-			vertexMapping[trb[i].a] = static_cast<uint32_t>(vertexBuffer.size());
-			vertexBuffer.push_back(trb[i].a);
-		}
-		else
-		{
-			indexBuffer.push_back(it->second);
-		}
-		it = vertexMapping.find(trb[i].b);
-		if (it == vertexMapping.end())
-		{
-			indexBuffer.push_back(static_cast<uint32_t>(vertexBuffer.size()));
-			vertexMapping[trb[i].b] = static_cast<uint32_t>(vertexBuffer.size());
-			vertexBuffer.push_back(trb[i].b);
-		}
-		else
-		{
-			indexBuffer.push_back(it->second);
-		}
-		it = vertexMapping.find(trb[i].c);
-		if (it == vertexMapping.end())
-		{
-			indexBuffer.push_back(static_cast<uint32_t>(vertexBuffer.size()));
-			vertexMapping[trb[i].c] = static_cast<uint32_t>(vertexBuffer.size());
-			vertexBuffer.push_back(trb[i].c);
-		}
-		else
-		{
-			indexBuffer.push_back(it->second);
-		}
-	}
-
-}
-
-void FractureTool::setRemoveIslands(bool isRemoveIslands)
-{
-	mRemoveIslands = isRemoveIslands;
-}
-
-int32_t FractureTool::islandDetectionAndRemoving(int32_t chunkId)
-{
-	if (chunkId == 0)
-	{
-		return 0;
-	}
-	int32_t chunkIndex = getChunkIndex(chunkId);
-	ChunkPostProcessor prc;
-	prc.triangulate(mChunkData[chunkIndex].meshData);
-
-	Mesh* chunk = mChunkData[chunkIndex].meshData;
-
-	std::vector<uint32_t>& mapping = prc.getBaseMapping();
-	std::vector<TriangleIndexed>& trs = prc.getBaseMeshIndexed();
-
-	std::vector<std::vector<uint32_t> > graph(prc.getWeldedVerticesCount());
-	std::vector<int32_t>& pm = prc.getPositionedMapping();
-	if (pm.size() == 0)
-	{
-		return 0;
-	}
-
-	/**
-		Chunk graph
-	*/
-	for (uint32_t i = 0; i < trs.size(); ++i)
-	{
-		graph[pm[trs[i].ea]].push_back(pm[trs[i].eb]);
-		graph[pm[trs[i].ea]].push_back(pm[trs[i].ec]);
-
-		graph[pm[trs[i].ec]].push_back(pm[trs[i].eb]);
-		graph[pm[trs[i].ec]].push_back(pm[trs[i].ea]);
-
-		graph[pm[trs[i].eb]].push_back(pm[trs[i].ea]);
-		graph[pm[trs[i].eb]].push_back(pm[trs[i].ec]);
-	}
-	for (uint32_t i = 0; i < chunk->getEdgesCount(); ++i)
-	{
-		int v1 = chunk->getEdges()[i].s;
-		int v2 = chunk->getEdges()[i].e;
-
-		v1 = pm[mapping[v1]];
-		v2 = pm[mapping[v2]];
-
-		graph[v1].push_back(v2);
-		graph[v2].push_back(v1);
-
-	}
-
-
-	/**
-		Walk graph, mark components
-	*/
-
-	std::vector<int32_t> comps(prc.getWeldedVerticesCount(), -1);
-	std::queue<uint32_t> que;
-	int32_t cComp = 0;
-	
-	for (uint32_t i = 0; i < prc.getWeldedVerticesCount(); ++i)
-	{
-		int32_t to = pm[i];
-		if (comps[to] != -1) continue;
-		que.push(to);
-		comps[to] = cComp;
-
-		while (!que.empty())
-		{
-			int32_t c = que.front();
-			que.pop();
-			
-			for (uint32_t j = 0; j < graph[c].size(); ++j)
-			{
-				if (comps[graph[c][j]] == -1)
-				{
-					que.push(graph[c][j]);
-					comps[graph[c][j]] = cComp;
-				}
-			}
-		}
-		cComp++;
-	}
-	for (uint32_t i = 0; i < prc.getWeldedVerticesCount(); ++i)
-	{
-		int32_t to = pm[i];
-		comps[i] = comps[to];
-	}
-	std::vector<uint32_t> longComps(chunk->getVerticesCount());
-	for (uint32_t i = 0; i < chunk->getVerticesCount(); ++i)
-	{
-		int32_t to = mapping[i];
-		longComps[i] = comps[to];
-	}
-	
-	if (cComp > 1)
-	{
-		std::vector<std::vector<Vertex> >	compVertices(cComp);
-		std::vector<std::vector<Facet> >	compFacets(cComp);
-		std::vector<std::vector<Edge> >		compEdges(cComp);
-
-
-		std::vector<uint32_t>				compVertexMapping(chunk->getVerticesCount(), 0);
-		Vertex* vrts = chunk->getVertices();
-		for (uint32_t v = 0; v < chunk->getVerticesCount(); ++v)
-		{
-			int32_t vComp = comps[mapping[v]];
-			compVertexMapping[v] = static_cast<uint32_t>(compVertices[vComp].size());
-			compVertices[vComp].push_back(vrts[v]);
-		}
-		
-		Facet* fcb = chunk->getFacetsBuffer();
-		Edge* edb = chunk->getEdges();
-
-		for (uint32_t fc = 0; fc < chunk->getFacetCount(); ++fc)
-		{
-			std::vector<uint32_t> edgesPerComp(cComp, 0);
-			for (uint32_t ep = fcb[fc].firstEdgeNumber; ep < fcb[fc].firstEdgeNumber + fcb[fc].edgesCount; ++ep)
-			{
-				int32_t vComp = comps[mapping[edb[ep].s]];
-				edgesPerComp[vComp]++;
-				compEdges[vComp].push_back(Edge(compVertexMapping[edb[ep].s], compVertexMapping[edb[ep].e]));
-			}
-			for (int32_t c = 0; c < cComp; ++c)
-			{
-				if (edgesPerComp[c] == 0)
-				{
-					continue;
-				}
-				compFacets[c].push_back(*chunk->getFacet(fc));
-				compFacets[c].back().edgesCount = edgesPerComp[c];
-				compFacets[c].back().firstEdgeNumber = static_cast<int32_t>(compEdges[c].size()) - edgesPerComp[c];
-			}
-		}
-
-		delete mChunkData[chunkIndex].meshData;
-		mChunkData[chunkIndex].meshData = new Mesh(compVertices[0].data(), compEdges[0].data(), compFacets[0].data(), static_cast<uint32_t>(compVertices[0].size()),
-													static_cast<uint32_t>(compEdges[0].size()), static_cast<uint32_t>(compFacets[0].size()));;
-		for (int32_t i = 1; i < cComp; ++i)
-		{
-			mChunkData.push_back(ChunkInfo(mChunkData[chunkIndex]));
-			mChunkData.back().chunkId = mChunkIdCounter++;
-			mChunkData.back().meshData = new Mesh(compVertices[i].data(), compEdges[i].data(), compFacets[i].data(), static_cast<uint32_t>(compVertices[i].size()),
-													static_cast<uint32_t>(compEdges[i].size()), static_cast<uint32_t>(compFacets[i].size()));
-		}
-		
-		return cComp;
-	}
-	return 0;
-}
-
-void FractureTool::getBufferedBaseMeshes(std::vector<Vertex>& vertexBuffer, std::vector<std::vector<uint32_t> >& indexBuffer)
-{
-	std::map<Vertex, uint32_t, VrtComp> vertexMapping;
-	vertexBuffer.clear();
-	indexBuffer.clear();
-	indexBuffer.resize(mChunkPostprocessors.size());
-
-	for (uint32_t ch = 0; ch < mChunkPostprocessors.size(); ++ch)
-	{
-		std::vector<Triangle>& trb = mChunkPostprocessors[ch]->getBaseMesh();
-		weldVertices(vertexMapping, vertexBuffer, indexBuffer[ch], trb);
-	}
-	for (uint32_t i = 0; i < vertexBuffer.size(); ++i)
-	{
-		vertexBuffer[i].p = vertexBuffer[i].p * mScaleFactor + mOffset;
-	}
-}
-
-int32_t FractureTool::getChunkId(int32_t chunkIndex)
-{
-	if (chunkIndex < 0 || static_cast<uint32_t>(chunkIndex) >= mChunkData.size())
-	{
-		return -1;
-	}
-	return mChunkData[chunkIndex].chunkId;
-}
-
-void FractureTool::getBufferedNoiseMeshes(std::vector<Vertex>& vertexBuffer, std::vector<std::vector<uint32_t> >& indexBuffer)
-{
-	std::map<Vertex, uint32_t, VrtComp> vertexMapping;
-	vertexBuffer.clear();
-	indexBuffer.clear();
-	indexBuffer.resize(mChunkPostprocessors.size());
-
-	for (uint32_t ch = 0; ch < mChunkPostprocessors.size(); ++ch)
-	{
-		if (ch == 0)
-		{
-			std::vector<Triangle>& trb = mChunkPostprocessors[ch]->getBaseMesh();
-			weldVertices(vertexMapping, vertexBuffer, indexBuffer[ch], trb);
-		}
-		else
-		{
-			std::vector<Triangle>& trb = mChunkPostprocessors[ch]->getNoisyMesh();
-			weldVertices(vertexMapping, vertexBuffer, indexBuffer[ch], trb);
-		}				
-	}
-	for (uint32_t i = 0; i < vertexBuffer.size(); ++i)
-	{
-		vertexBuffer[i].p = vertexBuffer[i].p * mScaleFactor + mOffset;
-	}
-}
-
-
-} // namespace Blast
-} // namespace Nv
-
diff --git a/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringInternalCommon.h b/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringInternalCommon.h
deleted file mode 100644
index b8fb20e..0000000
--- a/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringInternalCommon.h
+++ /dev/null
@@ -1,193 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTINTERNALCOMMON_H
-#define NVBLASTINTERNALCOMMON_H
-#include "NvBlastExtAuthoringTypes.h"
-
-using namespace physx;
-
-namespace Nv
-{
-namespace Blast
-{
-
-/**
-Edge representation with index of parent facet
-*/
-struct EdgeWithParent
-{
-	int32_t s, e; // Starting and ending vertices
-	int32_t parent; // Parent facet index
-	EdgeWithParent() : s(0), e(0), parent(0) {}
-	EdgeWithParent(int32_t s, int32_t e, int32_t p) : s(s), e(e), parent(p) {}
-};
-
-
-/**
-Comparator for sorting edges according to parent facet number.
-*/
-struct EdgeComparator
-{
-	bool operator()(const EdgeWithParent& a, const EdgeWithParent& b) const
-	{
-		if (a.parent == b.parent)
-		{
-			if (a.s == b.s)
-			{
-				return a.e < b.e;
-			}
-			else
-			{
-				return a.s < b.s;
-			}
-		}
-		else
-		{
-			return a.parent < b.parent;
-		}
-	}
-};
-
-
-/**
-Vertex projection direction flag.
-*/
-enum ProjectionDirections
-{
-	YZ_PLANE = 1 << 1,
-	XY_PLANE = 1 << 2,
-	ZX_PLANE = 1 << 3,
-
-	OPPOSITE_WINDING = 1 << 4
-};
-
-/**
-Computes best direction to project points.
-*/
-NV_FORCE_INLINE ProjectionDirections getProjectionDirection(const physx::PxVec3& normal)
-{
-	float maxv = std::max(abs(normal.x), std::max(abs(normal.y), abs(normal.z)));
-	ProjectionDirections retVal;
-	if (maxv == abs(normal.x))
-	{
-		retVal = YZ_PLANE;
-		if (normal.x < 0) retVal = (ProjectionDirections)((int)retVal | (int)OPPOSITE_WINDING);
-		return retVal;
-	}
-	if (maxv == abs(normal.y))
-	{
-		retVal = ZX_PLANE;
-		if (normal.y > 0) retVal = (ProjectionDirections)((int)retVal | (int)OPPOSITE_WINDING);
-		return retVal;
-	}
-	retVal = XY_PLANE;
-	if (normal.z < 0) retVal = (ProjectionDirections)((int)retVal | (int)OPPOSITE_WINDING);
-	return retVal;
-}
-
-
-/**
-Computes point projected on given axis aligned plane.
-*/
-NV_FORCE_INLINE physx::PxVec2 getProjectedPoint(const physx::PxVec3& point, ProjectionDirections dir)
-{
-	if (dir & YZ_PLANE)
-	{
-		return physx::PxVec2(point.y, point.z);
-	}
-	if (dir & ZX_PLANE)
-	{
-		return physx::PxVec2(point.x, point.z);
-	}
-	return physx::PxVec2(point.x, point.y);
-}
-
-/**
-Computes point projected on given axis aligned plane, this method is polygon-winding aware.
-*/
-NV_FORCE_INLINE physx::PxVec2 getProjectedPointWithWinding(const physx::PxVec3& point, ProjectionDirections dir)
-{
-	if (dir & YZ_PLANE)
-	{
-		if (dir & OPPOSITE_WINDING)
-		{
-			return physx::PxVec2(point.z, point.y);
-		}
-		else
-		return physx::PxVec2(point.y, point.z);
-	}
-	if (dir & ZX_PLANE)
-	{
-		if (dir & OPPOSITE_WINDING)
-		{
-			return physx::PxVec2(point.z, point.x);
-		}
-		return physx::PxVec2(point.x, point.z);
-	}
-	if (dir & OPPOSITE_WINDING)
-	{
-		return physx::PxVec2(point.y, point.x);
-	}
-	return physx::PxVec2(point.x, point.y);
-}
-
-
-
-#define MAXIMUM_EXTENT 1000 * 1000 * 1000
-#define BBOX_TEST_EPS 1e-5f 
-
-/**
-Test fattened bounding box intersetion.
-*/
-NV_INLINE bool  weakBoundingBoxIntersection(const physx::PxBounds3& aBox, const physx::PxBounds3& bBox)
-{
-	if (std::max(aBox.minimum.x, bBox.minimum.x) > std::min(aBox.maximum.x, bBox.maximum.x) + BBOX_TEST_EPS)
-		return false;
-	if (std::max(aBox.minimum.y, bBox.minimum.y) > std::min(aBox.maximum.y, bBox.maximum.y) + BBOX_TEST_EPS)
-		return false;
-	if (std::max(aBox.minimum.z, bBox.minimum.z) > std::min(aBox.maximum.z, bBox.maximum.z) + BBOX_TEST_EPS)
-		return false;
-	return true;
-}
-
-
-
-/**
-Test segment vs plane intersection. If segment intersects the plane true is returned. Point of intersection is written into 'result'.
-*/
-NV_INLINE bool getPlaneSegmentIntersection(const PxPlane& pl, const PxVec3& a, const PxVec3& b, PxVec3& result)
-{
-	float div = (b - a).dot(pl.n);
-	if (PxAbs(div) < 0.0001f)
-	{
-		if (pl.contains(a))
-		{
-			result = a;
-			return true;
-		}
-		else
-		{
-			return false;
-		}
-	}
-	float t = (-a.dot(pl.n) - pl.d) / div;
-	if (t < 0.0f || t > 1.0f)
-	{
-		return false;
-	}
-	result = (b - a) * t + a;
-	return true;
-}
-
-}	// namespace Blast
-}	// namespace Nv
-
-#endif
\ No newline at end of file
diff --git a/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringMesh.cpp b/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringMesh.cpp
deleted file mode 100644
index a25d2fe..0000000
--- a/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringMesh.cpp
+++ /dev/null
@@ -1,558 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#define _CRT_SECURE_NO_WARNINGS
-
-#include "NvBlastExtAuthoringMesh.h"
-#include "NvBlastExtAuthoringTypes.h"
-#include <string.h>
-#include "NvBlastExtAuthoringPerlinNoise.h"
-
-using physx::PxVec2;
-using physx::PxVec3;
-using physx::PxBounds3;
-
-namespace Nv
-{
-namespace Blast
-{
-
-Mesh::Mesh(PxVec3* position, PxVec3* normals, PxVec2* uv, uint32_t verticesCount, uint32_t* indices, uint32_t indicesCount)
-{
-
-	mVertices.resize(verticesCount);
-	for (uint32_t i = 0; i < mVertices.size(); ++i)
-	{
-		mVertices[i].p = position[i];
-	}
-	if (normals != 0)
-	{
-		for (uint32_t i = 0; i < mVertices.size(); ++i)
-		{
-			mVertices[i].n = normals[i];
-		}
-
-	}
-	else
-	{
-		for (uint32_t i = 0; i < mVertices.size(); ++i)
-		{
-			mVertices[i].n = PxVec3(0, 0, 0);
-		}
-	}
-	if (uv != 0)
-	{
-		for (uint32_t i = 0; i < mVertices.size(); ++i)
-		{
-			mVertices[i].uv[0] = uv[i];
-		}
-	}
-	else
-	{
-		for (uint32_t i = 0; i < mVertices.size(); ++i)
-		{
-			mVertices[i].uv[0] = PxVec2(0, 0);
-		}
-	}
-	mEdges.resize(indicesCount);
-	mFacets.resize(indicesCount / 3);
-	mBounds.setEmpty();
-	for (uint32_t i = 0; i < verticesCount; ++i)
-	{
-		mBounds.include(mVertices[i].p);
-	}
-	int32_t facetId = 0;
-	for (uint32_t i = 0; i < indicesCount; i += 3)
-	{
-		mEdges[i].s = indices[i];
-		mEdges[i].e = indices[i + 1];
-
-		mEdges[i + 1].s = indices[i + 1];
-		mEdges[i + 1].e = indices[i + 2];
-
-		mEdges[i + 2].s = indices[i + 2];
-		mEdges[i + 2].e = indices[i];
-		mFacets[facetId].firstEdgeNumber = i;
-		mFacets[facetId].edgesCount = 3;
-		facetId++;
-	}
-}
-
-Mesh::Mesh(Vertex* vertices, Edge* edges, Facet* facets, uint32_t posCount, uint32_t edgesCount, uint32_t facetsCount)
-{
-	mVertices.resize(posCount);
-	mEdges.resize(edgesCount);
-	mFacets.resize(facetsCount);
-
-	memcpy(mVertices.data(), vertices, sizeof(Vertex) * posCount);
-	memcpy(mEdges.data(), edges, sizeof(Edge) * edgesCount);
-	memcpy(mFacets.data(), facets, sizeof(Facet) * facetsCount);
-	mBounds.setEmpty();
-	for (uint32_t i = 0; i < posCount; ++i)
-	{
-		mBounds.include(mVertices[i].p);
-	}
-}
-
-float Mesh::getMeshVolume()
-{
-	/**
-		Check if mesh boundary consist only of triangles
-	*/
-	for (uint32_t i = 0; i < mFacets.size(); ++i)
-	{
-		if (mFacets[i].edgesCount != 3)
-		{
-			return 0.0f;
-		}
-	}	
-
-	float volume = 0;
-	for (uint32_t i = 0; i < mFacets.size(); ++i)
-	{
-		int32_t offset = mFacets[i].firstEdgeNumber;
-		PxVec3& a = mVertices[mEdges[offset].s].p;
-		PxVec3& b = mVertices[mEdges[offset + 1].s].p;
-		PxVec3& c = mVertices[mEdges[offset + 2].s].p;
-		
-		volume += (a.x * b.y * c.z - a.x * b.z * c.y - a.y * b.x * c.z + a.y * b.z * c.x + a.z * b.x * c.y - a.z * b.y * c.x);
-	}
-	return (1.0f / 6.0f) * abs(volume);
-}
-
-
-uint32_t Mesh::getFacetCount()
-{
-	return static_cast<uint32_t>(mFacets.size());
-}
-
-Vertex* Mesh::getVertices()
-{
-	return mVertices.data();
-}
-
-Edge* Mesh::getEdges()
-{
-	return mEdges.data();
-}
-
-uint32_t Mesh::getEdgesCount()
-{
-	return static_cast<uint32_t>(mEdges.size());
-}
-uint32_t Mesh::getVerticesCount()
-{
-	return static_cast<uint32_t>(mVertices.size());
-}
-Facet* Mesh::getFacetsBuffer()
-{
-	return mFacets.data();
-}
-Facet* Mesh::getFacet(int32_t facet)
-{
-	return &mFacets[facet];
-}
-
-
-Mesh::~Mesh()
-{
-}
-
-PxBounds3& Mesh::getBoundingBox()
-{
-	return mBounds;
-}
-
-void Mesh::recalculateBoundingBox()
-{
-	mBounds.setEmpty();
-	for (uint32_t i = 0; i < mVertices.size(); ++i)
-	{
-		mBounds.include(mVertices[i].p);
-	}
-}
-
-
-
-void getTangents(PxVec3& normal, PxVec3& t1, PxVec3& t2)
-{
-
-	if (abs(normal.z) < 0.9)
-	{
-		t1 = normal.cross(PxVec3(0, 0, 1));
-	}
-	else
-	{
-		t1 = normal.cross(PxVec3(1, 0, 0));
-	}
-	t2 = t1.cross(normal);
-}
-
-Mesh* getCuttingBox(const PxVec3& point, const PxVec3& normal, float size, int32_t id)
-{
-	PxVec3 lNormal = normal.getNormalized();
-	PxVec3 t1, t2;
-	getTangents(lNormal, t1, t2);
-
-	std::vector<Vertex> positions(8);
-	positions[0].p = point + (t1 + t2) * size;
-	positions[1].p = point + (t2 - t1) * size;
-
-	positions[2].p = point + (-t1 - t2) * size;
-	positions[3].p = point + (t1 - t2) * size;
-
-
-	positions[4].p = point + (t1 + t2 + lNormal) * size;
-	positions[5].p = point + (t2 - t1 + lNormal) * size;
-
-	positions[6].p = point + (-t1 - t2 + lNormal) * size;
-	positions[7].p = point + (t1 - t2 + lNormal) * size;
-
-	positions[0].n = -lNormal;
-	positions[1].n = -lNormal;
-
-	positions[2].n = -lNormal;
-	positions[3].n = -lNormal;
-
-
-	positions[4].n = -lNormal;
-	positions[5].n = -lNormal;
-
-	positions[6].n = -lNormal;
-	positions[7].n = -lNormal;
-
-	positions[0].uv[0] = PxVec2(0, 0);
-	positions[1].uv[0] = PxVec2(10, 0);
-
-	positions[2].uv[0] = PxVec2(10, 10);
-	positions[3].uv[0] = PxVec2(0, 10);
-
-
-	positions[4].uv[0] = PxVec2(0, 0);
-	positions[5].uv[0] = PxVec2(10, 0);
-
-	positions[6].uv[0] = PxVec2(10, 10);
-	positions[7].uv[0] = PxVec2(0, 10);
-
-
-	std::vector<Edge> edges;
-	std::vector<Facet> facets;
-
-	edges.push_back(Edge(0, 1));
-	edges.push_back(Edge(1, 2));
-	edges.push_back(Edge(2, 3));
-	edges.push_back(Edge(3, 0));
-	facets.push_back(Facet(0, 4, id));
-
-
-	edges.push_back(Edge(0, 3));
-	edges.push_back(Edge(3, 7));
-	edges.push_back(Edge(7, 4));
-	edges.push_back(Edge(4, 0));
-	facets.push_back(Facet(4, 4, id));
-
-	edges.push_back(Edge(3, 2));
-	edges.push_back(Edge(2, 6));
-	edges.push_back(Edge(6, 7));
-	edges.push_back(Edge(7, 3));
-	facets.push_back(Facet(8, 4, id));
-
-	edges.push_back(Edge(5, 6));
-	edges.push_back(Edge(6, 2));
-	edges.push_back(Edge(2, 1));
-	edges.push_back(Edge(1, 5));
-	facets.push_back(Facet(12, 4, id));
-
-	edges.push_back(Edge(4, 5));
-	edges.push_back(Edge(5, 1));
-	edges.push_back(Edge(1, 0));
-	edges.push_back(Edge(0, 4));
-	facets.push_back(Facet(16, 4, id));
-
-	edges.push_back(Edge(4, 7));
-	edges.push_back(Edge(7, 6));
-	edges.push_back(Edge(6, 5));
-	edges.push_back(Edge(5, 4));
-	facets.push_back(Facet(20, 4, id));
-	return new Mesh(positions.data(), edges.data(), facets.data(), static_cast<uint32_t>(positions.size()), static_cast<uint32_t>(edges.size()), static_cast<uint32_t>(facets.size()));
-}
-
-void inverseNormalAndSetIndices(Mesh* mesh, int32_t id)
-{
-	for (uint32_t i = 0; i < mesh->getVerticesCount(); ++i)
-	{
-		mesh->getVertices()[i].n *= -1.0f;
-	}
-	for (uint32_t i = 0; i < mesh->getFacetCount(); ++i)
-	{
-		mesh->getFacet(i)->userData = id;
-	}
-
-}
-
-void setCuttingBox(const PxVec3& point, const PxVec3& normal, Mesh* mesh, float size, int32_t id)
-{
-	PxVec3 t1, t2;
-	PxVec3 lNormal = normal.getNormalized();
-	getTangents(lNormal, t1, t2);
-
-	Vertex* positions = mesh->getVertices();
-	positions[0].p = point + (t1 + t2) * size;
-	positions[1].p = point + (t2 - t1) * size;
-
-	positions[2].p = point + (-t1 - t2) * size;
-	positions[3].p = point + (t1 - t2) * size;
-
-
-	positions[4].p = point + (t1 + t2 + lNormal) * size;
-	positions[5].p = point + (t2 - t1 + lNormal) * size;
-
-	positions[6].p = point + (-t1 - t2 + lNormal) * size;
-	positions[7].p = point + (t1 - t2 + lNormal) * size;
-
-	positions[0].n = -lNormal;
-	positions[1].n = -lNormal;
-
-	positions[2].n = -lNormal;
-	positions[3].n = -lNormal;
-
-
-	positions[4].n = -lNormal;
-	positions[5].n = -lNormal;
-
-	positions[6].n = -lNormal;
-	positions[7].n = -lNormal;
-
-	for (uint32_t i = 0; i < mesh->getFacetCount(); ++i)
-	{
-		mesh->getFacet(i)->userData = id;
-	}
-	mesh->recalculateBoundingBox();
-}
-
-bool Mesh::isValid()
-{
-	return mVertices.size() > 0 && mEdges.size() > 0 && mFacets.size() > 0;
-}
-
-Mesh* getNoisyCuttingBoxPair(const physx::PxVec3& point, const physx::PxVec3& normal, float size, float jaggedPlaneSize, uint32_t resolution,  int32_t id, float amplitude, float frequency, int32_t octaves, int32_t seed)
-{
-	SimplexNoise nEval(amplitude, frequency, octaves, seed);
-	PxVec3 t1, t2;
-	PxVec3 lNormal = normal.getNormalized();
-	getTangents(lNormal, t1, t2);
-
-	std::vector<Vertex> vertices ((resolution + 1) * (resolution + 1) + 12);
-	PxVec3 cPosit = point + (t1 + t2) * jaggedPlaneSize;
-	PxVec3 t1d = -t1 * 2.0f * jaggedPlaneSize / resolution;
-	PxVec3 t2d = -t2 * 2.0f * jaggedPlaneSize / resolution;
-
-	int32_t vrtId = 0;
-	for (uint32_t i = 0; i < resolution + 1; ++i)
-	{
-		PxVec3 lcPosit = cPosit;
-		for (uint32_t j = 0; j < resolution + 1; ++j)
-		{
-			vertices[vrtId].p = lcPosit;
-			lcPosit += t1d;
-			vrtId++;
-		}
-		cPosit += t2d;
-	}
-
-	
-	for (uint32_t i = 1; i < resolution; ++i)
-	{
-		for (uint32_t j = 1; j < resolution; ++j)
-		{
-			PxVec3& pnt = vertices[i * (resolution + 1) + j].p;
-			pnt += lNormal * nEval.sample(pnt);
-		}
-	}
-
-	std::vector<Edge> edges;
-	std::vector<Facet> facets;
-	for (uint32_t i = 0; i < resolution; ++i)
-	{
-		for (uint32_t j = 0; j < resolution; ++j)
-		{
-			uint32_t start = edges.size();
-			edges.push_back(Edge(i * (resolution + 1) + j, i * (resolution + 1) + j + 1));
-			edges.push_back(Edge(i * (resolution + 1) + j + 1, (i + 1) * (resolution + 1) + j + 1));
-			edges.push_back(Edge((i + 1) * (resolution + 1) + j + 1, (i + 1) * (resolution + 1) + j));
-			edges.push_back(Edge((i + 1) * (resolution + 1) + j, i * (resolution + 1) + j));
-			facets.push_back(Facet(start, 4, id));
-		}
-	}
-	uint32_t offset = (resolution + 1) * (resolution + 1);
-
-	vertices[0 + offset].p = point + (t1 + t2) * size;
-	vertices[1 + offset].p = point + (t2 - t1) * size;
-
-	vertices[2 + offset].p = point + (-t1 - t2) * size;
-	vertices[3 + offset].p = point + (t1 - t2) * size;
-
-	vertices[8 + offset].p = point + (t1 + t2) * jaggedPlaneSize;
-	vertices[9 + offset].p = point + (t2 - t1) * jaggedPlaneSize;
-
-	vertices[10 + offset].p = point + (-t1 - t2) * jaggedPlaneSize;
-	vertices[11 + offset].p = point + (t1 - t2) * jaggedPlaneSize;
-
-
-	vertices[4 + offset].p = point + (t1 + t2 + lNormal) * size;
-	vertices[5 + offset].p = point + (t2 - t1 + lNormal) * size;
-
-	vertices[6 + offset].p = point + (-t1 - t2 + lNormal) * size;
-	vertices[7 + offset].p = point + (t1 - t2 + lNormal) * size;
-
-	for (uint32_t i = 1; i < resolution; ++i)
-	{
-		for (uint32_t j = 1; j < resolution; ++j)
-		{
-			PxVec3 v1 = vertices[(resolution + 1) * (i + 1) + j].p - vertices[(resolution + 1) * i + j].p;
-			PxVec3 v2 = vertices[(resolution + 1) * (i) + j + 1].p - vertices[(resolution + 1) * i + j].p;
-			PxVec3 v3 = vertices[(resolution + 1) * (i - 1) + j].p - vertices[(resolution + 1) * i + j].p;
-			PxVec3 v4 = vertices[(resolution + 1) * (i) + j - 1].p - vertices[(resolution + 1) * i + j].p;
-
-			vertices[(resolution + 1) * i + j].n = v1.cross(v2) + v2.cross(v3) + v3.cross(v4) + v4.cross(v1);
-			vertices[(resolution + 1) * i + j].n.normalize();
-		}
-	}
-	
-	int32_t edgeOffset = edges.size();
-	edges.push_back(Edge(0 + offset, 1 + offset));
-	edges.push_back(Edge(1 + offset, 2 + offset));
-	edges.push_back(Edge(2 + offset, 3 + offset));
-	edges.push_back(Edge(3 + offset, 0 + offset));
-
-	edges.push_back(Edge(11 + offset, 10 + offset));
-	edges.push_back(Edge(10 + offset, 9 + offset));
-	edges.push_back(Edge(9 + offset, 8 + offset));
-	edges.push_back(Edge(8 + offset, 11 + offset));
-
-	facets.push_back(Facet(edgeOffset, 8, id));
-
-
-
-	edges.push_back(Edge(0 + offset, 3 + offset));
-	edges.push_back(Edge(3 + offset, 7 + offset));
-	edges.push_back(Edge(7 + offset, 4 + offset));
-	edges.push_back(Edge(4 + offset, 0 + offset));
-	facets.push_back(Facet(8 + edgeOffset, 4, id));
-
-	edges.push_back(Edge(3 + offset, 2 + offset));
-	edges.push_back(Edge(2 + offset, 6 + offset));
-	edges.push_back(Edge(6 + offset, 7 + offset));
-	edges.push_back(Edge(7 + offset, 3 + offset));
-	facets.push_back(Facet(12 + edgeOffset, 4, id));
-
-	edges.push_back(Edge(5 + offset, 6 + offset));
-	edges.push_back(Edge(6 + offset, 2 + offset));
-	edges.push_back(Edge(2 + offset, 1 + offset));
-	edges.push_back(Edge(1 + offset, 5 + offset));
-	facets.push_back(Facet(16 + edgeOffset, 4, id));
-
-	edges.push_back(Edge(4 + offset, 5 + offset));
-	edges.push_back(Edge(5 + offset, 1 + offset));
-	edges.push_back(Edge(1 + offset, 0 + offset));
-	edges.push_back(Edge(0 + offset, 4 + offset));
-	facets.push_back(Facet(20 + edgeOffset, 4, id));
-
-	edges.push_back(Edge(4 + offset, 7 + offset));
-	edges.push_back(Edge(7 + offset, 6 + offset));
-	edges.push_back(Edge(6 + offset, 5 + offset));
-	edges.push_back(Edge(5 + offset, 4 + offset));
-	facets.push_back(Facet(24 + edgeOffset, 4, id));
-
-	//
-	return new Mesh(vertices.data(), edges.data(), facets.data(), vertices.size(), edges.size(), facets.size());
-}
-
-Mesh* getBigBox(const PxVec3& point, float size)
-{
-	PxVec3 normal(0, 0, 1);
-	normal.normalize();
-	PxVec3 t1, t2;
-	getTangents(normal, t1, t2);
-
-	std::vector<Vertex> positions(8);
-	positions[0].p = point + (t1 + t2 - normal) * size;
-	positions[1].p = point + (t2 - t1 - normal) * size;
-
-	positions[2].p = point + (-t1 - t2 - normal) * size;
-	positions[3].p = point + (t1 - t2 - normal) * size;
-
-
-	positions[4].p = point + (t1 + t2 + normal) * size;
-	positions[5].p = point + (t2 - t1 + normal) * size;
-
-	positions[6].p = point + (-t1 - t2 + normal) * size;
-	positions[7].p = point + (t1 - t2 + normal) * size;
-
-	positions[0].uv[0] = PxVec2(0, 0);
-	positions[1].uv[0] = PxVec2(10, 0);
-
-	positions[2].uv[0] = PxVec2(10, 10);
-	positions[3].uv[0] = PxVec2(0, 10);
-
-
-	positions[4].uv[0] = PxVec2(0, 0);
-	positions[5].uv[0] = PxVec2(10, 0);
-
-	positions[6].uv[0] = PxVec2(10, 10);
-	positions[7].uv[0] = PxVec2(0, 10);
-
-
-	std::vector<Edge> edges;
-	std::vector<Facet> facets;
-
-	edges.push_back(Edge(0, 1));
-	edges.push_back(Edge(1, 2));
-	edges.push_back(Edge(2, 3));
-	edges.push_back(Edge(3, 0));
-	facets.push_back(Facet(0, 4));
-
-
-	edges.push_back(Edge(0, 3));
-	edges.push_back(Edge(3, 7));
-	edges.push_back(Edge(7, 4));
-	edges.push_back(Edge(4, 0));
-	facets.push_back(Facet(4, 4));
-
-	edges.push_back(Edge(3, 2));
-	edges.push_back(Edge(2, 6));
-	edges.push_back(Edge(6, 7));
-	edges.push_back(Edge(7, 3));
-	facets.push_back(Facet(8, 4));
-
-	edges.push_back(Edge(5, 6));
-	edges.push_back(Edge(6, 2));
-	edges.push_back(Edge(2, 1));
-	edges.push_back(Edge(1, 5));
-	facets.push_back(Facet(12, 4));
-
-	edges.push_back(Edge(4, 5));
-	edges.push_back(Edge(5, 1));
-	edges.push_back(Edge(1, 0));
-	edges.push_back(Edge(0, 4));
-	facets.push_back(Facet(16, 4));
-
-	edges.push_back(Edge(4, 7));
-	edges.push_back(Edge(7, 6));
-	edges.push_back(Edge(6, 5));
-	edges.push_back(Edge(5, 4));
-	facets.push_back(Facet(20, 4));
-	for (int i = 0; i < 8; ++i)
-		positions[i].n = PxVec3(0, 0, 0);
-	return new Mesh(positions.data(), edges.data(), facets.data(), static_cast<uint32_t>(positions.size()), static_cast<uint32_t>(edges.size()), static_cast<uint32_t>(facets.size()));
-}
-
-} // namespace Blast
-} // namespace Nv
diff --git a/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringPerlinNoise.h b/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringPerlinNoise.h
deleted file mode 100644
index 95308c2..0000000
--- a/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringPerlinNoise.h
+++ /dev/null
@@ -1,373 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTAUTHORINGPERLINNOISE_H
-#define NVBLASTEXTAUTHORINGPERLINNOISE_H
-
-
-#include <NvBlastExtAuthoringTypes.h>
-
-#include <PxVec4.h>
-#include <PxVec3.h>
-
-#define PERLIN_NOISE_SAMPLE_TABLE 512
-using physx::PxVec3;
-namespace Nv
-{
-namespace Blast
-{
-
-/***********
-	Noise generation routines, copied from Apex. 	
-*/
-
-
-NV_INLINE float at3(const float& rx, const float& ry, const float& rz, const PxVec3 q)
-{
-	return rx * q[0] + ry * q[1] + rz * q[2];
-}
-
-NV_INLINE float fade(float t) { return t * t * t * (t * (t  * 6.0f - 15.0f) + 10.0f); }
-
-NV_INLINE float lerp(float t, float a, float b) { return a + t * (b - a); }
-
-NV_INLINE void setup(int i, PxVec3 point, float& t, int& b0, int& b1, float& r0, float& r1)
-{
-	t = point[i] + (0x1000);
-	b0 = ((int)t) & (PERLIN_NOISE_SAMPLE_TABLE - 1);
-	b1 = (b0 + 1)   & (PERLIN_NOISE_SAMPLE_TABLE - 1);
-	r0 = t - (int)t;
-	r1 = r0 - 1.0f;
-}
-
-
-NV_INLINE float noiseSample(PxVec3 point, int* p, PxVec3* g)
-{
-	int bx0, bx1, by0, by1, bz0, bz1, b00, b10, b01, b11;
-	float rx0, rx1, ry0, ry1, rz0, rz1, sy, sz, a, b, c, d, t, u, v;
-	PxVec3 q;
-	int i, j;
-
-	setup(0, point, t, bx0, bx1, rx0, rx1);
-	setup(1, point, t, by0, by1, ry0, ry1);
-	setup(2, point, t, bz0, bz1, rz0, rz1);
-
-	i = p[bx0];
-	j = p[bx1];
-
-	b00 = p[i + by0];
-	b10 = p[j + by0];
-	b01 = p[i + by1];
-	b11 = p[j + by1];
-
-	t = fade(rx0);
-	sy = fade(ry0);
-	sz = fade(rz0);
-
-	q = g[b00 + bz0]; u = at3(rx0, ry0, rz0, q);
-	q = g[b10 + bz0]; v = at3(rx1, ry0, rz0, q);
-	a = lerp(t, u, v);
-
-	q = g[b01 + bz0]; u = at3(rx0, ry1, rz0, q);
-	q = g[b11 + bz0]; v = at3(rx1, ry1, rz0, q);
-	b = lerp(t, u, v);
-
-	c = lerp(sy, a, b);
-
-	q = g[b00 + bz1]; u = at3(rx0, ry0, rz1, q);
-	q = g[b10 + bz1]; v = at3(rx1, ry0, rz1, q);
-	a = lerp(t, u, v);
-
-	q = g[b01 + bz1]; u = at3(rx0, ry1, rz1, q);
-	q = g[b11 + bz1]; v = at3(rx1, ry1, rz1, q);
-	b = lerp(t, u, v);
-
-	d = lerp(sy, a, b);
-
-	return lerp(sz, c, d);
-}
-
-/**
-	Perlin Noise generation tool
-*/
-class PerlinNoise
-{
-public:
-	/**
-		\param[in] rnd Random value generator
-		\param[in] octaves Number of noise octaves
-		\param[in] frequency Frequency of noise
-		\param[in] amplitude Amplitude of noise
-	*/
-	PerlinNoise(Nv::Blast::RandomGeneratorBase* rnd, int octaves = 1, float frequency = 1., float amplitude = 1.)
-		: mRnd(rnd),
-		mOctaves(octaves),
-		mFrequency(frequency),
-		mAmplitude(amplitude),
-		mbInit(false)
-	{
-
-	}
-
-	/*
-		Reset state of noise generator
-		\param[in] octaves Number of noise octaves
-		\param[in] frequency Frequency of noise
-		\param[in] amplitude Amplitude of noise
-	*/
-	void reset(int octaves = 1, float frequency = 1.f, float amplitude = 1.f)
-	{
-		mOctaves = octaves;
-		mFrequency = frequency;
-		mAmplitude = amplitude;
-		init();
-	}
-
-	/**
-		Get Perlin Noise value at given point
-	*/
-	float sample(const physx::PxVec3& point)
-	{
-		return perlinNoise(point);
-	}
-
-private:
-	PerlinNoise& operator=(const PerlinNoise&);
-
-	float perlinNoise(physx::PxVec3 point)
-	{
-		if (!mbInit)
-			init();
-
-		const int octaves = mOctaves;
-		const float frequency = mFrequency;
-		float amplitude = mAmplitude;
-		float result = 0.0f;
-
-		point *= frequency;
-
-		for (int i = 0; i < octaves; ++i)
-		{
-			PxVec3 lpnt;
-			lpnt[0] = point.x;
-			lpnt[1] = point.y;
-			lpnt[2] = point.z;
-			result += (noiseSample(lpnt, p, g)) * amplitude;
-			point *= 2.0f;
-			amplitude *= 0.5f;
-		}
-		return result;
-	}
-
-	void init(void)
-	{
-		mbInit = true;
-
-		unsigned  i, j;
-		int k;
-
-		for (i = 0; i < (unsigned)PERLIN_NOISE_SAMPLE_TABLE; i++)
-		{
-			p[i] = (int)i;
-			for (j = 0; j < 3; ++j)
-				g[i][j] = mRnd->getRandomValue();
-			g[i].normalize();
-		}
-
-		while (--i)
-		{
-			k = p[i];
-			j = static_cast<uint32_t>(mRnd->getRandomValue() * PERLIN_NOISE_SAMPLE_TABLE);
-			p[i] = p[j];
-			p[j] = k;
-		}
-
-		for (i = 0; i < PERLIN_NOISE_SAMPLE_TABLE + 2; ++i)
-		{
-			p[(unsigned)PERLIN_NOISE_SAMPLE_TABLE + i] = p[i];
-			for (j = 0; j < 3; ++j)
-				g[(unsigned)PERLIN_NOISE_SAMPLE_TABLE + i][j] = g[i][j];
-		}
-
-	}
-
-	Nv::Blast::RandomGeneratorBase*	mRnd;
-	int								mOctaves;
-	float							mFrequency;
-	float							mAmplitude;
-
-	// Permutation vector
-	int								p[(unsigned)(PERLIN_NOISE_SAMPLE_TABLE + PERLIN_NOISE_SAMPLE_TABLE + 2)];
-	// Gradient vector
-	PxVec3							g[(unsigned)(PERLIN_NOISE_SAMPLE_TABLE + PERLIN_NOISE_SAMPLE_TABLE + 2)];
-
-	bool							mbInit;
-};
-
-
-/**
-	Simplex noise generation tool
-*/
-class SimplexNoise
-{
-
-	int32_t				mOctaves;
-	float				mAmplitude;
-	float				mFrequency;
-	int32_t				mSeed;
-
-	static const int	X_NOISE_GEN = 1619;
-	static const int	Y_NOISE_GEN = 31337;
-	static const int	Z_NOISE_GEN = 6971;
-	static const int	W_NOISE_GEN = 1999;
-	static const int	SEED_NOISE_GEN = 1013;
-	static const int	SHIFT_NOISE_GEN = 8;
-
-	NV_INLINE int fastfloor(float x)
-	{
-		return (x >= 0) ? (int)x : (int)(x - 1);
-	}
-
-	SimplexNoise& operator=(const SimplexNoise&)
-	{
-		return *this;
-	}
-
-public:
-	/**
-		\param[in] ampl Amplitude of noise
-		\param[in] freq Frequency of noise
-		\param[in] octaves Number of noise octaves
-		\param[in] seed Random seed value
-	*/
-	SimplexNoise(float ampl, float freq, int32_t octaves, int32_t seed) : mOctaves(octaves), mAmplitude(ampl), mFrequency(freq), mSeed(seed) {};
-	// 4D simplex noise
-	// returns: (x,y,z) = noise grad, w = noise value
-
-	/**
-		Evaluate noise at given 4d-point
-		\param[in] x x coordinate of point
-		\param[in] y y coordinate of point
-		\param[in] z z coordinate of point
-		\param[in] w w coordinate of point
-		\param[in] seed Random seed value
-		\return Noise valued vector (x,y,z) and scalar (w)
-	*/
-	physx::PxVec4 eval4D(float x, float y, float z, float w, int seed)
-	{
-		// The skewing and unskewing factors are hairy again for the 4D case
-		const float F4 = (physx::PxSqrt(5.0f) - 1.0f) / 4.0f;
-		const float G4 = (5.0f - physx::PxSqrt(5.0f)) / 20.0f;
-		// Skew the (x,y,z,w) space to determine which cell of 24 simplices we're in
-		float s = (x + y + z + w) * F4; // Factor for 4D skewing
-		int ix = fastfloor(x + s);
-		int iy = fastfloor(y + s);
-		int iz = fastfloor(z + s);
-		int iw = fastfloor(w + s);
-		float tu = (ix + iy + iz + iw) * G4; // Factor for 4D unskewing
-											// Unskew the cell origin back to (x,y,z,w) space
-		float x0 = x - (ix - tu); // The x,y,z,w distances from the cell origin
-		float y0 = y - (iy - tu);
-		float z0 = z - (iz - tu);
-		float w0 = w - (iw - tu);
-
-		int c = (x0 > y0) ? (1 << 0) : (1 << 2);
-		c += (x0 > z0) ? (1 << 0) : (1 << 4);
-		c += (x0 > w0) ? (1 << 0) : (1 << 6);
-		c += (y0 > z0) ? (1 << 2) : (1 << 4);
-		c += (y0 > w0) ? (1 << 2) : (1 << 6);
-		c += (z0 > w0) ? (1 << 4) : (1 << 6);
-
-		physx::PxVec4 res;
-		res.setZero();
-
-		// Calculate the contribution from the five corners
-		for (int p = 4; p >= 0; --p)
-		{
-			int ixp = ((c >> 0) & 3) >= p ? 1 : 0;
-			int iyp = ((c >> 2) & 3) >= p ? 1 : 0;
-			int izp = ((c >> 4) & 3) >= p ? 1 : 0;
-			int iwp = ((c >> 6) & 3) >= p ? 1 : 0;
-
-			float xp = x0 - ixp + (4 - p) * G4;
-			float yp = y0 - iyp + (4 - p) * G4;
-			float zp = z0 - izp + (4 - p) * G4;
-			float wp = w0 - iwp + (4 - p) * G4;
-
-			float t = 0.6f - xp * xp - yp * yp - zp * zp - wp * wp;
-			if (t > 0)
-			{
-				//get index
-				int gradIndex = int((
-					X_NOISE_GEN    * (ix + ixp)
-					+ Y_NOISE_GEN    * (iy + iyp)
-					+ Z_NOISE_GEN    * (iz + izp)
-					+ W_NOISE_GEN    * (iw + iwp)
-					+ SEED_NOISE_GEN * seed)
-					& 0xffffffff);
-				gradIndex ^= (gradIndex >> SHIFT_NOISE_GEN);
-				gradIndex &= 31;
-
-				physx::PxVec4 g;
-				{
-					const int h = gradIndex;
-					const int hs = 2 - (h >> 4);
-					const int h1 = (h >> 3);
-					g.x = (h1 == 0) ? 0.0f : ((h & 4) ? -1.0f : 1.0f);
-					g.y = (h1 == 1) ? 0.0f : ((h & (hs << 1)) ? -1.0f : 1.0f);
-					g.z = (h1 == 2) ? 0.0f : ((h & hs) ? -1.0f : 1.0f);
-					g.w = (h1 == 3) ? 0.0f : ((h & 1) ? -1.0f : 1.0f);
-				}
-				float gdot = (g.x * xp + g.y * yp + g.z * zp + g.w * wp);
-
-				float t2 = t * t;
-				float t3 = t2 * t;
-				float t4 = t3 * t;
-
-				float dt4gdot = 8 * t3 * gdot;
-
-				res.x += t4 * g.x - dt4gdot * xp;
-				res.y += t4 * g.y - dt4gdot * yp;
-				res.z += t4 * g.z - dt4gdot * zp;
-				res.w += t4 * gdot;
-			}
-		}
-		// scale the result to cover the range [-1,1]
-		res *= 27;
-		return res;
-	}
-
-	/**
-		Evaluate noise at given 3d-point
-		\param[in] p Point in which noise will be evaluated
-		\return Noise value at given point
-	*/
-	float sample(physx::PxVec3 p)
-	{
-		p *= mFrequency;
-		float result = 0.0f;
-		float alpha = 1;
-		for (int32_t i = 1; i <= mOctaves; ++i)
-		{
-			result += eval4D(p.x * i, p.y * i, p.z * i, i * 5.0f, mSeed).w * alpha;
-			alpha *= 0.45;
-		}
-		return result * mAmplitude;
-	}
-
-};
-
-
-	} // Blast namespace
-} // Nv namespace
-
-
-
-#endif
\ No newline at end of file
diff --git a/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringTriangulator.cpp b/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringTriangulator.cpp
deleted file mode 100644
index 0b7187f..0000000
--- a/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringTriangulator.cpp
+++ /dev/null
@@ -1,1439 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-// This warning arises when using some stl containers with older versions of VC
-// c:\program files (x86)\microsoft visual studio 12.0\vc\include\xtree(1826): warning C4702: unreachable code
-#include "NvPreprocessor.h"
-#if NV_VC && NV_VC < 14
-#pragma warning(disable : 4702)
-#endif
-#include "NvBlastExtAuthoringTriangulator.h"
-#include "NvBlastExtAuthoringMesh.h"
-#include "NvBlastExtAuthoringTypes.h"
-#include <math.h>
-#include "NvPreprocessor.h"
-#include <algorithm>
-#include <vector>
-#include <set>
-#include "NvBlastExtAuthoringBooleanTool.h"
-#include <queue>
-#include "NvBlastExtAuthoringPerlinNoise.h"
-#include <NvBlastAssert.h>
-
-using physx::PxVec3;
-using physx::PxVec2;
-
-#define VEC_COMPARISON_OFFSET 1e-5f
-#define TWO_VERTICES_THRESHOLD 1e-7
-
-namespace Nv
-{
-namespace Blast
-{
-
-bool VrtComp::operator()(const Vertex& a, const Vertex& b) const
-{
-	if (a.p.x + VEC_COMPARISON_OFFSET < b.p.x) return true;
-	if (a.p.x - VEC_COMPARISON_OFFSET > b.p.x) return false;
-	if (a.p.y + VEC_COMPARISON_OFFSET < b.p.y) return true;
-	if (a.p.y - VEC_COMPARISON_OFFSET > b.p.y) return false;
-	if (a.p.z + VEC_COMPARISON_OFFSET < b.p.z) return true;
-	if (a.p.z - VEC_COMPARISON_OFFSET > b.p.z) return false;
-
-	if (a.n.x + 1e-3 < b.n.x) return true;
-	if (a.n.x - 1e-3 > b.n.x) return false;
-	if (a.n.y + 1e-3 < b.n.y) return true;
-	if (a.n.y - 1e-3 > b.n.y) return false;
-	if (a.n.z + 1e-3 < b.n.z) return true;
-	if (a.n.z - 1e-3 > b.n.z) return false;
-
-
-	if (a.uv[0].x + 1e-3 < b.uv[0].x) return true;
-	if (a.uv[0].x - 1e-3 > b.uv[0].x) return false;
-	if (a.uv[0].y + 1e-3 < b.uv[0].y) return true;
-	return false;
-}
-
-bool VrtPositionComparator::operator()(const PxVec3& a, const PxVec3& b) const
-{
-	if (a.x + VEC_COMPARISON_OFFSET < b.x) return true;
-	if (a.x - VEC_COMPARISON_OFFSET > b.x) return false;
-	if (a.y + VEC_COMPARISON_OFFSET < b.y) return true;
-	if (a.y - VEC_COMPARISON_OFFSET > b.y) return false;
-	if (a.z + VEC_COMPARISON_OFFSET < b.z) return true;
-	if (a.z - VEC_COMPARISON_OFFSET > b.z) return false;
-	return false;
-}
-
-NV_FORCE_INLINE bool compareTwoVertices(const PxVec3& a, const PxVec3& b)
-{
-	return std::abs(b.x - a.x) < TWO_VERTICES_THRESHOLD && std::abs(b.y - a.y) < TWO_VERTICES_THRESHOLD && std::abs(b.z - a.z) < TWO_VERTICES_THRESHOLD;
-}
-NV_FORCE_INLINE bool compareTwoVertices(const PxVec2& a, const PxVec2& b)
-{
-	return std::abs(b.x - a.x) < TWO_VERTICES_THRESHOLD && std::abs(b.y - a.y) < TWO_VERTICES_THRESHOLD;
-}
-
-NV_FORCE_INLINE float getRotation(const PxVec2& a, const PxVec2& b)
-{
-	return a.x * b.y - a.y * b.x;
-}
-
-inline bool pointInside(PxVec2 a, PxVec2 b, PxVec2 c, PxVec2 pnt)
-{
-	if (compareTwoVertices(a, pnt) || compareTwoVertices(b, pnt) || compareTwoVertices(c, pnt))
-	{
-		return false;
-	}
-	float v1 = (getRotation((b - a), (pnt - a)));
-	float v2 = (getRotation((c - b), (pnt - b)));
-	float v3 = (getRotation((a - c), (pnt - c)));
-
-	return (v1 >= 0.0f && v2 >= 0.0f && v3 >= 0.0f) ||
-		(v1 <= 0.0f && v2 <= 0.0f && v3 <= 0.0f);
-
-}
-void ChunkPostProcessor::triangulatePolygonWithEarClipping(std::vector<uint32_t>& inputPolygon, Vertex* vert, ProjectionDirections dir)
-{
-	//	return;
-	//for (uint32_t i = 0; i < inputPolygon.size(); ++i)
-	//{
-	//	mBaseMeshTriangles.push_back(TriangleIndexed(inputPolygon[i], inputPolygon[i], inputPolygon[(i + 1) % inputPolygon.size()]));
-	//}
-	//return;
-	int32_t vCount = static_cast<int32_t>(inputPolygon.size());
-
-	if (vCount < 3)
-	{
-		return;
-	}
-	for (int32_t curr = 0; curr < vCount && vCount > 2; ++curr)
-	{
-		int32_t prev = (curr == 0) ? vCount - 1 : curr - 1;
-		int32_t next = (curr == vCount - 1) ? 0 : curr + 1;
-
-		Vertex cV = vert[inputPolygon[curr]];
-		Vertex nV = vert[inputPolygon[prev]];
-		Vertex pV = vert[inputPolygon[next]];
-
-		PxVec2 cVp = getProjectedPoint(cV.p, dir);
-		PxVec2 nVp = getProjectedPoint(nV.p, dir);
-		PxVec2 pVp = getProjectedPoint(pV.p, dir);
-
-		// Check wheather curr is ear-tip
-		float rot = getRotation((pVp - nVp).getNormalized(), (cVp - nVp).getNormalized());
-		if (!(dir & OPPOSITE_WINDING)) rot = -rot;
-		if (rot > 0.0001)
-		{
-			bool good = true;
-			for (int vrt = 0; vrt < vCount; ++vrt)
-			{
-				if (vrt == curr || vrt == prev || vrt == next) continue;
-				if (pointInside(cVp, nVp, pVp, getProjectedPoint(vert[inputPolygon[vrt]].p, dir)))
-				{
-					good = false;
-					break;
-				}
-			}
-			if (good)
-			{
-				addEdgeTr(Edge(inputPolygon[curr], inputPolygon[prev]));
-				addEdgeTr(Edge(inputPolygon[next], inputPolygon[prev]));
-				addEdgeTr(Edge(inputPolygon[curr], inputPolygon[next]));
-
-				mBaseMeshTriangles.push_back(TriangleIndexed(inputPolygon[curr], inputPolygon[prev], inputPolygon[next]));
-				vCount--;
-				inputPolygon.erase(inputPolygon.begin() + curr);
-				curr = -1;
-			}
-		}
-	}
-}
-
-
-
-struct LoopInfo
-{
-	LoopInfo()
-	{
-		used = false;
-	}
-	PxVec3 normal;
-	float area;
-	int32_t index;
-	bool used;
-	bool operator<(const LoopInfo& b) const
-	{
-		return area < b.area;
-	}
-};
-
-int32_t unitePolygons(std::vector<uint32_t>& externalLoop, std::vector<uint32_t>& internalLoop, Vertex* vrx, ProjectionDirections dir)
-{
-	if (externalLoop.size() < 3 || internalLoop.size() < 3)
-		return 1;
-	/**
-		Find point with maximum x-coordinate
-	*/
-	float x_max = -MAXIMUM_EXTENT;
-	int32_t mIndex = -1;
-	for (uint32_t i = 0; i < internalLoop.size(); ++i)
-	{
-		float nx = getProjectedPoint(vrx[internalLoop[i]].p, dir).x;
-		if (nx > x_max)
-		{
-			mIndex = i;
-			x_max = nx;
-		}
-	}
-	if (mIndex == -1)
-	{
-		return 1;
-	}
-
-	/**
-		Search for base point on external loop
-	*/
-	float minX = MAXIMUM_EXTENT;
-	int32_t vrtIndex = -1;
-	bool isFromBuffer = 0;
-	PxVec2 holePoint = getProjectedPoint(vrx[internalLoop[mIndex]].p, dir);
-	PxVec2 computedPoint;
-	for (uint32_t i = 0; i < externalLoop.size(); ++i)
-	{
-		int32_t nx = (i + 1) % externalLoop.size();
-		PxVec2 pnt1 = getProjectedPoint(vrx[externalLoop[i]].p, dir);
-		PxVec2 pnt2 = getProjectedPoint(vrx[externalLoop[nx]].p, dir);
-		if (pnt1.x < x_max && pnt2.x < x_max)
-		{
-			continue;
-		}
-		PxVec2 vc = pnt2 - pnt1;
-		if (vc.y == 0 && pnt1.y == holePoint.y)
-		{
-			if (pnt1.x < minX && pnt1.x < pnt2.x && pnt1.x > x_max)
-			{
-				minX = pnt1.x;
-				vrtIndex = i;
-				isFromBuffer = true;
-			}
-			if (pnt2.x < minX && pnt2.x < pnt1.x && pnt2.x > x_max)
-			{
-				minX = pnt2.x;
-				vrtIndex = nx;
-				isFromBuffer = true;
-			}
-		}
-		else
-		{
-			float t = (holePoint.y - pnt1.y) / vc.y;
-			if (t <= 1 && t >= 0)
-			{
-				PxVec2 tempPoint = vc * t + pnt1;
-				if (tempPoint.x < minX && tempPoint.x > x_max)
-				{
-					minX = tempPoint.x;
-					vrtIndex = i;
-					isFromBuffer = false;
-					computedPoint = tempPoint;
-				}
-			}
-		}
-	}
-	if (vrtIndex == -1)
-	{
-		//	std::cout << "Triangulation: base vertex for inner loop is not found..." << std::endl;
-		return 1;
-	}
-	int32_t bridgePoint = -1;
-	float bestAngle = 100;
-	if (!isFromBuffer)
-	{
-		PxVec2 ex1 = getProjectedPoint(vrx[externalLoop[vrtIndex]].p, dir);
-		PxVec2 ex2 = getProjectedPoint(vrx[externalLoop[(vrtIndex + 1) % externalLoop.size()]].p, dir);
-
-		if (ex1.x > ex2.x)
-		{
-			vrtIndex = (vrtIndex + 1) % externalLoop.size();
-			ex1 = ex2;
-		}
-		/* Check if some point is inside triangle */
-		bool notFound = true;
-		for (int32_t i = 0; i < (int32_t)externalLoop.size(); ++i)
-		{
-			PxVec2 tempPoint = getProjectedPoint(vrx[externalLoop[i]].p, dir);
-			if (pointInside(holePoint, ex1, computedPoint, tempPoint))
-			{
-				notFound = false;
-				PxVec2 cVp = getProjectedPoint(vrx[externalLoop[i]].p, dir);
-				PxVec2 pVp = getProjectedPoint(vrx[externalLoop[(i - 1 + externalLoop.size()) % externalLoop.size()]].p, dir);
-				PxVec2 nVp = getProjectedPoint(vrx[externalLoop[(i + 1) % externalLoop.size()]].p, dir);
-				float rt = getRotation((cVp - pVp).getNormalized(), (nVp - pVp).getNormalized());
-				if ((dir & OPPOSITE_WINDING)) rt = -rt;
-				if (rt < 0.000001)
-					continue;
-				float tempAngle = PxVec2(1, 0).dot((tempPoint - holePoint).getNormalized());
-				if (bestAngle < tempAngle)
-				{
-					bestAngle = tempAngle;
-					bridgePoint = i;
-				}
-			}
-		}
-		if (notFound)
-		{
-			bridgePoint = vrtIndex;
-		}
-		if (bridgePoint == -1)
-		{
-			//	std::cout << "Triangulation: bridge vertex for inner loop is not found..." << std::endl;
-			return 1;
-		}
-	}
-	else
-	{
-		bridgePoint = vrtIndex;
-	}
-	std::vector<uint32_t> temporal;
-
-	for (int32_t i = 0; i <= bridgePoint; ++i)
-	{
-		temporal.push_back(externalLoop[i]);
-	}
-	temporal.push_back(internalLoop[mIndex]);
-	for (int32_t i = (mIndex + 1) % internalLoop.size(); i != mIndex; i = (i + 1) % internalLoop.size())
-	{
-		temporal.push_back(internalLoop[i]);
-	}
-	temporal.push_back(internalLoop[mIndex]);
-	for (uint32_t i = bridgePoint; i < externalLoop.size(); ++i)
-	{
-		temporal.push_back(externalLoop[i]);
-	}
-	externalLoop = temporal;
-	return 0;
-}
-
-void ChunkPostProcessor::buildPolygonAndTriangulate(std::vector<Edge>& edges, Vertex* vertices, int32_t userData)
-{
-	std::vector<std::vector<uint32_t> > serializedLoops;
-
-	std::set<int> visitedVertices;
-	std::vector<int> used(edges.size(), 0);
-	uint32_t collected = 0;
-
-	std::vector<int> edgesIds;
-	/**
-	Add first edge to polygon
-	*/
-	edgesIds.push_back(0);
-	visitedVertices.insert(edges[0].s);
-	visitedVertices.insert(edges[0].e);
-	used[0] = true;
-	collected = 1;
-	uint32_t lastEdge = 0;
-	bool successfullPass = false;
-	for (; collected < edges.size();)
-	{
-		successfullPass = false;
-		for (uint32_t p = 0; p < edges.size(); ++p)
-		{
-			if (used[p] == 0 && edges[p].s == edges[lastEdge].e)
-			{
-				successfullPass = true;
-				collected++;
-				used[p] = true;
-				edgesIds.push_back(p);
-				lastEdge = p;
-				if (visitedVertices.find(edges[p].e) != visitedVertices.end()) // if we formed loop, detach it and triangulate
-				{
-					serializedLoops.push_back(std::vector<uint32_t>());
-					std::vector<uint32_t>& serializedPositions = serializedLoops.back();
-					while (edgesIds.size() > 0)
-					{
-						serializedPositions.push_back(edges[edgesIds.back()].s);
-						visitedVertices.erase(edges[edgesIds.back()].s);
-						if (edges[edgesIds.back()].s == edges[p].e)
-						{
-							edgesIds.pop_back();
-							break;
-						}
-						edgesIds.pop_back();
-					}
-					if (edgesIds.size() > 0)
-					{
-						lastEdge = edgesIds.back();
-					}
-					else
-					{
-						for (uint32_t t = 0; t < edges.size(); ++t)
-						{
-							if (used[t] == 0)
-							{
-								edgesIds.push_back(t);
-								visitedVertices.insert(edges[t].s);
-								visitedVertices.insert(edges[t].e);
-								used[t] = true;
-								collected++;
-								lastEdge = t;
-								break;
-							}
-						}
-					}
-				}
-				else
-				{
-					visitedVertices.insert(edges[p].e);
-				}
-			}
-		}
-		if (!successfullPass)
-		{
-			break;
-		}
-	}
-
-	std::vector<LoopInfo> loopsInfo(serializedLoops.size());
-	// Compute normal to whole polygon, and areas of loops
-	PxVec3 wholeFacetNormal(0, 0, 0);
-	for (uint32_t loop = 0; loop < serializedLoops.size(); ++loop)
-	{
-		PxVec3 loopNormal(0, 0, 0);
-		std::vector<uint32_t>& pos = serializedLoops[loop];
-		for (uint32_t vrt = 1; vrt + 1 < serializedLoops[loop].size(); ++vrt)
-		{
-			loopNormal += (vertices[pos[vrt]].p - vertices[pos[0]].p).cross(vertices[pos[vrt + 1]].p - vertices[pos[0]].p);
-		}
-		loopsInfo[loop].area = loopNormal.magnitude();
-		loopsInfo[loop].normal = loopNormal;
-		loopsInfo[loop].index = loop;
-		wholeFacetNormal += loopNormal;
-	}
-
-	// Change areas signs according to winding direction
-	for (uint32_t loop = 0; loop < serializedLoops.size(); ++loop)
-	{
-		if (wholeFacetNormal.dot(loopsInfo[loop].normal) < 0)
-		{
-			loopsInfo[loop].area = -loopsInfo[loop].area;
-		}
-	}
-	ProjectionDirections dir = getProjectionDirection(wholeFacetNormal);
-	std::sort(loopsInfo.begin(), loopsInfo.end());
-
-	std::vector<PxVec3> tempPositions;
-	int32_t oldSize = static_cast<int32_t>(mBaseMeshTriangles.size());
-	for (uint32_t extPoly = 0; extPoly < loopsInfo.size(); ++extPoly)
-	{
-		if (loopsInfo[extPoly].area < 0)
-		{
-			continue; // Polygon with negative area is hole
-		}
-		int32_t baseLoop = loopsInfo[extPoly].index;
-		for (uint32_t intPoly = 0; intPoly < loopsInfo.size(); ++intPoly)
-		{
-			if (loopsInfo[intPoly].area > 0 || loopsInfo[intPoly].used || abs(loopsInfo[intPoly].area) > loopsInfo[extPoly].area)
-			{
-				continue;
-			}
-			int32_t holeLoop = loopsInfo[intPoly].index;
-
-			if (!unitePolygons(serializedLoops[baseLoop], serializedLoops[holeLoop], vertices, dir))
-			{
-				loopsInfo[intPoly].used = true;
-			};
-		}
-		triangulatePolygonWithEarClipping(serializedLoops[baseLoop],vertices, dir);
-	}
-	for (uint32_t i = oldSize; i < mBaseMeshTriangles.size(); ++i)
-	{
-		mBaseMeshTriangles[i].userInfo = userData;
-	}
-}
-
-NV_FORCE_INLINE int32_t ChunkPostProcessor::addVerticeIfNotExist(Vertex& p)
-{
-	auto it = mVertMap.find(p);
-	if (it == mVertMap.end())
-	{
-		mVertMap[p] = static_cast<int32_t>(mVertices.size());
-		mVertices.push_back(p);
-		return static_cast<int32_t>(mVertices.size()) - 1;
-	}
-	else
-	{
-		return it->second;
-	}
-}
-
-NV_FORCE_INLINE void ChunkPostProcessor::addEdgeIfValid(EdgeWithParent& ed)
-{
-	if (ed.s == ed.e)
-		return;
-	EdgeWithParent opposite(ed.e, ed.s, ed.parent);
-	auto it = mEdgeMap.find(opposite);
-	if (it == mEdgeMap.end())
-	{
-		mEdgeMap[ed] = static_cast<int32_t>(mBaseMeshEdges.size());
-		mBaseMeshEdges.push_back(ed);
-	}
-	else
-	{
-		if (mBaseMeshEdges[it->second].s == NOT_VALID_VERTEX)
-		{
-			mBaseMeshEdges[it->second].s = ed.s;
-			mBaseMeshEdges[it->second].e = ed.e;
-		}
-		mBaseMeshEdges[it->second].s = NOT_VALID_VERTEX;
-	}
-}
-
-
-
-void ChunkPostProcessor::prepare(Mesh* mesh)
-{
-	Edge* ed = mesh->getEdges();
-	Vertex* vr = mesh->getVertices();
-	mBaseMapping.resize(mesh->getVerticesCount());
-	for (uint32_t i = 0; i < mesh->getFacetCount(); ++i)
-	{
-		Facet* fc = mesh->getFacet(i);
-		for (uint32_t j = fc->firstEdgeNumber; j < fc->firstEdgeNumber + fc->edgesCount; ++j)
-		{
-			int32_t a = addVerticeIfNotExist(vr[ed[j].s]);
-			int32_t b = addVerticeIfNotExist(vr[ed[j].e]);
-			mBaseMapping[ed[j].s] = a;
-			mBaseMapping[ed[j].e] = b;
-			EdgeWithParent e(a, b, i);
-			addEdgeIfValid(e);
-		}
-	}
-	std::vector<EdgeWithParent> temp;
-	temp.reserve(mBaseMeshEdges.size());
-	for (uint32_t i = 0; i < mBaseMeshEdges.size(); ++i)
-	{
-		if (mBaseMeshEdges[i].s != NOT_VALID_VERTEX)
-		{
-			temp.push_back(mBaseMeshEdges[i]);
-		}
-	}
-
-}
-
-void ChunkPostProcessor::reset()
-{
-	isTesselated = false;
-	mVertices.clear();
-	mBaseMeshEdges.clear();
-	mVertMap.clear();
-	mEdgeMap.clear();
-	mTrMeshEdgeMap.clear();
-	mTrMeshEdges.clear();
-	mTrMeshEdToTr.clear();
-	mBaseMeshTriangles.clear();
-	mEdgeFlag.clear();
-	mVertexValence.clear();
-	mRestrictionFlag.clear();
-	mVerticesDistances.clear();
-	mVerticesNormalsSmoothed.clear();
-
-	mBaseMeshResultTriangles.clear();
-	mTesselatedMeshResultTriangles.clear();
-	mTesselatedMeshTriangles.clear();
-}
-
-void ChunkPostProcessor::triangulate(Mesh* mesh)
-{
-	reset();
-	if (mesh == nullptr || !mesh->isValid())
-	{
-		return;
-	}
-	prepare(mesh);
-	if (mBaseMeshEdges.empty())
-	{
-		return;
-	}
-	std::vector<Edge> temp;
-	int32_t fP = mBaseMeshEdges[0].parent;
-	for (uint32_t i = 0; i < mBaseMeshEdges.size(); ++i)
-	{
-		if (fP != mBaseMeshEdges[i].parent)
-		{
-			if (temp.empty() == false)
-			{
-				buildPolygonAndTriangulate(temp, &mVertices[0], mesh->getFacet(fP)->userData);
-			}
-			temp.clear();
-			fP = mBaseMeshEdges[i].parent;
-		}
-		temp.push_back(Edge(mBaseMeshEdges[i].s, mBaseMeshEdges[i].e));
-	}
-	buildPolygonAndTriangulate(temp, &mVertices[0], mesh->getFacet(fP)->userData);
-
-	/* Build final triangles */
-
-	mBaseMeshResultTriangles.clear();
-	for (uint32_t i = 0; i < mBaseMeshTriangles.size(); ++i)
-	{
-		if (mBaseMeshTriangles[i].ea == NOT_VALID_VERTEX)
-		{
-			continue;
-		}
-		mBaseMeshResultTriangles.push_back(Triangle(mVertices[mBaseMeshTriangles[i].ea], mVertices[mBaseMeshTriangles[i].eb], mVertices[mBaseMeshTriangles[i].ec]));
-		mBaseMeshResultTriangles.back().userInfo = mBaseMeshTriangles[i].userInfo;
-	}
-
-	computePositionedMapping();
-}
-
-void ChunkPostProcessor::prebuildTesselatedTriangles()
-{
-	mTesselatedMeshResultTriangles.clear();
-	for (uint32_t i = 0; i < mTesselatedMeshTriangles.size(); ++i)
-	{
-		if (mTesselatedMeshTriangles[i].ea == NOT_VALID_VERTEX)
-		{
-			continue;
-		}
-		mTesselatedMeshResultTriangles.push_back(Triangle(mVertices[mTesselatedMeshTriangles[i].ea], mVertices[mTesselatedMeshTriangles[i].eb], mVertices[mTesselatedMeshTriangles[i].ec]));
-		mTesselatedMeshResultTriangles.back().userInfo = mTesselatedMeshTriangles[i].userInfo;
-	}
-
-}
-
-
-int32_t ChunkPostProcessor::addEdgeTr(const Edge& e)
-{
-	Edge ed = e;
-	if (ed.e < ed.s) std::swap(ed.s, ed.e);
-	auto it = mTrMeshEdgeMap.find(ed);
-	if (it == mTrMeshEdgeMap.end())
-	{
-		mTrMeshEdToTr.push_back(EdgeToTriangles());
-		mTrMeshEdgeMap[ed] = (int)mTrMeshEdToTr.size() - 1;
-		mTrMeshEdges.push_back(ed);
-		mEdgeFlag.push_back(INTERNAL_EDGE);
-		return (int32_t)mTrMeshEdToTr.size() - 1;
-	}
-	else
-	{
-		return it->second;
-	}
-}
-
-int32_t ChunkPostProcessor::findEdge(const Edge& e)
-{
-	Edge ed = e;
-	if (ed.e < ed.s) std::swap(ed.s, ed.e);
-	auto it = mTrMeshEdgeMap.find(ed);
-	if (it == mTrMeshEdgeMap.end())
-	{
-		return -1;
-	}
-	return it->second;
-}
-
-void ChunkPostProcessor::updateEdgeTriangleInfo()
-{
-	mTrMeshEdToTr.clear();
-	mTrMeshEdToTr.resize(mTrMeshEdges.size());
-	for (uint32_t i = 0; i < mTesselatedMeshTriangles.size(); ++i)
-	{
-		TriangleIndexed& tr = mTesselatedMeshTriangles[i];
-		if (tr.ea == NOT_VALID_VERTEX)
-			continue;
-		int32_t ed = addEdgeTr(Edge(tr.ea, tr.eb));
-		mTrMeshEdToTr[ed].add(i);
-		ed = addEdgeTr(Edge(tr.ea, tr.ec));
-		mTrMeshEdToTr[ed].add(i);
-		ed = addEdgeTr(Edge(tr.ec, tr.eb));
-		mTrMeshEdToTr[ed].add(i);
-	}
-}
-
-void ChunkPostProcessor::updateVertEdgeInfo()
-{
-	mVertexToTriangleMap.clear();
-	mVertexToTriangleMap.resize(mVertices.size());
-	for (uint32_t i = 0; i < mTesselatedMeshTriangles.size(); ++i)
-	{
-		TriangleIndexed& tr = mTesselatedMeshTriangles[i];
-		if (tr.ea == NOT_VALID_VERTEX) continue;
-		mVertexToTriangleMap[tr.ea].push_back(i);
-		mVertexToTriangleMap[tr.eb].push_back(i);
-		mVertexToTriangleMap[tr.ec].push_back(i);
-	}
-	mVertexValence.clear();
-	mVertexValence.resize(mVertices.size(), 0);
-
-	for (uint32_t i = 0; i < mTrMeshEdges.size(); ++i)
-	{
-		if (mTrMeshEdToTr[i].c != 0)
-		{
-			mVertexValence[mTrMeshEdges[i].s]++;
-			mVertexValence[mTrMeshEdges[i].e]++;
-		}
-	}
-}
-
-
-void ChunkPostProcessor::collapseEdge(int32_t id)
-{
-	Edge cEdge = mTrMeshEdges[id];
-	uint32_t from = cEdge.s;
-	uint32_t to = cEdge.e;
-
-
-	if (mRestrictionFlag[from] && mRestrictionFlag[to])
-	{
-		return;
-	}
-	
-	if (mVertexValence[from] > mVertexValence[to])
-	{
-		std::swap(from, to);
-	}
-
-	if (mRestrictionFlag[from])
-	{
-		std::swap(from, to);
-	}
-
-	std::set<int32_t> connectedToBegin;
-	std::set<int32_t> connectedToEnd;
-	std::set<int32_t> neighboorTriangles;
-
-	int32_t trWithEdge[2] = {-1, -1};
-	int32_t cntr = 0;
-	for (uint32_t i = 0; i < mVertexToTriangleMap[from].size(); ++i)
-	{
-		if (mTesselatedMeshTriangles[mVertexToTriangleMap[from][i]].ea == NOT_VALID_VERTEX)
-			continue;
-		if (neighboorTriangles.insert(mVertexToTriangleMap[from][i]).second && mTesselatedMeshTriangles[mVertexToTriangleMap[from][i]].isContainEdge(from, to))
-		{
-			trWithEdge[cntr] = mVertexToTriangleMap[from][i];
-			cntr++;
-		}
-	}
-	for (uint32_t i = 0; i < mVertexToTriangleMap[to].size(); ++i)
-	{
-		if (mTesselatedMeshTriangles[mVertexToTriangleMap[to][i]].ea == NOT_VALID_VERTEX)
-			continue;
-		if (neighboorTriangles.insert(mVertexToTriangleMap[to][i]).second && mTesselatedMeshTriangles[mVertexToTriangleMap[to][i]].isContainEdge(from, to))
-		{
-			trWithEdge[cntr] = mVertexToTriangleMap[to][i];
-			cntr++;
-		}
-	}
-
-	if (cntr == 0)
-	{
-		return;
-	}
-	if (cntr > 2)
-	{
-		return;
-	}
-
-	for (uint32_t i: neighboorTriangles)
-	{
-		if (mTesselatedMeshTriangles[i].ea == from || mTesselatedMeshTriangles[i].eb == from || mTesselatedMeshTriangles[i].ec == from)
-		{
-			if (mTesselatedMeshTriangles[i].ea != to && mTesselatedMeshTriangles[i].ea != from)
-				connectedToBegin.insert(mTesselatedMeshTriangles[i].ea);
-			if (mTesselatedMeshTriangles[i].eb != to && mTesselatedMeshTriangles[i].eb != from)
-				connectedToBegin.insert(mTesselatedMeshTriangles[i].eb);
-			if (mTesselatedMeshTriangles[i].ec != to && mTesselatedMeshTriangles[i].ec != from)
-				connectedToBegin.insert(mTesselatedMeshTriangles[i].ec);
-		}
-
-		if (mTesselatedMeshTriangles[i].ea == to || mTesselatedMeshTriangles[i].eb == to || mTesselatedMeshTriangles[i].ec == to)
-		{
-			if (mTesselatedMeshTriangles[i].ea != to && mTesselatedMeshTriangles[i].ea != from)
-				connectedToEnd.insert(mTesselatedMeshTriangles[i].ea);
-			if (mTesselatedMeshTriangles[i].eb != to && mTesselatedMeshTriangles[i].eb != from)
-				connectedToEnd.insert(mTesselatedMeshTriangles[i].eb);
-			if (mTesselatedMeshTriangles[i].ec != to && mTesselatedMeshTriangles[i].ec != from)
-				connectedToEnd.insert(mTesselatedMeshTriangles[i].ec);
-		}
-	}
-	bool canBeCollapsed = true;
-	for (auto it = connectedToBegin.begin(); it != connectedToBegin.end(); ++it)
-	{
-		uint32_t currV = *it;
-		if (connectedToEnd.find(currV) == connectedToEnd.end())
-			continue;
-		bool found = false;
-		for (int32_t tr : neighboorTriangles)
-		{
-			if ((mTesselatedMeshTriangles[tr].ea == from || mTesselatedMeshTriangles[tr].eb == from || mTesselatedMeshTriangles[tr].ec == from) &&
-				(mTesselatedMeshTriangles[tr].ea == to || mTesselatedMeshTriangles[tr].eb == to || mTesselatedMeshTriangles[tr].ec == to) &&
-				(mTesselatedMeshTriangles[tr].ea == currV || mTesselatedMeshTriangles[tr].eb == currV || mTesselatedMeshTriangles[tr].ec == currV))
-			{
-				found = true; 
-				break;
-			}
-		}
-		if (!found)
-		{
-			canBeCollapsed = false;
-			break;
-		}
-	}
-	
-	if (canBeCollapsed)
-	{
-		for (int32_t i : neighboorTriangles)
-		{
-			if (trWithEdge[0] == i) continue;
-			if (cntr == 2 && trWithEdge[1] == i) continue;
-			TriangleIndexed tr = mTesselatedMeshTriangles[i];
-			PxVec3 oldNormal = (mVertices[tr.eb].p - mVertices[tr.ea].p).cross(mVertices[tr.ec].p - mVertices[tr.ea].p);
-
-			if (tr.ea == from)
-			{
-				tr.ea = to;
-			}
-			else
-				if (tr.eb == from)
-				{
-					tr.eb = to;
-				}
-				else
-					if (tr.ec == from)
-					{
-						tr.ec = to;
-					}
-			PxVec3 newNormal = (mVertices[tr.eb].p - mVertices[tr.ea].p).cross(mVertices[tr.ec].p - mVertices[tr.ea].p);
-			if (newNormal.magnitude() < 1e-8f)
-			{
-				canBeCollapsed = false;
-				break;
-			}
-			if (oldNormal.dot(newNormal) < 0)
-			{
-				canBeCollapsed = false;
-				break;
-			}
-		}
-	}
-
-	if (canBeCollapsed)
-	{
-		mTesselatedMeshTriangles[trWithEdge[0]].ea = NOT_VALID_VERTEX;
-		if (cntr == 2)mTesselatedMeshTriangles[trWithEdge[1]].ea = NOT_VALID_VERTEX;
-
-		for (int32_t i : neighboorTriangles)
-		{
-			if (mTesselatedMeshTriangles[i].ea == NOT_VALID_VERTEX)
-				continue;
-			if (mTesselatedMeshTriangles[i].ea == from)
-			{
-				mTesselatedMeshTriangles[i].ea = to;
-				mVertexToTriangleMap[from].clear();
-				mVertexToTriangleMap[to].push_back(i);
-			}
-			else
-			if (mTesselatedMeshTriangles[i].eb == from)
-			{
-				mTesselatedMeshTriangles[i].eb = to;
-				mVertexToTriangleMap[from].clear();
-				mVertexToTriangleMap[to].push_back(i);
-			}
-			else
-			if (mTesselatedMeshTriangles[i].ec == from)
-			{
-				mTesselatedMeshTriangles[i].ec = to;
-				mVertexToTriangleMap[from].clear();
-				mVertexToTriangleMap[to].push_back(i);
-			}
-		}
-	}
-}
-
-
-void ChunkPostProcessor::divideEdge(int32_t id)
-{
-
-	if (mTrMeshEdToTr[id].c == 0 )
-	{
-		return;
-	}
-
-	Edge cEdge = mTrMeshEdges[id];
-	EdgeFlag snapRestriction = mEdgeFlag[id];
-	Vertex middle;
-	uint32_t nv = NOT_VALID_VERTEX;
-	for (int32_t t = 0; t < mTrMeshEdToTr[id].c; ++t)
-	{
-		int32_t oldTriangleIndex = mTrMeshEdToTr[id].tr[t];
-		TriangleIndexed tr = mTesselatedMeshTriangles[mTrMeshEdToTr[id].tr[t]];
-
-		if (tr.ea == NOT_VALID_VERTEX)
-		{
-			continue;
-		}
-
-		uint32_t pbf[3];
-		pbf[0] = tr.ea;
-		pbf[1] = tr.eb;
-		pbf[2] = tr.ec;		
-		for (int32_t p = 0; p < 3; ++p)
-		{
-			int32_t pnx = (p + 1) % 3;
-			int32_t opp = (p + 2) % 3;
-
-			if ((pbf[p] == cEdge.s && pbf[pnx] == cEdge.e) || (pbf[p] == cEdge.e && pbf[pnx] == cEdge.s))
-			{
-				if (nv == NOT_VALID_VERTEX)
-				{
-					middle.p = (mVertices[pbf[p]].p + mVertices[pbf[pnx]].p) * 0.5f;
-					middle.n = (mVertices[pbf[p]].n + mVertices[pbf[pnx]].n) * 0.5f;
-					middle.uv[0] = (mVertices[pbf[p]].uv[0] + mVertices[pbf[pnx]].uv[0]) * 0.5f;
-
-					nv = (uint32_t)mVertices.size();
-					mVertices.push_back(middle);
-				}
-				if (nv < mRestrictionFlag.size())
-				{
-					mRestrictionFlag[nv] = ((snapRestriction == EXTERNAL_BORDER_EDGE) || (snapRestriction == INTERNAL_BORDER_EDGE));
-				}
-				else
-				{
-					mRestrictionFlag.push_back((snapRestriction == EXTERNAL_BORDER_EDGE) || (snapRestriction == INTERNAL_BORDER_EDGE));
-				}
-	
-				uint32_t ind1 = addEdgeTr(Edge(pbf[p], nv));
-				uint32_t ind2 = addEdgeTr(Edge(nv, pbf[pnx]));
-				uint32_t ind3 = addEdgeTr(Edge(nv, pbf[opp]));
-
-		
-				mEdgeFlag[ind1] = snapRestriction;
-				mEdgeFlag[ind2] = snapRestriction;
-				mEdgeFlag[ind3] = INTERNAL_EDGE;
-				
-				mTrMeshEdToTr[ind1].add(mTrMeshEdToTr[id].tr[t]);
-				int32_t userInfo = mTesselatedMeshTriangles[mTrMeshEdToTr[id].tr[t]].userInfo;
-				mTesselatedMeshTriangles[mTrMeshEdToTr[id].tr[t]] = TriangleIndexed(pbf[p], nv, pbf[opp]);
-				mTesselatedMeshTriangles[mTrMeshEdToTr[id].tr[t]].userInfo = userInfo;
-				mTrMeshEdToTr[ind2].add((int32_t)mTesselatedMeshTriangles.size());
-				mTrMeshEdToTr[ind3].add((int32_t)mTrMeshEdToTr[id].tr[t]);
-				mTrMeshEdToTr[ind3].add((int32_t)mTesselatedMeshTriangles.size());
-				mTesselatedMeshTriangles.push_back(TriangleIndexed(nv,pbf[pnx], pbf[opp]));
-				mTesselatedMeshTriangles.back().userInfo = userInfo;
-				int32_t ed1 = findEdge(Edge(pbf[pnx], pbf[opp]));
-				mTrMeshEdToTr[ed1].replace(oldTriangleIndex, (int32_t)mTesselatedMeshTriangles.size() - 1);
-				break;
-			}
-		}
-	}
-}
-
-
-NV_FORCE_INLINE void markEdge(int32_t ui, int32_t ed, std::vector<ChunkPostProcessor::EdgeFlag>& shortMarkup, std::vector<int32_t>& lastOwner)
-{
-	if (shortMarkup[ed] == ChunkPostProcessor::NONE)
-	{
-		if (ui == 0)
-		{
-			shortMarkup[ed] = ChunkPostProcessor::EXTERNAL_EDGE;
-		}
-		else
-		{
-			shortMarkup[ed] = ChunkPostProcessor::INTERNAL_EDGE;
-		}
-		lastOwner[ed] = ui;
-	}
-	else
-	{
-		if (ui != 0)
-		{
-			if (shortMarkup[ed] == ChunkPostProcessor::EXTERNAL_EDGE)
-			{
-				shortMarkup[ed] = ChunkPostProcessor::EXTERNAL_BORDER_EDGE;
-			}
-			if ((shortMarkup[ed] == ChunkPostProcessor::INTERNAL_EDGE) && ui != lastOwner[ed])
-			{
-				shortMarkup[ed] = ChunkPostProcessor::INTERNAL_BORDER_EDGE;
-			}
-		}
-		else
-		{
-			if (shortMarkup[ed] != ChunkPostProcessor::EXTERNAL_EDGE)
-			{
-				shortMarkup[ed] = ChunkPostProcessor::EXTERNAL_BORDER_EDGE;
-			}
-		}
-	}
-}
-
-float falloffFunction(float x, float mx)
-{
-	float t = (x) / (mx + 1e-6f);
-	t = std::min(1.0f, t);
-	return t * t;
-}
-
-void ChunkPostProcessor::recalcNoiseDirs()
-{
-	/**
-		Compute normals direction to apply noise
-	*/
-	mVerticesNormalsSmoothed.resize(mVertices.size(), PxVec3(0, 0, 0));
-	for (uint32_t i = 0; i < mTesselatedMeshTriangles.size(); ++i)
-	{
-		if (mTesselatedMeshTriangles[i].ea == NOT_VALID_VERTEX)
-		{
-			continue;
-		}
-		TriangleIndexed& tr = mTesselatedMeshTriangles[i];
-		if (tr.userInfo == 0) continue;
-			
-		if (tr.userInfo < 0)
-			mVerticesNormalsSmoothed[mPositionMappedVrt[tr.ea]] += mVertices[tr.ea].n.getNormalized();
-		else
-			mVerticesNormalsSmoothed[mPositionMappedVrt[tr.ea]] -= mVertices[tr.ea].n.getNormalized();
-
-		if (tr.userInfo < 0)
-			mVerticesNormalsSmoothed[mPositionMappedVrt[tr.eb]] += mVertices[tr.eb].n.getNormalized();
-		else
-			mVerticesNormalsSmoothed[mPositionMappedVrt[tr.eb]] -= mVertices[tr.eb].n.getNormalized();
-
-		if (tr.userInfo < 0)
-			mVerticesNormalsSmoothed[mPositionMappedVrt[tr.ec]] += mVertices[tr.ec].n.getNormalized();
-		else
-			mVerticesNormalsSmoothed[mPositionMappedVrt[tr.ec]] -= mVertices[tr.ec].n.getNormalized();
-
-	}
-	for (uint32_t i = 0; i < mVerticesNormalsSmoothed.size(); ++i)
-	{
-
-		mVerticesNormalsSmoothed[i] = mVerticesNormalsSmoothed[mPositionMappedVrt[i]];
-		mVerticesNormalsSmoothed[i].normalize();
-	}
-}
-
-
-
-void ChunkPostProcessor::applyNoise(SimplexNoise& noise, float falloff, int32_t relaxIterations, float relaxFactor)
-{
-	NVBLAST_ASSERT(isTesselated);
-	if (isTesselated == false)
-	{
-		return;
-	}
-	mRestrictionFlag.clear();
-	mRestrictionFlag.resize(mVertices.size(), false);
-
-	for (uint32_t i = 0; i < mTrMeshEdges.size(); ++i)
-	{
-		if (mTrMeshEdToTr[i].c != 0)
-		{
-			if (mEdgeFlag[i] == EXTERNAL_EDGE || mEdgeFlag[i] == EXTERNAL_BORDER_EDGE)
-			{
-				mRestrictionFlag[mTrMeshEdges[i].e] = true;
-				mRestrictionFlag[mTrMeshEdges[i].s] = true;
-			}
-		}
-	}
-	std::vector<Vertex> localVertices = mVertices;
-	
-	recalcNoiseDirs();
-
-	relax(relaxIterations, relaxFactor, localVertices);
-	
-
-	/** 
-		Apply noise
-	*/
-	for (uint32_t i = 0; i < localVertices.size(); ++i)
-	{
-
-		if (!mRestrictionFlag[i])
-		{
-
-			float d = noise.sample(localVertices[i].p);
-			localVertices[i].p += (falloffFunction(mVerticesDistances[i], falloff)) * mVerticesNormalsSmoothed[i] * d;
-		}
-	}
-
-
-	/* Recalculate smoothed normals*/
-	mVerticesNormalsSmoothed.assign(mVerticesNormalsSmoothed.size(), PxVec3(0, 0, 0));
-	for (uint32_t i = 0; i < mTesselatedMeshTriangles.size(); ++i)
-	{
-		if (mTesselatedMeshTriangles[i].ea == NOT_VALID_VERTEX)
-		{
-			continue;
-		}
-		TriangleIndexed& tr = mTesselatedMeshTriangles[i];
-		if (tr.userInfo == 0) continue;
-
-		Triangle pTr(localVertices[tr.ea], localVertices[tr.eb], localVertices[tr.ec]);
-		PxVec3 nrm = pTr.getNormal().getNormalized();
-
-		mVerticesNormalsSmoothed[mPositionMappedVrt[tr.ea]] += nrm;
-		mVerticesNormalsSmoothed[mPositionMappedVrt[tr.eb]] += nrm;
-		mVerticesNormalsSmoothed[mPositionMappedVrt[tr.ec]] += nrm;
-	}
-	for (uint32_t i = 0; i < mVerticesNormalsSmoothed.size(); ++i)
-	{
-		mVerticesNormalsSmoothed[i] = mVerticesNormalsSmoothed[mPositionMappedVrt[i]];
-		mVerticesNormalsSmoothed[i].normalize();
-	}
-	for (uint32_t i = 0; i < mTesselatedMeshTriangles.size(); ++i)
-	{
-		if (mTesselatedMeshTriangles[i].ea == NOT_VALID_VERTEX)
-		{
-			continue;
-		}
-		TriangleIndexed& tr = mTesselatedMeshTriangles[i];
-		if (tr.userInfo == 0) continue;
-
-		localVertices[tr.ea].n = mVerticesNormalsSmoothed[mPositionMappedVrt[tr.ea]];
-		localVertices[tr.eb].n = mVerticesNormalsSmoothed[mPositionMappedVrt[tr.eb]];
-		localVertices[tr.ec].n = mVerticesNormalsSmoothed[mPositionMappedVrt[tr.ec]];
-	}
-
-	mTesselatedMeshResultTriangles.clear();
-	for (uint32_t i = 0; i < mTesselatedMeshTriangles.size(); ++i)
-	{
-		if (mTesselatedMeshTriangles[i].ea == NOT_VALID_VERTEX)
-		{
-			continue;
-		}
-		mTesselatedMeshResultTriangles.push_back(Triangle(localVertices[mTesselatedMeshTriangles[i].ea], localVertices[mTesselatedMeshTriangles[i].eb], localVertices[mTesselatedMeshTriangles[i].ec]));
-		mTesselatedMeshResultTriangles.back().userInfo = mTesselatedMeshTriangles[i].userInfo;
-	}
-
-
-}
-
-
-void ChunkPostProcessor::computePositionedMapping()
-{
-	std::map<PxVec3, int32_t, VrtPositionComparator> mPosMap;
-	mPositionMappedVrt.clear();
-	mPositionMappedVrt.resize(mVertices.size());
-
-	for (uint32_t i = 0; i < mVertices.size(); ++i)
-	{
-		auto it = mPosMap.find(mVertices[i].p);
-
-		if (it == mPosMap.end())
-		{
-			mPosMap[mVertices[i].p] = i;
-			mPositionMappedVrt[i] = i;
-		}
-		else
-		{
-			mPositionMappedVrt[i] = it->second;
-		}
-	}
-}
-
-void ChunkPostProcessor::computeFalloffAndNormals()
-{
-	// Map newly created vertices according to positions
-
-	computePositionedMapping();
-
-	mGeometryGraph.resize(mVertices.size());
-	for (uint32_t i = 0; i < mTrMeshEdges.size(); ++i)
-	{
-		if (mTrMeshEdToTr[i].c == 0)
-		{
-			continue;
-		}
-		int32_t v1 = mPositionMappedVrt[mTrMeshEdges[i].s];
-		int32_t v2 = mPositionMappedVrt[mTrMeshEdges[i].e];
-
-		if (std::find(mGeometryGraph[v1].begin(), mGeometryGraph[v1].end(), v2) == mGeometryGraph[v1].end())
-			mGeometryGraph[v1].push_back(v2);
-		if (std::find(mGeometryGraph[v2].begin(), mGeometryGraph[v2].end(), v1) == mGeometryGraph[v2].end())
-			mGeometryGraph[v2].push_back(v1);
-	}
-	mVerticesDistances.clear();
-	mVerticesDistances.resize(mVertices.size(), 10000.0f);
-
-	std::queue<int32_t> que;
-
-	for (uint32_t i = 0; i < mTrMeshEdges.size(); ++i)
-	{
-		if (mTrMeshEdToTr[i].c != 0 && (mEdgeFlag[i] == EXTERNAL_EDGE || mEdgeFlag[i] == EXTERNAL_BORDER_EDGE))
-		{
-			int32_t v1 = mPositionMappedVrt[mTrMeshEdges[i].s];
-			int32_t v2 = mPositionMappedVrt[mTrMeshEdges[i].e];
-			mVerticesDistances[v1] = 0.0f;
-			mVerticesDistances[v2] = 0.0f;
-			que.push(v1);
-			que.push(v2);
-		}
-	}
-	while (!que.empty())
-	{
-		int32_t curr = que.front();
-		que.pop();
-
-		for (uint32_t i = 0; i < mGeometryGraph[curr].size(); ++i)
-		{
-			int32_t to = mGeometryGraph[curr][i];
-			float d = mVerticesDistances[curr] + 0.1f;// (mVertices[to].p - mVertices[curr].p).magnitudeSquared();
-			if (d < mVerticesDistances[to])
-			{
-				mVerticesDistances[to] = d;
-				que.push(to);
-			}
-		}
-	}
-
-	for (uint32_t i = 0; i < mVerticesDistances.size(); ++i)
-	{
-		int32_t from = mPositionMappedVrt[i];
-		mVerticesDistances[i] = mVerticesDistances[from]; 
-	}
-}
-
-bool edgeOverlapTest(PxVec3& as, PxVec3& ae, PxVec3& bs, PxVec3& be)
-{
-	//return false;
-	if (std::max(std::min(as.x, ae.x), std::min(bs.x, be.x)) > std::min(std::max(as.x, ae.x), std::max(bs.x, be.x))) return false;
-	if (std::max(std::min(as.y, ae.y), std::min(bs.y, be.y)) > std::min(std::max(as.y, ae.y), std::max(bs.y, be.y))) return false;
-	if (std::max(std::min(as.z, ae.z), std::min(bs.z, be.z)) > std::min(std::max(as.z, ae.z), std::max(bs.z, be.z))) return false;
-
-	return ((bs - as).cross(ae - as)).magnitudeSquared() < 1e-12f && ((be - as).cross(ae - as)).magnitudeSquared() < 1e-12f;
-}
-
-void ChunkPostProcessor::relax(int32_t iteration, float factor, std::vector<Vertex>& vertices)
-{
-	std::vector<PxVec3> verticesTemp(vertices.size());
-	std::vector<PxVec3> normalsTemp(vertices.size());
-	for (int32_t iter = 0; iter < iteration; ++iter)
-	{
-		for (uint32_t i = 0; i < vertices.size(); ++i)
-		{
-			if (mRestrictionFlag[i])
-			{
-				continue;
-			}
-			PxVec3 cps = vertices[i].p;
-			PxVec3 cns = mVerticesNormalsSmoothed[i];
-			PxVec3 averaged(0, 0, 0);
-			PxVec3 averagedNormal(0, 0, 0);
-
-			for (uint32_t p = 0; p < mGeometryGraph[mPositionMappedVrt[i]].size(); ++p)
-			{
-				int32_t to = mGeometryGraph[mPositionMappedVrt[i]][p];
-				averaged += vertices[to].p;
-				averagedNormal += mVerticesNormalsSmoothed[to];
-
-			}
-			averaged *= (1.0f / mGeometryGraph[mPositionMappedVrt[i]].size());
-			averagedNormal *= (1.0f / mGeometryGraph[mPositionMappedVrt[i]].size());
-			verticesTemp[i] = cps + (averaged - cps) * factor;
-			normalsTemp[i] = cns * (1.0f - factor) + averagedNormal * factor;
-		}
-		for (uint32_t i = 0; i < vertices.size(); ++i)
-		{
-			if (mRestrictionFlag[i])
-			{
-				continue;
-			}
-			vertices[i].p = verticesTemp[i];
-			mVerticesNormalsSmoothed[i] = normalsTemp[i].getNormalized();
-
-		}
-	}
-
-}
-
-void ChunkPostProcessor::prebuildEdgeFlagArray()
-{
-	mRestrictionFlag.clear();
-	mRestrictionFlag.resize(mVertices.size());
-	mEdgeFlag.clear();
-	mEdgeFlag.resize(mTrMeshEdges.size(), NONE);
-
-	std::map<PxVec3, int32_t, VrtPositionComparator> mPosMap;
-	mPositionMappedVrt.clear();
-	mPositionMappedVrt.resize(mVertices.size(), 0);
-
-	for (uint32_t i = 0; i < mVertices.size(); ++i)
-	{
-		auto it = mPosMap.find(mVertices[i].p);
-
-		if (it == mPosMap.end())
-		{
-			mPosMap[mVertices[i].p] = i;
-			mPositionMappedVrt[i] = i;
-		}
-		else
-		{
-			mPositionMappedVrt[i] = it->second;
-		}
-	}
-
-	std::map<Edge, int32_t> mPositionEdgeMap;
-	std::vector<int32_t> mPositionBasedEdges(mTrMeshEdges.size());
-
-
-	for (uint32_t i = 0; i < mTrMeshEdges.size(); ++i)
-	{
-		Edge tmp = Edge(mPositionMappedVrt[mTrMeshEdges[i].s], mPositionMappedVrt[mTrMeshEdges[i].e]);
-		if (tmp.e < tmp.s) std::swap(tmp.e, tmp.s);
-		auto it = mPositionEdgeMap.find(tmp);
-		if (it == mPositionEdgeMap.end())
-		{
-			mPositionEdgeMap[tmp] = i;
-			mPositionBasedEdges[i] = i;
-		}
-		else
-		{
-			mPositionBasedEdges[i] = it->second;
-		}
-	}
-
-	std::vector<EdgeFlag> shortMarkup(mTrMeshEdges.size(), NONE);
-	std::vector<int32_t> lastOwner(mTrMeshEdges.size(), 0);
-
-	std::vector<std::vector<int32_t> > edgeOverlap(mTrMeshEdges.size());
-	for (auto it1 = mPositionEdgeMap.begin(); it1 != mPositionEdgeMap.end(); ++it1)
-	{
-		auto it2 = it1;
-		it2++;
-		for (; it2 != mPositionEdgeMap.end(); ++it2)
-		{
-			Edge& ed1 = mTrMeshEdges[it1->second];
-			Edge& ed2 = mTrMeshEdges[it2->second];
-			
-			if (edgeOverlapTest(mVertices[ed1.s].p, mVertices[ed1.e].p, mVertices[ed2.s].p, mVertices[ed2.e].p))
-			{
-				edgeOverlap[it1->second].push_back(it2->second);
-			}
-		}
-	}
-
-	for (uint32_t i = 0; i < mTesselatedMeshTriangles.size(); ++i)
-	{
-		int32_t ui = mTesselatedMeshTriangles[i].userInfo;
-		int32_t ed = mPositionBasedEdges[findEdge(Edge(mTesselatedMeshTriangles[i].ea, mTesselatedMeshTriangles[i].eb))];
-
-		
-		markEdge(ui, ed, shortMarkup, lastOwner);
-		for (uint32_t ov = 0; ov < edgeOverlap[ed].size(); ++ov)
-		{
-			markEdge(ui, edgeOverlap[ed][ov], shortMarkup, lastOwner);
-		}
-
-		ed = mPositionBasedEdges[findEdge(Edge(mTesselatedMeshTriangles[i].ea, mTesselatedMeshTriangles[i].ec))];
-		markEdge(ui, ed, shortMarkup, lastOwner);
-		for (uint32_t ov = 0; ov < edgeOverlap[ed].size(); ++ov)
-		{
-			markEdge(ui, edgeOverlap[ed][ov], shortMarkup, lastOwner);
-		}
-
-		ed = mPositionBasedEdges[findEdge(Edge(mTesselatedMeshTriangles[i].eb, mTesselatedMeshTriangles[i].ec))];
-		markEdge(ui, ed, shortMarkup, lastOwner);
-		for (uint32_t ov = 0; ov < edgeOverlap[ed].size(); ++ov)
-		{
-			markEdge(ui, edgeOverlap[ed][ov], shortMarkup, lastOwner);
-		}
-
-	}
-
-	for (uint32_t i = 0; i < mTrMeshEdges.size(); ++i)
-	{
-		mEdgeFlag[i] = shortMarkup[mPositionBasedEdges[i]];
-	}
-
-	for (uint32_t i = 0; i < mTesselatedMeshTriangles.size(); ++i)
-	{
-		if (mTesselatedMeshTriangles[i].userInfo != 0) continue;
-
-		int32_t ed = findEdge(Edge(mTesselatedMeshTriangles[i].ea, mTesselatedMeshTriangles[i].eb));
-		mEdgeFlag[ed] = EXTERNAL_EDGE;
-		ed = findEdge(Edge(mTesselatedMeshTriangles[i].ec, mTesselatedMeshTriangles[i].eb));
-		mEdgeFlag[ed] = EXTERNAL_EDGE;
-		ed = findEdge(Edge(mTesselatedMeshTriangles[i].ea, mTesselatedMeshTriangles[i].ec));
-		mEdgeFlag[ed] = EXTERNAL_EDGE;
-	}
-}
-
-
-
-void ChunkPostProcessor::tesselateInternalSurface(float maxLenIn)
-{
-	mTesselatedMeshTriangles = mBaseMeshTriangles;
-	if (mTesselatedMeshTriangles.empty())
-	{
-		return;
-	}
-
-	updateEdgeTriangleInfo();
-	prebuildEdgeFlagArray();
-	mRestrictionFlag.resize(mVertices.size(), 0);
-	for (uint32_t i = 0; i < mTrMeshEdges.size(); ++i)
-	{
-		if (mEdgeFlag[i] == EXTERNAL_EDGE || mEdgeFlag[i] == EXTERNAL_BORDER_EDGE || mEdgeFlag[i] == INTERNAL_BORDER_EDGE)
-		{
-			mRestrictionFlag[mTrMeshEdges[i].s] = 1;
-			mRestrictionFlag[mTrMeshEdges[i].e] = 1;
-		}
-	}
-
-	
-	float maxLen = std::max(0.1f, maxLenIn);
-	while (maxLen > maxLenIn)
-	{
-		float mlSq = maxLen * maxLen;
-		float minD = maxLen * 0.5f;
-		minD = minD * minD;
-		
-		for (int32_t iter = 0; iter < 15; ++iter)
-		{
-			updateVertEdgeInfo();
-			uint32_t oldSize = (uint32_t)mTrMeshEdges.size();
-			for (uint32_t i = 0; i < oldSize; ++i)
-			{
-				if (mEdgeFlag[i] == EXTERNAL_EDGE || mEdgeFlag[i] == INTERNAL_BORDER_EDGE)
-				{
-					continue;
-				}
-				if ((mVertices[mTrMeshEdges[i].s].p - mVertices[mTrMeshEdges[i].e].p).magnitudeSquared() < minD)
-				{
-					collapseEdge(i);
-				}
-			}
-
-			oldSize = (uint32_t)mTrMeshEdges.size();
-			updateEdgeTriangleInfo();
-			for (uint32_t i = 0; i < oldSize; ++i)
-			{
-				if (mEdgeFlag[i] == EXTERNAL_EDGE)
-				{
-					continue;
-				}
-				if ((mVertices[mTrMeshEdges[i].s].p - mVertices[mTrMeshEdges[i].e].p).magnitudeSquared() > mlSq)
-				{
-					divideEdge(i);
-				}
-			}
-		}
-		maxLen *= 0.3;
-		maxLen = std::max(maxLen, maxLenIn);
-	}
-	computeFalloffAndNormals();
-	prebuildTesselatedTriangles();
-	isTesselated = true;
-}
-
-} // namespace Blast
-} // namespace Nv
\ No newline at end of file
diff --git a/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringTriangulator.h b/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringTriangulator.h
deleted file mode 100644
index 83942f4..0000000
--- a/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringTriangulator.h
+++ /dev/null
@@ -1,261 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTAUTHORINGTRIANGULATOR_H
-#define NVBLASTEXTAUTHORINGTRIANGULATOR_H
-
-
-#include <vector>
-#include <map>
-#include "NvBlastExtAuthoringTypes.h"
-#include "NvBlastExtAuthoringMesh.h"
-#include "NvBlastExtAuthoringInternalCommon.h"
-
-namespace Nv
-{
-namespace Blast
-{
-class SimplexNoise;
-
-/**
-	Vertex comparator for vertex welding.
-*/
-struct VrtComp
-{
-	bool operator()(const Vertex& a, const Vertex& b) const;
-};
-
-/**
-	Vertex comparator for vertex welding (not accounts normal and uv parameters of vertice).
-*/
-struct VrtPositionComparator
-{
-	bool operator()(const physx::PxVec3& a, const physx::PxVec3& b) const;
-};
-
-/**
-	Structure used on tesselation stage. Maps edge to two neighboor triangles
-*/
-struct EdgeToTriangles
-{
-	int32_t tr[2];
-	int32_t c;
-	EdgeToTriangles()
-	{
-		c = 0;
-	}
-	/**
-		Add triangle to edge. Should not be called more than twice for one edge!!!!.
-	*/
-	void	add(int32_t t)
-	{
-		tr[c] = t;
-		++c;
-	}
-	/**
-		Replaces mapping from one triangle to another.
-	*/
-	void	replace(int32_t from, int32_t to)
-	{
-		if (tr[0] == from)
-		{
-			tr[0] = to;
-		}
-		else
-		{
-			if (c == 2 && tr[1] == from)
-			{
-				tr[1] = to;
-			}
-		}
-	}
-	/**
-		Get triangle which is mapped by this edge and which index is different than provided.
-	*/
-	int32_t	getNot(int32_t id)
-	{
-		if (tr[0] != id)
-		{
-			return tr[0];
-		}
-		if (c == 2 && tr[1] != id)
-		{
-			return tr[1];
-		}
-		return -1;
-	}
-
-};
-
-
-/**
-	Tool for doing all post processing steps of authoring.
-*/
-class ChunkPostProcessor
-{
-public:
-	/**
-		Edge flags
-	*/
-	enum EdgeFlag{ INTERNAL_EDGE, EXTERNAL_BORDER_EDGE, INTERNAL_BORDER_EDGE, EXTERNAL_EDGE, NONE };
-
-	/**
-		Triangulates provided mesh and saves result internally. Uses Ear-clipping algorithm.
-		\param[in] mesh Mesh for triangulation
-	*/
-	void							triangulate(Mesh* mesh);
-
-	/**
-		\return Return array of triangles of base mesh.
-	*/
-	std::vector<Triangle>&			getBaseMesh()
-	{
-		return mBaseMeshResultTriangles;
-	}
-
-	/**
-		\return Return array of TriangleIndexed of base mesh. Each TriangleIndexed contains index of corresponding vertex in internal vertex buffer.
-	*/
-	std::vector<TriangleIndexed>&	getBaseMeshIndexed()
-	{
-		return mBaseMeshTriangles;
-	}
-
-
-	/**
-		\return Return mapping from vertices of input Mesh to internal vertices buffer. Used for island detection.
-	*/
-	std::vector<uint32_t>&			getBaseMapping()
-	{
-		return mBaseMapping;
-	};
-	/**
-		\return Return mapping from vertices of input Mesh to internal vertices buffer, only positions are accounted. Used for island detection. 
-	*/
-	std::vector<int32_t>&			getPositionedMapping()
-	{
-		return mPositionMappedVrt;
-	};
-
-	/**
-		\return Return internal vertex buffer size. Vertices internally are welded with some threshold.
-	*/
-	uint32_t						getWeldedVerticesCount()
-	{
-		return static_cast<uint32_t>(mVertices.size());
-	}	
-	/**
-		Tesselate internal surface. 
-		\param[in] maxLen - maximal length of edge on internal surface. 
-	*/
-	void							tesselateInternalSurface(float maxLen);
-
-	/**
-		Apply noise to internal surface. Must be called only after tesselation!!! 
-		\param[in] noise - noise generator
-		\param[in] falloff - damping of noise around of external surface
-		\param[in] relaxIterations - number of smoothing iterations before applying noise
-		\param[in] relaxFactor - amount of smooting before applying noise.
-	*/
-	void							applyNoise(SimplexNoise& noise, float falloff, int32_t relaxIterations, float relaxFactor);
-
-	/**
-		\return Return array of noised mesh triangles.
-	*/
-	std::vector<Triangle>&			getNoisyMesh()
-	{
-		return mTesselatedMeshResultTriangles;
-	};
-
-	/**
-		Removes all information about mesh triangulation, tesselation, etc.
-	*/
-	void							reset();
-
-private:
-
-	
-
-	void							collapseEdge(int32_t id);
-	void							divideEdge(int32_t id);
-	void							updateVertEdgeInfo();
-	void							updateEdgeTriangleInfo();
-
-	int32_t							addVerticeIfNotExist(Vertex& p);
-	void							addEdgeIfValid(EdgeWithParent& ed);
-	
-	/* Data used before triangulation to build polygon loops*/
-
-	std::vector<Vertex>									mVertices;
-	std::vector<EdgeWithParent>							mBaseMeshEdges;
-	std::map<Vertex, int32_t, VrtComp>					mVertMap;
-	std::map<EdgeWithParent, int32_t, EdgeComparator>	mEdgeMap;
-	std::vector<uint32_t>								mBaseMapping;
-	
-
-
-	/**
-		Unite all almost similar vertices, update edges according to this changes
-	*/
-	void							prepare(Mesh* mesh);
-
-	/* ------------------------------------------------------------ */
-
-	/* Triangulation and tesselation stage data */
-	bool												isTesselated;
-
-	std::map<Edge,	int32_t>							mTrMeshEdgeMap;
-	std::vector<Edge>									mTrMeshEdges;
-	std::vector<EdgeToTriangles>						mTrMeshEdToTr;
-	std::vector<int32_t>								mVertexValence;
-	std::vector<std::vector<int32_t> >					mVertexToTriangleMap;
-
-	std::vector<bool>									mRestrictionFlag;
-	std::vector<EdgeFlag>								mEdgeFlag;
-
-	std::vector<float>									mVerticesDistances;
-	std::vector<physx::PxVec3>							mVerticesNormalsSmoothed;
-	std::vector<int32_t>								mPositionMappedVrt;
-	std::vector<std::vector<int32_t> >					mGeometryGraph;
-
-
-	int32_t							addEdgeTr(const Edge& ed);
-	int32_t							findEdge(const Edge& e);
-
-	void							prebuildEdgeFlagArray();
-	void							computePositionedMapping();
-	
-	void							computeFalloffAndNormals();
-
-
-		
-	void							triangulatePolygonWithEarClipping(std::vector<uint32_t>& inputPolygon, Vertex* vert, ProjectionDirections dir);
-	void							buildPolygonAndTriangulate(std::vector<Edge>& edges, Vertex* vertices, int32_t userData);
-	
-	void							relax(int32_t iterations, float factor, std::vector<Vertex>& vertices);
-	void							recalcNoiseDirs();
-
-	std::vector<TriangleIndexed>						mBaseMeshTriangles;
-	std::vector<TriangleIndexed>						mTesselatedMeshTriangles;
-
-	/**
-		Final triangles
-	*/
-	void prebuildTesselatedTriangles();
-
-	std::vector<Triangle>								mBaseMeshResultTriangles;
-	std::vector<Triangle>								mTesselatedMeshResultTriangles;
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif	// ifndef NVBLASTEXTAUTHORINGTRIANGULATOR_H
diff --git a/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringVSA.h b/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringVSA.h
deleted file mode 100644
index fd0c9c9..0000000
--- a/NvBlast/sdk/extensions/authoring/source/NvBlastExtAuthoringVSA.h
+++ /dev/null
@@ -1,312 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTAUTHORINGVSA_H
-#define NVBLASTEXTAUTHORINGVSA_H
-
-namespace Nv
-{
-namespace Blast
-{
-
-/*
-	This code copied from APEX GSA
-*/
-
-namespace VSA
-{
-typedef float real;
-
-struct VS3D_Halfspace_Set
-{
-	virtual	real	farthest_halfspace(real plane[4], const real point[4]) = 0;
-};
-
-
-// Simple types and operations for internal calculations
-struct Vec3 { real x, y, z; };	// 3-vector 
-inline Vec3	vec3(real x, real y, real z) { Vec3 r; r.x = x; r.y = y; r.z = z; return r; }	// vector builder
-inline Vec3	operator +	(const Vec3& a, const Vec3& b) { return vec3(a.x + b.x, a.y + b.y, a.z + b.z); }			// vector addition
-inline Vec3	operator *	(real s, const Vec3& v) { return vec3(s*v.x, s*v.y, s*v.z); }				// scalar multiplication
-inline real	operator |	(const Vec3& a, const Vec3& b) { return a.x*b.x + a.y*b.y + a.z*b.z; }				// dot product
-inline Vec3 operator ^	(const Vec3& a, const Vec3& b) { return vec3(a.y*b.z - b.y*a.z, a.z*b.x - b.z*a.x, a.x*b.y - b.x*a.y); }	// cross product
-
-struct Vec4 { Vec3 v; real w; };	// 4-vector split into 3-vector and scalar parts
-inline Vec4	vec4(const Vec3& v, real w) { Vec4 r; r.v = v; r.w = w; return r; }	// vector builder
-inline real	operator | (const Vec4& a, const Vec4& b) { return (a.v | b.v) + a.w*b.w; }			// dot product
-
-// More accurate perpendicular
-inline Vec3	perp(const Vec3& a, const Vec3& b)
-{
-	Vec3 c = a^b;	// Cross-product gives perpendicular
-#if VS3D_HIGH_ACCURACY || REAL_DOUBLE
-	const real c2 = c | c;
-	if (c2 != 0) c = c + (1 / c2)*((a | c)*(c^b) + (b | c)*(a^c));	// Improvement to (a b)^T(c) = (0)
-#endif
-	return c;
-}
-
-// Square
-inline real	sq(real x) { return x*x; }
-
-// Returns index of the extremal element in a three-element set {e0, e1, e2} based upon comparisons c_ij. The extremal index m is such that c_mn is true, or e_m == e_n, for all n.
-inline int	ext_index(int c_10, int c_21, int c_20) { return c_10 << c_21 | (c_21&c_20) << 1; }
-
-// Returns index (0, 1, or 2) of minimum argument
-inline int	index_of_min(real x0, real x1, real x2) { return ext_index((int)(x1 < x0), (int)(x2 < x1), (int)(x2 < x0)); }
-
-// Compare fractions with positive deominators.  Returns a_num*sqrt(a_rden2) > b_num*sqrt(b_rden2)
-inline bool frac_gt(real a_num, real a_rden2, real b_num, real b_rden2)
-{
-	const bool a_num_neg = a_num < 0;
-	const bool b_num_neg = b_num < 0;
-	return a_num_neg != b_num_neg ? b_num_neg : ((a_num*a_num*a_rden2 > b_num*b_num*b_rden2) != a_num_neg);
-}
-
-// Returns index (0, 1, or 2) of maximum fraction with positive deominators
-inline int	index_of_max_frac(real x0_num, real x0_rden2, real x1_num, real x1_rden2, real x2_num, real x2_rden2)
-{
-	return ext_index((int)frac_gt(x1_num, x1_rden2, x0_num, x0_rden2), (int)frac_gt(x2_num, x2_rden2, x1_num, x1_rden2), (int)frac_gt(x2_num, x2_rden2, x0_num, x0_rden2));
-}
-
-// Compare values given their signs and squares.  Returns a > b.  a2 and b2 may have any constant offset applied to them.
-inline bool sgn_sq_gt(real sgn_a, real a2, real sgn_b, real b2) { return sgn_a*sgn_b < 0 ? (sgn_b < 0) : ((a2 > b2) != (sgn_a < 0)); }
-
-// Returns index (0, 1, or 2) of maximum value given their signs and squares.  sq_x0, sq_x1, and sq_x2 may have any constant offset applied to them.
-inline int	index_of_max_sgn_sq(real sgn_x0, real sq_x0, real sgn_x1, real sq_x1, real sgn_x2, real sq_x2)
-{
-	return ext_index((int)sgn_sq_gt(sgn_x1, sq_x1, sgn_x0, sq_x0), (int)sgn_sq_gt(sgn_x2, sq_x2, sgn_x1, sq_x1), (int)sgn_sq_gt(sgn_x2, sq_x2, sgn_x0, sq_x0));
-}
-
-// Project 2D (homogeneous) vector onto 2D half-space boundary
-inline void project2D(Vec3& r, const Vec3& plane, real delta, real recip_n2, real eps2)
-{
-	r = r + (-delta*recip_n2)*vec3(plane.x, plane.y, 0);
-	r = r + (-(r | plane)*recip_n2)*vec3(plane.x, plane.y, 0);	// Second projection for increased accuracy
-	if ((r | r) > eps2) return;
-	r = (-plane.z*recip_n2)*vec3(plane.x, plane.y, 0);
-	r.z = 1;
-}
-
-
-// Update function for vs3d_test
-static bool vs3d_update(Vec4& p, Vec4 S[4], int& plane_count, const Vec4& q, real eps2)
-{
-	// h plane is the last plane
-	const Vec4& h = S[plane_count - 1];
-
-	// Handle plane_count == 1 specially (optimization; this could be commented out)
-	if (plane_count == 1)
-	{
-		// Solution is objective projected onto h plane
-		p = q;
-		p.v = p.v + -(p | h)*h.v;
-		if ((p | p) <= eps2) p = vec4(-h.w*h.v, 1);	// If p == 0 then q is a direction vector, any point in h is a support point
-		return true;
-	}
-
-	// Create basis in the h plane
-	const int min_i = index_of_min(h.v.x*h.v.x, h.v.y*h.v.y, h.v.z*h.v.z);
-	const Vec3 y = h.v^vec3((real)(min_i == 0), (real)(min_i == 1), (real)(min_i == 2));
-	const Vec3 x = y^h.v;
-
-	// Use reduced vector r instead of p
-	Vec3 r = { x | q.v, y | q.v, q.w*(y | y) };	// (x|x) = (y|y) = square of plane basis scale
-
-	// If r == 0 (within epsilon), then it is a direction vector, and we have a bounded solution
-	if ((r | r) <= eps2) r.z = 1;
-
-	// Create plane equations in the h plane.  These will not be normalized in general.
-	int N = 0;			// Plane count in h subspace
-	Vec3 R[3];			// Planes in h subspace
-	real recip_n2[3];	// Plane normal vector reciprocal lengths squared
-	real delta[3];		// Signed distance of objective to the planes
-	int index[3];		// Keep track of original plane indices
-	for (int i = 0; i < plane_count - 1; ++i)
-	{
-		const Vec3& vi = S[i].v;
-		const real cos_theta = h.v | vi;
-		R[N] = vec3(x | vi, y | vi, S[i].w - h.w*cos_theta);
-		index[N] = i;
-		const real n2 = R[N].x*R[N].x + R[N].y*R[N].y;
-		if (n2 >= eps2)
-		{
-			const real lin_norm = (real)1.5 - (real)0.5*n2;	// 1st-order approximation to 1/sqrt(n2) expanded about n2 = 1
-			R[N] = lin_norm*R[N];	// We don't need normalized plane equations, but rescaling (even with an approximate normalization) gives better numerical behavior
-			recip_n2[N] = 1 / (R[N].x*R[N].x + R[N].y*R[N].y);
-			delta[N] = r | R[N];
-			++N;	// Keep this plane
-		}
-		else if (cos_theta < 0) return false;	// Parallel cases are redundant and rejected, anti-parallel cases are 1D voids
-	}
-
-	// Now work with the N-sized R array of half-spaces in the h plane
-	switch (N)
-	{
-	case 1: one_plane :
-		if (delta[0] < 0) N = 0;	// S[0] is redundant, eliminate it
-		else project2D(r, R[0], delta[0], recip_n2[0], eps2);
-		break;
-	case 2: two_planes :
-		if (delta[0] < 0 && delta[1] < 0) N = 0;	// S[0] and S[1] are redundant, eliminate them
-		else
-		{
-			const int max_d_index = (int)frac_gt(delta[1], recip_n2[1], delta[0], recip_n2[0]);
-			project2D(r, R[max_d_index], delta[max_d_index], recip_n2[max_d_index], eps2);
-			const int min_d_index = max_d_index ^ 1;
-			const real new_delta_min = r | R[min_d_index];
-			if (new_delta_min < 0)
-			{
-				index[0] = index[max_d_index];
-				N = 1;	// S[min_d_index] is redundant, eliminate it
-			}
-			else
-			{
-				// Set r to the intersection of R[0] and R[1] and keep both
-				r = perp(R[0], R[1]);
-				if (r.z*r.z*recip_n2[0] * recip_n2[1] < eps2)
-				{
-					if (R[0].x*R[1].x + R[0].y*R[1].y < 0) return false;	// 2D void found
-					goto one_plane;
-				}
-				r = (1 / r.z)*r;	// We could just as well multiply r by sgn(r.z); we just need to ensure r.z > 0
-			}
-		}
-		break;
-	case 3:
-		if (delta[0] < 0 && delta[1] < 0 && delta[2] < 0) N = 0;	// S[0], S[1], and S[2] are redundant, eliminate them
-		else
-		{
-			const Vec3 row_x = { R[0].x, R[1].x, R[2].x };
-			const Vec3 row_y = { R[0].y, R[1].y, R[2].y };
-			const Vec3 row_w = { R[0].z, R[1].z, R[2].z };
-			const Vec3 cof_w = perp(row_x, row_y);
-			const bool detR_pos = (row_w | cof_w) > 0;
-			const int nrw_sgn0 = cof_w.x*cof_w.x*recip_n2[1] * recip_n2[2] < eps2 ? 0 : (((int)((cof_w.x > 0) == detR_pos) << 1) - 1);
-			const int nrw_sgn1 = cof_w.y*cof_w.y*recip_n2[2] * recip_n2[0] < eps2 ? 0 : (((int)((cof_w.y > 0) == detR_pos) << 1) - 1);
-			const int nrw_sgn2 = cof_w.z*cof_w.z*recip_n2[0] * recip_n2[1] < eps2 ? 0 : (((int)((cof_w.z > 0) == detR_pos) << 1) - 1);
-
-			if ((nrw_sgn0 | nrw_sgn1 | nrw_sgn2) >= 0) return false;	// 3D void found
-
-			const int positive_width_count = ((nrw_sgn0 >> 1) & 1) + ((nrw_sgn1 >> 1) & 1) + ((nrw_sgn2 >> 1) & 1);
-			if (positive_width_count == 1)
-			{
-				// A single positive width results from a redundant plane.  Eliminate it and peform N = 2 calculation.
-				const int pos_width_index = ((nrw_sgn1 >> 1) & 1) | (nrw_sgn2 & 2);	// Calculates which index corresponds to the positive-width side
-				R[pos_width_index] = R[2];
-				recip_n2[pos_width_index] = recip_n2[2];
-				delta[pos_width_index] = delta[2];
-				index[pos_width_index] = index[2];
-				N = 2;
-				goto two_planes;
-			}
-
-			// Find the max dot product of r and R[i]/|R_normal[i]|.  For numerical accuracy when the angle between r and the i^{th} plane normal is small, we take some care below:
-			const int max_d_index = r.z != 0
-				? index_of_max_frac(delta[0], recip_n2[0], delta[1], recip_n2[1], delta[2], recip_n2[2])	// displacement term resolves small-angle ambiguity, just use dot product
-				: index_of_max_sgn_sq(delta[0], -sq(r.x*R[0].y - r.y*R[0].x)*recip_n2[0], delta[1], -sq(r.x*R[1].y - r.y*R[1].x)*recip_n2[1], delta[2], -sq(r.x*R[2].y - r.y*R[2].x)*recip_n2[2]);	// No displacement term.  Use wedge product to find the sine of the angle.
-
-			// Project r onto max-d plane
-			project2D(r, R[max_d_index], delta[max_d_index], recip_n2[max_d_index], eps2);
-			N = 1;	// Unless we use a vertex in the loop below
-			const int index_max = index[max_d_index];
-
-			// The number of finite widths should be >= 2.  If not, it should be 0, but in any case it implies three parallel lines in the plane, which we should not have here.
-			// If we do have three parallel lines (# of finite widths < 2), we've picked the line corresponding to the half-plane farthest from r, which is correct.
-			const int finite_width_count = (nrw_sgn0 & 1) + (nrw_sgn1 & 1) + (nrw_sgn2 & 1);
-			if (finite_width_count >= 2)
-			{
-				const int i_remaining[2] = { (1 << max_d_index) & 3, (3 >> max_d_index) ^ 1 };	// = {(max_d_index+1)%3, (max_d_index+2)%3}
-				const int i_select = (int)frac_gt(delta[i_remaining[1]], recip_n2[i_remaining[1]], delta[i_remaining[0]], recip_n2[i_remaining[0]]);	// Select the greater of the remaining dot products
-				for (int i = 0; i < 2; ++i)
-				{
-					const int j = i_remaining[i_select^i];	// i = 0 => the next-greatest, i = 1 => the least
-					if ((r | R[j]) >= 0)
-					{
-						r = perp(R[max_d_index], R[j]);
-						r = (1 / r.z)*r;	// We could just as well multiply r by sgn(r.z); we just need to ensure r.z > 0
-						index[1] = index[j];
-						N = 2;
-						break;
-					}
-				}
-			}
-
-			index[0] = index_max;
-		}
-		break;
-	}
-
-	// Transform r back to 3D space
-	p = vec4(r.x*x + r.y*y + (-r.z*h.w)*h.v, r.z);
-
-	// Pack S array with kept planes
-	if (N < 2 || index[1] != 0) { for (int i = 0; i < N; ++i) S[i] = S[index[i]]; }	// Safe to copy columns in order
-	else { const Vec4 temp = S[0]; S[0] = S[index[0]]; S[1] = temp; }	// Otherwise use temp storage to avoid overwrite
-	S[N] = h;
-	plane_count = N + 1;
-
-	return true;
-}
-
-
-// Performs the VS algorithm for D = 3
-inline int vs3d_test(VS3D_Halfspace_Set& halfspace_set, real* q = nullptr)
-{
-	// Objective = q if it is not NULL, otherwise it is the origin represented in homogeneous coordinates
-	const Vec4 objective = q ? (q[3] != 0 ? vec4((1 / q[3])*vec3(q[0], q[1], q[2]), 1) : *(Vec4*)q) : vec4(vec3(0, 0, 0), 1);
-
-	// Tolerance for 3D void simplex algorithm
-	const real eps_f = (real)1 / (sizeof(real) == 4 ? (1L << 23) : (1LL << 52));	// Floating-point epsilon
-#if VS3D_HIGH_ACCURACY || REAL_DOUBLE
-	const real eps = 8 * eps_f;
-#else
-	const real eps = 80 * eps_f;
-#endif
-	const real eps2 = eps*eps;	// Using epsilon squared
-
-	// Maximum allowed iterations of main loop.  If exceeded, error code is returned
-	const int max_iteration_count = 50;
-
-	// State
-	Vec4 S[4];				// Up to 4 planes
-	int plane_count = 0;	// Number of valid planes
-	Vec4 p = objective;		// Test point, initialized to objective
-
-	// Default result, changed to valid result if found in loop below
-	int result = -1;
-
-	// Iterate until a stopping condition is met or the maximum number of iterations is reached
-	for (int i = 0; result < 0 && i < max_iteration_count; ++i)
-	{
-		Vec4& plane = S[plane_count++];
-		real delta = halfspace_set.farthest_halfspace(&plane.v.x, &p.v.x);
-#if VS3D_UNNORMALIZED_PLANE_HANDLING != 0
-		const real recip_norm = vs3d_recip_sqrt(plane.v | plane.v);
-		plane = vec4(recip_norm*plane.v, recip_norm*plane.w);
-		delta *= recip_norm;
-#endif
-		if (delta <= 0 || delta*delta <= eps2*(p | p)) result = 1;	// Intersection found
-		else if (!vs3d_update(p, S, plane_count, objective, eps2)) result = 0;	// Void simplex found
-	}
-
-	// If q is given, fill it with the solution (normalize p.w if it is not zero)
-	if (q) *(Vec4*)q = (p.w != 0) ? vec4((1 / p.w)*p.v, 1) : p;
-
-	return result;
-}
-
-} // namespace VSA
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTEXTAUTHORINGVSA_H
diff --git a/NvBlast/sdk/extensions/authoring/source/NvBlastExtTriangleProcessor.cpp b/NvBlast/sdk/extensions/authoring/source/NvBlastExtTriangleProcessor.cpp
deleted file mode 100644
index 3c3e540..0000000
--- a/NvBlast/sdk/extensions/authoring/source/NvBlastExtTriangleProcessor.cpp
+++ /dev/null
@@ -1,355 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastExtTriangleProcessor.h"
-#include "NvBlastExtAuthoringInternalCommon.h"
-#define COLLIN_EPS 1e-4f
-#define V_COMP_EPS 1e-5f
-
-using namespace physx;
-
-namespace Nv
-{
-namespace Blast
-{
-/**
-	Segments bounding box interseciton test
-*/
-bool boundingRectangleIntersection(const PxVec2& s1, const PxVec2& e1, const PxVec2& s2, const PxVec2& e2)
-{
-	// sl1/sl2 is always left bottom end of rectangle
-	// se1/el2 is always right top end of rectangle
-
-	PxF32 sl1, sl2, el1, el2;
-	if (s1.x < e1.x)
-	{
-		sl1 = s1.x;
-		el1 = e1.x;
-	}
-	else
-	{
-		el1 = s1.x;
-		sl1 = e1.x;
-	}
-
-	if (s2.x < e2.x)
-	{
-		sl2 = s2.x;
-		el2 = e2.x;
-	}
-	else
-	{
-		el2 = s2.x;
-		sl2 = e2.x;
-	}
-	if (PxMax(sl1, sl2) > PxMin(el1, el2))
-		return false;
-
-	if (s1.y < e1.y)
-	{
-		sl1 = s1.y;
-		el1 = e1.y;
-	}
-	else
-	{
-		el1 = s1.y;
-		sl1 = e1.y;
-	}
-
-	if (s2.y < e2.y)
-	{
-		sl2 = s2.y;
-		el2 = e2.y;
-	}
-	else
-	{
-		el2 = s2.y;
-		sl2 = e2.y;
-	}
-	if (PxMax(sl1, sl2) > PxMin(el1, el2))
-		return false;
-
-	return true;
-}
-
-inline PxF32 getRotation(PxVec2 a, PxVec2 b)
-{
-	return a.x * b.y - a.y * b.x;
-}
-
-inline PxF32 getParameter(const PxVec2& a, const PxVec2& b, const PxVec2& point)
-{
-	return (point - a).magnitude() / (b - a).magnitude();
-}
-inline PxVec3 lerp3D(const PxVec3& a, const PxVec3& b, const PxF32 t)
-{
-	return (b - a) * t + a;
-}
-
-
-
-struct Line2D
-{
-	PxVec2 normal;
-	PxF32 c;
-	Line2D(PxVec2 vec, PxVec2 point)
-	{
-		normal.x = vec.y;
-		normal.y = -vec.x;
-		c = -normal.dot(point);
-	}
-};
-
-
-uint32_t TriangleProcessor::getSegmentIntersection(const PxVec2& s1, const PxVec2& e1, const PxVec2& s2, const PxVec2& e2, PxF32& t1)
-{
-	if (!boundingRectangleIntersection(s1, e1, s2, e2))
-		return 0;
-
-	PxVec2 vec1 = e1 - s1;
-	PxVec2 vec2 = e2 - s2;
-	PxF32 det1 = getRotation(vec1, vec2);
-	if (PxAbs(det1) < COLLIN_EPS)
-	{
-		return 0;
-	}
-	Line2D lineA(vec1, s1);
-	Line2D lineB(vec2, s2);
-	PxVec2 fInt;
-
-	PxF32 detX = lineA.normal.y * lineB.c - lineA.c * lineB.normal.y;
-	PxF32 detY = lineA.c * lineB.normal.x - lineB.c * lineA.normal.x;
-	PxF32 x = detX / det1;
-	PxF32 y = detY / det1;
-
-	if (x + V_COMP_EPS >= PxMax(PxMin(s1.x, e1.x), PxMin(s2.x, e2.x)) &&
-		x - V_COMP_EPS <= PxMin(PxMax(s1.x, e1.x), PxMax(s2.x, e2.x)) &&
-		y + V_COMP_EPS >= PxMax(PxMin(s1.y, e1.y), PxMin(s2.y, e2.y)) &&
-		y - V_COMP_EPS <= PxMin(PxMax(s1.y, e1.y), PxMax(s2.y, e2.y)))
-	{
-		fInt.x = x;
-		fInt.y = y;
-		t1 = getParameter(s1, e1, fInt);
-		return 1;
-	}
-
-	return 0;
-}
-
-struct cwComparer
-{
-	PxVec3 basePoint;
-	PxVec3 normal;
-	cwComparer(PxVec3 basePointIn, PxVec3 norm)
-	{
-		basePoint = basePointIn;
-		normal = norm;
-	};
-	bool operator()(const PxVec3& a, const PxVec3& b)
-	{
-		PxVec3 norm = (a - basePoint).cross(b - basePoint);
-		return normal.dot(norm) > 0;		
-	}
-};
-
-bool vec3Comparer(const PxVec3& a, const PxVec3& b)
-{
-		if (a.x + V_COMP_EPS < b.x) return true;
-		if (a.x - V_COMP_EPS > b.x) return false;
-		if (a.y + V_COMP_EPS < b.y) return true;
-		if (a.y - V_COMP_EPS > b.y) return false;
-		if (a.z + V_COMP_EPS < b.z) return true;
-		return false;
-}
-
-void TriangleProcessor::sortToCCW(std::vector<PxVec3>& points, PxVec3& normal)
-{
-	std::sort(points.begin(), points.end(), vec3Comparer);
-	int lastUnique = 0;
-	for (uint32_t i = 1; i < points.size(); ++i)
-	{
-		PxVec3 df = points[i] - points[lastUnique];
-		if (df.x > V_COMP_EPS || df.y > V_COMP_EPS || df.z > V_COMP_EPS)
-		{
-			points[++lastUnique] = points[i];
-		}
-	}
-	points.resize(lastUnique + 1);
-	if (points.size() > 2)
-	{
-		cwComparer compr(points[0], normal);
-		std::sort(points.begin() + 1, points.end(), compr);
-	}
-}
-
-
-
-void TriangleProcessor::buildConvexHull(std::vector<PxVec3>& points, std::vector<PxVec3>& convexHull,const PxVec3& normal)
-{
-
-	std::sort(points.begin(), points.end(), vec3Comparer);
-	int lastUnique = 0;
-	for (uint32_t i = 1; i < points.size(); ++i)
-	{
-		PxVec3 df = points[i] - points[lastUnique];
-		if (df.x > V_COMP_EPS || df.y > V_COMP_EPS || df.z > V_COMP_EPS)
-		{
-			points[++lastUnique] = points[i];
-		}
-	}
-	points.resize(lastUnique + 1);
-	if (points.size() > 2)
-	{
-		cwComparer compr(points[0], normal);
-		std::sort(points.begin() + 1, points.end(), compr);
-	}
-	if (points.size() < 3)
-		return;
-	convexHull.push_back(points[0]);
-	convexHull.push_back(points[1]);
-	ProjectionDirections projectionDirection = getProjectionDirection(normal);
-	for (uint32_t i = 2; i < points.size(); ++i)
-	{
-		PxVec2 pnt = getProjectedPointWithWinding(points[i], projectionDirection);
-		PxVec2 vec = pnt - getProjectedPointWithWinding(convexHull.back(), projectionDirection);
-		if (vec.x < V_COMP_EPS && vec.y < V_COMP_EPS)
-		{
-			continue;
-		}
-		if (getRotation(vec, getProjectedPointWithWinding(convexHull.back(), projectionDirection) - getProjectedPointWithWinding(convexHull[convexHull.size() - 2], projectionDirection)) < 0)
-		{
-			convexHull.push_back(points[i]);
-		}
-		else
-		{
-			while (convexHull.size() > 1 && getRotation(vec, getProjectedPointWithWinding(convexHull.back(), projectionDirection) - getProjectedPointWithWinding(convexHull[convexHull.size() - 2], projectionDirection)) > 0)
-			{
-				convexHull.pop_back();
-				vec = pnt - getProjectedPointWithWinding(convexHull.back(), projectionDirection);
-			}
-			convexHull.push_back(points[i]);
-		}
-	}
-}
-
-
-uint32_t TriangleProcessor::getTriangleIntersection(TrPrcTriangle& a, TrPrcTriangle2d& aProjected, TrPrcTriangle &b, PxVec3& centroid, std::vector<PxVec3>& intersectionBuffer, PxVec3 normal)
-{
-
-	b.points[0] -= centroid;
-	b.points[1] -= centroid;
-	b.points[2] -= centroid;
-
-	ProjectionDirections prjDir = getProjectionDirection(normal);
-
-	TrPrcTriangle2d bProjected;
-	bProjected.points[0] = getProjectedPointWithWinding(b.points[0], prjDir);
-	bProjected.points[1] = getProjectedPointWithWinding(b.points[1], prjDir);
-	bProjected.points[2] = getProjectedPointWithWinding(b.points[2], prjDir);
-
-
-	if (!triangleBoundingBoxIntersection(aProjected, bProjected)) return 0;
-
-	//* Check triangle A against points of B *//
-	for (int i = 0; i < 3; ++i)
-	{
-		if (isPointInside(bProjected.points[i], aProjected))
-		{
-			intersectionBuffer.push_back(b.points[i]);
-		}
-	}
-	//* Check triangle B against points of A *//
-	for (int i = 0; i < 3; ++i)
-	{
-		if (isPointInside(aProjected.points[i], bProjected))
-		{
-			intersectionBuffer.push_back(a.points[i]);
-		}
-	}
-
-	//* Check edges intersection *//
-	float param = 0;
-	for (int i = 0; i < 3; ++i)
-	{
-		for (int j = 0; j < 3; ++j)
-		{
-			if (getSegmentIntersection(aProjected.points[i], aProjected.points[(i + 1) % 3], bProjected.points[j], bProjected.points[(j + 1) % 3], param))
-			{
-				intersectionBuffer.push_back(lerp3D(a.points[i], a.points[(i + 1) % 3], param));
-			}
-		}
-	}
-
-	if (intersectionBuffer.size() == 0)
-		return 0;
-
-	// Intersection between two triangles is convex, but points should be reordered to construct right polygon //
-	std::vector<PxVec3> intrs;
-	buildConvexHull(intersectionBuffer, intrs, normal);
-	intersectionBuffer = intrs;
-
-	// Return all points back from origin //
-	for (uint32_t i = 0; i < intersectionBuffer.size(); ++i)
-	{
-		intersectionBuffer[i] += centroid;
-	}
-	return 1;
-}
-
-
-
-bool TriangleProcessor::triangleBoundingBoxIntersection(TrPrcTriangle2d& a, TrPrcTriangle2d& b)
-{
-	float fb = std::min(a.points[0].x, std::min(a.points[1].x, a.points[2].x));
-	float fe = std::max(a.points[0].x, std::max(a.points[1].x, a.points[2].x));
-
-	float sb = std::min(b.points[0].x, std::min(b.points[1].x, b.points[2].x));
-	float se = std::max(b.points[0].x, std::max(b.points[1].x, b.points[2].x));
-
-	if (std::min(fe, se) + V_COMP_EPS < std::max(fb, sb)) return 0;
-
-	fb = std::min(a.points[0].y, std::min(a.points[1].y, a.points[2].y));
-	fe = std::max(a.points[0].y, std::max(a.points[1].y, a.points[2].y));
-
-	sb = std::min(b.points[0].y, std::min(b.points[1].y, b.points[2].y));
-	se = std::max(b.points[0].y, std::max(b.points[1].y, b.points[2].y));
-	if (std::min(fe, se) + V_COMP_EPS < std::max(fb, sb)) return 0;
-	return 1;
-}
-
-
-uint32_t TriangleProcessor::isPointInside(const PxVec2& point, const TrPrcTriangle2d& triangle)
-{
-	PxF32 av = getRotation(point - triangle.points[0], triangle.points[1] - triangle.points[0]);
-	PxF32 bv = getRotation(point - triangle.points[1], triangle.points[2] - triangle.points[1]);
-	PxF32 cv = getRotation(point - triangle.points[2], triangle.points[0] - triangle.points[2]);
-
-
-	if (PxAbs(av) < COLLIN_EPS) av = 0;
-	if (PxAbs(bv) < COLLIN_EPS) bv = 0;
-	if (PxAbs(cv) < COLLIN_EPS) cv = 0;
-
-	if (av >= 0 && bv >= 0 && cv >= 0)
-	{
-		if (av == 0 || bv == 0 || cv == 0)
-			return 2;
-		return 1;
-	}
-	if (av <= 0 && bv <= 0 && cv <= 0)
-	{
-		if (av == 0 || bv == 0 || cv == 0)
-			return 2;
-		return 1;
-	}
-	return 0;
-}
-
-} // namespace Blast
-} // namespace Nv
diff --git a/NvBlast/sdk/extensions/authoring/source/NvBlastExtTriangleProcessor.h b/NvBlast/sdk/extensions/authoring/source/NvBlastExtTriangleProcessor.h
deleted file mode 100644
index db9f682..0000000
--- a/NvBlast/sdk/extensions/authoring/source/NvBlastExtTriangleProcessor.h
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTTRIANGLEPROCESSOR_H
-#define NVBLASTEXTTRIANGLEPROCESSOR_H
-
-#include <PxPhysicsAPI.h>
-#include <vector>
-#include <algorithm>
-
-using namespace physx;
-
-
-namespace Nv
-{
-namespace Blast
-{
-	
-/**
-	Triangle processor internal triangle representation. Contains only vertex positions.
-*/
-struct TrPrcTriangle
-{
-	PxVec3 points[3];
-	TrPrcTriangle(PxVec3 a = PxVec3(0.0f), PxVec3 b = PxVec3(0.0f), PxVec3 c = PxVec3(0.0f))
-	{
-		points[0] = a;
-		points[1] = b;
-		points[2] = c;
-	}
-
-	TrPrcTriangle& operator=(const TrPrcTriangle& b)
-	{
-		points[0] = b.points[0];
-		points[1] = b.points[1];
-		points[2] = b.points[2];
-		return *this;
-	}
-
-	TrPrcTriangle(const TrPrcTriangle& b)
-	{
-		points[0] = b.points[0];
-		points[1] = b.points[1];
-		points[2] = b.points[2];
-	}
-	PxVec3 getNormal() const
-	{
-		return (points[1] - points[0]).cross(points[2] - points[0]);
-	}
-};
-
-/**
-	Triangle processor internal 2D triangle representation. Contains only vertex positions.
-*/
-struct TrPrcTriangle2d
-{
-	PxVec2 points[3];
-	TrPrcTriangle2d(PxVec2 a = PxVec2(0.0f), PxVec2 b = PxVec2(0.0f), PxVec2 c = PxVec2(0.0f))
-	{
-		points[0] = a;
-		points[1] = b;
-		points[2] = c;
-	}
-
-	TrPrcTriangle2d operator=(const TrPrcTriangle2d& b)
-	{
-		points[0] = b.points[0];
-		points[1] = b.points[1];
-		points[2] = b.points[2];
-		return *this;
-	}
-
-	TrPrcTriangle2d(const TrPrcTriangle2d& b)
-	{
-		points[0] = b.points[0];
-		points[1] = b.points[1];
-		points[2] = b.points[2];
-	}
-};
-
-class TriangleProcessor
-{
-public:
-
-
-	TriangleProcessor()
-	{};
-	~TriangleProcessor()
-	{
-	}
-		
-
-	/**
-		Build intersection between two triangles
-		\param[in] a			First triangle (A)
-		\param[in] aProjected	Projected triangle A
-		\param[in] b			Second triangle (B)
-		\param[in] centroid		Centroid of first triangle (A)
-		\param[out] intersectionBuffer Result intersection polygon
-		\param[in] normal		Normal vector to triangle (Common for both A and B).
-		\return 1 - if if intersection is found.
-	*/	
-	uint32_t	getTriangleIntersection(TrPrcTriangle& a, TrPrcTriangle2d& aProjected, TrPrcTriangle &b, PxVec3& centroid, std::vector<PxVec3>& intersectionBuffer, PxVec3 normal);
-
-	/**
-		Test whether BB of triangles intersect.
-		\param[in] a			First triangle (A)
-		\param[in] b			Second triangle (B)
-		\return true - if intersect
-	*/
-	bool		triangleBoundingBoxIntersection(TrPrcTriangle2d& a, TrPrcTriangle2d& b);
-		
-
-	/**
-		Test whether point is inside of triangle.
-		\param[in] point		Point coordinates in 2d space.
-		\param[in] triangle		Triangle in 2d space.
-		\return 1 - if inside, 2 if on edge, 0 if neither inside nor edge.
-	*/
-	uint32_t	isPointInside(const PxVec2& point, const TrPrcTriangle2d& triangle);
-
-	/**
-		Segment intersection point
-		\param[in] s1 Segment-1 start point
-		\param[in] e1 Segment-1 end point
-		\param[in] s2 Segment-2 start point
-		\param[in] e2 Segment-2 end point
-		\param[out] t1 Intersection point parameter relatively to Segment-1, lies in [0.0, 1.0] range.
-		\return 0 if there is no intersections, 1 - if intersection is found.
-	*/
-	uint32_t	getSegmentIntersection(const PxVec2& s1, const PxVec2& e1, const PxVec2& s2, const PxVec2& e2, PxF32& t1);
-
-	/**
-		Sort vertices of polygon in CCW-order
-	*/
-	void		sortToCCW(std::vector<PxVec3>& points, PxVec3& normal);
-	
-	/**
-		Builds convex polygon for given set of points. Points should be coplanar.
-		\param[in] points Input array of points
-		\param[out] convexHull Output polygon
-		\param[in] normal Normal vector to polygon.	
-	*/
-	void		buildConvexHull(std::vector<PxVec3>& points, std::vector<PxVec3>& convexHull, const PxVec3& normal);
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // NVBLASTEXTTRIANGLEPROCESSOR_H
diff --git a/NvBlast/sdk/extensions/common/source/NvBlastExtAllocator.h b/NvBlast/sdk/extensions/common/source/NvBlastExtAllocator.h
deleted file mode 100644
index d917cbf..0000000
--- a/NvBlast/sdk/extensions/common/source/NvBlastExtAllocator.h
+++ /dev/null
@@ -1,127 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTALLOCATOR_H
-#define NVBLASTEXTALLOCATOR_H
-
-#include "NvBlastTkFramework.h"
-#include "PxAllocatorCallback.h"
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-/**
-ExtAllocator uses TkFramework allocator
-*/
-class ExtAllocator
-{
-public:
-	ExtAllocator(const char* = 0)
-	{
-	}
-
-	void* allocate(size_t size, const char* filename, int line)
-	{
-		return NvBlastTkFrameworkGet()->getAllocatorCallback().allocate(size, nullptr, filename, line);
-	}
-
-	void deallocate(void* ptr)
-	{
-		NvBlastTkFrameworkGet()->getAllocatorCallback().deallocate(ptr);
-	}
-
-
-	/**
-	Aligned allocation.
-
-	Example using 16-byte alignment:
-
-	// b will lie on a 16-byte boundary and point to 50 bytes of usable memory
-	void* b = alignedAlloc<16>(50);
-	*/
-	template<int A>
-	static void* alignedAlloc(size_t size, const char* filename, int line)
-	{
-		NV_COMPILE_TIME_ASSERT(A > 0 && A <= 256);
-		unsigned char* mem = (unsigned char*)ExtAllocator().allocate(size + A, filename, line);
-		const unsigned char offset = (unsigned char)((uintptr_t)A - (uintptr_t)mem % A - 1);
-		mem += offset;
-		*mem++ = offset;
-		return mem;
-	}
-
-	template<int A>
-	static void* alignedAlloc(size_t size)
-	{
-		return alignedAlloc<A>(size, __FILE__, __LINE__);
-	}
-
-
-	/**
-	Version of alignedAlloc specialized 16-byte aligned allocation.
-	*/
-	static void* alignedAlloc16(size_t size)
-	{
-		return alignedAlloc<16>(size);
-	}
-
-
-	/**
-	Aligned deallocation.
-
-	Memory freed using this function MUST have been allocated using alignedAlloc.
-
-	Example using free:
-
-	// Using the memory pointer b from the example above (for alignedAlloc)
-	alignedFree(b);
-	*/
-	static void alignedFree(void* block)
-	{
-		if (block != nullptr)
-		{
-			unsigned char* mem = (unsigned char*)block;
-			const unsigned char offset = *--mem;
-			ExtAllocator().deallocate(mem - offset);
-		}
-	};
-};
-
-
-/**
-ExtAlignedAllocator uses ExtAllocator
-*/
-template<int A>
-class ExtAlignedAllocator
-{
-public:
-	ExtAlignedAllocator(const char* = 0)
-	{
-	}
-
-	void* allocate(size_t size, const char* filename, int line)
-	{
-		return ExtAllocator::alignedAlloc<A>(size, filename, line);
-	}
-
-	void deallocate(void* ptr)
-	{
-		return ExtAllocator::alignedFree(ptr);
-	}
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // #ifndef NVBLASTEXTALLOCATOR_H
diff --git a/NvBlast/sdk/extensions/common/source/NvBlastExtArray.h b/NvBlast/sdk/extensions/common/source/NvBlastExtArray.h
deleted file mode 100644
index 9ea4777..0000000
--- a/NvBlast/sdk/extensions/common/source/NvBlastExtArray.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTARRAY_H
-#define NVBLASTEXTARRAY_H
-
-
-#include "NvBlastExtAllocator.h"
-#include "PsInlineArray.h"
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-template <class T>
-struct ExtArray
-{
-	typedef physx::shdfnd::Array<T, ExtAllocator> type;
-};
-
-
-template <class T, uint32_t N>
-struct ExtInlineArray
-{
-	typedef physx::shdfnd::InlineArray<T, N, ExtAllocator> type;
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // #ifndef NVBLASTEXTARRAY_H
diff --git a/NvBlast/sdk/extensions/common/source/NvBlastExtDefs.h b/NvBlast/sdk/extensions/common/source/NvBlastExtDefs.h
deleted file mode 100644
index 72b6c1d..0000000
--- a/NvBlast/sdk/extensions/common/source/NvBlastExtDefs.h
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTDEFS_H
-#define NVBLASTEXTDEFS_H
-
-#include "NvBlastTkFramework.h"
-#include "PxAllocatorCallback.h"
-#include <new>
-
-
-//////// Log macros that use the ExtContext log function ////////
-
-#define NVBLASTEXT_LOG_ERROR(_msg)		NVBLAST_LOG_ERROR(NvBlastTkFrameworkGet()->getLogFn(), _msg)
-#define NVBLASTEXT_LOG_WARNING(_msg)	NVBLAST_LOG_WARNING(NvBlastTkFrameworkGet()->getLogFn(), _msg)
-#define NVBLASTEXT_LOG_INFO(_msg)		NVBLAST_LOG_INFO(NvBlastTkFrameworkGet()->getLogFn(), _msg)
-#define NVBLASTEXT_LOG_DEBUG(_msg)		NVBLAST_LOG_DEBUG(NvBlastTkFrameworkGet()->getLogFn(), _msg)
-
-#define NVBLASTEXT_CHECK(_expr, _messageType, _msg, _onFail)								\
-	{																						\
-		if(!(_expr))																		\
-		{																					\
-			(*NvBlastTkFrameworkGet()->getLogFn())(_messageType, _msg, __FILE__, __LINE__);	\
-			{ _onFail; };																	\
-		}																					\
-	}																													
-
-#define NVBLASTEXT_CHECK_ERROR(_expr, _msg, _onFail)	NVBLASTEXT_CHECK(_expr, NvBlastMessage::Error, _msg, _onFail)
-#define NVBLASTEXT_CHECK_WARNING(_expr, _msg, _onFail)	NVBLASTEXT_CHECK(_expr, NvBlastMessage::Warning, _msg, _onFail)
-#define NVBLASTEXT_CHECK_INFO(_expr, _msg, _onFail)		NVBLASTEXT_CHECK(_expr, NvBlastMessage::Info, _msg, _onFail)
-#define NVBLASTEXT_CHECK_DEBUG(_expr, _msg, _onFail)	NVBLASTEXT_CHECK(_expr, NvBlastMessage::Debug, _msg, _onFail)
-
-
-//////// Allocator macros ////////
-
-/**
-Placement new with ExtContext allocation.
-Example: Foo* foo = NVBLASTEXT_NEW(Foo, context) (params);
-*/
-#define NVBLASTEXT_NEW(T) new (NvBlastTkFrameworkGet()->getAllocatorCallback().allocate(sizeof(T), #T, __FILE__, __LINE__)) T
-
-/**
-Respective delete to NVBLASTEXT_NEW
-Example: NVBLASTEXT_DELETE(foo, Foo, context);
-*/
-#define NVBLASTEXT_DELETE(obj, T)				\
-	(obj)->~T();								\
-	NvBlastTkFrameworkGet()->getAllocatorCallback().deallocate(obj)
-
-
-//////// Util macros ////////
-
-// Macro to load a uint32_t (or larger) with four characters
-#define NVBLASTEXT_FOURCC(_a, _b, _c, _d)	( (uint32_t)(_a) | (uint32_t)(_b)<<8 | (uint32_t)(_c)<<16 | (uint32_t)(_d)<<24 )
-
-
-#endif // #ifndef NVBLASTEXTDEFS_H
diff --git a/NvBlast/sdk/extensions/common/source/NvBlastExtHashMap.h b/NvBlast/sdk/extensions/common/source/NvBlastExtHashMap.h
deleted file mode 100644
index 0fa094e..0000000
--- a/NvBlast/sdk/extensions/common/source/NvBlastExtHashMap.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTHASHMAP_H
-#define NVBLASTEXTHASHMAP_H
-
-
-#include "NvBlastExtAllocator.h"
-#include "PsHashMap.h"
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-template <class Key, class Value, class HashFn = physx::shdfnd::Hash<Key>>
-struct ExtHashMap
-{
-	typedef physx::shdfnd::HashMap<Key, Value, HashFn, ExtAllocator> type;
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // #ifndef NVBLASTEXTHASHMAP_H
diff --git a/NvBlast/sdk/extensions/common/source/NvBlastExtHashSet.h b/NvBlast/sdk/extensions/common/source/NvBlastExtHashSet.h
deleted file mode 100644
index 97fc0a9..0000000
--- a/NvBlast/sdk/extensions/common/source/NvBlastExtHashSet.h
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTHASHSET_H
-#define NVBLASTEXTHASHSET_H
-
-
-#include "NvBlastExtAllocator.h"
-#include "PsHashSet.h"
-
-namespace Nv
-{
-namespace Blast
-{
-
-template <class Key, class HashFn = physx::shdfnd::Hash<Key>>
-struct ExtHashSet
-{
-	typedef physx::shdfnd::HashSet<Key, HashFn, ExtAllocator> type;
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // #ifndef NVBLASTEXTHASHSET_H
diff --git a/NvBlast/sdk/extensions/converter/include/NvBlastExtDataConverter.h b/NvBlast/sdk/extensions/converter/include/NvBlastExtDataConverter.h
deleted file mode 100644
index b251518..0000000
--- a/NvBlast/sdk/extensions/converter/include/NvBlastExtDataConverter.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTDATACONVERTER_H
-#define NVBLASTEXTDATACONVERTER_H
-
-
-#include "NvBlast.h"
-#include <vector>
-
-namespace Nv
-{
-namespace Blast
-{
-	/**
-	Generic version conversion function for Blast data blocks.
-
-	Automatically determines block type (one of NvBlastDataBlock::Type) and uses appropriate converter.
-
-	\param[out] outBlock		User-supplied memory block to fill with new data.
-	\param[in]  inBlock			Data block to convert.
-	\param[in]  outBlockVersion	Version to convert too, pass 'nullptr' to convert to the latest version.
-
-	\return	true iff conversion was successful.
-	*/
-	NVBLAST_API bool convertDataBlock(std::vector<char>& outBlock, const std::vector<char>& inBlock, uint32_t* outBlockVersion = nullptr);
-
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTEXTDATACONVERTER_H
diff --git a/NvBlast/sdk/extensions/converter/source/conversion/NvBlastExtAssetBlockVersionConverter_v0_v1.h b/NvBlast/sdk/extensions/converter/source/conversion/NvBlastExtAssetBlockVersionConverter_v0_v1.h
deleted file mode 100644
index 44a0b54..0000000
--- a/NvBlast/sdk/extensions/converter/source/conversion/NvBlastExtAssetBlockVersionConverter_v0_v1.h
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTASSETBLOCKVERSIONCONVERTER_V0_V1_H
-#define NVBLASTEXTASSETBLOCKVERSIONCONVERTER_V0_V1_H
-
-
-#include "NvBlastExtBinaryBlockConverter.h"
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-/*
-	WARNING: THIS CLASS IS AN EXAMPLE.
-	REPLACE WITH ACTUAL CONVERSION CODE ONCE NEEDED.
-*/
-class NvBlastAssetBlockVersionConverter_v0_v1 : public BinaryBlockConverter::VersionConverter
-{
-public:
-	virtual uint32_t getVersionFrom() const { return NvBlastAssetDataFormat::Initial; }
-
-	virtual uint32_t getVersionTo() const { return 1/*NvBlastAssetDataFormat::BondCountSwap*/; }
-
-	// remains the same
-	struct SupportGraph
-	{
-		uint32_t	m_nodeCount;
-		uint32_t	m_chunkIndicesOffset;
-		uint32_t	m_adjacencyPartitionOffset;
-		uint32_t	m_adjacentNodeIndicesOffset;
-		uint32_t	m_adjacentBondIndicesOffset;
-	};
-
-	// prev version 
-	struct AssetDataHeaderPrev
-	{
-		uint32_t		m_formatVersion;
-		uint32_t		m_size;
-		NvBlastID		m_ID;
-		uint32_t		m_totalChunkCount;
-		SupportGraph	m_graph;
-		uint32_t		m_leafChunkCount;
-		uint32_t		m_firstSubsupportChunkIndex; // 0
-		uint32_t		m_bondCount; // 1
-	};
-
-	// new version
-	struct AssetDataHeaderNew
-	{
-		uint32_t		m_formatVersion;
-		uint32_t		m_size;
-		NvBlastID		m_ID;
-		uint32_t		m_totalChunkCount;
-		SupportGraph	m_graph;
-		uint32_t		m_leafChunkCount;
-		uint32_t		m_bondCount; // 1
-		uint32_t		m_firstSubsupportChunkIndex; // 0
-	};
-
-	bool convert(const std::vector<char>& from, std::vector<char>& to) const
-	{
-		to = from;
-
-		const AssetDataHeaderPrev* headerPrev = reinterpret_cast<const AssetDataHeaderPrev*>(from.data());
-		AssetDataHeaderNew* headerNew = reinterpret_cast<AssetDataHeaderNew*>(to.data());
-		headerNew->m_bondCount = headerPrev->m_bondCount;
-		headerNew->m_firstSubsupportChunkIndex = headerPrev->m_firstSubsupportChunkIndex;
-		headerNew->m_formatVersion = (uint32_t)getVersionTo();
-
-		return true;
-	}
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTEXTASSETBLOCKVERSIONCONVERTER_V0_V1_H
diff --git a/NvBlast/sdk/extensions/converter/source/conversion/NvBlastExtBinaryBlockConverter.cpp b/NvBlast/sdk/extensions/converter/source/conversion/NvBlastExtBinaryBlockConverter.cpp
deleted file mode 100644
index a606b70..0000000
--- a/NvBlast/sdk/extensions/converter/source/conversion/NvBlastExtBinaryBlockConverter.cpp
+++ /dev/null
@@ -1,152 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastExtBinaryBlockConverter.h"
-#include <iostream>
-#include <algorithm>
-#include <queue>
-#include <limits>
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-bool BinaryBlockConverter::convertBinaryBlock(std::vector<char>& outBlock, const std::vector<VersionConverterPtr>& converters, const std::vector<char>& inBlock, uint32_t outBlockVersion, uint32_t inBlockVersion)
-{
-	if (inBlock.empty())
-	{
-		std::cerr << "Conversion failed: empty input block." << std::endl;
-		return false;
-	}
-
-	// starting version
-	uint32_t version;
-	version = inBlockVersion;
-	std::cout << "Input block version: " << version << std::endl;
-
-	// target version
-	const uint32_t targetVersion = outBlockVersion;
-	std::cout << "Target version: " << targetVersion << std::endl;
-
-	// search conversion path
-	std::vector<VersionConverterPtr> conversionPath;
-	if (!findShortestPath(conversionPath, converters, version, targetVersion))
-	{
-		std::cerr << "Conversion failed: can't find conversion path." << std::endl;
-		return false;
-	}
-
-	// starting convertion loop
-	std::vector<char> blockFrom(inBlock.begin(), inBlock.end());
-	std::vector<char> blockTo(inBlock.size());
-	for (const VersionConverterPtr converter : conversionPath)
-	{
-		// actual conversion call
-		std::cout << "Converting from version: " << converter->getVersionFrom() << " -> " << converter->getVersionTo() << " Result: ";
-		if (!converter->convert(blockFrom, blockTo))
-		{
-			std::cout << "Fail." << std::endl;
-			std::cerr << "Conversion failed: inside converter for version: " << version << std::endl;
-			return false;
-		}
-		else
-		{
-			std::cout << "Success." << std::endl;
-			blockFrom.swap(blockTo);
-			version = converter->getVersionTo();
-		}
-	}
-
-	// copy result
-	outBlock = blockFrom;
-
-	return true;
-}
-
-
-/**
-Finds shortest path form versionFrom to verstionTo using breadth-first search with DP
-*/
-bool BinaryBlockConverter::findShortestPath(std::vector<VersionConverterPtr>& conversionPath, const std::vector<VersionConverterPtr>& converters, uint32_t versionFrom, uint32_t versionTo)
-{
-	// find max version
-	uint32_t versionMax = 0;
-	for (VersionConverterPtr c : converters)
-	{
-		versionMax = std::max(versionMax, c->getVersionFrom());
-		versionMax = std::max(versionMax, c->getVersionTo());
-	}
-
-	// dynamic programming data
-	struct Node
-	{
-		uint32_t distance;
-		VersionConverterPtr converter;
-
-		Node() : distance(std::numeric_limits<uint32_t>::max()), converter(nullptr) {}
-	};
-	std::vector<Node> nodes(versionMax + 1);
-
-	// initial state (start from versionTo)
-	std::queue<uint32_t> q;
-	q.emplace(versionTo);
-	nodes[versionTo].distance = 0;
-	nodes[versionTo].converter = nullptr;
-
-	// breadth-first search
-	bool found = false;
-	while (!q.empty() && !found)
-	{
-		uint32_t v0 = q.front();
-		q.pop();
-
-		for (const VersionConverterPtr c : converters)
-		{
-			if (c->getVersionTo() == v0)
-			{
-				uint32_t v1 = c->getVersionFrom();
-				if (nodes[v1].distance > nodes[v0].distance + 1)
-				{
-					nodes[v1].distance = nodes[v0].distance + 1;
-					nodes[v1].converter = c;
-					q.emplace(v1);
-				}
-
-				if (c->getVersionFrom() == versionFrom)
-				{
-					found = true;
-					break;
-				}
-			}
-		}
-	}
-
-	if (found)
-	{
-		// unfold found path to result conversionPath
-		uint32_t v = versionFrom;
-		conversionPath.clear();
-		while (nodes[v].converter.get() != nullptr)
-		{
-			conversionPath.push_back(nodes[v].converter);
-			v = nodes[v].converter->getVersionTo();
-		}
-		return true;
-	}
-	else
-	{
-		return false;
-	}
-}
-
-} // namespace Blast
-} // namespace Nv
diff --git a/NvBlast/sdk/extensions/converter/source/conversion/NvBlastExtBinaryBlockConverter.h b/NvBlast/sdk/extensions/converter/source/conversion/NvBlastExtBinaryBlockConverter.h
deleted file mode 100644
index 83eb6b3..0000000
--- a/NvBlast/sdk/extensions/converter/source/conversion/NvBlastExtBinaryBlockConverter.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTBINARYBLOCKCONVERTER_H
-#define NVBLASTEXTBINARYBLOCKCONVERTER_H
-
-
-#include "NvBlast.h"
-#include <vector>
-#include <memory>
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-/**
-Generic binary block converter class.
-
-BinaryBlockConverter is an abstract class, as well as it's member class VersionConverter. In order to implement your own
-binary converter - implement for every version conversion BinaryBlockConverter::VersionConverter. Then implement BinaryBlockConverter
-where getVersionConverters() should return all your implemented BinaryBlockConverter::VersionConverter's.
-		
-*/
-class BinaryBlockConverter
-{
-public:
-	class VersionConverter
-	{
-	public:
-		virtual uint32_t getVersionFrom() const = 0;
-		virtual uint32_t getVersionTo() const = 0;
-		virtual bool convert(const std::vector<char>& from, std::vector<char>& to) const = 0;
-	};
-
-	typedef std::shared_ptr<VersionConverter> VersionConverterPtr;
-
-	static bool convertBinaryBlock(std::vector<char>& outBlock, const std::vector<VersionConverterPtr>& converters, const std::vector<char>& inBlock, uint32_t outBlockVersion, uint32_t inBlockVersion);
-protected:
-
-private:
-	static bool findShortestPath(std::vector<VersionConverterPtr>& conversionPath, const std::vector<VersionConverterPtr>& converters, uint32_t versionFrom, uint32_t versionTo);
-};
-	
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTEXTBINARYBLOCKCONVERTER_H
diff --git a/NvBlast/sdk/extensions/converter/source/conversion/NvBlastExtDataConverter.cpp b/NvBlast/sdk/extensions/converter/source/conversion/NvBlastExtDataConverter.cpp
deleted file mode 100644
index fe8c745..0000000
--- a/NvBlast/sdk/extensions/converter/source/conversion/NvBlastExtDataConverter.cpp
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastExtDataConverter.h"
-#include "NvBlastExtBinaryBlockConverter.h"
-
-#include <iostream>
-
-// asset converters
-#include "NvBlastExtAssetBlockVersionConverter_v0_v1.h"
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//													Asset Block Converter
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-NV_INLINE std::vector<BinaryBlockConverter::VersionConverterPtr> getAssetConverters()
-{
-	/**
-		+==========================================+
-		|  HINT: ADD NEW VERSION CONVERTERS THERE  |
-		+==========================================+
-	*/
-	BinaryBlockConverter::VersionConverterPtr converters[] = 
-	{
-		std::make_shared<NvBlastAssetBlockVersionConverter_v0_v1>()
-	};
-
-	return std::vector<BinaryBlockConverter::VersionConverterPtr>(converters, converters + sizeof(converters) / sizeof(converters[0]));
-}
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//													Family Converter
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-NV_INLINE std::vector<BinaryBlockConverter::VersionConverterPtr> getFamilyConverters()
-{
-	/**
-		+==========================================+
-		|  HINT: ADD NEW VERSION CONVERTERS THERE  |
-		+==========================================+
-	*/
-	BinaryBlockConverter::VersionConverterPtr converters[] = 
-	{
-		nullptr //std::make_shared<NvBlastFamilyVersionConverter_v0_v1>()
-	};
-
-	return std::vector<BinaryBlockConverter::VersionConverterPtr>(converters, converters + sizeof(converters) / sizeof(converters[0]));
-}
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//													Generic Block Converter
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-bool convertDataBlock(std::vector<char>& outBlock, const std::vector<char>& inBlock, uint32_t* outBlockVersion)
-{
-	// Pick header to determine dataType and version
-	if (inBlock.size() < sizeof(NvBlastDataBlock))
-	{
-		std::cerr << "Conversion failed: invalid block, passed block is too small." << std::endl;
-		return false;
-	}
-	const NvBlastDataBlock* dataBlock = reinterpret_cast<const NvBlastDataBlock*>(inBlock.data());
-		
-	// Select appropriate converters and version based on dataType
-	std::vector<BinaryBlockConverter::VersionConverterPtr> converters;
-	uint32_t version;
-	switch (dataBlock->dataType)
-	{
-	case NvBlastDataBlock::AssetDataBlock:
-		std::cout << "Input block dataType: NvBlastDataBlock::Asset" << std::endl;
-		converters = getAssetConverters();
-		version = (outBlockVersion == nullptr ? static_cast<uint32_t>(NvBlastAssetDataFormat::Current) : *outBlockVersion);
-		break;
-	case NvBlastDataBlock::FamilyDataBlock:
-		std::cout << "Input block dataType: NvBlastDataBlock::Family" << std::endl;
-		converters = getFamilyConverters();
-		version = (outBlockVersion == nullptr ? static_cast<uint32_t>(NvBlastFamilyDataFormat::Current) : *outBlockVersion);
-		break;
-	default:
-		std::cerr << "Conversion failed: unsupported dataType: " << dataBlock->dataType << std::endl;
-		return false;
-	}
-
-	return BinaryBlockConverter::convertBinaryBlock(outBlock, converters, inBlock, version, dataBlock->formatVersion);
-}
-
-} // namespace Blast
-} // namespace Nv
diff --git a/NvBlast/sdk/extensions/import/include/NvBlastExtApexImportTool.h b/NvBlast/sdk/extensions/import/include/NvBlastExtApexImportTool.h
deleted file mode 100644
index bbfcfce..0000000
--- a/NvBlast/sdk/extensions/import/include/NvBlastExtApexImportTool.h
+++ /dev/null
@@ -1,199 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTAPEXIMPORTTOOL_H
-#define NVBLASTEXTAPEXIMPORTTOOL_H
-
-#include "NvBlast.h"
-#include <vector>
-#include <string>
-#include "NvBlastExtPxAsset.h"
-
-namespace physx
-{
-class PxErrorCallback;
-class PxAllocatorCallback;
-namespace general_PxIOStream2
-{
-class PxFileBuf;
-}
-}
-
-namespace nvidia
-{
-namespace apex
-{
-class ApexSDK;
-class ModuleDestructible;
-class DestructibleAsset;
-}
-using namespace physx::general_PxIOStream2;
-}
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-struct CollisionHull;
-class TkFramework;
-
-namespace ApexImporter
-{
-
-struct ApexImporterConfig
-{
-	/**
-		Interface search mode:
-
-		EXACT -				-   Importer tries to find triangles from two chunks which lay in common surface.
-								If such triangles are found, their intersections are considered as the interface.
-
-		FORCED				-	Bond creation is forced no matter how far chunks from each other.
-
-	*/
-	enum InterfaceSearchMode { EXACT, FORCED, MODE_COUNT };
-
-	ApexImporterConfig()
-	{
-		setDefaults();
-	}
-
-	void setDefaults()
-	{
-		infSearchMode				=	EXACT;
-	}
-	InterfaceSearchMode infSearchMode;
-};
-
-
-class ApexDestruction;
-
-
-/** 
-	ApexImportTool provides routines to create NvBlastAssets from APEX assets.
-*/
-class ApexImportTool
-{
-public:
-
-	/**	
-		Constructor should be provided with user defined allocator and massage function:
-		\param[in] logFn		User - supplied message function(see NvBlastLog definition).May be NULL.
-	*/
-	ApexImportTool(NvBlastLog logFn = NULL);
-	~ApexImportTool();
-
-	//////////////////////////////////////////////////////////////////////////////
-
-	/**
-		Before using ApexImportTool should be initialized. ApexSDK and ModuleDestructible initialized internally.
-		\return		If true, ApexImportTool initialized successfully.
-	*/
-	bool								initialize();
-
-	/**
-		Before using ApexImportTool should be initialized. User can provide existing ApexSDK and ModuleDestructible objects
-		\param[in]	apexSdk					Pointer on ApexSDK object
-		\param[in]	moduleDestructible		Pointer on ModuleDestructible object
-		\return								If true, ApexImportTool initialized successfully.
-	*/
-	bool								initialize(nvidia::apex::ApexSDK* apexSdk, nvidia::apex::ModuleDestructible* moduleDestructible);
-
-	/**
-		Checks whether ApexImportTool is initialized and can be used.
-		\return			If true, ApexImportTool initialized successfully.
-	*/
-	bool								isValid();
-
-
-	/**
-		Method loads APEX Destruction asset from file
-		\param[in] stream		Pointer on PxFileBuf stream with Apex Destruction asset
-		\return					If not 0, pointer on DestructibleAsset object is returned. 
-	*/
-	nvidia::apex::DestructibleAsset*	loadAssetFromFile(nvidia::PxFileBuf* stream);
-
-
-	/**
-		Method builds NvBlastAsset form provided DestructibleAsset. DestructibleAsset must contain support graph!
-		\param[out] chunkReorderInvMap	Chunk map from blast chunk to apex chunk to be filled.
-		\param[in] apexAsset			Pointer on DestructibleAsset object which should be converted to NvBlastAsset
-		\param[out] chunkDescriptors	Reference on chunk descriptors array to be filled. 
-		\param[out] bondDescriptors		Reference on bond descriptors array to be filled.
-		\param[out] flags				Reference on chunk flags to be filled.
-		
-		\return							If true, output arrays are filled.
-	*/
-	bool								importApexAsset(std::vector<uint32_t>& chunkReorderInvMap, const nvidia::apex::DestructibleAsset* apexAsset,
-											std::vector<NvBlastChunkDesc>& chunkDescriptors, std::vector<NvBlastBondDesc>& bondDescriptors, std::vector<uint32_t>& flags);
-
-	/**
-		Method builds NvBlastAsset form provided DestructibleAsset. DestructibleAsset must contain support graph!
-		Parameteres of conversion could be provided with ApexImporterConfig. 
-		\param[out] chunkReorderInvMap	Chunk map from blast chunk to apex chunk to be filled.
-		\param[in] apexAsset			Pointer on DestructibleAsset object which should be converted to NvBlastAsset
-		\param[out] chunkDescriptors	Reference on chunk descriptors array to be filled.
-		\param[out] bondDescriptors		Reference on bond descriptors array to be filled.
-		\param[out] flags				Reference on chunk flags to be filled.
-		\param[in] config				ApexImporterConfig object with conversion parameters, see above.
-		\return							If true, output arrays are filled.
-	*/
-	bool								importApexAsset(std::vector<uint32_t>& chunkReorderInvMap, const nvidia::apex::DestructibleAsset* apexAsset,
-											std::vector<NvBlastChunkDesc>& chunkDescriptors, std::vector<NvBlastBondDesc>& bondDescriptors, std::vector<uint32_t>& flags,
-											const ApexImporterConfig& config);
-
-
-	/**
-		Method serializes user-supplied NvBlastAsset object to user-supplied PxFileBuf stream.
-		\param[in] asset		Pointer on NvBlastAsset object which should be serialized
-		\param[in] stream		Pointer on PxFileBuf object in which NvBlastAsset should be serialized.
-		\return					If true, NvBlastAsset object serialized successfully.
-	*/
-	bool								saveAsset(const NvBlastAsset* asset, nvidia::PxFileBuf* stream);
-
-	/**
-		Method creates collision geometry from user-supplied APEX Destructible asset.
-		\param[in]	apexAsset				Pointer on DestructibleAsset object for which collision geometry should be created.
-		\param[in]	chunkCount				Blast asset chunk count, should be equal to number of blast chunk descriptors which are gathered at ApexImportTool::importApexAsset(...)
-		\param[in]	chunkReorderInvMap		Chunk map from blast chunk to apex chunk filled in ApexImportTool::importApexAsset(...)
-		\param[in]	apexChunkFlags			Chunk flags array
-		\param[out]	physicsChunks			Chunk physics info output array
-		\param[out]	physicsSubchunks		Chunk collision geometry and transformation data output array
-		\return								If true - success, output arrays are filled.
-	*/
-	bool								getCollisionGeometry(const nvidia::apex::DestructibleAsset* apexAsset, uint32_t chunkCount, std::vector<uint32_t>& chunkReorderInvMap,
-												const std::vector<uint32_t>& apexChunkFlags, std::vector<ExtPxAssetDesc::ChunkDesc>& physicsChunks,
-												std::vector<ExtPxAssetDesc::SubchunkDesc>& physicsSubchunks);
-
-	ApexDestruction*					m_apexDestruction;
-	//////////////////////////////////////////////////////////////////////////////
-
-private:
-	bool								importApexAssetInternal(std::vector<uint32_t>& chunkReorderInvMap, const nvidia::apex::DestructibleAsset* apexAsset,
-											std::vector<NvBlastChunkDesc>& chunkDescriptors, std::vector<NvBlastBondDesc>& bondDesc, std::vector<uint32_t>& flags,
-											const ApexImporterConfig& configDesc);
-	
-
-protected:
-	NvBlastLog	m_log;
-
-protected:
-	ApexImportTool(const ApexImportTool&);
-	ApexImportTool& operator=(const ApexImportTool&);
-};
-
-} // namespace ApexImporter
-
-} // namespace Blast
-} // namespace Nv
-
-#endif // NVBLASTEXTAPEXIMPORTTOOL_H
diff --git a/NvBlast/sdk/extensions/import/source/NvBlastExtApexDestruction.cpp b/NvBlast/sdk/extensions/import/source/NvBlastExtApexDestruction.cpp
deleted file mode 100644
index 889a8c8..0000000
--- a/NvBlast/sdk/extensions/import/source/NvBlastExtApexDestruction.cpp
+++ /dev/null
@@ -1,220 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastExtApexDestruction.h"
-
-
-#include "PxPhysicsAPI.h"
-#include "Apex.h"
-#include <ModuleDestructible.h>
-#include <DestructibleAsset.h>
-#include "NullRenderer.h"
-#include "PsString.h"
-
-using namespace nvidia;
-using namespace apex;
-
-//////////////////////////////////////////////////////////////////////////////
-
-PxDefaultAllocator gPxAllocator;
-PxDefaultErrorCallback gErrorCallback;
-NullRenderResourceManager gNullRenderer;
-
-/////////////////////////////////////////////////////////////////////////////
-
-namespace Nv
-{
-namespace Blast
-{
-using namespace ApexImporter;
-
-ApexDestruction::ApexDestruction(NvBlastLog log)
-{
-	m_log = log;
-	initialize();
-}
-
-ApexDestruction::ApexDestruction(ApexSDK* apexSdk, ModuleDestructible* moduleDestructible, NvBlastLog log)
-{
-	m_log = log;
-
-	m_Foundation.reset(&apexSdk->getPhysXSDK()->getFoundation(), false);
-	m_PhysxSDK.reset(apexSdk->getPhysXSDK(), false);
-	m_Cooking.reset(apexSdk->getCookingInterface(), false);
-	m_ApexSDK.reset(apexSdk, false);
-	for (uint32_t i = 0; i < apexSdk->getNbModules(); ++i)
-	{
-		if (!physx::shdfnd::strcmp(apexSdk->getModules()[i]->getName(), "Legacy"))
-		{
-			hasLegacyModule = true;
-		}
-	}
-	m_DestructibleModule.reset(moduleDestructible, false);
-}
-
-
-bool ApexDestruction::isValid()
-{
-	return m_PhysxSDK && m_Cooking && m_ApexSDK && m_DestructibleModule && hasLegacyModule;
-}
-
-bool ApexDestruction::initialize()
-{
-	if (isValid())
-	{
-		return true;
-	}
-
-	//////////////////////////////////////////////////////////////////////////////
-
-	m_Foundation.reset(PxCreateFoundation(PX_FOUNDATION_VERSION, gPxAllocator, gErrorCallback));
-	if (!m_Foundation)
-	{
-		if (m_log)
-		{
-			m_log(NvBlastMessage::Error, "Error: failed to create Foundation\n", __FILE__, __LINE__);
-		}
-		return false;
-	}
-	physx::PxTolerancesScale scale;
-	m_PhysxSDK.reset(PxCreatePhysics(PX_PHYSICS_VERSION, *m_Foundation, scale, true));
-	if (!m_PhysxSDK)
-	{
-		if (m_log)
-		{
-			m_log(NvBlastMessage::Error, "Error: failed to create PhysX\n", __FILE__, __LINE__);
-		}
-		return false;
-	}
-
-#if 0
-	if (!PxInitExtensions(*mPhysxSDK, 0))
-	{
-		if (m_log)
-		{
-			m_log(Error, "Error: failed to init PhysX extensions\n", __FILE__, __LINE__);
-		}
-		return false;
-	}
-#endif
-
-	physx::PxCookingParams cookingParams(scale);
-	cookingParams.buildGPUData = true;
-	m_Cooking.reset(PxCreateCooking(PX_PHYSICS_VERSION, m_PhysxSDK->getFoundation(), cookingParams));
-	if (!m_Cooking)
-	{
-		m_log(NvBlastMessage::Error, "Error: failed to create PhysX Cooking\n", __FILE__, __LINE__);
-		return false;
-	}
-
-	//////////////////////////////////////////////////////////////////////////////
-
-	ApexSDKDesc apexSDKDesc;
-	apexSDKDesc.physXSDK = m_PhysxSDK.get();
-	apexSDKDesc.cooking = m_Cooking.get();
-	apexSDKDesc.renderResourceManager = &gNullRenderer;
-	apexSDKDesc.resourceCallback = nullptr;
-	apexSDKDesc.foundation = &m_PhysxSDK->getFoundation();
-
-	m_ApexSDK.reset(CreateApexSDK(apexSDKDesc, nullptr, APEX_SDK_VERSION));
-	if (!m_ApexSDK)
-	{
-		if (m_log)
-		{
-			m_log(NvBlastMessage::Error, "Error: failed to create APEX\n", __FILE__, __LINE__);
-		}
-		return false;
-	}
-
-	//////////////////////////////////////////////////////////////////////////////
-
-	m_DestructibleModule.reset(static_cast<nvidia::apex::ModuleDestructible*>(m_ApexSDK->createModule("Destructible")), ApexReleaser(*m_ApexSDK));
-	if (!m_DestructibleModule)
-	{
-		if (m_log)
-		{
-			m_log(NvBlastMessage::Error, "Error: failed to create ModuleDestructible\n", __FILE__, __LINE__);
-		}
-		return false;
-	}
-
-	if (!m_ApexSDK->createModule("Legacy"))
-	{
-		if (m_log)
-		{
-			m_log(NvBlastMessage::Error, "Error: failed to create Legacy module\n", __FILE__, __LINE__);
-		}
-		return false;
-	};
-
-
-	float massScaleExponenent = 1.f;
-	float massScale = 1.f;
-
-	NvParameterized::Interface* params = m_DestructibleModule->getDefaultModuleDesc();
-	NvParameterized::Handle paramsHandle(params);
-	paramsHandle.getParameter("scaledMassExponent");
-	paramsHandle.setParamF32(massScaleExponenent);
-	paramsHandle.getParameter("massScale");
-	paramsHandle.setParamF32(massScale);
-	m_DestructibleModule->init(*params);
-
-	return true;
-}
-
-DestructibleAsset* ApexDestruction::loadAsset(physx::PxFileBuf* stream)
-{
-	DestructibleAsset* asset = nullptr;
-
-	if (stream && stream->isOpen())
-	{
-		NvParameterized::Serializer::SerializeType serType = apexSDK()->getSerializeType(*stream);
-		NvParameterized::Serializer::ErrorType serError;
-		NvParameterized::Serializer* ser = apexSDK()->createSerializer(serType);
-		PX_ASSERT(ser);
-
-		NvParameterized::Serializer::DeserializedData data;
-		serError = ser->deserialize(*stream, data);
-
-		if (serError == NvParameterized::Serializer::ERROR_NONE && data.size() == 1)
-		{
-			NvParameterized::Interface* params = data[0];
-			if (!physx::shdfnd::strcmp(params->className(), "DestructibleAssetParameters"))
-			{
-				asset = static_cast<DestructibleAsset*>(apexSDK()->createAsset(params, ""));
-			}
-			else
-			{
-				m_log(NvBlastMessage::Error, "Error: deserialized data is not an APEX Destructible\n", __FILE__, __LINE__);
-			}
-		}
-		else
-		{
-			m_log(NvBlastMessage::Error, "Error: failed to deserialize\n", __FILE__, __LINE__);
-		}
-		ser->release();
-	}
-
-	if (!asset)
-	{
-		char message[255] = { 0 };
-		sprintf(message, "Error: failed to load asset...\n");
-		m_log(NvBlastMessage::Error, message, __FILE__, __LINE__);
-	}
-
-	return asset;
-}
-
-ApexDestruction::~ApexDestruction()
-{
-}
-
-} // namespace Blast
-} // namespace Nv
diff --git a/NvBlast/sdk/extensions/import/source/NvBlastExtApexDestruction.h b/NvBlast/sdk/extensions/import/source/NvBlastExtApexDestruction.h
deleted file mode 100644
index 6560aed..0000000
--- a/NvBlast/sdk/extensions/import/source/NvBlastExtApexDestruction.h
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTAPEXDESTRUCTION_H
-#define NVBLASTEXTAPEXDESTRUCTION_H
-
-#include "ApexUsingNamespace.h"
-#include "NvBlastExtScopedResource.h"
-#include "PsUtilities.h"
-#include <string>
-#include <NvBlastTypes.h>
-#include <PxFileBuf.h>
-
-namespace physx
-{
-	class PxFoundation;
-}
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-namespace ApexImporter
-{
-	/**
-		Class for working with APEX Destruction assets.
-	*/
-class ApexDestruction
-{
-	PX_NOCOPY(ApexDestruction)
-
-public:
-	ApexDestruction(NvBlastLog log = NULL);
-
-	ApexDestruction(nvidia::apex::ApexSDK* apexSdk, nvidia::apex::ModuleDestructible* moduleDestructible, NvBlastLog log = NULL);
-	~ApexDestruction();
-
-	//////////////////////////////////////////////////////////////////////////////
-	/**
-		ApexDestruction initialization. If APEX SDK and ModuleDestructible was provided to constructor, they will be used. 
-		Otherwise, PhysXSDK and APEX SDK will be initialized.
-	*/
-	bool initialize();
-
-	/**
-		/return Return True if tool initialized sucessfully.
-	*/
-	bool isValid();
-
-	/**
-		Load Apex Destructible asset from PxFileBuf stream
-		\param[in] stream Apex asset stream
-		/return Return DestructibleAsset* if success, otherwise nullptr is returned.
-	*/
-	nvidia::apex::DestructibleAsset*	loadAsset(physx::PxFileBuf* stream);
-
-	/**
-		/return Return PxFoundation.
-	*/
-	physx::PxFoundation*				foundation() { return m_Foundation.get(); }
-	/**
-		/return Return PxPhysics.
-	*/
-	physx::PxPhysics*					physxSDK() { return m_PhysxSDK.get(); }
-	/**
-		/return Return PxCooking.
-	*/
-	physx::PxCooking*					cooking() { return m_Cooking.get(); }
-	/**
-		/return Return ApexSDK.
-	*/
-	nvidia::apex::ApexSDK*				apexSDK() { return m_ApexSDK.get(); }
-
-	/**
-		/return Return ModuleDestructible.
-	*/
-	nvidia::apex::ModuleDestructible*	destructibleModule() { return m_DestructibleModule.get(); }
-
-private:
-	bool hasLegacyModule;
-	NvBlastLog														m_log;
-	//////////////////////////////////////////////////////////////////////////////
-
-protected:
-	ScopedResource<physx::PxFoundation>								m_Foundation;
-	ScopedResource<physx::PxPhysics>								m_PhysxSDK;
-	ScopedResource<physx::PxCooking>								m_Cooking;
-	ScopedResource<nvidia::apex::ApexSDK>							m_ApexSDK;
-	ScopedResource<nvidia::apex::ModuleDestructible, ApexReleaser>	m_DestructibleModule;
-
-};
-
-} // namespace ApexImporter
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // NVBLASTEXTAPEXDESTRUCTION_H
diff --git a/NvBlast/sdk/extensions/import/source/NvBlastExtApexImportTool.cpp b/NvBlast/sdk/extensions/import/source/NvBlastExtApexImportTool.cpp
deleted file mode 100644
index d2def6f..0000000
--- a/NvBlast/sdk/extensions/import/source/NvBlastExtApexImportTool.cpp
+++ /dev/null
@@ -1,490 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastExtApexImportTool.h"
-
-#if NV_VC
-#pragma warning(push)
-#pragma warning(disable: 4996) // 'fopen' unsafe warning, from NxFileBuffer.h
-#endif
-
-#include "PxFoundation.h"
-#include "PxErrorCallback.h"
-#include "PxAllocatorCallback.h"
-
-#include "NvBlastIndexFns.h"
-#include "DestructibleAsset.h"
-#include "NvBlastExtApexDestruction.h"
-#include <PxConvexMesh.h>
-#include "PxPhysics.h"
-#include "NvBlastExtAuthoringCollisionBuilder.h"
-#include "NvBlastExtPxAsset.h"
-#include "NvBlastExtAuthoringTypes.h"
-#include "NvBlastExtAuthoringBondGenerator.h"
-
-using namespace nvidia;
-using namespace apex;
-
-namespace Nv
-{
-namespace Blast
-{
-
-namespace ApexImporter
-{
-	/**
-		Should be consistent with IntPair in APEX
-	*/
-	struct IntPair
-	{
-		void	set(int32_t _i0, int32_t _i1)
-		{
-			i0 = _i0;
-			i1 = _i1;
-		}
-
-		int32_t	i0, i1;
-
-		static	int	compare(const void* a, const void* b)
-		{
-			const int32_t diff0 = ((IntPair*)a)->i0 - ((IntPair*)b)->i0;
-			return diff0 ? diff0 : (((IntPair*)a)->i1 - ((IntPair*)b)->i1);
-		}
-	};
-
-ApexImportTool::ApexImportTool(NvBlastLog log)
-	: m_apexDestruction(NULL), m_log(log)
-{
-}
-
-
-bool ApexImportTool::isValid()
-{
-	return m_apexDestruction && m_apexDestruction->isValid();
-}
-
-
-bool ApexImportTool::initialize()
-{
-	if (isValid())
-	{
-		return true;
-	}
-	m_log(NvBlastMessage::Info, "APEX initialization \n", __FILE__, __LINE__);
-	m_apexDestruction = new ApexDestruction(m_log);
-	return isValid();
-}
-
-
-bool ApexImportTool::initialize(nvidia::apex::ApexSDK* apexSdk, nvidia::apex::ModuleDestructible* moduleDestructible)
-{
-	if (isValid())
-	{
-		return true;
-	}
-	m_log(NvBlastMessage::Info, "APEX initialization \n", __FILE__, __LINE__);
-	m_apexDestruction = new ApexDestruction(apexSdk, moduleDestructible, m_log);
-	return isValid();
-}
-
-DestructibleAsset* ApexImportTool::loadAssetFromFile(physx::PxFileBuf* stream)
-{
-	return m_apexDestruction->loadAsset(stream);
-}
-
-
-bool ApexImportTool::getCollisionGeometry(const nvidia::apex::DestructibleAsset* apexAsset, uint32_t chunkCount, std::vector<uint32_t>& chunkReorderInvMap,
-						const std::vector<uint32_t>& apexChunkFlags, std::vector<ExtPxAssetDesc::ChunkDesc>& physicsChunks,
-						std::vector<ExtPxAssetDesc::SubchunkDesc>& physicsSubchunks)
-{
-	physicsChunks.clear();
-	physicsChunks.resize(chunkCount);
-	// prepare physics asset desc (convexes, transforms)
-	ConvexMeshBuilder collisionBuilder(m_apexDestruction->cooking(), &m_apexDestruction->apexSDK()->getPhysXSDK()->getPhysicsInsertionCallback());
-	int32_t apexHullCount = 0;
-	const uint32_t apexChunkCount = apexAsset->getChunkCount();
-	for (uint32_t chunkIndex = 0; chunkIndex < chunkCount; ++chunkIndex)
-	{
-		uint32_t apexChunkIndex = chunkReorderInvMap[chunkIndex];
-		if (apexChunkIndex < apexChunkCount)
-		{
-			uint32_t partIndex = apexAsset->getPartIndex(apexChunkIndex);
-			apexHullCount += apexAsset->getPartConvexHullCount(partIndex);
-		}
-	}
-	physicsSubchunks.reserve(chunkCount);
-	{
-		for (uint32_t chunkIndex = 0; chunkIndex < chunkCount; ++chunkIndex)
-		{
-			uint32_t apexChunkIndex = chunkReorderInvMap[chunkIndex];
-			if (apexChunkIndex < apexChunkCount)
-			{
-				uint32_t partIndex = apexAsset->getPartIndex(apexChunkIndex);
-				uint32_t partConvexHullCount = apexAsset->getPartConvexHullCount(partIndex);
-				NvParameterized::Interface** cxInterfaceArray = apexAsset->getPartConvexHullArray(partIndex);
-				physicsChunks[chunkIndex].subchunkCount = partConvexHullCount;
-				for (uint32_t hull = 0; hull < partConvexHullCount; ++hull)
-				{
-					NvParameterized::Handle paramHandle(cxInterfaceArray[hull]);
-					int32_t verticesCount = 0;
-					paramHandle.getParameter("vertices");
-					paramHandle.getArraySize(verticesCount);
-					std::vector<PxVec3> vertexData(verticesCount);
-					paramHandle.getParamVec3Array(vertexData.data(), verticesCount);
-
-					PxConvexMesh* convexMesh = collisionBuilder.buildConvexMesh(vertexData);
-
-					const ExtPxAssetDesc::SubchunkDesc subchunk =
-					{
-						PxTransform(PxIdentity),
-						PxConvexMeshGeometry(convexMesh)
-					};
-					physicsSubchunks.push_back(subchunk);
-				}
-				physicsChunks[chunkIndex].subchunks = partConvexHullCount ? (&physicsSubchunks.back() + 1 - partConvexHullCount) : nullptr;
-
-				// static flag set
-				physicsChunks[chunkIndex].isStatic = (apexChunkFlags[apexChunkIndex] & (1 << 1)) != 0;
-			}
-			else
-			{
-				// this is earth chunk
-				physicsChunks[chunkIndex].isStatic = true;
-			}
-		}
-	}
-
-	// check that vector didn't grow
-	if (static_cast<int32_t>(physicsSubchunks.size()) > apexHullCount)
-	{
-		m_log(NvBlastMessage::Error, "Error: sub chunk count seems to be wrong.  \n", __FILE__, __LINE__);
-		return false;
-	}
-	return true;
-}
-
-void gatherChunkHullPoints(const DestructibleAsset* apexAsset, std::vector<std::vector<PxVec3> >& hullPoints)
-{
-	hullPoints.resize(apexAsset->getChunkCount());
-	for (uint32_t chunk = 0; chunk < apexAsset->getChunkCount(); ++chunk)
-	{
-		int32_t part = apexAsset->getPartIndex(chunk);
-		NvParameterized::Interface** cxInterfaceArray = apexAsset->getPartConvexHullArray(part);
-		for (uint32_t hull = 0; hull < apexAsset->getPartConvexHullCount(part); ++hull)
-		{
-			NvParameterized::Handle paramHandle(cxInterfaceArray[hull]);
-			int32_t verticesCount = 0;
-			paramHandle.getParameter("vertices");
-			paramHandle.getArraySize(verticesCount);
-			uint32_t oldSize = (uint32_t)hullPoints[chunk].size();
-			hullPoints[chunk].resize(hullPoints[chunk].size() + verticesCount);
-			paramHandle.getParamVec3Array(hullPoints[chunk].data() + oldSize, verticesCount);
-		}
-	}
-}
-PxBounds3 gatherChunkTriangles(const DestructibleAsset* apexAsset, std::vector<std::vector<Nv::Blast::Triangle> >& chunkTriangles, int32_t posBufferIndex, float scale, PxVec3 offset )
-{
-
-	PxBounds3 bnd;
-	bnd.setEmpty();
-	chunkTriangles.clear();
-	chunkTriangles.resize(apexAsset->getChunkCount());
-	for (uint32_t chunkIndex = 0; chunkIndex < apexAsset->getChunkCount(); ++chunkIndex)
-	{
-		uint32_t part = apexAsset->getPartIndex(chunkIndex);
-		const RenderMeshAsset* rAsset = apexAsset->getRenderMeshAsset();
-		uint32_t submeshCount = rAsset->getSubmeshCount();
-		for (uint32_t submeshIndex = 0; submeshIndex < submeshCount; ++submeshIndex)
-		{
-			const RenderSubmesh& currentSubmesh = rAsset->getSubmesh(submeshIndex);
-			const uint32_t* indexArray = currentSubmesh.getIndexBuffer(part);
-			uint32_t indexCount = currentSubmesh.getIndexCount(part);
-			const PxVec3* positions = reinterpret_cast<const PxVec3*>(currentSubmesh.getVertexBuffer().getBuffer(posBufferIndex));
-
-			for (uint32_t i = 0; i < indexCount; i += 3)
-			{
-				Vertex a;
-				Vertex b;
-				Vertex c;
-				bnd.include(positions[indexArray[i]]);
-				bnd.include(positions[indexArray[i + 1]]);
-				bnd.include(positions[indexArray[i + 2]]);
-
-				a.p = positions[indexArray[i]] - offset;
-				b.p = positions[indexArray[i + 1]] - offset;
-				c.p = positions[indexArray[i + 2]] - offset;
-				a.p *= scale;
-				b.p *= scale;
-				c.p *= scale;
-				chunkTriangles[chunkIndex].push_back(Nv::Blast::Triangle(a, b, c));
-			}
-		}
-	}
-	return bnd;
-}
-
-bool ApexImportTool::importApexAsset(std::vector<uint32_t>& chunkReorderInvMap, const nvidia::apex::DestructibleAsset* apexAsset,
-	std::vector<NvBlastChunkDesc>& chunkDescriptors, std::vector<NvBlastBondDesc>& bondDescriptors, std::vector<uint32_t>& apexChunkFlags)
-{
-	ApexImporterConfig configDesc;
-	configDesc.setDefaults();
-	return importApexAsset(chunkReorderInvMap, apexAsset, chunkDescriptors, bondDescriptors, apexChunkFlags, configDesc);
-}
-
-
-bool ApexImportTool::importApexAsset(std::vector<uint32_t>& chunkReorderInvMap, const nvidia::apex::DestructibleAsset* apexAsset,
-	std::vector<NvBlastChunkDesc>& chunkDescriptors, std::vector<NvBlastBondDesc>& bondDescriptors, std::vector<uint32_t>& apexChunkFlags, const ApexImporterConfig& configDesc)
-{
-	return importApexAssetInternal(chunkReorderInvMap, apexAsset, chunkDescriptors, bondDescriptors, apexChunkFlags, configDesc);
-}
-
-
-bool ApexImportTool::importApexAssetInternal(std::vector<uint32_t>& chunkReorderInvMap, const nvidia::apex::DestructibleAsset* apexAsset,
-	std::vector<NvBlastChunkDesc>& chunkDescriptors, std::vector<NvBlastBondDesc>& bondsDescriptors, std::vector<uint32_t>& apexChunkFlags, const ApexImporterConfig& configDesc)
-{
-
-	if (!apexAsset)
-	{
-		if (m_log != NULL)
-		{
-			m_log(NvBlastMessage::Error, "Error: attempting to import NULL Apex asset.\n", __FILE__, __LINE__);
-		}
-		return false;
-	}
-	
-	// Build chunk descriptors for asset //
-	const uint32_t apexChunkCount = apexAsset->getChunkCount();
-	chunkDescriptors.clear();
-	chunkDescriptors.resize(apexChunkCount);
-	uint32_t rootChunkIndex = 0;
-
-	for (uint32_t i = 0; i < apexChunkCount; ++i)
-	{
-		// Use bounds center for centroid
-		const PxBounds3 bounds = apexAsset->getChunkActorLocalBounds(i);
-		const PxVec3 center = bounds.getCenter();
-		memcpy(chunkDescriptors[i].centroid, &center.x, 3 * sizeof(float));
-
-		// Find chunk volume
-		uint32_t partIndex = apexAsset->getPartIndex(i);
-		uint32_t partConvexHullCount = apexAsset->getPartConvexHullCount(partIndex);
-		NvParameterized::Interface** cxInterfaceArray = apexAsset->getPartConvexHullArray(partIndex);
-		chunkDescriptors[i].volume = 0.0f;
-		for (uint32_t hull = 0; hull < partConvexHullCount; ++hull)
-		{
-			NvParameterized::Handle paramHandle(cxInterfaceArray[hull]);
-			float hullVolume;
-			paramHandle.getParameter("volume");
-			paramHandle.getParamF32(hullVolume);
-			chunkDescriptors[i].volume += hullVolume;
-		}
-
-		int32_t parent = apexAsset->getChunkParentIndex(i);
-		if (parent == -1)
-		{
-			rootChunkIndex = i;
-			chunkDescriptors[i].parentChunkIndex = UINT32_MAX;
-		}
-		else
-		{
-			chunkDescriptors[i].parentChunkIndex = parent;
-		}
-
-		chunkDescriptors[i].flags = 0;
-		chunkDescriptors[i].userData = i;
-	}
-	// Get support graph data from Apex asset //
-
-	const NvParameterized::Interface* assetParameterized = apexAsset->getAssetNvParameterized();
-	uint32_t maximumSupportDepth = 0;
-
-	NvParameterized::Handle parameterHandle(*assetParameterized);
-	parameterHandle.getParameter("supportDepth");
-	parameterHandle.getParamU32(maximumSupportDepth);
-	std::vector<std::pair<uint32_t, uint32_t> > overlapsBuffer;
-	uint32_t overlapsCount = apexAsset->getCachedOverlapCountAtDepth(maximumSupportDepth);
-	if (overlapsCount != 0)
-	{
-		const IntPair* overlap = reinterpret_cast<const IntPair*>(apexAsset->getCachedOverlapsAtDepth(maximumSupportDepth));
-		for (uint32_t i = 0; i < overlapsCount; ++i)
-		{
-			chunkDescriptors[overlap[i].i0].flags = NvBlastChunkDesc::SupportFlag;
-			chunkDescriptors[overlap[i].i1].flags = NvBlastChunkDesc::SupportFlag;
-			overlapsBuffer.push_back(std::make_pair(overlap[i].i0, overlap[i].i1));
-		}
-	}
-
-	// Format all connections as (chunk with lower index) -> (chunk with higher index) // 
-
-	for (uint32_t i = 0; i < overlapsBuffer.size(); ++i)
-	{
-		if (overlapsBuffer[i].first > overlapsBuffer[i].second)
-		{
-			std::swap(overlapsBuffer[i].first, overlapsBuffer[i].second);
-		}
-	}
-
-	// Unique all connections //
-	std::sort(overlapsBuffer.begin(), overlapsBuffer.end());
-	overlapsBuffer.resize(std::unique(overlapsBuffer.begin(), overlapsBuffer.end()) - overlapsBuffer.begin());
-
-	// Build bond descriptors (acquire area, normal, centroid)
-	bondsDescriptors.clear();
-	bondsDescriptors.resize(overlapsBuffer.size());
-
-	Nv::Blast::BlastBondGenerator bondGenTool(GetApexSDK()->getCookingInterface(), &GetApexSDK()->getPhysXSDK()->getPhysicsInsertionCallback());
-	std::vector<std::vector<Nv::Blast::Triangle> > chunkTriangles;
-	
-	PxBounds3 bnds = apexAsset->getRenderMeshAsset()->getBounds();
-	PxVec3 offset = bnds.getCenter();
-	float scale = 1.0f / PxMax(PxAbs(bnds.getExtents(0)), PxMax(PxAbs(bnds.getExtents(1)), PxAbs(bnds.getExtents(2))));
-
-	bnds = gatherChunkTriangles(apexAsset, chunkTriangles, 0, scale, offset);
-
-
-	BondGenerationConfig cf;
-	cf.bondMode = BondGenerationConfig::AVERAGE;
-	if (configDesc.infSearchMode == configDesc.EXACT)
-	{
-		cf.bondMode = BondGenerationConfig::EXACT;
-	}
-
-	bondGenTool.createBondBetweenMeshes(chunkTriangles, bondsDescriptors, overlapsBuffer, cf);
-	
-
-
-	float inverScale = 1.0f / scale;
-
-	for (uint32_t i = 0; i < bondsDescriptors.size(); ++i)
-	{
-		bondsDescriptors[i].bond.area *= inverScale * inverScale;
-		bondsDescriptors[i].bond.centroid[0] *= inverScale;
-		bondsDescriptors[i].bond.centroid[1] *= inverScale;
-		bondsDescriptors[i].bond.centroid[2] *= inverScale;
-
-		bondsDescriptors[i].bond.centroid[0] += offset.x;
-		bondsDescriptors[i].bond.centroid[1] += offset.y;
-		bondsDescriptors[i].bond.centroid[2] += offset.z;
-
-	}
-	
-	/// Delete all bonds with zero area ///
-	for (uint32_t i = 0; i < bondsDescriptors.size(); ++i)
-	{
-		if (bondsDescriptors[i].bond.area == 0)
-		{
-			bondsDescriptors[i].chunkIndices[0] = bondsDescriptors.back().chunkIndices[0];
-			bondsDescriptors[i].chunkIndices[1] = bondsDescriptors.back().chunkIndices[1];
-			bondsDescriptors[i].bond = bondsDescriptors.back().bond;
-			bondsDescriptors.pop_back();
-			--i;
-		}
-	}
-
-
-
-	apexChunkFlags.clear();
-	apexChunkFlags.resize(chunkDescriptors.size());
-	// special 'earth chunk'
-	{
-		uint32_t earthChunkIndex = (uint32_t)chunkDescriptors.size();
-		NvBlastChunkDesc earthChunk;
-		memset(earthChunk.centroid, 0, 3 * sizeof(float));
-		earthChunk.volume = 0.0f;
-		earthChunk.parentChunkIndex = rootChunkIndex;
-		earthChunk.flags = NvBlastChunkDesc::SupportFlag;
-		earthChunk.userData = earthChunkIndex;
-		uint32_t chunksConnectedToEarth = 0;
-		for (uint32_t i = 0; i < chunkDescriptors.size(); i++)
-		{
-			uint32_t chunkID = i;
-			const NvParameterized::Interface* assetInterface = apexAsset->getAssetNvParameterized();
-			NvParameterized::Handle chunksHandle(*assetInterface, "chunks");
-			chunksHandle.set(chunkID);
-			NvParameterized::Handle flagsHandle(*assetInterface);
-			chunksHandle.getChildHandle(assetInterface, "flags", flagsHandle);
-			uint32_t flags;
-			flagsHandle.getParamU32(flags);
-
-			apexChunkFlags[chunkID] = flags;
-
-			// world support flag
-			if (flags & (1 << 0))
-			{
-				NvBlastBondDesc bond;
-				bond.chunkIndices[0] = i;
-				bond.chunkIndices[1] = earthChunkIndex;
-				bond.bond.area = 0.1f; // ???
-				PxVec3 center = apexAsset->getChunkActorLocalBounds(chunkID).getCenter();
-				memcpy(&bond.bond.centroid, &center.x, sizeof(PxVec3));
-				PxVec3 normal = PxVec3(0, 0, 1);
-				memcpy(&bond.bond.normal, &normal.x, sizeof(PxVec3));
-				bondsDescriptors.push_back(bond);
-				chunksConnectedToEarth++;
-			}
-		}
-		if (chunksConnectedToEarth > 0)
-		{
-			chunkDescriptors.push_back(earthChunk);
-		}
-	}
-
-	const uint32_t chunkCount = static_cast<uint32_t>(chunkDescriptors.size());
-	const uint32_t bondCount = static_cast<uint32_t>(bondsDescriptors.size());
-	std::vector<uint32_t> chunkReorderMap(chunkCount);
-	std::vector<NvBlastChunkDesc> scratch(chunkCount);
-	NvBlastEnsureAssetExactSupportCoverage(chunkDescriptors.data(), chunkCount, scratch.data(), m_log);
-	NvBlastBuildAssetDescChunkReorderMap(chunkReorderMap.data(), chunkDescriptors.data(), chunkCount, scratch.data(), m_log);
-	NvBlastApplyAssetDescChunkReorderMapInplace(chunkDescriptors.data(), chunkCount, bondsDescriptors.data(), bondCount, chunkReorderMap.data(), scratch.data(), m_log);
-	chunkReorderInvMap.resize(chunkReorderMap.size());
-	Nv::Blast::invertMap(chunkReorderInvMap.data(), chunkReorderMap.data(), static_cast<uint32_t>(chunkReorderMap.size()));
-	return true;
-}
-
-
-bool ApexImportTool::saveAsset(const NvBlastAsset* asset, PxFileBuf* stream)
-{
-	if (!asset)
-	{
-		if (m_log != NULL)
-		{
-			m_log(NvBlastMessage::Error, "Error: attempting to serialize NULL asset.\n", __FILE__, __LINE__);
-		}
-		return false;
-	}
-	if (!stream)
-	{
-		if (m_log != NULL)
-		{
-			m_log(NvBlastMessage::Error, "Error: bad output stream.\n", __FILE__, __LINE__);
-		}
-		return false;
-	}
-	const void* assetData = asset;
-	uint32_t assetDataSize = NvBlastAssetGetSize(asset, m_log);
-	stream->write(assetData, assetDataSize);
-	stream->close();
-	if (m_log != NULL)
-	{
-		m_log(NvBlastMessage::Info, "Saving finished... \n", __FILE__, __LINE__);
-	}
-	return true;
-}
-
-
-ApexImportTool::~ApexImportTool()
-{
-	delete m_apexDestruction;
-}
-
-} // namespace ApexImporter
-
-} // namespace Blast
-} // namespace Nv
diff --git a/NvBlast/sdk/extensions/import/source/NvBlastExtScopedResource.cpp b/NvBlast/sdk/extensions/import/source/NvBlastExtScopedResource.cpp
deleted file mode 100644
index 7cf7492..0000000
--- a/NvBlast/sdk/extensions/import/source/NvBlastExtScopedResource.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastExtScopedResource.h"
-
-#include <ApexSDK.h>
-#include <RenderMeshAsset.h>
-#include <DestructibleAsset.h>
-#include <ModuleDestructible.h>
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-namespace ApexImporter
-{
-
-void ApexReleaser::release(nvidia::apex::RenderMeshAssetAuthoring& a)
-{
-	if (mApex)
-		mApex->releaseAssetAuthoring(a);
-}
-
-
-void ApexReleaser::release(nvidia::apex::DestructibleAssetAuthoring& a)
-{
-	if (mApex)
-		mApex->releaseAssetAuthoring(a);
-}
-
-
-void ApexReleaser::release(nvidia::apex::ModuleDestructible& a)
-{
-	if (mApex)
-		mApex->releaseModule(&a);
-}
-
-} // namespace ApexImporter
-
-} // namespace Blast
-} // namespace Nv
diff --git a/NvBlast/sdk/extensions/import/source/NvBlastExtScopedResource.h b/NvBlast/sdk/extensions/import/source/NvBlastExtScopedResource.h
deleted file mode 100644
index e0d35b7..0000000
--- a/NvBlast/sdk/extensions/import/source/NvBlastExtScopedResource.h
+++ /dev/null
@@ -1,160 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTSCOPEDRESOURCE_H
-#define NVBLASTEXTSCOPEDRESOURCE_H
-
-#include <PxAssert.h>
-
-
-#pragma warning(push)
-#pragma warning(disable:4512)
-
-namespace nvidia
-{
-namespace apex
-{
-class ApexSDK;
-class Asset;
-class DestructibleAsset;
-class AssetAuthoring;
-class ModuleDestructible;
-class RenderMeshAssetAuthoring;
-class DestructibleAssetAuthoring;
-}
-}
-
-namespace Nv
-{
-namespace Blast
-{
-
-namespace ApexImporter
-{
-
-template <class T>
-class DefaultReleaser
-{
-public:
-	DefaultReleaser() { }
-	PX_INLINE void release(T& t) { t.release(); }
-};
-
-class ApexReleaser
-{
-public:
-	ApexReleaser() : mApex(nullptr) { }
-	ApexReleaser(nvidia::apex::ApexSDK& apex) : mApex(&apex) { }
-
-	void	release(nvidia::apex::RenderMeshAssetAuthoring&);
-	void	release(nvidia::apex::DestructibleAssetAuthoring&);
-	void	release(nvidia::apex::ModuleDestructible&);
-
-protected:
-	bool					mbValid;
-	nvidia::apex::ApexSDK*	mApex;
-};
-
-template< class Releasable, class Releaser = DefaultReleaser<Releasable> >
-class ScopedResource
-{
-public:
-	ScopedResource()
-		: mpReleasable(nullptr), mIsReleasable(true){}
-
-	ScopedResource(Releasable* pReleasable, const Releaser& releaser)
-		: mpReleasable(pReleasable),
-		mReleaser(releaser), mIsReleasable(true) { }
-
-	ScopedResource(Releasable* pReleasable, bool isReleasable = true)
-		: mpReleasable(pReleasable), mIsReleasable(isReleasable) { }
-
-	~ScopedResource()
-	{
-		destroy();
-	}
-
-	PX_INLINE operator bool() const
-	{
-		return (nullptr != mpReleasable);
-	}
-
-	PX_INLINE Releasable* get() const
-	{
-		return mpReleasable;
-	}
-
-	PX_INLINE Releasable* release()
-	{
-		Releasable* pReleasable = mpReleasable;
-		mpReleasable = nullptr;
-		return pReleasable;
-	}
-
-	PX_INLINE Releasable& operator* () const
-	{
-		PX_ASSERT(*this);
-		return *mpReleasable;
-	}
-
-	PX_INLINE Releasable* operator-> () const
-	{
-		return mpReleasable;
-	}
-
-	PX_INLINE bool operator==(const ScopedResource& b) const
-	{
-		return mpReleasable == b.mpReleasable;
-	}
-
-	PX_INLINE bool operator!=(const ScopedResource& b) const
-	{
-		return !(*this == b);
-	}
-
-	PX_INLINE void reset(Releasable* pReleasable, bool isReleasable = true)
-	{
-		if (mpReleasable == pReleasable) return;
-		destroy();
-		mpReleasable = pReleasable;
-		mIsReleasable = isReleasable;
-	}
-
-	PX_INLINE void reset(Releasable* pReleasable, const Releaser& releaser, bool isReleasable = true)
-	{
-		reset(pReleasable);
-		mReleaser = releaser;
-		mIsReleasable = isReleasable;
-	}
-
-private:
-
-	void destroy()
-	{
-		if (*this && mIsReleasable)
-			mReleaser.release(*mpReleasable);
-	}
-
-	ScopedResource(const ScopedResource&);
-	ScopedResource& operator=(const ScopedResource&);
-
-	Releasable*	mpReleasable;
-	Releaser	mReleaser;
-	bool		mIsReleasable;
-};
-
-} // namespace ApexImporter
-
-} // namespace Blast
-} // namespace Nv
-
-#pragma warning(pop)
-
-#endif // NVBLASTEXTSCOPEDRESOURCE_H
diff --git a/NvBlast/sdk/extensions/physx/include/NvBlastExtImpactDamageManager.h b/NvBlast/sdk/extensions/physx/include/NvBlastExtImpactDamageManager.h
deleted file mode 100644
index ac3576d..0000000
--- a/NvBlast/sdk/extensions/physx/include/NvBlastExtImpactDamageManager.h
+++ /dev/null
@@ -1,142 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTIMPACTDAMAGEMANAGER_H
-#define NVBLASTEXTIMPACTDAMAGEMANAGER_H
-
-#include "PxFiltering.h"
-#include "NvPreprocessor.h"
-
-// Forward declarations
-namespace physx
-{
-struct PxContactPair;
-struct PxContactPairHeader;
-}
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-// Forward declarations
-class ExtPxActor;
-class ExtPxManager;
-
-
-/**
-Custom Damage Function
-*/
-typedef bool(*ExtImpactDamageFunction)(void* data, ExtPxActor* actor, physx::PxShape* shape, physx::PxVec3 worldPos, physx::PxVec3 worldForce);
-
-
-/**
-Impact Damage Manager Settings.
-*/
-struct ExtImpactSettings
-{
-	bool					isSelfCollissionEnabled;	//!<	family's self collision enabled
-	float					fragility;					//!<	global fragility factor
-	ExtImpactDamageFunction damageFunction;				//!<	custom damage function, can be nullptr, default internal one will be used in that case.
-	void*					damageFunctionData;			//!<	data to be passed in custom damage function
-
-
-	ExtImpactSettings() :
-		isSelfCollissionEnabled(false),
-		fragility(1.0f),
-		damageFunction(nullptr)
-	{}
-};
-
-
-/**
-Impact Damage Manager.
-
-Requires ExtPxManager.
-Call onContact from PxSimulationEventCallback onContact to accumulate damage.
-Call applyDamage to apply accumulated damage.
-*/
-class NV_DLL_EXPORT ExtImpactDamageManager
-{
-public:
-	//////// manager creation ////////
-
-	/**
-	Create a new ExtImpactDamageManager.
-
-	\param[in]	pxManager	The ExtPxManager instance to be used by impact damage manager.
-	\param[in]	settings		The settings to be set on ExtImpactDamageManager.
-
-	\return the new ExtImpactDamageManager if successful, NULL otherwise.
-	*/
-	static ExtImpactDamageManager*	create(ExtPxManager* pxManager, ExtImpactSettings settings = ExtImpactSettings());
-
-	/**
-	Release this manager.
-	*/
-	virtual void					release() = 0;
-
-
-	//////// interface ////////
-
-	/**
-	Set ExtImpactDamageManager settings.
-
-	\param[in]	settings		The settings to be set on ExtImpactDamageManager.
-	*/
-	virtual void					setSettings(const ExtImpactSettings& settings) = 0;
-
-	/**
-	This method is equal to PxSimulationEventCallback::onContact.
-
-	User should implement own PxSimulationEventCallback onContact and call this method in order ExtImpactDamageManager to work correctly.
-	
-	Contacts will be processed and impact damage will be accumulated.
-
-	\param[in] pairHeader Information on the two actors whose shapes triggered a contact report.
-	\param[in] pairs The contact pairs of two actors for which contact reports have been requested. @see PxContactPair.
-	\param[in] nbPairs The number of provided contact pairs.
-
-	@see PxSimulationEventCallback
-	*/
-	virtual void					onContact(const physx::PxContactPairHeader& pairHeader, const physx::PxContactPair* pairs, uint32_t nbPairs) = 0;
-
-
-	/**
-	Apply accumulated impact damage.
-	*/
-	virtual void					applyDamage() = 0;
-
-
-	//////// filter shader ////////
-
-	/**
-	Custom implementation of PxSimulationFilterShader, enables necessary information to be passed in onContact().
-	Set it in your PxScene PxSceneDesc in order to impact damage to work correctly or implement your own.
-
-	@see PxSimulationFilterShader
-	*/
-	static physx::PxFilterFlags		FilterShader(
-		physx::PxFilterObjectAttributes attributes0,
-		physx::PxFilterData filterData0,
-		physx::PxFilterObjectAttributes attributes1,
-		physx::PxFilterData filterData1,
-		physx::PxPairFlags& pairFlags,
-		const void* constantBlock,
-		uint32_t constantBlockSize);
-
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTEXTIMPACTDAMAGEMANAGER_H
diff --git a/NvBlast/sdk/extensions/physx/include/NvBlastExtPx.h b/NvBlast/sdk/extensions/physx/include/NvBlastExtPx.h
deleted file mode 100644
index b2d938b..0000000
--- a/NvBlast/sdk/extensions/physx/include/NvBlastExtPx.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTPX_H
-#define NVBLASTEXTPX_H
-
-
-/**
-This is the main include header for the BlastExt Physics, for users who
-want to use a single #include file.
-
-Alternatively, one can instead directly #include a subset of the below files.
-*/
-
-#include "NvBlastExtPxActor.h"
-#include "NvBlastExtPxAsset.h"
-#include "NvBlastExtPxFamily.h"
-#include "NvBlastExtPxListener.h"
-#include "NvBlastExtPxManager.h"
-
-
-#endif // ifndef NVBLASTEXTPX_H
diff --git a/NvBlast/sdk/extensions/physx/include/NvBlastExtPxActor.h b/NvBlast/sdk/extensions/physx/include/NvBlastExtPxActor.h
deleted file mode 100644
index 994ace7..0000000
--- a/NvBlast/sdk/extensions/physx/include/NvBlastExtPxActor.h
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTPXACTOR_H
-#define NVBLASTEXTPXACTOR_H
-
-#include "NvBlastTypes.h"
-
-
-// Forward declarations
-namespace physx
-{
-	class PxRigidDynamic;
-}
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-// Forward declarations
-class ExtPxFamily;
-class TkActor;
-
-
-/**
-Actor.
-
-Corresponds one to one to PxRigidDynamic and ExtActor.
-*/
-class ExtPxActor
-{
-public:
-	/**
-	Get the number of visible chunks for this actor.  May be used in conjunction with getChunkIndices().
-
-	\return	the number of visible chunk indices for the actor.
-	*/
-	virtual uint32_t				getChunkCount() const = 0;
-
-	/**
-	Access actor's array of chunk indices. Use getChunkCount() to get a size of this array.
-
-	\return	a pointer to an array of chunk indices of an actor.
-	*/
-	virtual const uint32_t*			getChunkIndices() const = 0;
-
-	/**
-	Every actor has corresponding PxActor.
-
-	/return a pointer to PxRigidDynamic actor.
-	*/
-	virtual physx::PxRigidDynamic&	getPhysXActor() const = 0;
-
-	/**
-	Every actor has corresponding TkActor.
-
-	/return a pointer to TkActor actor.
-	*/
-	virtual TkActor&				getTkActor() const = 0;
-
-	/**
-	Every actor has corresponding ExtPxFamily.
-
-	/return a pointer to ExtPxFamily family.
-	*/
-	virtual ExtPxFamily&			getFamily() const = 0;
-};
-
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTEXTPXACTOR_H
diff --git a/NvBlast/sdk/extensions/physx/include/NvBlastExtPxAsset.h b/NvBlast/sdk/extensions/physx/include/NvBlastExtPxAsset.h
deleted file mode 100644
index a4dbe0e..0000000
--- a/NvBlast/sdk/extensions/physx/include/NvBlastExtPxAsset.h
+++ /dev/null
@@ -1,201 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTPXASSET_H
-#define NVBLASTEXTPXASSET_H
-
-#include "NvBlastTkFramework.h"
-#include "PxConvexMeshGeometry.h"
-#include "PxTransform.h"
-#include "NvBlastPreprocessor.h"
-
-
-// Forward declarations
-namespace physx
-{
-class PxCooking;
-
-namespace general_PxIOStream2
-{
-class PxFileBuf;
-}
-}
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-
-/**
-Descriptor for PxAsset creation.
-
-PxAsset creates TkAsset internally, so TkAssetDesc must be filled.
-In addition it needs physics chunks data. Every chunk can have any amount of Convexes (Subchunks).
-*/
-struct ExtPxAssetDesc : public TkAssetDesc
-{
-	/**
-	Physics Subchunk.
-
-	Represents convex and it's position.
-	*/
-	struct SubchunkDesc
-	{
-		physx::PxTransform			transform;			//!<	convex local transform
-		physx::PxConvexMeshGeometry	geometry;			//!<	convex geometry
-	};
-
-	/**
-	Physics Chunk.
-
-	Contains any amount of subchunks. Empty subchunks array makes chunk invisible.
-	*/
-	struct ChunkDesc
-	{
-		SubchunkDesc*	subchunks;			//!< array of subchunks for chunk, can be empty
-		uint32_t		subchunkCount;		//!< size array of subchunks for chunk, can be 0
-		bool			isStatic;			//!< is chunk static. Static chunk makes PxActor Kinematic.
-	};
-
-	ChunkDesc*	pxChunks;		//!< array of chunks in asset, should be of size chunkCount (@see NvBlastAssetDesc)
-};
-
-
-/**
-Physics Subchunk. 
-
-Represents convex and it's local position.
-*/
-struct ExtPxSubchunk
-{
-	physx::PxTransform			transform;			//!<	convex local transform
-	physx::PxConvexMeshGeometry	geometry;			//!<	convex geometry
-};
-
-
-/**
-Physics Chunk.
-
-Contains any amount of subchunks.
-*/
-struct ExtPxChunk
-{
-	uint32_t	firstSubchunkIndex;	//!<	first Subchunk index in Subchunk's array in ExtPhyicsAsset
-	uint32_t	subchunkCount;		//!<	Subchunk count. Can be 0.
-	bool		isStatic;			//!<	is chunk static (kinematic)?.
-};
-
-
-/**
-Asset.
-
-Keeps all the static data needed for physics.
-*/
-class NV_DLL_EXPORT ExtPxAsset
-{
-public:
-
-	/**
-	Create a new ExtPxAsset.
-
-	\param[in]	desc			The ExtPxAssetDesc descriptor to be used, @see ExtPxAssetDesc.
-	\param[in]	framework		The TkFramework instance to be used to create TkAsset.
-
-	\return the new ExtPxAsset if successful, NULL otherwise.
-	*/
-	static ExtPxAsset*				create(const ExtPxAssetDesc& desc, TkFramework& framework);
-
-
-	/*
-		Factory method for deserialization
-
-		Doesn't specify chunks or subchunks as they'll be fed in during deserialization to avoid copying stuff around.
-	
-	*/
-	static ExtPxAsset*				create(TkAsset* asset);
-
-
-	/**
-	Deserialize an ExtPxAsset object from the given stream.
-
-	\param[in]	stream			User-defined stream object.
-	\param[in]	framework		The TkFramework instance to be used to deserialize TkAsset.
-	\param[in]	physics			The PxPhysics instance to be to deserialize PxConvexMesh(s).
-
-	\return pointer the deserialized ExtPxAsset object if successful, or NULL if unsuccessful.
-	*/
-	static ExtPxAsset*				deserialize(physx::general_PxIOStream2::PxFileBuf& stream, TkFramework& framework, physx::PxPhysics& physics);
-
-	/**
-	Release this ExtPxAsset.
-	*/
-	virtual void					release() = 0;
-
-	/**
-	Write the asset's data to the user-defined PxFileBuf stream. Underlying TkAsset would be also serialized.
-
-	\param[in]	stream			User-defined stream object.
-	\param[in]	cooking			The PxCooking instance to be used to serialize PxConvexMesh(s).
-
-	\return true if serialization was successful, false otherwise.
-	*/
-	virtual bool					serialize(physx::general_PxIOStream2::PxFileBuf& stream, physx::PxCooking& cooking) const = 0;
-	
-	/**
-	Every ExtPxAsset has corresponding TkAsset.
-
-	/return a pointer to TkAsset actor.
-	*/
-	virtual const TkAsset&			getTkAsset() const = 0;
-
-	/**
-	Get the number of chunks for this asset.  May be used in conjunction with getChunks().
-
-	\return	the number of chunks for the asset.
-	*/
-	virtual uint32_t				getChunkCount() const = 0;
-
-	/**
-	Access asset's array of chunks. Use getChunkCount() to get the size of this array.
-
-	\return	a pointer to an array of chunk of an asset.
-	*/
-	virtual const ExtPxChunk*		getChunks() const = 0;
-	
-	/**
-	Get the number of subchunks for this asset.  May be used in conjunction with getSubchunks().
-	Subchunk count is the maximum value of ExtPxChunk: (firstSubchunkIndex + subchunkCount).
-
-	\return	the number of subchunks for the asset.
-	*/
-	virtual uint32_t				getSubchunkCount() const = 0;
-	
-	/**
-	Access asset's array of subchunks. Use getSubchunkCount() to get the size of this array.
-
-	\return	a pointer to an array of subchunks of an asset.
-	*/
-	virtual const ExtPxSubchunk*	getSubchunks() const = 0;
-
-	/**
-	Pointer field available to the user.
-	*/
-	void*	userData;
-};
-
-
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTEXTPXASSET_H
diff --git a/NvBlast/sdk/extensions/physx/include/NvBlastExtPxFamily.h b/NvBlast/sdk/extensions/physx/include/NvBlastExtPxFamily.h
deleted file mode 100644
index 7805c15..0000000
--- a/NvBlast/sdk/extensions/physx/include/NvBlastExtPxFamily.h
+++ /dev/null
@@ -1,223 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTPXFAMILY_H
-#define NVBLASTEXTPXFAMILY_H
-
-#include "PxFiltering.h"
-
-
-// Forward declarations
-namespace physx
-{
-class PxRigidDynamic;
-class PxMaterial;
-class PxScene;
-class PxTransform;
-}
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-// Forward declarations
-class ExtPxActor;
-class ExtPxAsset;
-class ExtPxListener;
-class TkFamily;
-
-
-/**
-PxShape Desc.
-
-Used to set settings for newly created PxShapes.
-
-@see PxShape
-*/
-struct ExtPxShapeDescTemplate
-{
-	uint8_t				flags;					//!<	PxShapeFlags flags
-	physx::PxFilterData	simulationFilterData;	//!<	user definable collision filter data
-	physx::PxFilterData	queryFilterData;		//!<	user definable query filter data.
-	float				contactOffset;			//!<	contact offset
-	float				restOffset;				//!<	rest offset
-};
-
-
-/**
-PxActor Desc.
-
-Used to set settings for newly created PxActors.
-*/
-struct ExtPxActorDescTemplate
-{
-	uint8_t				flags;						//!<	actor flags
-};
-
-
-/**
-Physics Spawn Settings.
-
-This Struct unifies setting to be used when PhysX actors are created.
-*/
-struct ExtPxSpawnSettings
-{
-	physx::PxScene*		scene;			//!< PxScene for PxActors to be spawned
-	physx::PxMaterial*	material;		//!< default PxMaterial
-	float				density;		//!< default density for PhysX
-};
-
-
-/**
-PxFamily.
-
-A collection of actors. Maps 1 to 1 with TkFamily.
-*/
-class ExtPxFamily
-{
-public:
-	/**
-	Spawn ExtPxFamily. Can be called only once. Actual PhysX actors will created and placed in PxScene
-
-	\param[in]	pose			World transform.
-	\param[in]  scale			Scale applied to spawned actors.
-	\param[in]	settings		Spawn settings.
-
-	\return true if spawn was successful, false otherwise.
-	*/
-	virtual bool							spawn(const physx::PxTransform& pose, const physx::PxVec3& scale, const ExtPxSpawnSettings& settings) = 0;
-
-	
-	/**
-	Despawn this ExtPxFamily. This removes the PhysX actors from PxScene and deletes them, as well as
-	deleting the created ExtPxActors
-
-	This does not call release() on the family.
-
-	\returns true if successful.
-	*/
-	virtual bool							despawn() = 0;
-
-
-	/**
-	The number of actors currently in this family.
-
-	\return the number of ExtPxActor that currently exist in this family.
-	*/
-	virtual uint32_t						getActorCount() const = 0;
-
-	/**
-	Retrieve an array of pointers (into the user-supplied buffer) to actors.
-
-	\param[out]	buffer			A user-supplied array of ExtPxActor pointers.
-	\param[in]	bufferSize		The number of elements available to write into buffer.
-
-	\return the number of ExtPxActor pointers written to the buffer.
-	*/
-	virtual uint32_t						getActors(ExtPxActor** buffer, uint32_t bufferSize) const = 0;
-
-	/**
-	Every family has corresponding TkFamily.
-
-	/return a pointer to TkFamily actor.
-	*/
-	virtual TkFamily&						getTkFamily() const = 0;
-
-	/**
-	Access an array of shapes of subchunks. The size of array is equal getPxAsset()->getSubchunkCount().
-	For every corresponding subchunk it contains pointer to created PxShape or nullptr.
-
-	\return	the pointer to subchunk shapes array.
-	*/
-	virtual const physx::PxShape* const*	getSubchunkShapes() const = 0;
-
-	/**
-	Every family has an associated asset.
-
-	\return a pointer to the (const) ExtPxAsset object.
-	*/
-	virtual const ExtPxAsset&				getPxAsset() const = 0;
-
-	/**
-	Set the default material to be used for PxRigidDynamic creation.
-
-	\param[in] material			The material to be the new default.
-	*/
-	virtual void							setMaterial(physx::PxMaterial& material) = 0;
-
-	/*
-	Set ExtPxPxShapeDesc to be used on all newly created PxShapes.
-
-	NOTE: Using it will override marking LEAF_CHUNK in simulationFilterData.word3 now.
-
-	\param[in] pxShapeDesc		The PxShape desc to be the new default. Can be nullptr.
-	*/
-	virtual void							setPxShapeDescTemplate(const ExtPxShapeDescTemplate* pxShapeDesc) = 0;
-
-	/**
-	Get the default ExtPxPxShapeDesc to be used on all newly created PxShapes.
-
-	\return a pointer to the default PxShape desc. Can be nullptr.
-	*/
-	virtual const ExtPxShapeDescTemplate*	getPxShapeDescTemplate() const = 0;
-
-	/*
-	Set ExtPxPxActorDesc to be used on all newly created PxActors.
-	
-	\param[in] pxActorDesc		The PxActor desc to be the new default. Can be nullptr.
-	*/
-	virtual void							setPxActorDesc(const ExtPxActorDescTemplate* pxActorDesc) = 0;
-
-	/**
-	Get the default ExtPxPxActorDesc to be used on all newly created PxActors.
-
-	\return a pointer to the default PxActor desc. Can be nullptr.
-	*/
-	virtual const ExtPxActorDescTemplate*	getPxActorDesc() const = 0;
-
-	/**
-	Add a user implementation of ExtPxListener to this family's list of listeners.  
-
-	\param[in]	listener		The event listener to add.
-	*/
-	virtual void							subscribe(ExtPxListener& listener) = 0;
-
-	/**
-	Remove a user implementation of ExtPxListener from this family's list of listeners.
-
-	\param[in]	listener		The event listener to remove.
-	*/
-	virtual void							unsubscribe(ExtPxListener& listener) = 0;
-
-	/**
-	Call after split.
-	*/
-	virtual void							postSplitUpdate() = 0;
-
-	/**
-	Release this family.
-	*/
-	virtual void							release() = 0;
-
-	/**
-	UserData pointer. Free to be used by user in any way.
-	*/
-	void* userData;
-};
-
-
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTEXTPXFAMILY_H
diff --git a/NvBlast/sdk/extensions/physx/include/NvBlastExtPxListener.h b/NvBlast/sdk/extensions/physx/include/NvBlastExtPxListener.h
deleted file mode 100644
index 4c43283..0000000
--- a/NvBlast/sdk/extensions/physx/include/NvBlastExtPxListener.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTPXLISTENER_H
-#define NVBLASTEXTPXLISTENER_H
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-// Forward declarations
-class ExtPxFamily;
-class ExtPxActor;
-
-
-/**
-Physics Listener Interface.
-
-Actor create/destroy events listener.
-*/
-class ExtPxListener
-{
-public:
-	/**
-	Interface to be implemented by the user. Will be called when ExtPxFamily creates new actor.
-
-	\param[in]	family	Corresponding ExtPxFamily with new actor.
-	\param[in]	actor	The new actor.
-	*/
-	virtual void	onActorCreated(ExtPxFamily& family, ExtPxActor& actor) = 0;
-
-	/**
-	Interface to be implemented by the user. Will be called when ExtPxFamily destroy an actor.
-
-	\param[in]	family	Corresponding ExtPxFamily.
-	\param[in]	actor	The actor to be destroyed.
-	*/
-	virtual void	onActorDestroyed(ExtPxFamily& family, ExtPxActor& actor) = 0;
-};
-
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTEXTPXLISTENER_H
diff --git a/NvBlast/sdk/extensions/physx/include/NvBlastExtPxManager.h b/NvBlast/sdk/extensions/physx/include/NvBlastExtPxManager.h
deleted file mode 100644
index 9d73898..0000000
--- a/NvBlast/sdk/extensions/physx/include/NvBlastExtPxManager.h
+++ /dev/null
@@ -1,245 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTPXMANAGER_H
-#define NVBLASTEXTPXMANAGER_H
-
-#include "NvBlastTypes.h"
-#include "PxConvexMeshGeometry.h"
-#include "PxTransform.h"
-#include "NvPreprocessor.h"
-
-
-// Forward declarations
-namespace physx
-{
-class PxPhysics;
-class PxRigidDynamic;
-class PxJoint;
-
-namespace general_PxIOStream2
-{
-class PxFileBuf;
-}
-}
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-// Forward declarations
-class ExtPxActor;
-class ExtPxAsset;
-class ExtPxFamily;
-class ExtPxListener;
-class TkFamily;
-class TkFramework;
-class TkGroup;
-class TkJoint;
-
-
-/**
-Family Desc.
-
-Used to create Physics Family.
-*/
-struct ExtPxFamilyDesc
-{
-	const ExtPxAsset*	pxAsset;		//!< px asset to create from, pointer will be stored in family.
-	NvBlastActorDesc	actorDesc;		//!< actor descriptor to be used when creating TkActor.
-	TkGroup*			group;			//!< if not nullptr, created TkActor will be placed in group
-};
-
-
-/**
-Function pointer for PxJoint creation.
-
-It will be called when new joints are being created. It should return valid PxJoint pointer or nullptr.
-*/
-typedef physx::PxJoint*(*ExtPxCreateJointFunction)(ExtPxActor* actor0, const physx::PxTransform& localFrame0, ExtPxActor* actor1, const physx::PxTransform& localFrame1, physx::PxPhysics& physics, TkJoint& joint);
-
-
-/**
-Physics Manager.
-
-Used to create and manage Physics Families.
-*/
-class NV_DLL_EXPORT ExtPxManager
-{
-public:
-	//////// manager creation ////////
-
-	/**
-	Create a new ExtPxManager.
-
-	\param[in]	physics			The PxPhysics instance to be used by ExtPxManager.
-	\param[in]	framework		The TkFramework instance to be used by ExtPxManager.
-	\param[in]	createFn		The function to be used when creating joints, can be nullptr.
-	\param[in]	useUserData		Flag if ExtPxManager is allowed to override PxActor's userData, it will store pointer to PxActor there.
-	It is recommended as fastest way. If set to 'false' HashMap will be used.
-
-	\return the new ExtPxManager if successful, NULL otherwise.
-	*/
-	static ExtPxManager*		create(physx::PxPhysics& physics, TkFramework& framework, ExtPxCreateJointFunction createFn = nullptr, bool useUserData = true);
-
-	/**
-	Release this manager.
-	*/
-	virtual void				release() = 0;
-
-
-	//////// impact ////////
-
-	/**
-	Simulation Filter data to be set on leaf chunk actors
-	*/
-	enum FilterDataAttributes
-	{
-		LEAF_CHUNK = 1,
-	};
-
-
-	//////// interface ////////
-
-	/**
-	Create a px family from the given descriptor.
-
-	\param[in]	desc			The family descriptor (see ExtPxFamilyDesc).
-
-	\return the created family, if the descriptor was valid and memory was available for the operation.  Otherwise, returns NULL.
-	*/
-	virtual ExtPxFamily*		createFamily(const ExtPxFamilyDesc& desc) = 0;
-
-	/**
-	Create a px joint associated with TkJoint.
-
-	ExtPxCreateJointFunction will be called after this call.
-	ExtPxCreateJointFunction must be set, nothing will happen otherwise.
-
-	\param[in]	joint			TkJoint to be used to create px joint.
-
-	\return true iff Joint was created.
-	*/
-	virtual bool				createJoint(TkJoint& joint) = 0;
-
-	/**
-	Destroy a px joint associated with TkJoint.
-
-	\param[in]	joint			TkJoint to be used to destroy px joint.
-	*/
-	virtual void				destroyJoint(TkJoint& joint) = 0;
-
-	/**
-	Set ExtPxCreateJointFunction to be used when new joints are being created.\
-
-	\param[in]	createFn		Create function pointer to set, can be nullptr.
-	*/
-	virtual void				setCreateJointFunction(ExtPxCreateJointFunction createFn) = 0;
-
-	/**
-	The number of families currently in this manager.
-
-	\return the number of ExtPxFamily that currently exist in this manger.
-	*/
-	virtual uint32_t			getFamilyCount() const = 0;
-
-	/**
-	Retrieve an array of pointers (into the user-supplied buffer) to families.
-
-	\param[out]	buffer			A user-supplied array of ExtPxFamily pointers.
-	\param[in]	bufferSize		The number of elements available to write into buffer.
-
-	\return the number of ExtPxFamily pointers written to the buffer.
-	*/
-	virtual uint32_t			getFamilies(ExtPxFamily** buffer, uint32_t bufferSize) const = 0;
-
-	/**
-	Look up an associated ExtPxFamily by TkFamily pointer.
-
-	\param[in]	family			The TkFamily pointer to look up.
-
-	\return pointer to the ExtPxFamily object if it exists, NULL otherwise.
-	*/
-	virtual ExtPxFamily*		getFamilyFromTkFamily(TkFamily& family) const = 0;
-
-	/**
-	Look up an associated ExtPxActor by PxRigidDynamic pointer.
-
-	\param[in]	pxActor			The PxRigidDynamic pointer to look up.
-
-	\return pointer to the ExtPxActor object if it exists, NULL otherwise.
-	*/
-	virtual ExtPxActor*			getActorFromPhysXActor(const physx::PxRigidDynamic& pxActor) const = 0;
-
-	/**
-	Get a PxPhysics object pointer used upon manager creation.
-
-	\return a pointer to the (const) PxPhysics object.
-	*/
-	virtual physx::PxPhysics&	getPhysics() const = 0;
-
-	/**
-	Get a TkFramework object pointer used upon manager creation.
-
-	\return a pointer to the TkFramework object.
-	*/
-	virtual TkFramework&		getFramework() const = 0;
-
-	/**
-	Get if useUserData was set upon manager creation.
-
-	\return true iff PxActor userData is used by manager.
-	*/
-	virtual bool				isPxUserDataUsed() const = 0;
-
-	/**
-	Limits the total number of actors that can exist at a given time.  A value of zero disables this (gives no limit).
-
-	\param[in]	limit			If not zero, the maximum number of actors that will be allowed to exist.
-	*/
-	virtual void				setActorCountLimit(uint32_t limit) = 0;
-
-	/**
-	Retrieve the limit to the total number of actors that can exist at a given time.  A value of zero disables this (gives no limit).
-
-	\return the limit to the total number of actors that can exist at a given time (or zero if there is no limit).
-	*/
-	virtual uint32_t			getActorCountLimit() = 0;
-
-	/**
-	The total number of PxActors generated by Blast.
-
-	\return the total number of PxActors generated by Blast.
-	*/
-	virtual uint32_t			getPxActorCount() const = 0;
-
-	/**
-	Add a user implementation of ExtPxListener to this family's list of listeners.
-
-	\param[in]	listener		The event listener to add.
-	*/
-	virtual void				subscribe(ExtPxListener& listener) = 0;
-
-	/**
-	Remove a user implementation of ExtPxListener from this family's list of listeners.
-
-	\param[in]	listener		The event listener to remove.
-	*/
-	virtual void				unsubscribe(ExtPxListener& listener) = 0;
-};
-
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTEXTPXMANAGER_H
diff --git a/NvBlast/sdk/extensions/physx/include/NvBlastExtStressSolver.h b/NvBlast/sdk/extensions/physx/include/NvBlastExtStressSolver.h
deleted file mode 100644
index 2fd389d..0000000
--- a/NvBlast/sdk/extensions/physx/include/NvBlastExtStressSolver.h
+++ /dev/null
@@ -1,209 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTSTRESSSOLVER_H
-#define NVBLASTEXTSTRESSSOLVER_H
-
-#include "common/PxRenderBuffer.h"
-#include <vector>
-#include "NvPreprocessor.h"
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-// forward declarations
-class ExtPxFamily;
-class ExtPxActor;
-
-/**
-Stress Solver Settings
-
-Stress on every bond is calculated as 
-stress = bond.linearStress * stressLinearFactor + bond.angularStress * stressAngularFactor
-where:
-bond.linearStress - is linear stress force on particular bond
-bond.angularStress - is angular stress force on particular bond
-stressLinearFactor, stressAngularFactor - are a multiplier parameter set by this struct
-
-Support graph reduction:
-2 ^ reduction level = max node count to be aggregated during graph reduction, so 0 is 2 % 0 = 1, basically use support graph.
-So N nodes graph will be simplified to contain ~ N / (2 ^ reduction level)
-*/
-struct ExtStressSolverSettings
-{
-	float		stressLinearFactor;			//!<	linear stress on bond multiplier
-	float		stressAngularFactor;		//!<	angular stress on bond multiplier
-	uint32_t	bondIterationsPerFrame;		//!<	number of bond iterations to perform per frame, @see getIterationsPerFrame() below
-	uint32_t	graphReductionLevel;		//!<	graph reduction level
-
-	ExtStressSolverSettings() :
-		stressLinearFactor(0.00004f),
-		stressAngularFactor(0.00007f),
-		bondIterationsPerFrame(18000),
-		graphReductionLevel(3)
-	{}
-};
-
-
-/**
-Stress Solver.
-
-Uses ExtPxFamily, allocates and prepares it's graph once when it's created. Then it's being quickly updated on every 
-actor split.
-Works on both dynamic and static actor's within family.
-For static actors it applies gravity.
-For dynamic actors it applies centrifugal force.
-Additionally applyImpulse() method can be used to apply external impulse (like impact damage).
-*/
-class NV_DLL_EXPORT ExtStressSolver
-{
-public:
-	//////// creation ////////
-
-	/**
-	Create a new ExtStressSolver.
-
-	\param[in]	family			The ExtPxFamily instance to calculate stress on.
-	\param[in]	settings		The settings to be set on ExtStressSolver.
-
-	\return the new ExtStressSolver if successful, NULL otherwise.
-	*/
-	static ExtStressSolver*					create(ExtPxFamily& family, ExtStressSolverSettings settings = ExtStressSolverSettings());
-
-
-	//////// interface ////////
-
-	/**
-	Release this stress solver.
-	*/
-	virtual void							release() = 0;
-
-	/**
-	Set stress solver settings.
-	Changing graph reduction level will lead to graph being rebuilt (which is fast, but still not recommended).
-	All other settings are applied instantly and can be changed every frame.
-
-	\param[in]	settings		The settings to be set on ExtStressSolver.
-	*/
-	virtual void							setSettings(const ExtStressSolverSettings& settings) = 0;
-
-	/**
-	Get stress solver settings.
-
-	\return the pointer to stress solver settings currently set.
-	*/
-	virtual const ExtStressSolverSettings&	getSettings() const = 0;
-
-	/**
-	Apply external impulse on particular actor of family
-
-	\param[in]	actor			The ExtPxActor to apply impulse on.
-	\param[in]	position		Local position in actor's coordinates to apply impulse on.
-	\param[in]	force			Impulse to apply (kg * m / s).
-	*/
-	virtual void							applyImpulse(ExtPxActor& actor, physx::PxVec3 position, physx::PxVec3 force) = 0;
-
-	/**
-	Update stress solver.
-
-	Calculate stress and optionally apply damage.
-
-	\param[in]	doDamage		If 'true' damage will be applied after stress solver.
-	*/
-	virtual void							update(bool doDamage = true) = 0;
-
-	/**
-	Reset stress solver.
-
-	Stress solver uses warm start internally, calling this function will flush all previous data calculated and also zeros frame count.
-	This function is to be used for debug purposes. 
-	*/
-	virtual void							reset() = 0;
-
-	/**
-	Debug Render Mode
-	*/
-	enum DebugRenderMode
-	{
-		STRESS_GRAPH = 0,					//!<	render only stress graph
-		STRESS_GRAPH_NODES_IMPULSES = 1,	//!<	render stress graph + nodes impulses after solving stress
-		STRESS_GRAPH_BONDS_IMPULSES = 2		//!<	render stress graph + bonds impulses after solving stress
-	};
-
-	/**
-	Fill debug render for passed array of support graph nodes.
-
-	\param[in]	nodes			Node indices of support graph to debug render for.
-	\param[out]	lines			Lines array to fill.
-	\param[in]	mode			Debug render mode.
-	\param[in]	scale			Scale to be applied on impulses.
-	*/
-	virtual void							fillDebugRender(const std::vector<uint32_t>& nodes, std::vector<physx::PxDebugLine>& lines, DebugRenderMode mode, float scale = 1.0f) = 0;
-
-	/**
-	Get stress solver linear error.
-
-	\return the total linear error of stress calculation.
-	*/
-	virtual float							getStressErrorLinear() const = 0;
-
-	/**
-	Get stress solver angular error.
-
-	\return the total angular error of stress calculation.
-	*/
-	virtual float							getStressErrorAngular() const = 0;
-
-	/**
-	Get stress solver total iterations count since it was created (or reset).
-
-	\return the iterations count.
-	*/
-	virtual uint32_t						getIterationCount() const = 0;
-
-	/**
-	Get stress solver total frames count (update() calls) since it was created (or reset).
-
-	\return the frames count.
-	*/
-	virtual uint32_t						getFrameCount() const = 0;
-
-	/**
-	Get stress solver bonds count, after graph reduction was applied.
-
-	\return the bonds count.
-	*/
-	virtual uint32_t						getBondCount() const = 0;
-
-
-	//////// helpers ////////
-
-	/**
-	Get iteration per frame (update() call).
-
-	Helper method to know how many solver iterations are made per frame.
-
-	\return the iterations per frame count.
-	*/
-	uint32_t								getIterationsPerFrame() const
-	{
-		uint32_t perFrame = getSettings().bondIterationsPerFrame / (getBondCount() + 1);
-		return perFrame > 0 ? perFrame : 1;
-	}
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTEXTSTRESSSOLVER_H
diff --git a/NvBlast/sdk/extensions/physx/include/NvBlastExtSync.h b/NvBlast/sdk/extensions/physx/include/NvBlastExtSync.h
deleted file mode 100644
index 805378a..0000000
--- a/NvBlast/sdk/extensions/physx/include/NvBlastExtSync.h
+++ /dev/null
@@ -1,213 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTSYNC_H
-#define NVBLASTEXTSYNC_H
-
-#include "NvBlastTk.h"
-#include "foundation/PxTransform.h"
-#include "foundation/PxAllocatorCallback.h"
-#include "NvPreprocessor.h"
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-class ExtPxFamily;
-class ExtPxManager;
-
-
-/**
-Sync Event types
-*/
-struct ExtSyncEventType
-{
-	enum Enum
-	{
-		Fracture = 0, //!< Contains Fracture commands
-		FamilySync,	  //!< Contains full family Family blob
-		Physics,	  //!< Contains actor's physical info, like transforms
-
-		Count
-	};
-};
-
-
-/**
-Generic Sync Event
-*/
-struct NV_DLL_EXPORT ExtSyncEvent
-{
-	ExtSyncEvent(ExtSyncEventType::Enum t) : type(t) {}
-	virtual ~ExtSyncEvent() {}
-
-	template<class T>
-	const T* getEvent() const { return reinterpret_cast<const T*>(this); }
-
-	/**
-	Any Event can be copied (cloned).
-
-	\return	the pointer to the new copy of event.
-	*/
-	virtual ExtSyncEvent* clone() const = 0;
-
-	void release();
-
-	ExtSyncEventType::Enum	type;		//!< Event type
-	uint64_t				timestamp;	//!< Event timestamp
-	NvBlastID				familyID;	//!< TkFamily ID
-};
-
-
-/**
-Generic CRTP for Sync Events
-*/
-template <class T, ExtSyncEventType::Enum eventType>
-struct ExtSyncEventInstance : public ExtSyncEvent
-{
-	ExtSyncEventInstance() : ExtSyncEvent(eventType) {}
-
-	static const ExtSyncEventType::Enum EVENT_TYPE = eventType;
-
-	ExtSyncEvent* clone() const override
-	{
-		return new (NvBlastTkFrameworkGet()->getAllocatorCallback().allocate(sizeof(T), nullptr, __FILE__, __LINE__)) T(*(T*)this);
-	}
-};
-
-
-/**
-Fracture Sync Event
-*/
-struct ExtSyncEventFracture : public ExtSyncEventInstance<ExtSyncEventFracture, ExtSyncEventType::Fracture>
-{
-	std::vector<NvBlastBondFractureData>	bondFractures;	//!< bond fracture data
-	std::vector<NvBlastChunkFractureData>	chunkFractures;	//!< chunk fracture data
-};
-
-
-/**
-Family Sync Event
-*/
-struct ExtSyncEventFamilySync : public ExtSyncEventInstance<ExtSyncEventFamilySync, ExtSyncEventType::FamilySync>
-{
-	std::vector<char> family;	//!< family binary blob
-};
-
-
-/**
-Physics Sync Event
-*/
-struct ExtSyncEventPhysicsSync : public ExtSyncEventInstance<ExtSyncEventPhysicsSync, ExtSyncEventType::Physics>
-{
-	struct ActorData
-	{
-		uint32_t			actorIndex;	//!< actor index in family
-		physx::PxTransform	transform;	//!< actor world transform
-	};
-
-	std::vector<ActorData> data;		//!< actors data
-};
-
-
-/**
-Sync Manager.
-
-Implements TkEventListener interface. It can be directly subscribed to listen for family events.
-*/
-class NV_DLL_EXPORT ExtSync : public TkEventListener
-{
-public:
-	//////// creation ////////
-
-	/**
-	Create a new ExtSync.
-
-	\return the new ExtSync if successful, NULL otherwise.
-	*/
-	static ExtSync*		create();
-
-
-	//////// common interface ////////
-
-	/**
-	Release Sync manager.
-	*/
-	virtual void		release() = 0;
-
-
-	//////// server-side interface ////////
-
-	/**
-	TkEventListener interface. 
-
-	\param[in]	events		The array of events being dispatched.
-	\param[in]	eventCount	The number of events in the array.
-	*/
-	virtual void		receive(const TkEvent* events, uint32_t eventCount)  = 0;
-
-	/**
-	Sync family state. Writes to internal sync buffer.
-
-	\param[in]	family		The TkFamily to sync
-	*/
-	virtual void		syncFamily(const TkFamily& family) = 0;
-
-	/**
-	Sync PxFamily state. Writes to internal sync buffer.
-
-	\param[in]	family		The ExtPxFamily to sync
-	*/
-	virtual void		syncFamily(const ExtPxFamily& family) = 0;
-
-	/**
-	The size of internal sync buffer (events count).
-
-	\return the number of events in internal sync buffer.
-	*/
-	virtual uint32_t	getSyncBufferSize() const = 0;
-
-	/**
-	Acquire internal sync buffer.
-
-	\param[in] buffer		Reference to sync event buffer pointer to be set.
-	\param[in] size			Reference to the size of the buffer array to be set.
-	*/
-	virtual void		acquireSyncBuffer(const ExtSyncEvent*const*& buffer, uint32_t& size) const = 0;
-
-	/**
-	Clear internal sync buffer.
-	*/
-	virtual void		releaseSyncBuffer() = 0;
-
-
-	//////// client-side interface ////////
-
-	/**
-	Apply external sync buffer on TkFramework and possibly ExtPxManager. This function call will result in
-	respective families/actors changes in order to synchronize state.
-
-	\param[in]	framework			The TkFramework instance to be used.
-	\param[in]	buffer				Sync buffer array pointer.
-	\param[in]	size				Sync buffer array size.
-	\param[in]	groupForNewActors	TkGroup to be used for newly created actors. Can be nullptr.
-	\param[in]	manager				The ExtPxManager instance to be used. Can be nullptr, physics sync events will be ignored in that case.
-	*/
-	virtual void		applySyncBuffer(TkFramework& framework, const ExtSyncEvent** buffer, uint32_t size, TkGroup* groupForNewActors, ExtPxManager* manager = nullptr) = 0;
-
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTEXTSYNC_H
diff --git a/NvBlast/sdk/extensions/physx/source/physics/NvBlastExtImpactDamageManager.cpp b/NvBlast/sdk/extensions/physx/source/physics/NvBlastExtImpactDamageManager.cpp
deleted file mode 100644
index 54d2696..0000000
--- a/NvBlast/sdk/extensions/physx/source/physics/NvBlastExtImpactDamageManager.cpp
+++ /dev/null
@@ -1,448 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastExtImpactDamageManager.h"
-#include "NvBlastExtPxManager.h"
-#include "NvBlastExtPxFamily.h"
-#include "NvBlastExtPxActor.h"
-#include "NvBlastExtPxListener.h"
-
-#include "NvBlastAssert.h"
-
-#include "NvBlastExtDamageShaders.h"
-#include "NvBlastExtArray.h"
-#include "NvBlastExtDefs.h"
-
-#include "PxRigidDynamic.h"
-#include "PxSimulationEventCallback.h"
-#include "PxRigidBodyExt.h"
-
-#include "NvBlastTkFramework.h"
-#include "NvBlastTkActor.h"
-#include "NvBlastTkFamily.h"
-#include "NvBlastTkAsset.h"
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-using namespace physx;
-
-const float MIN_IMPACT_VELOCITY_SQUARED = 1.0f;
-
-
-class ExtImpactDamageManagerImpl final : public ExtImpactDamageManager
-{
-public:
-	ExtImpactDamageManagerImpl(ExtPxManager* pxManager, ExtImpactSettings settings)
-		: m_pxManager(pxManager), m_settings(settings), m_listener(this), m_usePxUserData(m_pxManager->isPxUserDataUsed())
-	{
-		NVBLAST_ASSERT_WITH_MESSAGE(pxManager != nullptr, "ExtImpactDamageManager creation: input ExtPxManager is nullptr.");
-		m_pxManager->subscribe(m_listener);
-
-		m_impactDamageBuffer.reserve(32);
-	}
-
-	~ExtImpactDamageManagerImpl()
-	{
-		m_pxManager->unsubscribe(m_listener);
-	}
-
-	virtual void					release() override
-	{
-		NVBLASTEXT_DELETE(this, ExtImpactDamageManagerImpl);
-	}
-
-
-	//////// interface ////////
-
-	virtual void					setSettings(const ExtImpactSettings& settings) override
-	{
-		m_settings = settings;
-	}
-
-	virtual void					onContact(const PxContactPairHeader& pairHeader, const PxContactPair* pairs, uint32_t nbPairs) override;
-
-	virtual void					applyDamage() override;
-
-
-	//////// public methods ////////
-
-	void							queueImpactDamage(ExtPxActor* actor, PxVec3 force, PxVec3 position, PxShape* shape)
-	{
-		ImpactDamageData data = { actor, force, position, shape };
-		m_impactDamageBuffer.pushBack(data);
-	}
-
-
-private:
-	//////// physics manager listener ////////
-
-	class PxManagerListener : public ExtPxListener
-	{
-	public:
-		PxManagerListener(ExtImpactDamageManagerImpl* manager) : m_manager(manager) {}
-
-		virtual void onActorCreated(ExtPxFamily&, ExtPxActor&) override {}
-		virtual void onActorDestroyed(ExtPxFamily& family, ExtPxActor& actor) override
-		{
-			NV_UNUSED(family);
-
-			// filter out actor from queued buffer
-			auto& buffer = m_manager->m_impactDamageBuffer;
-			for (int32_t i = 0; i < (int32_t)buffer.size(); ++i)
-			{
-				if (buffer[i].actor == &actor)
-				{
-					buffer.replaceWithLast(i);
-					i--;
-				}
-			}
-		}
-	private:
-		ExtImpactDamageManagerImpl* m_manager;
-	};
-
-
-	//////// private methods ////////
-
-	void ensureBuffersSize(ExtPxActor* actor);
-	void damageActor(ExtPxActor* actor, PxShape* shape, PxVec3 position, PxVec3 force);
-
-
-	//////// data ////////
-
-	ExtPxManager*						m_pxManager;
-	ExtImpactSettings					m_settings;
-	PxManagerListener					m_listener;
-	ExtArray<PxContactPairPoint>::type	m_pairPointBuffer;
-	bool								m_usePxUserData;
-
-	struct ImpactDamageData
-	{
-		ExtPxActor*	actor;
-		PxVec3				force;
-		PxVec3				position;
-		PxShape*			shape;
-	};
-
-	ExtArray<ImpactDamageData>::type	m_impactDamageBuffer;
-
-	NvBlastFractureBuffers				m_fractureBuffers;
-	ExtArray<uint8_t>::type				m_fractureData;
-};
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//												ExtImpactDamageManagerImpl
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-ExtImpactDamageManager* ExtImpactDamageManager::create(ExtPxManager* pxManager, ExtImpactSettings settings)
-{
-	return NVBLASTEXT_NEW(ExtImpactDamageManagerImpl) (pxManager, settings);
-}
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//												onContact callback call
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-void ExtImpactDamageManagerImpl::onContact(const PxContactPairHeader& pairHeader, const PxContactPair* pairs, uint32_t nbPairs)
-{
-	if (pairHeader.flags & physx::PxContactPairHeaderFlag::eREMOVED_ACTOR_0 ||
-		pairHeader.flags & physx::PxContactPairHeaderFlag::eREMOVED_ACTOR_1 ||
-		pairHeader.actors[0] == nullptr ||
-		pairHeader.actors[1] == nullptr)
-	{
-		return;
-	}
-
-	PxRigidActor* rigidActor0 = pairHeader.actors[0];
-	PxRigidActor* rigidActor1 = pairHeader.actors[1];
-
-	ExtPxActor* actors[2];
-
-	if (m_usePxUserData)
-	{
-		actors[0] = (ExtPxActor*)rigidActor0->userData;
-		actors[1] = (ExtPxActor*)rigidActor1->userData;
-	}
-	else
-	{
-		PxRigidDynamic* rigidDynamic0 = rigidActor0->is<PxRigidDynamic>();
-		PxRigidDynamic* rigidDynamic1 = rigidActor1->is<PxRigidDynamic>();
-		actors[0] = rigidDynamic0 ? m_pxManager->getActorFromPhysXActor(*rigidDynamic0) : nullptr;
-		actors[1] = rigidDynamic1 ? m_pxManager->getActorFromPhysXActor(*rigidDynamic1) : nullptr;
-	}
-	
-
-	// check one of them is blast actor
-	if (actors[0] == nullptr && actors[1] == nullptr)
-	{
-		return;
-	}
-
-	// self-collision check
-	if (actors[0] != nullptr && actors[1] != nullptr)
-	{
-		if (&actors[0]->getFamily() == &actors[1]->getFamily() && !m_settings.isSelfCollissionEnabled)
-			return;
-	}
-
-	for (uint32_t pairIdx = 0; pairIdx < nbPairs; pairIdx++)
-	{
-		const PxContactPair& currentPair = pairs[pairIdx];
-
-		if (currentPair.flags & physx::PxContactPairFlag::eREMOVED_SHAPE_0 ||
-			currentPair.flags & physx::PxContactPairFlag::eREMOVED_SHAPE_1 ||
-			currentPair.shapes[0] == nullptr ||
-			currentPair.shapes[1] == nullptr)
-		{
-			continue;
-		}
-
-		float masses[2] = { 0, 0 };
-		{
-			for (int i = 0; i < 2; ++i)
-			{
-				PxRigidDynamic* rigidDynamic = pairHeader.actors[i]->is<physx::PxRigidDynamic>();
-				if (rigidDynamic)
-				{
-					if (!(rigidDynamic->getRigidBodyFlags() & physx::PxRigidBodyFlag::eKINEMATIC))
-					{
-						masses[i] = rigidDynamic->getMass();
-					}
-				}
-			}
-		};
-
-		float reducedMass;
-		if (masses[0] == 0.0f)
-		{
-			reducedMass = masses[1];
-		}
-		else if (masses[1] == 0.0f)
-		{
-			reducedMass = masses[0];
-		}
-		else
-		{
-			reducedMass = masses[0] * masses[1] / (masses[0] + masses[1]);
-		}
-
-
-		PxVec3 destructibleForces[2] = { PxVec3(0.0f), PxVec3(0.0f) };
-		PxVec3 avgContactPosition = PxVec3(0.0f);
-		PxVec3 avgContactNormal = PxVec3(0.0f);
-		uint32_t  numContacts = 0;
-
-		m_pairPointBuffer.resize(currentPair.contactCount);
-		uint32_t numContactsInStream = currentPair.contactCount > 0 ? currentPair.extractContacts(m_pairPointBuffer.begin(), currentPair.contactCount) : 0;
-
-		for (uint32_t contactIdx = 0; contactIdx < numContactsInStream; contactIdx++)
-		{
-			PxContactPairPoint& currentPoint = m_pairPointBuffer[contactIdx];
-
-			const PxVec3& patchNormal = currentPoint.normal;
-			const PxVec3& position = currentPoint.position;
-			PxVec3 velocities[2] = { PxVec3(0.0f), PxVec3(0.0f) };
-			for (int i = 0; i < 2; ++i)
-			{
-				PxRigidBody* rigidBody = pairHeader.actors[i]->is<physx::PxRigidBody>();
-				if (rigidBody)
-				{
-					velocities[i] = physx::PxRigidBodyExt::getVelocityAtPos(*rigidBody, position);
-				}
-			}
-
-			const PxVec3 velocityDelta = velocities[0] - velocities[1];
-			if (velocityDelta.magnitudeSquared() >= MIN_IMPACT_VELOCITY_SQUARED || reducedMass == 0.0f)	// If reduced mass == 0, this is kineamtic vs. kinematic.  Generate damage.
-			{
-				for (int i = 0; i < 2; ++i)
-				{
-					if (actors[i])
-					{
-						// this is not really physically correct, but at least its deterministic...
-						destructibleForces[i] += (patchNormal * patchNormal.dot(velocityDelta)) * reducedMass * (i ? 1.0f : -1.0f);
-					}
-				}
-				avgContactPosition += position;
-				avgContactNormal += patchNormal;
-				numContacts++;
-			}
-		}
-
-		if (numContacts)
-		{
-			avgContactPosition /= (float)numContacts;
-			avgContactNormal.normalize();
-			for (uint32_t i = 0; i < 2; i++)
-			{
-				const PxVec3 force = destructibleForces[i] / (float)numContacts;
-				ExtPxActor* actor = actors[i];
-				if (actor != nullptr)
-				{
-					if (!force.isZero())
-					{
-						queueImpactDamage(actor, force, avgContactPosition, currentPair.shapes[i]);
-					}
-					else if (reducedMass == 0.0f)	// Handle kinematic vs. kinematic
-					{
-						// holy molly
-					}
-				}
-			}
-		}
-	}
-}
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//										ExtImpactDamageManager damage processing
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-float clampedLerp(float from, float to, float t)
-{
-	t = PxClamp(t, 0.0f, 1.0f);
-	return (1 - t) * from + to * t;
-}
-
-void ExtImpactDamageManagerImpl::applyDamage()
-{
-	const auto damageFn = m_settings.damageFunction;
-	const auto damageFnData = m_settings.damageFunctionData;
-
-	for (const ImpactDamageData& data : m_impactDamageBuffer)
-	{
-		float forceMag = data.force.magnitude();
-		float acceleration = forceMag / data.actor->getPhysXActor().getMass();
-		float factor = acceleration * m_settings.fragility * 0.001f;
-		if (factor > 0.05f)
-		{
-			PxTransform t(data.actor->getPhysXActor().getGlobalPose().getInverse());
-			PxVec3 force = t.rotate(data.force);
-			PxVec3 position = t.transform(data.position);
-
-			if (!damageFn || !damageFn(damageFnData, data.actor, data.shape, position, force))
-			{
-				damageActor(data.actor, data.shape, position, force*.00001f);
-			}
-		}
-	}
-	m_impactDamageBuffer.clear();
-}
-
-void ExtImpactDamageManagerImpl::ensureBuffersSize(ExtPxActor* actor)
-{
-	const TkAsset* tkAsset = actor->getTkActor().getAsset();
-	const uint32_t chunkCount = tkAsset->getChunkCount();
-	const uint32_t bondCount = tkAsset->getBondCount();
-
-	m_fractureBuffers.bondFractureCount = bondCount;
-	m_fractureBuffers.chunkFractureCount = chunkCount;
-	m_fractureData.resize((uint32_t)(m_fractureBuffers.bondFractureCount*sizeof(NvBlastBondFractureData) + m_fractureBuffers.chunkFractureCount*sizeof(NvBlastChunkFractureData))); // chunk count + bond count
-	m_fractureBuffers.chunkFractures = reinterpret_cast<NvBlastChunkFractureData*>(m_fractureData.begin());
-	m_fractureBuffers.bondFractures = reinterpret_cast<NvBlastBondFractureData*>(&m_fractureData.begin()[m_fractureBuffers.chunkFractureCount*sizeof(NvBlastChunkFractureData)]);
-}
-
-void ExtImpactDamageManagerImpl::damageActor(ExtPxActor* actor, PxShape* /*shape*/, PxVec3 position, PxVec3 force)
-{
-	ensureBuffersSize(actor);
-
-	NvBlastExtShearDamageDesc damage[] = {
-		{
-			{ force[0], force[1], force[2] },			// shear
-			{ position[0], position[1], position[2] }	// position
-		}							
-	};
-
-	const void* familyMaterial = actor->getTkActor().getFamily().getMaterial();
-
-	// default material params settings
-	const NvBlastExtMaterial defaultMaterial = { 3.0f, 0.1f, 0.2f, 1.5f + 1e-5f, 0.95f };
-
-	NvBlastProgramParams programParams;
-	programParams.damageDescCount = 1;
-	programParams.damageDescBuffer = &damage;
-	programParams.material = familyMaterial == nullptr ? &defaultMaterial : familyMaterial;
-
-	NvBlastDamageProgram program = {
-		NvBlastExtShearGraphShader,
-		NvBlastExtShearSubgraphShader
-	};
-
-	NvBlastFractureBuffers fractureEvents = m_fractureBuffers;
-
-	actor->getTkActor().generateFracture(&fractureEvents, program, &programParams);
-	actor->getTkActor().applyFracture(nullptr, &fractureEvents);
-}
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//														Filter Shader
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-PxFilterFlags ExtImpactDamageManager::FilterShader(
-	PxFilterObjectAttributes attributes0,
-	PxFilterData filterData0,
-	PxFilterObjectAttributes attributes1,
-	PxFilterData filterData1,
-	PxPairFlags& pairFlags,
-	const void* constantBlock,
-	uint32_t constantBlockSize)
-{
-	PX_UNUSED(constantBlock);
-	PX_UNUSED(constantBlockSize);
-	// let triggers through
-	if (PxFilterObjectIsTrigger(attributes0) || PxFilterObjectIsTrigger(attributes1))
-	{
-		pairFlags = PxPairFlag::eTRIGGER_DEFAULT;
-		return PxFilterFlags();
-	}
-
-	if ((PxFilterObjectIsKinematic(attributes0) || PxFilterObjectIsKinematic(attributes1)) &&
-		(PxGetFilterObjectType(attributes0) == PxFilterObjectType::eRIGID_STATIC || PxGetFilterObjectType(attributes1) == PxFilterObjectType::eRIGID_STATIC))
-	{
-		return PxFilterFlag::eSUPPRESS;
-	}
-
-	// use a group-based mechanism if the first two filter data words are not 0
-	uint32_t f0 = filterData0.word0 | filterData0.word1;
-	uint32_t f1 = filterData1.word0 | filterData1.word1;
-	if (f0 && f1 && !(filterData0.word0&filterData1.word1 || filterData1.word0&filterData0.word1))
-		return PxFilterFlag::eSUPPRESS;
-
-	// determine if we should suppress notification
-	const bool suppressNotify = ((filterData0.word3 | filterData1.word3) & ExtPxManager::LEAF_CHUNK) != 0;
-
-	pairFlags = PxPairFlag::eCONTACT_DEFAULT;
-	if (!suppressNotify)
-	{
-		pairFlags = pairFlags
-			| PxPairFlag::eNOTIFY_CONTACT_POINTS
-			| PxPairFlag::eNOTIFY_THRESHOLD_FORCE_PERSISTS
-			| PxPairFlag::eNOTIFY_THRESHOLD_FORCE_FOUND
-			| PxPairFlag::eNOTIFY_TOUCH_FOUND
-			| PxPairFlag::eNOTIFY_TOUCH_PERSISTS;
-	}
-
-	// eSOLVE_CONTACT is invalid with kinematic pairs
-	if (PxFilterObjectIsKinematic(attributes0) && PxFilterObjectIsKinematic(attributes1))
-	{
-		pairFlags &= ~PxPairFlag::eSOLVE_CONTACT;
-	}
-
-	return PxFilterFlags();
-}
-
-} // namespace Blast
-} // namespace Nv
diff --git a/NvBlast/sdk/extensions/physx/source/physics/NvBlastExtImpulseStressSolver.cpp b/NvBlast/sdk/extensions/physx/source/physics/NvBlastExtImpulseStressSolver.cpp
deleted file mode 100644
index 8329de5..0000000
--- a/NvBlast/sdk/extensions/physx/source/physics/NvBlastExtImpulseStressSolver.cpp
+++ /dev/null
@@ -1,1312 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastExtImpulseStressSolver.h"
-#include "NvBlastExtPxAsset.h"
-#include "NvBlastExtPxFamily.h"
-#include "NvBlastExtPxActor.h"
-#include "NvBlastAssert.h"
-#include "NvBlastIndexFns.h"
-#include "NvBlastExtDefs.h"
-
-#include "NvBlastTkAsset.h"
-#include "NvBlastTkActor.h"
-#include "NvBlastTkFamily.h"
-
-#include "PxScene.h"
-#include "PxRigidDynamic.h"
-
-#include <PsVecMath.h>
-#include "PsFPU.h"
-
-#include <algorithm>
-#include <set>
-
-#define USE_SCALAR_IMPL 0
-#define WARM_START 1
-#define USE_PHYSX_CONVEX_DATA 1
-#define GRAPH_INTERGRIRY_CHECK 0
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-using namespace physx;
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//													 Solver
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-class SequentialImpulseSolver
-{
-public:
-	PX_ALIGN_PREFIX(16)
-	struct BondData
-	{
-		physx::PxVec3 impulseLinear;
-		uint32_t node0;
-		physx::PxVec3 impulseAngular;
-		uint32_t node1;
-		physx::PxVec3 offset0;
-		float invOffsetSqrLength;
-
-		float getStressHealth(const ExtStressSolverSettings& settings) const
-		{
-			return (impulseLinear.magnitude() * settings.stressLinearFactor + impulseAngular.magnitude() * settings.stressAngularFactor);
-		}
-	}
-	PX_ALIGN_SUFFIX(16);
-
-	PX_ALIGN_PREFIX(16)
-	struct NodeData
-	{
-		physx::PxVec3 velocityLinear;
-		float invI;
-		physx::PxVec3 velocityAngular;
-		float invMass;
-	}
-	PX_ALIGN_SUFFIX(16);
-
-	SequentialImpulseSolver(uint32_t nodeCount, uint32_t maxBondCount)
-	{
-		m_nodesData.resize(nodeCount);
-		m_bondsData.reserve(maxBondCount);
-	}
-
-	NV_INLINE const NodeData& getNodeData(uint32_t node) const
-	{
-		return m_nodesData[node];
-	}
-
-	NV_INLINE const BondData& getBondData(uint32_t bond) const
-	{
-		return m_bondsData[bond];
-	}
-
-	NV_INLINE uint32_t getBondCount() const
-	{
-		return m_bondsData.size();
-	}
-
-	NV_INLINE uint32_t getNodeCount() const
-	{
-		return m_nodesData.size();;
-	}
-
-	NV_INLINE void setNodeMassInfo(uint32_t node, float invMass, float invI)
-	{
-		m_nodesData[node].invMass = invMass;
-		m_nodesData[node].invI = invI;
-	}
-
-	NV_INLINE void initialize()
-	{
-		for (auto& node : m_nodesData)
-		{
-			node.velocityLinear = PxVec3(PxZero);
-			node.velocityAngular = PxVec3(PxZero);
-		}
-	}
-
-	NV_INLINE void setNodeVelocities(uint32_t node, const PxVec3& velocityLinear, const PxVec3& velocityAngular)
-	{
-		m_nodesData[node].velocityLinear = velocityLinear;
-		m_nodesData[node].velocityAngular = velocityAngular;
-	}
-
-	NV_INLINE uint32_t addBond(uint32_t node0, uint32_t node1, const PxVec3& offset)
-	{
-		const BondData data = {
-			PxVec3(PxZero), 
-			node0, 
-			PxVec3(PxZero), 
-			node1, 
-			offset, 
-			1.0f / offset.magnitudeSquared() 
-		};
-		m_bondsData.pushBack(data);
-		return m_bondsData.size() - 1;
-	}
-
-	NV_INLINE void replaceWithLast(uint32_t bondIndex)
-	{
-		m_bondsData.replaceWithLast(bondIndex);
-	}
-
-	NV_INLINE void reset(uint32_t nodeCount)
-	{
-		m_bondsData.clear();
-		m_nodesData.resize(nodeCount);
-	}
-
-	NV_INLINE void clearBonds()
-	{
-		m_bondsData.clear();
-	}
-
-	void solve(uint32_t iterationCount, bool warmStart = false)
-	{
-		solveInit(warmStart);
-
-		for (uint32_t i = 0; i < iterationCount; ++i)
-		{
-			iterate();
-		}
-	}
-
-	void calcError(float& linear, float& angular)
-	{
-		linear = 0.0f;
-		angular = 0.0f;
-		for (BondData& bond : m_bondsData)
-		{
-			NodeData* node0 = &m_nodesData[bond.node0];
-			NodeData* node1 = &m_nodesData[bond.node1];
-
-			const PxVec3 vA = node0->velocityLinear - node0->velocityAngular.cross(bond.offset0);
-			const PxVec3 vB = node1->velocityLinear + node1->velocityAngular.cross(bond.offset0);
-
-			const PxVec3 vErrorLinear = vA - vB;
-			const PxVec3 vErrorAngular = node0->velocityAngular - node1->velocityAngular;
-
-			linear += vErrorLinear.magnitude();
-			angular += vErrorAngular.magnitude();
-		}
-	}
-
-private:
-	void solveInit(bool warmStart = false)
-	{
-		if (warmStart)
-		{
-			for (BondData& bond : m_bondsData)
-			{
-				NodeData* node0 = &m_nodesData[bond.node0];
-				NodeData* node1 = &m_nodesData[bond.node1];
-
-				const PxVec3 velocityLinearCorr0 = bond.impulseLinear * node0->invMass;
-				const PxVec3 velocityLinearCorr1 = bond.impulseLinear * node1->invMass;
-
-				const PxVec3 velocityAngularCorr0 = bond.impulseAngular * node0->invI - bond.offset0.cross(velocityLinearCorr0) * bond.invOffsetSqrLength;
-				const PxVec3 velocityAngularCorr1 = bond.impulseAngular * node1->invI + bond.offset0.cross(velocityLinearCorr1) * bond.invOffsetSqrLength;
-
-				node0->velocityLinear += velocityLinearCorr0;
-				node1->velocityLinear -= velocityLinearCorr1;
-
-				node0->velocityAngular += velocityAngularCorr0;
-				node1->velocityAngular -= velocityAngularCorr1;
-			}
-		}
-		else
-		{
-			for (BondData& bond : m_bondsData)
-			{
-				bond.impulseLinear = PxVec3(PxZero);
-				bond.impulseAngular = PxVec3(PxZero);
-			}
-		}
-	}
-
-
-	NV_INLINE void iterate()
-	{
-		using namespace physx::shdfnd::aos;
-
-		for (BondData& bond : m_bondsData)
-		{
-			NodeData* node0 = &m_nodesData[bond.node0];
-			NodeData* node1 = &m_nodesData[bond.node1];
-
-#if USE_SCALAR_IMPL
-			const PxVec3 vA = node0->velocityLinear - node0->velocityAngular.cross(bond.offset0);
-			const PxVec3 vB = node1->velocityLinear + node1->velocityAngular.cross(bond.offset0);
-
-			const PxVec3 vErrorLinear = vA - vB;
-			const PxVec3 vErrorAngular = node0->velocityAngular - node1->velocityAngular;
-
-			const float weightedMass = 1.0f / (node0->invMass + node1->invMass);
-			const float weightedInertia = 1.0f / (node0->invI + node1->invI);
-
-			const PxVec3 outImpulseLinear = -vErrorLinear * weightedMass * 0.5f;
-			const PxVec3 outImpulseAngular = -vErrorAngular * weightedInertia * 0.5f;
-
-			bond.impulseLinear += outImpulseLinear;
-			bond.impulseAngular += outImpulseAngular;
-
-			const PxVec3 velocityLinearCorr0 = outImpulseLinear * node0->invMass;
-			const PxVec3 velocityLinearCorr1 = outImpulseLinear * node1->invMass;
-
-			const PxVec3 velocityAngularCorr0 = outImpulseAngular * node0->invI - bond.offset0.cross(velocityLinearCorr0) * bond.invOffsetSqrLength;
-			const PxVec3 velocityAngularCorr1 = outImpulseAngular * node1->invI + bond.offset0.cross(velocityLinearCorr1) * bond.invOffsetSqrLength;
-
-			node0->velocityLinear += velocityLinearCorr0;
-			node1->velocityLinear -= velocityLinearCorr1;
-
-			node0->velocityAngular += velocityAngularCorr0;
-			node1->velocityAngular -= velocityAngularCorr1;
-#else
-			const Vec3V velocityLinear0 = V3LoadUnsafeA(node0->velocityLinear);
-			const Vec3V velocityLinear1 = V3LoadUnsafeA(node1->velocityLinear);
-			const Vec3V velocityAngular0 = V3LoadUnsafeA(node0->velocityAngular);
-			const Vec3V velocityAngular1 = V3LoadUnsafeA(node1->velocityAngular);
-
-			const Vec3V offset = V3LoadUnsafeA(bond.offset0);
-			const Vec3V vA = V3Add(velocityLinear0, V3Neg(V3Cross(velocityAngular0, offset)));
-			const Vec3V vB = V3Add(velocityLinear1, V3Cross(velocityAngular1, offset));
-
-			const Vec3V vErrorLinear = V3Sub(vA, vB);
-			const Vec3V vErrorAngular = V3Sub(velocityAngular0, velocityAngular1);
-
-			const FloatV invM0 = FLoad(node0->invMass);
-			const FloatV invM1 = FLoad(node1->invMass);
-			const FloatV invI0 = FLoad(node0->invI);
-			const FloatV invI1 = FLoad(node1->invI);
-			const FloatV invOffsetSqrLength = FLoad(bond.invOffsetSqrLength);
-
-			const FloatV weightedMass = FLoad(-0.5f / (node0->invMass + node1->invMass));
-			const FloatV weightedInertia = FLoad(-0.5f / (node0->invI + node1->invI));
-
-			const Vec3V outImpulseLinear = V3Scale(vErrorLinear, weightedMass);
-			const Vec3V outImpulseAngular = V3Scale(vErrorAngular, weightedInertia);
-
-			V3StoreA(V3Add(V3LoadUnsafeA(bond.impulseLinear), outImpulseLinear), bond.impulseLinear);
-			V3StoreA(V3Add(V3LoadUnsafeA(bond.impulseAngular), outImpulseAngular), bond.impulseAngular);
-
-			const Vec3V velocityLinearCorr0 = V3Scale(outImpulseLinear, invM0);
-			const Vec3V velocityLinearCorr1 = V3Scale(outImpulseLinear, invM1);
-
-			const Vec3V velocityAngularCorr0 = V3Sub(V3Scale(outImpulseAngular, invI0), V3Scale(V3Cross(offset, velocityLinearCorr0), invOffsetSqrLength));
-			const Vec3V velocityAngularCorr1 = V3Add(V3Scale(outImpulseAngular, invI1),	V3Scale(V3Cross(offset, velocityLinearCorr1), invOffsetSqrLength));
-
-			V3StoreA(V3Add(velocityLinear0, velocityLinearCorr0), node0->velocityLinear);
-			V3StoreA(V3Sub(velocityLinear1, velocityLinearCorr1), node1->velocityLinear);
-
-			V3StoreA(V3Add(velocityAngular0, velocityAngularCorr0), node0->velocityAngular);
-			V3StoreA(V3Sub(velocityAngular1, velocityAngularCorr1), node1->velocityAngular);
-#endif
-		}
-	}
-
-	shdfnd::Array<BondData, ExtAlignedAllocator<16>>		m_bondsData;
-	shdfnd::Array<NodeData, ExtAlignedAllocator<16>>		m_nodesData;
-};
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//													 Graph Processor
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-#if GRAPH_INTERGRIRY_CHECK
-#define CHECK_GRAPH_INTEGRITY checkGraphIntegrity()
-#else
-#define CHECK_GRAPH_INTEGRITY ((void)0)
-#endif
-
-class SupportGraphProcessor
-{
-
-public:
-	struct BondData
-	{
-		uint32_t node0;
-		uint32_t node1;
-		uint32_t blastBondIndex;
-	};
-
-	struct NodeData
-	{
-		float mass;
-		float volume;
-		PxVec3 localPos;
-		bool isStatic;
-		uint32_t solverNode;
-		uint32_t neighborsCount;
-		PxVec3 impulse;
-	};
-
-	struct SolverNodeData
-	{
-		uint32_t supportNodesCount;
-		PxVec3 localPos;
-		union
-		{
-			float mass;
-			int32_t indexShift;
-		};
-		float volume;
-		bool isStatic;
-	};
-
-	struct SolverBondData
-	{
-		ExtInlineArray<uint32_t, 8>::type blastBondIndices;
-	};
-
-	SupportGraphProcessor(uint32_t nodeCount, uint32_t maxBondCount) : m_solver(nodeCount, maxBondCount), m_nodesDirty(true)
-	{
-		m_nodesData.resize(nodeCount);
-		m_bondsData.reserve(maxBondCount);
-
-		m_solverNodesData.resize(nodeCount);
-		m_solverBondsData.reserve(maxBondCount);
-
-		m_solverBondsMap.reserve(maxBondCount);
-
-		m_blastBondIndexMap.resize(maxBondCount);
-		memset(m_blastBondIndexMap.begin(), 0xFF, m_blastBondIndexMap.size() * sizeof(uint32_t));
-	}
-
-	NV_INLINE const NodeData& getNodeData(uint32_t node) const
-	{
-		return m_nodesData[node];
-	}
-
-	NV_INLINE const BondData& getBondData(uint32_t bond) const
-	{
-		return m_bondsData[bond];
-	}
-
-	NV_INLINE const SolverNodeData& getSolverNodeData(uint32_t node) const
-	{
-		return m_solverNodesData[node];
-	}
-
-	NV_INLINE const SolverBondData& getSolverBondData(uint32_t bond) const
-	{
-		return m_solverBondsData[bond];
-	}
-
-	NV_INLINE const SequentialImpulseSolver::BondData& getSolverInternalBondData(uint32_t bond) const
-	{
-		return m_solver.getBondData(bond);
-	}
-
-	NV_INLINE const SequentialImpulseSolver::NodeData& getSolverInternalNodeData(uint32_t node) const
-	{
-		return m_solver.getNodeData(node);
-	}
-
-	NV_INLINE uint32_t getBondCount() const
-	{
-		return m_bondsData.size();
-	}
-
-	NV_INLINE uint32_t getNodeCount() const
-	{
-		return m_nodesData.size();;
-	}
-
-	NV_INLINE uint32_t getSolverBondCount() const
-	{
-		return m_solverBondsData.size();
-	}
-
-	NV_INLINE uint32_t getSolverNodeCount() const
-	{
-		return m_solverNodesData.size();;
-	}
-
-	NV_INLINE void setNodeInfo(uint32_t node, float mass, float volume, PxVec3 localPos,	bool isStatic)
-	{
-		m_nodesData[node].mass = mass;
-		m_nodesData[node].volume = volume;
-		m_nodesData[node].localPos = localPos;
-		m_nodesData[node].isStatic = isStatic;
-	}
-
-	NV_INLINE void setNodeNeighborsCount(uint32_t node, uint32_t neighborsCount)
-	{
-		// neighbors count is expected to be the number of nodes on 1 island/actor.
-		m_nodesData[node].neighborsCount = neighborsCount;
-
-		// check for too huge aggregates (happens after island's split)
-		if (!m_nodesDirty)
-		{
-			m_nodesDirty |= (m_solverNodesData[m_nodesData[node].solverNode].supportNodesCount > neighborsCount / 2);
-		}
-	}
-
-	NV_INLINE void initialize()
-	{
-		sync();
-		
-		m_solver.initialize();
-
-		for (auto& node : m_nodesData)
-		{
-			node.impulse = PxVec3(PxZero);
-		}
-	}
-
-	NV_INLINE void addNodeImpulse(uint32_t node, const PxVec3& impulse)
-	{
-		m_nodesData[node].impulse += impulse;
-	}
-
-	NV_INLINE void addNodeVelocity(uint32_t node, const PxVec3& velocity)
-	{
-		PxVec3 impulse = velocity * m_nodesData[node].mass;
-		addNodeImpulse(node, impulse);
-	}
-
-	NV_INLINE void addBond(uint32_t node0, uint32_t node1, uint32_t blastBondIndex)
-	{
-		if (isInvalidIndex(m_blastBondIndexMap[blastBondIndex]))
-		{
-			const BondData data = {
-				node0,
-				node1,
-				blastBondIndex
-			};
-			m_bondsData.pushBack(data);
-			m_blastBondIndexMap[blastBondIndex] = m_bondsData.size() - 1;
-		}
-	}
-
-	NV_INLINE void removeBondIfExists(uint32_t blastBondIndex)
-	{
-		const uint32_t bondIndex = m_blastBondIndexMap[blastBondIndex];
-
-		if (!isInvalidIndex(bondIndex))
-		{
-			const BondData& bond = m_bondsData[bondIndex];
-			const uint32_t solverNode0 = m_nodesData[bond.node0].solverNode;
-			const uint32_t solverNode1 = m_nodesData[bond.node1].solverNode;
-			bool isBondInternal = (solverNode0 == solverNode1);
-
-			if (isBondInternal)
-			{
-				// internal bond sadly requires graph resync (it never happens on reduction level '0')
-				m_nodesDirty = true;
-			}
-			else if (!m_nodesDirty)
-			{
-				// otherwise it's external bond, we can remove it manually and keep graph synced
-				// we don't need to spend time there if (m_nodesDirty == true), graph will be resynced anyways
-
-				BondKey solverBondKey(solverNode0, solverNode1);
-				auto entry = m_solverBondsMap.find(solverBondKey);
-				if (entry)
-				{
-					const uint32_t solverBondIndex = entry->second;
-					auto& blastBondIndices = m_solverBondsData[solverBondIndex].blastBondIndices;
-					blastBondIndices.findAndReplaceWithLast(blastBondIndex);
-					if (blastBondIndices.empty())
-					{
-						// all bonds associated with this solver bond were removed, so let's remove solver bond
-
-						m_solverBondsData.replaceWithLast(solverBondIndex);
-						m_solver.replaceWithLast(solverBondIndex);
-						if (m_solver.getBondCount() > 0)
-						{
-							// update 'previously last' solver bond mapping
-							const auto& solverBond = m_solver.getBondData(solverBondIndex);
-							m_solverBondsMap[BondKey(solverBond.node0, solverBond.node1)] = solverBondIndex;
-						}
-
-						m_solverBondsMap.erase(solverBondKey);
-					}
-				}
-
-				CHECK_GRAPH_INTEGRITY;
-			}
-
-			// remove bond from graph processor's list
-			m_blastBondIndexMap[blastBondIndex] = invalidIndex<uint32_t>();
-			m_bondsData.replaceWithLast(bondIndex);
-			m_blastBondIndexMap[m_bondsData[bondIndex].blastBondIndex] = m_bondsData.size() > bondIndex ? bondIndex : invalidIndex<uint32_t>();
-		}
-	}
-
-	NV_INLINE void setGraphReductionLevel(uint32_t level)
-	{
-		m_graphReductionLevel = level;
-		m_nodesDirty = true;
-	}
-
-	uint32_t getGraphReductionLevel() const
-	{
-		return m_graphReductionLevel;
-	}
-
-	void solve(uint32_t iterationCount, bool warmStart = false)
-	{
-		CHECK_GRAPH_INTEGRITY;
-
-		for (const NodeData& node : m_nodesData)
-		{
-			const SequentialImpulseSolver::NodeData& solverNode = m_solver.getNodeData(node.solverNode);
-			m_solver.setNodeVelocities(node.solverNode, solverNode.velocityLinear + node.impulse * solverNode.invMass, PxVec3(PxZero));
-		}
-
-		m_solver.solve(iterationCount, warmStart);
-	}
-
-	void calcError(float& linear, float& angular)
-	{
-		m_solver.calcError(linear, angular);
-	}
-
-	void generateFracture(ExtArray<NvBlastBondFractureData>::type& bondFractureBuffer, const ExtStressSolverSettings& settings, const float* blastBondHealths)
-	{
-		CHECK_GRAPH_INTEGRITY;
-
-		for (uint32_t i = 0; i < m_solverBondsData.size(); ++i)
-		{
-			const SequentialImpulseSolver::BondData& solverInternalBond = m_solver.getBondData(i);
-			if (solverInternalBond.getStressHealth(settings) > 1.0f)
-			{
-				const auto& blastBondIndices = m_solverBondsData[i].blastBondIndices;
-				for (auto blastBondIndex : blastBondIndices)
-				{
-					const uint32_t bondIndex = m_blastBondIndexMap[blastBondIndex];
-					if (!isInvalidIndex(bondIndex))
-					{
-						const BondData& bond = m_bondsData[bondIndex];
-
-						NVBLAST_ASSERT(getNodeData(bond.node0).solverNode != getNodeData(bond.node1).solverNode);
-						NVBLAST_ASSERT(bond.blastBondIndex == blastBondIndex);
-
-						NvBlastBondFractureData data;
-						data.health = blastBondHealths[blastBondIndex];
-						data.nodeIndex0 = bond.node0;
-						data.nodeIndex1 = bond.node1;
-						bondFractureBuffer.pushBack(data);
-					}
-				}
-			}
-		}
-	}
-
-private:
-
-	NV_INLINE void sync()
-	{
-		if (m_nodesDirty)
-		{
-			syncNodes();
-		}
-		if (m_bondsDirty)
-		{
-			syncBonds();
-		}
-
-		CHECK_GRAPH_INTEGRITY;
-	}
-
-	void syncNodes()
-	{
-		// init with 1<->1 blast nodes to solver nodes mapping
-		m_solverNodesData.resize(m_nodesData.size());
-		for (uint32_t i = 0; i < m_nodesData.size(); ++i)
-		{
-			m_nodesData[i].solverNode = i;
-			m_solverNodesData[i].supportNodesCount = 1;
-			m_solverNodesData[i].indexShift = 0;
-		}
-
-		// for static nodes aggregate size per graph reduction level is lower, it
-		// falls behind on few levels. (can be made as parameter)
-		const uint32_t STATIC_NODES_COUNT_PENALTY = 2 << 2;
-
-		// reducing graph by aggregating nodes level by level
-		for (uint32_t k = 0; k < m_graphReductionLevel; k++)
-		{
-			const uint32_t maxAggregateSize = 1 << (k + 1);
-
-			for (const BondData& bond : m_bondsData)
-			{
-				NodeData& node0 = m_nodesData[bond.node0];
-				NodeData& node1 = m_nodesData[bond.node1];
-
-				if (node0.isStatic != node1.isStatic)
-					continue;
-
-				if (node0.solverNode == node1.solverNode)
-					continue;
-
-				SolverNodeData& solverNode0 = m_solverNodesData[node0.solverNode];
-				SolverNodeData& solverNode1 = m_solverNodesData[node1.solverNode];
-				
-				const int countPenalty = node0.isStatic ? STATIC_NODES_COUNT_PENALTY : 1;
-				const uint32_t aggregateSize = std::min<uint32_t>(maxAggregateSize, node0.neighborsCount / 2);
-
-				if (solverNode0.supportNodesCount * countPenalty >= aggregateSize)
-					continue;
-				if (solverNode1.supportNodesCount * countPenalty >= aggregateSize)
-					continue;
-
-				if (solverNode0.supportNodesCount >= solverNode1.supportNodesCount)
-				{
-					solverNode1.supportNodesCount--;
-					solverNode0.supportNodesCount++;
-					node1.solverNode = node0.solverNode;
-				}
-				else if (solverNode1.supportNodesCount >= solverNode0.supportNodesCount)
-				{
-					solverNode1.supportNodesCount++;
-					solverNode0.supportNodesCount--;
-					node0.solverNode = node1.solverNode;
-				}
-			}
-		}
-
-		// Solver Nodes now sparse, a lot of empty ones. Rearrange them by moving all non-empty to the front
-		// 2 passes used for that
-		{
-			uint32_t currentNode = 0;
-			for (; currentNode < m_solverNodesData.size(); ++currentNode)
-			{
-				if (m_solverNodesData[currentNode].supportNodesCount > 0)
-					continue;
-
-				// 'currentNode' is free
-
-				// search next occupied node
-				uint32_t k = currentNode + 1;
-				for (; k < m_solverNodesData.size(); ++k)
-				{
-					if (m_solverNodesData[k].supportNodesCount > 0)
-					{
-						// replace currentNode and keep indexShift
-						m_solverNodesData[currentNode].supportNodesCount = m_solverNodesData[k].supportNodesCount;
-						m_solverNodesData[k].indexShift = k - currentNode;
-						m_solverNodesData[k].supportNodesCount = 0;
-						break;
-					}
-				}
-
-				if (k == m_solverNodesData.size())
-				{
-					break;
-				}
-			}
-			for (auto& node : m_nodesData)
-			{
-				node.solverNode -= m_solverNodesData[node.solverNode].indexShift;
-			}
-
-			// now, we know total solver nodes count and which nodes are aggregated into them
-			m_solverNodesData.resize(currentNode);
-		}
-
-
-		// calculate all needed data
-		for (SolverNodeData& solverNode : m_solverNodesData)
-		{
-			solverNode.supportNodesCount = 0;
-			solverNode.localPos = PxVec3(PxZero);
-			solverNode.mass = 0.0f;
-			solverNode.volume = 0.0f;
-			solverNode.isStatic = false;
-		}
-
-		for (NodeData& node : m_nodesData)
-		{
-			SolverNodeData& solverNode = m_solverNodesData[node.solverNode];
-			solverNode.supportNodesCount++;
-			solverNode.localPos += node.localPos;
-			solverNode.mass += node.mass;
-			solverNode.volume += node.volume;
-			solverNode.isStatic |= node.isStatic;
-		}
-
-		for (SolverNodeData& solverNode : m_solverNodesData)
-		{
-			solverNode.localPos /= (float)solverNode.supportNodesCount;
-		}
-
-		m_solver.reset(m_solverNodesData.size());
-		for (uint32_t nodeIndex = 0; nodeIndex < m_solverNodesData.size(); ++nodeIndex)
-		{
-			const SolverNodeData& solverNode = m_solverNodesData[nodeIndex];
-
-			const float invMass = solverNode.isStatic ? 0.0f : 1.0f / solverNode.mass;
-			const float R = PxPow(solverNode.volume * 3.0f * PxInvPi / 4.0f, 1.0f / 3.0f); // sphere volume approximation
-			const float invI = invMass / (R * R * 0.4f); // sphere inertia tensor approximation: I = 2/5 * M * R^2 ; invI = 1 / I;
-			m_solver.setNodeMassInfo(nodeIndex, invMass, invI);
-		}
-
-		m_nodesDirty = false;
-
-		syncBonds();
-	}
-
-	void syncBonds()
-	{
-		// traverse all blast bonds and aggregate
-		m_solver.clearBonds();
-		m_solverBondsMap.clear();
-		m_solverBondsData.clear();
-		for (const BondData& bond : m_bondsData)
-		{
-			const NodeData& node0 = m_nodesData[bond.node0];
-			const NodeData& node1 = m_nodesData[bond.node1];
-
-			if (node0.solverNode == node1.solverNode)
-				continue; // skip (internal)
-
-			if (node0.isStatic && node1.isStatic)
-				continue;
-
-			BondKey key(node0.solverNode, node1.solverNode);
-			auto entry = m_solverBondsMap.find(key);
-			SolverBondData* data;
-			if (!entry)
-			{
-				m_solverBondsData.pushBack(SolverBondData());
-				data = &m_solverBondsData.back();
-				m_solverBondsMap[key] = m_solverBondsData.size() - 1;
-
-				SolverNodeData& solverNode0 = m_solverNodesData[node0.solverNode];
-				SolverNodeData& solverNode1 = m_solverNodesData[node1.solverNode];
-				m_solver.addBond(node0.solverNode, node1.solverNode, (solverNode1.localPos - solverNode0.localPos) * 0.5f);
-			}
-			else
-			{
-				data = &m_solverBondsData[entry->second];
-			}
-			data->blastBondIndices.pushBack(bond.blastBondIndex);
-		}
-
-		m_bondsDirty = false;
-	}
-
-#if GRAPH_INTERGRIRY_CHECK
-	void checkGraphIntegrity()
-	{
-		NVBLAST_ASSERT(m_solver.getBondCount() == m_solverBondsData.size());
-		NVBLAST_ASSERT(m_solver.getNodeCount() == m_solverNodesData.size());
-
-		std::set<uint64_t> solverBonds;
-		for (uint32_t i = 0; i < m_solverBondsData.size(); ++i)
-		{
-			const auto& bondData = m_solver.getBondData(i);
-			BondKey key(bondData.node0, bondData.node1);
-			NVBLAST_ASSERT(solverBonds.find(key) == solverBonds.end());
-			solverBonds.emplace(key);
-			auto entry = m_solverBondsMap.find(key);
-			NVBLAST_ASSERT(entry != nullptr);
-			const auto& solverBond = m_solverBondsData[entry->second];
-			for (auto& blastBondIndex : solverBond.blastBondIndices)
-			{
-				if (!isInvalidIndex(m_blastBondIndexMap[blastBondIndex]))
-				{
-					auto& b = m_bondsData[m_blastBondIndexMap[blastBondIndex]];
-					BondKey key2(m_nodesData[b.node0].solverNode, m_nodesData[b.node1].solverNode);
-					NVBLAST_ASSERT(key2 == key);
-				}
-			}
-		}
-
-		for (auto& solverBond : m_solverBondsData)
-		{
-			for (auto& blastBondIndex : solverBond.blastBondIndices)
-			{
-				if (!isInvalidIndex(m_blastBondIndexMap[blastBondIndex]))
-				{
-					auto& b = m_bondsData[m_blastBondIndexMap[blastBondIndex]];
-					NVBLAST_ASSERT(m_nodesData[b.node0].solverNode != m_nodesData[b.node1].solverNode);
-				}
-			}
-		}
-		uint32_t mappedBondCount = 0;
-		for (uint32_t i = 0; i < m_blastBondIndexMap.size(); i++)
-		{
-			const auto& bondIndex = m_blastBondIndexMap[i];
-			if (!isInvalidIndex(bondIndex))
-			{
-				mappedBondCount++;
-				NVBLAST_ASSERT(m_bondsData[bondIndex].blastBondIndex == i);
-			}
-		}
-		NVBLAST_ASSERT(m_bondsData.size() == mappedBondCount);
-	}
-#endif
-
-	struct BondKey
-	{
-		uint32_t node0;
-		uint32_t node1;
-
-		BondKey(uint32_t n0, uint32_t n1)
-		{
-			node0 = n0 < n1 ? n0 : n1;
-			node1 = n0 < n1 ? n1 : n0;
-		}
-
-		operator uint64_t() const
-		{
-			return static_cast<uint64_t>(node0) + (static_cast<uint64_t>(node1) << 32);
-		}
-	};
-
-	SequentialImpulseSolver			    m_solver;
-	ExtArray<SolverNodeData>::type	    m_solverNodesData;
-	ExtArray<SolverBondData>::type	    m_solverBondsData;
-
-	uint32_t						    m_graphReductionLevel;
-
-	bool	                            m_nodesDirty;
-	bool	                            m_bondsDirty;
-
-	ExtHashMap<BondKey, uint32_t>::type m_solverBondsMap;
-	ExtArray<uint32_t>::type		    m_blastBondIndexMap;
-
-	ExtArray<BondData>::type		    m_bondsData;
-	ExtArray<NodeData>::type		    m_nodesData;
-};
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//											 ExtImpulseStressSolver
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//													Creation
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-ExtImpulseStressSolver::ExtImpulseStressSolver(ExtPxFamily& family, ExtStressSolverSettings settings)
-	: m_family(family), m_settings(settings), m_isDirty(false), m_reset(false), 
-	m_errorAngular(std::numeric_limits<float>::max()), m_errorLinear(std::numeric_limits<float>::max()), m_framesCount(0)
-{
-
-	const TkAsset* tkAsset = m_family.getTkFamily().getAsset();
-	const ExtPxAsset& asset = m_family.getPxAsset();
-	const ExtPxChunk* chunks = asset.getChunks();
-	const ExtPxSubchunk* subChunks = asset.getSubchunks();
-	m_graph = tkAsset->getGraph();
-	const uint32_t bondCount = tkAsset->getBondCount();
-	
-	TkActor* tkActor;
-	m_family.getTkFamily().getActors(&tkActor, 1);
-	m_bondHealths = tkActor->getBondHealths();
-
-	m_graphProcessor = NVBLASTEXT_NEW(SupportGraphProcessor)(m_graph.nodeCount, bondCount);
-
-	// traverse graph and fill node info
-	for (uint32_t i = 0; i < m_graph.nodeCount; ++i)
-	{
-		uint32_t node0 = i;
-		uint32_t chunkIndex0 = m_graph.chunkIndices[node0];
-		const ExtPxChunk& chunk0 = chunks[chunkIndex0];
-
-		bool isChunkStatic = chunk0.isStatic;
-
-		for (uint32_t adjacencyIndex = m_graph.adjacencyPartition[node0]; adjacencyIndex < m_graph.adjacencyPartition[node0 + 1]; adjacencyIndex++)
-		{
-			uint32_t bondIndex = m_graph.adjacentBondIndices[adjacencyIndex];
-			if (m_bondHealths[bondIndex] <= 0.0f)
-				continue;
-			uint32_t node1 = m_graph.adjacentNodeIndices[adjacencyIndex];
-			uint32_t chunkIndex1 = m_graph.chunkIndices[node1];
-			const ExtPxChunk& chunk1 = chunks[chunkIndex1];
-
-			if (chunk1.subchunkCount == 0 || chunk1.isStatic)
-			{
-				isChunkStatic |= chunk1.isStatic;
-				continue;
-			}
-		}
-
-		// fill node info
-
-		float mass;
-		float volume;
-		PxVec3 localPos;
-		if (chunk0.subchunkCount > 0)
-		{
-#if USE_PHYSX_CONVEX_DATA
-			const ExtPxSubchunk& subChunk = subChunks[chunk0.firstSubchunkIndex];
-			PxVec3 localCenterOfMass;
-			PxMat33 intertia;
-			PxVec3 scale = subChunk.geometry.scale.scale;
-			subChunk.geometry.convexMesh->getMassInformation(mass, intertia, localCenterOfMass);
-			mass *= scale.x * scale.y * scale.z;
-			const PxTransform& chunk0LocalTransform = subChunk.transform;
-			localPos = chunk0LocalTransform.transform(localCenterOfMass);
-			volume = mass / 1.0f; // unit density
-#else
-			volume = solverChunk0.volume;
-			mass = volume * 1.0f; // density
-			localPos = *reinterpret_cast<const PxVec3*>(solverChunk0.centroid);
-#endif
-		}
-		else
-		{
-			mass = 0.0f;
-			volume = 0.0f;
-			localPos = PxVec3(PxZero);
-			isChunkStatic = true;
-		}
-		m_graphProcessor->setNodeInfo(node0, mass, volume, localPos, isChunkStatic);
-	}
-
-	// traverse graph and fill bond info
-	for (uint32_t node0 = 0; node0 < m_graph.nodeCount; ++node0)
-	{
-		for (uint32_t adjacencyIndex = m_graph.adjacencyPartition[node0]; adjacencyIndex < m_graph.adjacencyPartition[node0 + 1]; adjacencyIndex++)
-		{
-			uint32_t bondIndex = m_graph.adjacentBondIndices[adjacencyIndex];
-			if (m_bondHealths[bondIndex] <= 0.0f)
-				continue;
-			uint32_t node1 = m_graph.adjacentNodeIndices[adjacencyIndex];
-
-			if (node0 < node1)
-			{
-				m_graphProcessor->addBond(node0, node1, bondIndex);
-			}
-		}
-	}
-
-	// fire initial actor's created
-	ExtInlineArray<ExtPxActor*, 4>::type actors;;
-	actors.resize((uint32_t)m_family.getActorCount());
-	m_family.getActors(actors.begin(), actors.size());
-	for (const auto actor : actors)
-	{
-		onActorCreated(m_family, *actor);
-	}
-
-	m_family.subscribe(*this);
-}
-
-ExtImpulseStressSolver::~ExtImpulseStressSolver()
-{
-	NVBLASTEXT_DELETE(m_graphProcessor, SupportGraphProcessor);
-	m_family.unsubscribe(*this);
-}
-
-ExtStressSolver* ExtStressSolver::create(ExtPxFamily& family, ExtStressSolverSettings settings)
-{
-	return NVBLASTEXT_NEW(ExtImpulseStressSolver) (family, settings);
-}
-
-void ExtImpulseStressSolver::release()
-{
-	NVBLASTEXT_DELETE(this, ExtImpulseStressSolver);
-}
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//													Actors
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-void ExtImpulseStressSolver::onActorCreated(ExtPxFamily& /*family*/, ExtPxActor& actor)
-{
-	if (actor.getTkActor().getGraphNodeCount() > 1)
-	{
-		// update neighbors
-		{
-			const uint32_t graphNodeCount = actor.getTkActor().getGraphNodeCount();
-			uint32_t* graphNodeIndices = getScratchArray<uint32_t>(graphNodeCount);
-			actor.getTkActor().getGraphNodeIndices(graphNodeIndices, graphNodeCount);
-			for (uint32_t i = 0; i < graphNodeCount; ++i)
-			{
-				m_graphProcessor->setNodeNeighborsCount(graphNodeIndices[i], graphNodeCount);
-			}
-		}
-
-		m_actors.insert(&actor);
-		m_isDirty = true;
-	}
-}
-
-void ExtImpulseStressSolver::onActorDestroyed(ExtPxFamily& /*family*/, ExtPxActor& actor)
-{
-	if (m_actors.erase(&actor))
-	{
-		m_isDirty = true;
-	}
-}
-
-void ExtImpulseStressSolver::syncSolver()
-{
-	// traverse graph and remove dead bonds
-	for (uint32_t node0 = 0; node0 < m_graph.nodeCount; ++node0)
-	{
-		for (uint32_t adjacencyIndex = m_graph.adjacencyPartition[node0]; adjacencyIndex < m_graph.adjacencyPartition[node0 + 1]; adjacencyIndex++)
-		{
-			uint32_t node1 = m_graph.adjacentNodeIndices[adjacencyIndex];
-			if (node0 < node1)
-			{
-				uint32_t bondIndex = m_graph.adjacentBondIndices[adjacencyIndex];
-
-				if (m_bondHealths[bondIndex] <= 0.0f)
-				{
-					m_graphProcessor->removeBondIfExists(bondIndex);
-				}
-			}
-		}
-	}
-
-	m_isDirty = false;
-}
-
-
-void ExtImpulseStressSolver::initialize()
-{
-	if (m_reset)
-	{
-		m_framesCount = 0;
-	}
-
-	if (m_isDirty)
-	{
-		syncSolver();
-	}
-
-	if (m_settings.graphReductionLevel != m_graphProcessor->getGraphReductionLevel())
-	{
-		m_graphProcessor->setGraphReductionLevel(m_settings.graphReductionLevel);
-	}
-
-	m_graphProcessor->initialize();
-
-	for (auto it = m_actors.getIterator(); !it.done(); ++it)
-	{
-		const ExtPxActor* actor = *it;
-		const uint32_t graphNodeCount = actor->getTkActor().getGraphNodeCount();
-		uint32_t* graphNodeIndices = getScratchArray<uint32_t>(graphNodeCount);
-		actor->getTkActor().getGraphNodeIndices(graphNodeIndices, graphNodeCount);
-
-		PxRigidDynamic& rigidDynamic = actor->getPhysXActor();
-		const bool isStatic = rigidDynamic.getRigidBodyFlags() & PxRigidBodyFlag::eKINEMATIC;
-		if (isStatic)
-		{
-			PxVec3 gravity = rigidDynamic.getScene()->getGravity();
-			gravity = rigidDynamic.getGlobalPose().rotateInv(gravity);
-
-			for (uint32_t i = 0; i < graphNodeCount; ++i)
-			{
-				const uint32_t node = graphNodeIndices[i];
-				m_graphProcessor->addNodeVelocity(node, gravity);
-			}
-		}
-		else
-		{
-			PxVec3 cMassPose = rigidDynamic.getCMassLocalPose().p;
-
-			PxVec3 angularVelocity = rigidDynamic.getGlobalPose().rotateInv(rigidDynamic.getAngularVelocity());
-			//PxVec3 linearVelocity = rigidDynamic.getGlobalPose().rotateInv(rigidDynamic.getLinearVelocity());
-
-			// Apply centrifugal force
-			for (uint32_t i = 0; i < graphNodeCount; ++i)
-			{
-				const uint32_t node = graphNodeIndices[i];
-				const auto& localPos = m_graphProcessor->getNodeData(node).localPos;
-				// a = w x (w x r)
-				const PxVec3 centrifugalAcceleration = angularVelocity.cross(angularVelocity.cross(localPos - cMassPose));
-				m_graphProcessor->addNodeVelocity(node, centrifugalAcceleration);
-			}
-		}
-
-		const auto entry = m_impulseBuffer.find(actor);
-		if (entry)
-		{
-			for (const ImpulseData& data : entry->second)
-			{
-				float bestDist = FLT_MAX;
-				uint32_t bestNode = invalidIndex<uint32_t>();
-
-				for (uint32_t i = 0; i < graphNodeCount; ++i)
-				{
-					const uint32_t node = graphNodeIndices[i];
-					const float sqrDist = (data.position - m_graphProcessor->getNodeData(node).localPos).magnitudeSquared();
-					if (sqrDist < bestDist)
-					{
-						bestDist = sqrDist;
-						bestNode = node;
-					}
-				}
-
-				if (!isInvalidIndex(bestNode))
-				{
-					m_graphProcessor->addNodeImpulse(bestNode, data.impulse);
-				}
-			}
-			m_impulseBuffer[actor].clear();
-		}
-	}
-}
-
-void ExtImpulseStressSolver::applyImpulse(ExtPxActor& actor, physx::PxVec3 position, physx::PxVec3 force)
-{
-	ImpulseData data = { position, force };
-
-	m_impulseBuffer[&actor].pushBack(data);
-}
-
-uint32_t ExtImpulseStressSolver::getBondCount() const
-{
-	return m_graphProcessor->getSolverBondCount();
-}
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//													Update
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-void ExtImpulseStressSolver::update(bool doDamage)
-{
-	initialize();
-
-	solve();
-
-	if (doDamage)
-	{
-		applyDamage();
-	}
-
-	m_framesCount++;
-}
-
-void ExtImpulseStressSolver::solve()
-{
-	PX_SIMD_GUARD;
-
-	const uint32_t iterations = getIterationsPerFrame();
-	m_graphProcessor->solve(iterations, WARM_START && !m_reset);
-	m_reset = false;
-
-	m_graphProcessor->calcError(m_errorLinear, m_errorAngular);
-}
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//													Damage
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-void ExtImpulseStressSolver::applyDamage()
-{
-	m_bondFractureBuffer.clear();
-	m_graphProcessor->generateFracture(m_bondFractureBuffer, m_settings, m_bondHealths);
-
-	if (m_bondFractureBuffer.size() > 0)
-	{
-		NvBlastFractureBuffers fractureCommands;
-		fractureCommands.chunkFractureCount = 0;
-		fractureCommands.bondFractureCount = m_bondFractureBuffer.size();
-		fractureCommands.bondFractures = m_bondFractureBuffer.begin();
-
-		m_family.getTkFamily().applyFracture(&fractureCommands);
-	}
-}
-
-uint32_t ExtImpulseStressSolver::getIterationCount() const
-{
-	return getFrameCount() * getIterationsPerFrame();
-}
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//													Debug Render
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-static PxU32 PxVec4ToU32Color(const PxVec4& color)
-{
-	PxU32 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;
-}
-
-static PxVec4 PxVec4Lerp(const PxVec4 v0, const PxVec4 v1, float val)
-{
-	PxVec4 v(
-		v0.x * (1 - val) + v1.x * val,
-		v0.y * (1 - val) + v1.y * val,
-		v0.z * (1 - val) + v1.z * val,
-		v0.w * (1 - val) + v1.w * val
-		);
-	return v;
-}
-
-inline float clamp01(float v)
-{
-	return v < 0.0f ? 0.0f : (v > 1.0f ? 1.0f : v);
-}
-
-inline PxVec4 bondHealthColor(float healthFraction)
-{
-	healthFraction = clamp01(healthFraction);
-
-	const PxVec4 BOND_HEALTHY_COLOR(0.0f, 1.0f, 1.0f, 1.0f);
-	const PxVec4 BOND_MID_COLOR(1.0f, 1.0f, 0.0f, 1.0f);
-	const PxVec4 BOND_BROKEN_COLOR(1.0f, 0.0f, 0.0f, 1.0f);
-
-	return healthFraction < 0.5 ? PxVec4Lerp(BOND_BROKEN_COLOR, BOND_MID_COLOR, 2.0f * healthFraction) : PxVec4Lerp(BOND_MID_COLOR, BOND_HEALTHY_COLOR, 2.0f * healthFraction - 1.0f);
-}
-
-void ExtImpulseStressSolver::fillDebugRender(const std::vector<uint32_t>& nodes, std::vector<PxDebugLine>& lines, DebugRenderMode mode, float scale)
-{
-	const PxVec4 BOND_IMPULSE_LINEAR_COLOR(0.0f, 1.0f, 0.0f, 1.0f);
-	const PxVec4 BOND_IMPULSE_ANGULAR_COLOR(1.0f, 0.0f, 0.0f, 1.0f);
-
-	if (m_isDirty)
-		return;
-
-	ExtArray<uint8_t>::type& nodesSet = m_scratch;
-
-	nodesSet.resize(m_graphProcessor->getSolverNodeCount());
-	memset(nodesSet.begin(), 0, nodesSet.size() * sizeof(uint8_t));
-	for (auto& nodeIndex : nodes)
-	{
-		nodesSet[m_graphProcessor->getNodeData(nodeIndex).solverNode] = 1;
-	}
-
-	const uint32_t bondCount = m_graphProcessor->getSolverBondCount();
-	for (uint32_t i = 0; i < bondCount; ++i)
-	{
-		const auto& solverInternalBondData = m_graphProcessor->getSolverInternalBondData(i);
-		if (nodesSet[solverInternalBondData.node0] != 0)
-		{
-			NVBLAST_ASSERT(nodesSet[solverInternalBondData.node1] != 0);
-
-			const auto& solverInternalNode0 = m_graphProcessor->getSolverInternalNodeData(solverInternalBondData.node0);
-			const auto& solverInternalNode1 = m_graphProcessor->getSolverInternalNodeData(solverInternalBondData.node1);
-			const auto& solverNode0 = m_graphProcessor->getSolverNodeData(solverInternalBondData.node0);
-			const auto& solverNode1 = m_graphProcessor->getSolverNodeData(solverInternalBondData.node1);
-
-			PxVec3 p0 = solverNode0.localPos;
-			PxVec3 p1 = solverNode1.localPos;
-			PxVec3 center = (p0 + p1) * 0.5f;
-
-			const float stress = std::min<float>(solverInternalBondData.getStressHealth(m_settings), 1.0f);
-			PxVec4 color = bondHealthColor(1.0f - stress);
-
-			lines.push_back(PxDebugLine(p0, p1, PxVec4ToU32Color(color)));
-
-			float impulseScale = scale;
-
-			if (mode == DebugRenderMode::STRESS_GRAPH_NODES_IMPULSES)
-			{
-				lines.push_back(PxDebugLine(p0, p0 + solverInternalNode0.velocityLinear * impulseScale, PxVec4ToU32Color(BOND_IMPULSE_LINEAR_COLOR)));
-				lines.push_back(PxDebugLine(p0, p0 + solverInternalNode0.velocityAngular * impulseScale, PxVec4ToU32Color(BOND_IMPULSE_ANGULAR_COLOR)));
-				lines.push_back(PxDebugLine(p1, p1 + solverInternalNode1.velocityLinear * impulseScale, PxVec4ToU32Color(BOND_IMPULSE_LINEAR_COLOR)));
-				lines.push_back(PxDebugLine(p1, p1 + solverInternalNode1.velocityAngular * impulseScale, PxVec4ToU32Color(BOND_IMPULSE_ANGULAR_COLOR)));
-			}
-			else if (mode == DebugRenderMode::STRESS_GRAPH_BONDS_IMPULSES)
-			{
-				lines.push_back(PxDebugLine(center, center + solverInternalBondData.impulseLinear * impulseScale, PxVec4ToU32Color(BOND_IMPULSE_LINEAR_COLOR)));
-				lines.push_back(PxDebugLine(center, center + solverInternalBondData.impulseAngular * impulseScale, PxVec4ToU32Color(BOND_IMPULSE_ANGULAR_COLOR)));
-			}
-		}
-	}
-}
-
-
-} // namespace Blast
-} // namespace Nv
diff --git a/NvBlast/sdk/extensions/physx/source/physics/NvBlastExtImpulseStressSolver.h b/NvBlast/sdk/extensions/physx/source/physics/NvBlastExtImpulseStressSolver.h
deleted file mode 100644
index d274789..0000000
--- a/NvBlast/sdk/extensions/physx/source/physics/NvBlastExtImpulseStressSolver.h
+++ /dev/null
@@ -1,164 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTIMPULSESTRESSSOLVER_H
-#define NVBLASTEXTIMPULSESTRESSSOLVER_H
-
-#include "NvBlastExtStressSolver.h"
-#include "NvBlastExtPxManager.h"
-#include "NvBlastExtPxListener.h"
-#include "NvBlastTypes.h"
-#include <NvBlastExtArray.h>
-#include <NvBlastExtHashSet.h>
-#include <NvBlastExtHashMap.h>
-
-namespace Nv
-{
-namespace Blast
-{
-
-
-struct ExtStressNodeCachedData
-{
-	physx::PxVec3 localPos;
-	bool isStatic;
-};
-
-
-struct ExtStressBondCachedData
-{
-	uint32_t bondIndex;
-};
-
-class SupportGraphProcessor;
-
-/**
-*/
-class ExtImpulseStressSolver : public ExtStressSolver, ExtPxListener
-{
-	NV_NOCOPY(ExtImpulseStressSolver)
-
-public:
-	ExtImpulseStressSolver(ExtPxFamily& family, ExtStressSolverSettings settings);
-	virtual void							release() override;
-
-
-	//////// ExtStressSolver interface ////////
-
-	virtual void							setSettings(const ExtStressSolverSettings& settings) override
-	{
-		m_settings = settings;
-	}
-
-	virtual const ExtStressSolverSettings&	getSettings() const override
-	{
-		return m_settings;
-	}
-
-	virtual void							applyImpulse(ExtPxActor& actor, physx::PxVec3 position, physx::PxVec3 force) override;
-
-	virtual void							update(bool doDamage) override;
-
-	void									reset() override
-	{
-		m_reset = true;
-	}
-
-	virtual float							getStressErrorLinear() const override
-	{
-		return m_errorLinear;
-	}
-
-	virtual float							getStressErrorAngular() const override
-	{
-		return m_errorAngular;
-	}
-
-	virtual uint32_t						getIterationCount() const override;
-
-	virtual uint32_t						getFrameCount() const override
-	{
-		return m_framesCount;
-	}
-
-	virtual uint32_t						getBondCount() const override;
-
-	virtual void							fillDebugRender(const std::vector<uint32_t>& nodes, std::vector<physx::PxDebugLine>& lines, DebugRenderMode mode, float scale) override;
-
-
-	//////// ExtPxListener interface ////////
-
-	virtual void							onActorCreated(ExtPxFamily& family, ExtPxActor& actor) final;
-
-	virtual void							onActorDestroyed(ExtPxFamily& family, ExtPxActor& actor) final;
-
-
-private:
-	~ExtImpulseStressSolver();
-
-
-	//////// private methods ////////
-
-	void									solve();
-
-	void									applyDamage();
-
-	void									initialize();
-
-	NV_INLINE void							iterate();
-
-	void									syncSolver();
-
-	template<class T>
-	NV_INLINE T*							getScratchArray(uint32_t size);
-
-
-	//////// data ////////
-
-	struct ImpulseData
-	{
-		physx::PxVec3 position;
-		physx::PxVec3 impulse;
-	};
-
-	ExtPxFamily&														m_family;
-	ExtHashSet<ExtPxActor*>::type										m_actors;
-	ExtStressSolverSettings												m_settings;
-	NvBlastSupportGraph													m_graph;
-	bool																m_isDirty;
-	bool																m_reset;
-	const float*														m_bondHealths;
-	SupportGraphProcessor*												m_graphProcessor;
-	float																m_errorAngular;
-	float																m_errorLinear;
-	uint32_t															m_framesCount;
-	ExtArray<NvBlastBondFractureData>::type								m_bondFractureBuffer;
-	ExtHashMap<const ExtPxActor*, ExtArray<ImpulseData>::type>::type	m_impulseBuffer;
-	ExtArray<uint8_t>::type												m_scratch;
-};
-
-
-template<class T>
-NV_INLINE T* ExtImpulseStressSolver::getScratchArray(uint32_t size)
-{
-	const uint32_t scratchSize = sizeof(T) * size;
-	if (m_scratch.size() < scratchSize)
-	{
-		m_scratch.resize(scratchSize);
-	}
-	return reinterpret_cast<T*>(m_scratch.begin());
-}
-
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTEXTIMPULSESTRESSSOLVER_H
diff --git a/NvBlast/sdk/extensions/physx/source/physics/NvBlastExtPxActorImpl.cpp b/NvBlast/sdk/extensions/physx/source/physics/NvBlastExtPxActorImpl.cpp
deleted file mode 100644
index 7732d18..0000000
--- a/NvBlast/sdk/extensions/physx/source/physics/NvBlastExtPxActorImpl.cpp
+++ /dev/null
@@ -1,180 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastExtPxActorImpl.h"
-#include "NvBlastExtPxAsset.h"
-#include "NvBlastExtPxManagerImpl.h"
-#include "NvBlastExtPxFamilyImpl.h"
-
-#include "PxRigidDynamic.h"
-#include "PxPhysics.h"
-
-#include "NvBlastTkActor.h"
-#include "NvBlastTkAsset.h"
-
-#include "PxRigidBodyExt.h"
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-
-ExtPxActorImpl::ExtPxActorImpl(ExtPxFamilyImpl* family, TkActor* tkActor, const PxActorCreateInfo& pxActorInfo)
-	: m_family(family), m_tkActor(tkActor)
-{
-	const ExtPxChunk* pxChunks = m_family->m_pxAsset.getChunks();
-	const ExtPxSubchunk* pxSubchunks = m_family->m_pxAsset.getSubchunks();
-	const NvBlastChunk* chunks = m_tkActor->getAsset()->getChunks();
-	uint32_t nodeCount = m_tkActor->getGraphNodeCount();
-
-	PxFilterData simulationFilterData;	// Default constructor = {0,0,0,0}
-
-	// get visible chunk indices list
-	{
-		auto& chunkIndices = m_family->m_indicesScratch;
-		chunkIndices.resize(m_tkActor->getVisibleChunkCount());
-		m_tkActor->getVisibleChunkIndices(chunkIndices.begin(), static_cast<uint32_t>(chunkIndices.size()));
-
-		// fill visible chunk indices list with mapped to our asset indices
-		m_chunkIndices.reserve(chunkIndices.size());
-		for (const uint32_t chunkIndex : chunkIndices)
-		{
-			const ExtPxChunk& chunk = pxChunks[chunkIndex];
-			if (chunk.subchunkCount == 0)
-				continue;
-			m_chunkIndices.pushBack(chunkIndex);
-		}
-
-		// Single lower-support chunk actors might be leaf actors, check for this and disable contact callbacks if so
-		if (nodeCount <= 1)
-		{
-			PX_ASSERT(chunkIndices.size() == 1);
-			if (chunkIndices.size() > 0)
-			{
-				const NvBlastChunk& chunk = chunks[chunkIndices[0]];
-				if (chunk.firstChildIndex == chunk.childIndexStop)
-				{
-					simulationFilterData.word3 = ExtPxManager::LEAF_CHUNK;	// mark as leaf chunk if chunk has no children
-				}
-			}
-		}
-	}
-
-	// create rigidDynamic and setup
-	PxPhysics& physics = m_family->m_manager.m_physics;
-	m_rigidDynamic = physics.createRigidDynamic(pxActorInfo.m_transform);
-	if (m_family->m_pxActorDescTemplate != nullptr)
-	{
-		m_rigidDynamic->setActorFlags(static_cast<physx::PxActorFlags>(m_family->m_pxActorDescTemplate->flags));
-	}
-
-	// fill rigidDynamic with shapes
-	PxMaterial* material = m_family->m_spawnSettings.material;
-	for (uint32_t i = 0; i < m_chunkIndices.size(); ++i)
-	{
-		uint32_t chunkID = m_chunkIndices[i];
-		const ExtPxChunk& chunk = pxChunks[chunkID];
-		for (uint32_t c = 0; c < chunk.subchunkCount; c++)
-		{
-			const uint32_t subchunkIndex = chunk.firstSubchunkIndex + c;
-			auto& subchunk = pxSubchunks[subchunkIndex];
-			PxShape* shape = physics.createShape(subchunk.geometry, *material);
-			shape->setLocalPose(subchunk.transform);
-
-			const ExtPxShapeDescTemplate* pxShapeDesc = m_family->m_pxShapeDescTemplate;
-			if (pxShapeDesc != nullptr)
-			{
-				shape->setFlags(static_cast<PxShapeFlags>(pxShapeDesc->flags));
-				shape->setSimulationFilterData(pxShapeDesc->simulationFilterData);
-				shape->setQueryFilterData(pxShapeDesc->queryFilterData);
-				shape->setContactOffset(pxShapeDesc->contactOffset);
-				shape->setRestOffset(pxShapeDesc->restOffset);
-			}
-			else
-			{
-				shape->setSimulationFilterData(simulationFilterData);
-			}
-
-			m_rigidDynamic->attachShape(*shape);
-
-			PX_ASSERT_WITH_MESSAGE(m_family->m_subchunkShapes[subchunkIndex] == nullptr, "Chunk has some shapes(live).");
-			m_family->m_subchunkShapes[subchunkIndex] = shape;
-		}
-	}
-
-	// search for static chunk in actor's graph (make actor static if it contains static chunk)
-	bool staticFound = false;
-	if (nodeCount > 0)
-	{
-		auto& graphChunkIndices = m_family->m_indicesScratch;
-		graphChunkIndices.resize(nodeCount);
-		m_tkActor->getGraphNodeIndices(graphChunkIndices.begin(), static_cast<uint32_t>(graphChunkIndices.size()));
-		const NvBlastSupportGraph graph = m_tkActor->getAsset()->getGraph();
-
-		for (uint32_t i = 0; !staticFound && i < graphChunkIndices.size(); ++i)
-		{
-			uint32_t chunkIndex = graph.chunkIndices[graphChunkIndices[i]];
-			const ExtPxChunk& chunk = pxChunks[chunkIndex];
-			staticFound = chunk.isStatic;
-		}
-	}
-	m_rigidDynamic->setRigidBodyFlag(PxRigidBodyFlag::eKINEMATIC, staticFound);
-
-	// store pointer to actor in px userData
-	m_family->m_manager.registerActor(m_rigidDynamic, this);
-
-	// store pointer to actor in blast userData
-	m_tkActor->userData = this;
-
-	// update mass properties
-	PxRigidBodyExt::updateMassAndInertia(*m_rigidDynamic, m_family->m_spawnSettings.density);
-
-	// set initial velocities
-	if (!(m_rigidDynamic->getRigidBodyFlags() & PxRigidBodyFlag::eKINEMATIC))
-	{
-		m_rigidDynamic->setLinearVelocity(pxActorInfo.m_linearVelocity);
-		m_rigidDynamic->setAngularVelocity(pxActorInfo.m_angularVelocity);
-	}
-}
-
-void ExtPxActorImpl::release()
-{
-	if (m_rigidDynamic != nullptr)
-	{
-		m_family->m_manager.unregisterActor(m_rigidDynamic);
-		m_rigidDynamic->release();
-		m_rigidDynamic = nullptr;
-	}
-
-	const ExtPxChunk* pxChunks = m_family->m_pxAsset.getChunks();
-	for (uint32_t chunkID : m_chunkIndices)
-	{
-		const ExtPxChunk& chunk = pxChunks[chunkID];
-		for (uint32_t c = 0; c < chunk.subchunkCount; c++)
-		{
-			const uint32_t subchunkIndex = chunk.firstSubchunkIndex + c;
-			m_family->m_subchunkShapes[subchunkIndex] = nullptr;
-		}
-	}
-	m_chunkIndices.clear();
-
-	m_tkActor->userData = nullptr;
-}
-
-ExtPxFamily& ExtPxActorImpl::getFamily() const
-{
-	return *m_family;
-}
-
-
-} // namespace Blast
-} // namespace Nv
diff --git a/NvBlast/sdk/extensions/physx/source/physics/NvBlastExtPxActorImpl.h b/NvBlast/sdk/extensions/physx/source/physics/NvBlastExtPxActorImpl.h
deleted file mode 100644
index a592293..0000000
--- a/NvBlast/sdk/extensions/physx/source/physics/NvBlastExtPxActorImpl.h
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTPXACTORIMPL_H
-#define NVBLASTEXTPXACTORIMPL_H
-
-#include "NvBlastExtPxActor.h"
-#include "NvBlastExtArray.h"
-#include "PxTransform.h"
-
-
-using namespace physx;
-
-namespace Nv
-{
-namespace Blast
-{
-
-
-// Forward declarations
-class ExtPxFamilyImpl;
-
-struct PxActorCreateInfo
-{
-	PxTransform	m_transform;
-	PxVec3		m_scale;
-	PxVec3		m_linearVelocity;
-	PxVec3		m_angularVelocity;
-};
-
-
-class ExtPxActorImpl final : public ExtPxActor
-{
-public:
-	//////// ctor ////////
-
-	ExtPxActorImpl(ExtPxFamilyImpl* family, TkActor* tkActor, const PxActorCreateInfo& pxActorInfo);
-
-	~ExtPxActorImpl()
-	{
-		release();
-	}
-
-	void release();
-
-
-	//////// interface ////////
-
-	virtual uint32_t					getChunkCount() const override
-	{
-		return static_cast<uint32_t>(m_chunkIndices.size());
-	}
-
-	virtual const uint32_t*				getChunkIndices() const override
-	{
-		return m_chunkIndices.begin();
-	}
-
-	virtual PxRigidDynamic&				getPhysXActor() const override
-	{
-		return *m_rigidDynamic;
-	}
-
-	virtual TkActor&					getTkActor() const override
-	{
-		return *m_tkActor;
-	}
-
-	virtual ExtPxFamily&				getFamily() const override;
-
-
-private:
-	//////// data ////////
-
-	ExtPxFamilyImpl*					m_family;
-	TkActor*							m_tkActor;
-	PxRigidDynamic*						m_rigidDynamic;
-	ExtInlineArray<uint32_t, 4>::type	m_chunkIndices;
-};
-
-
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTEXTPXACTORIMPL_H
diff --git a/NvBlast/sdk/extensions/physx/source/physics/NvBlastExtPxAssetImpl.cpp b/NvBlast/sdk/extensions/physx/source/physics/NvBlastExtPxAssetImpl.cpp
deleted file mode 100644
index a0f75fc..0000000
--- a/NvBlast/sdk/extensions/physx/source/physics/NvBlastExtPxAssetImpl.cpp
+++ /dev/null
@@ -1,315 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastExtPxAssetImpl.h"
-#include "NvBlastExtHashMap.h"
-
-#include "NvBlastAssert.h"
-#include "NvBlastIndexFns.h"
-
-#include "NvBlastTkAsset.h"
-
-#include "PxIO.h"
-#include "PxPhysics.h"
-#include "PxFileBuf.h"
-#include "cooking/PxCooking.h"
-
-#include <algorithm>
-
-namespace Nv
-{
-namespace Blast
-{
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//											Helpers/Wrappers
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-class FileBufToPxInputStream final : public PxInputStream
-{
-public:
-	FileBufToPxInputStream(PxFileBuf& filebuf) : m_filebuf(filebuf) {}
-
-	virtual uint32_t read(void* dest, uint32_t count)
-	{
-		return m_filebuf.read(dest, count);
-	}
-
-private:
-	FileBufToPxInputStream& operator=(const FileBufToPxInputStream&);
-
-	PxFileBuf& m_filebuf;
-};
-
-
-class FileBufToPxOutputStream final : public PxOutputStream
-{
-public:
-	FileBufToPxOutputStream(PxFileBuf& filebuf) : m_filebuf(filebuf) {}
-
-	virtual uint32_t write(const void* src, uint32_t count) override
-	{
-		return m_filebuf.write(src, count);
-	}
-
-private:
-	FileBufToPxOutputStream& operator=(const FileBufToPxOutputStream&);
-
-	PxFileBuf& m_filebuf;
-};
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//										ExtPxAssetImpl Implementation
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-ExtPxAssetImpl::ExtPxAssetImpl(const ExtPxAssetDesc& desc, TkFramework& framework)
-{
-	m_tkAsset = framework.createAsset(desc);
-
-	// count subchunks and reserve memory
-	uint32_t subchunkCount = 0;
-	for (uint32_t i = 0; i < desc.chunkCount; ++i)
-	{
-		const auto& chunk = desc.pxChunks[i];
-		subchunkCount += static_cast<uint32_t>(chunk.subchunkCount);
-	}
-	m_subchunks.reserve(subchunkCount);
-
-	// fill chunks and subchunks
-	m_chunks.resize(desc.chunkCount);
-	for (uint32_t i = 0; i < desc.chunkCount; ++i)
-	{
-		const auto& chunk = desc.pxChunks[i];
-		m_chunks[i].isStatic = chunk.isStatic;
-		m_chunks[i].firstSubchunkIndex = m_subchunks.size();
-		m_chunks[i].subchunkCount = chunk.subchunkCount;
-		for (uint32_t k = 0; k < chunk.subchunkCount; ++k)
-		{
-			ExtPxSubchunk subchunk =
-			{
-				chunk.subchunks[k].transform,
-				chunk.subchunks[k].geometry
-			};
-			m_subchunks.pushBack(subchunk);
-		}
-	}
-}
-
-ExtPxAssetImpl::ExtPxAssetImpl(TkAsset* tkAsset):
-	m_tkAsset(tkAsset)
-{
-
-}
-
-ExtPxAssetImpl::~ExtPxAssetImpl()
-{
-	if (m_tkAsset)
-	{
-		m_tkAsset->release();
-	}
-}
-
-void ExtPxAssetImpl::release()
-{
-	NVBLASTEXT_DELETE(this, ExtPxAssetImpl);
-}
-
-NV_INLINE bool serializeConvexMesh(const PxConvexMesh& convexMesh, PxCooking& cooking, ExtArray<uint32_t>::type& indicesScratch, 
-	ExtArray<PxHullPolygon>::type hullPolygonsScratch, PxOutputStream& stream)
-{
-	PxConvexMeshDesc desc;
-	desc.points.data = convexMesh.getVertices();
-	desc.points.count = convexMesh.getNbVertices();
-	desc.points.stride = sizeof(PxVec3);
-
-	hullPolygonsScratch.resize(convexMesh.getNbPolygons());
-
-	uint32_t indexCount = 0;
-	for (uint32_t i = 0; i < convexMesh.getNbPolygons(); i++)
-	{
-		PxHullPolygon polygon;
-		convexMesh.getPolygonData(i, polygon);
-		if (polygon.mNbVerts)
-		{
-			indexCount = std::max<uint32_t>(indexCount, polygon.mIndexBase + polygon.mNbVerts);
-		}
-	}
-	indicesScratch.resize(indexCount);
-
-	for (uint32_t i = 0; i < convexMesh.getNbPolygons(); i++)
-	{
-		PxHullPolygon polygon;
-		convexMesh.getPolygonData(i, polygon);
-		for (uint32_t j = 0; j < polygon.mNbVerts; j++)
-		{
-			indicesScratch[polygon.mIndexBase + j] = convexMesh.getIndexBuffer()[polygon.mIndexBase + j];
-		}
-
-		hullPolygonsScratch[i] = polygon;
-	}
-
-	desc.indices.count = indexCount;
-	desc.indices.data = indicesScratch.begin();
-	desc.indices.stride = sizeof(uint32_t);
-
-	desc.polygons.count = convexMesh.getNbPolygons();
-	desc.polygons.data = hullPolygonsScratch.begin();
-	desc.polygons.stride = sizeof(PxHullPolygon);
-
-	return cooking.cookConvexMesh(desc, stream);
-}
-
-bool ExtPxAssetImpl::serialize(PxFileBuf& stream, PxCooking& cooking) const
-{
-	// Header data
-	stream.storeDword(ClassID);
-	stream.storeDword(Version::Current);
-
-	m_tkAsset->serialize(stream);
-
-	// Chunks
-	const uint32_t chunkCount = m_tkAsset->getChunkCount();
-	for (uint32_t i = 0; i < chunkCount; ++i)
-	{
-		const ExtPxChunk& chunk = m_chunks[i];
-		stream.storeDword(chunk.firstSubchunkIndex);
-		stream.storeDword(chunk.subchunkCount);
-		stream.storeDword(chunk.isStatic ? 1 : 0);
-	}
-
-	stream.storeDword(m_subchunks.size());
-
-	ExtArray<uint32_t>::type indicesScratch(512);
-	ExtArray<PxHullPolygon>::type hullPolygonsScratch(512);
-	ExtHashMap<PxConvexMesh*, uint32_t>::type convexReuseMap;
-
-	FileBufToPxOutputStream outputStream(stream);
-	for (uint32_t i = 0; i < m_subchunks.size(); ++i)
-	{
-		auto& subchunk = m_subchunks[i];
-
-		// Subchunk transform
-		stream.storeFloat(subchunk.transform.q.x);	stream.storeFloat(subchunk.transform.q.y);	stream.storeFloat(subchunk.transform.q.z);	stream.storeFloat(subchunk.transform.q.w);
-		stream.storeFloat(subchunk.transform.p.x);	stream.storeFloat(subchunk.transform.p.y);	stream.storeFloat(subchunk.transform.p.z);
-
-		// Subchunk scale
-		stream.storeFloat(subchunk.geometry.scale.scale.x);	stream.storeFloat(subchunk.geometry.scale.scale.y);	stream.storeFloat(subchunk.geometry.scale.scale.z);
-		stream.storeFloat(subchunk.geometry.scale.rotation.x);	stream.storeFloat(subchunk.geometry.scale.rotation.y);	stream.storeFloat(subchunk.geometry.scale.rotation.z);	stream.storeFloat(subchunk.geometry.scale.rotation.w);
-
-		auto convexMesh = subchunk.geometry.convexMesh;
-		NVBLASTEXT_CHECK_ERROR(convexMesh != nullptr, "ExtPxAssetImpl::serialize: subchunk convexMesh is nullptr.", return false);
-
-		auto entry = convexReuseMap.find(convexMesh);
-		if (entry)
-		{
-			stream.storeDword(entry->second);
-		}
-		else
-		{
-			stream.storeDword(invalidIndex<uint32_t>());
-			if (!serializeConvexMesh(*convexMesh, cooking, indicesScratch, hullPolygonsScratch, outputStream))
-			{
-				NVBLASTEXT_LOG_ERROR("ExtPxAssetImpl::serialize: subchunk convexMesh cooking/serialization failed.");
-				return false;
-			}
-			convexReuseMap[convexMesh] = i;
-		}
-	}
-
-	return true;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//										ExtPxAsset Static
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-ExtPxAsset*	ExtPxAsset::create(const ExtPxAssetDesc& desc, TkFramework& framework)
-{
-	ExtPxAssetImpl* asset = NVBLASTEXT_NEW(ExtPxAssetImpl)(desc, framework);
-	return asset;
-}
-
-
-Nv::Blast::ExtPxAsset* ExtPxAsset::create(TkAsset* tkAsset)
-{
-	ExtPxAssetImpl* asset = NVBLASTEXT_NEW(ExtPxAssetImpl)(tkAsset);
-
-	// Don't populate the chunks or subchunks!
-
-	return asset;
-}
-
-ExtPxAsset* ExtPxAsset::deserialize(PxFileBuf& stream, TkFramework& framework, PxPhysics& physics)
-{
-	ExtPxAssetImpl::DataHeader header;
-	header.dataType = stream.readDword();
-	header.version = stream.readDword();
-	NVBLASTEXT_CHECK_ERROR(header.dataType == ExtPxAssetImpl::ClassID,	"ExtPxAsset::deserialize: wrong data type in filebuf stream.",	return nullptr);
-	NVBLASTEXT_CHECK_ERROR(header.version == ExtPxAssetImpl::Version::Current, "ExtPxAsset::deserialize: wrong data version in filebuf stream.", return nullptr);
-
-	TkAsset* tkAsset = static_cast<TkAsset*>(framework.deserialize(stream));
-	NVBLASTEXT_CHECK_ERROR(tkAsset != nullptr, "ExtPxAsset::deserialize: failed to deserialize TkAsset.", return nullptr);
-
-	ExtPxAssetImpl* asset = NVBLASTEXT_NEW(ExtPxAssetImpl)(tkAsset);
-
-	asset->m_chunks.resize(asset->m_tkAsset->getChunkCount());
-
-	const uint32_t chunkCount = asset->m_chunks.size();
-	for (uint32_t i = 0; i < chunkCount; ++i)
-	{
-		ExtPxChunk& chunk = asset->m_chunks[i];
-		chunk.firstSubchunkIndex = stream.readDword();
-		chunk.subchunkCount = stream.readDword();
-		chunk.isStatic = 0 != stream.readDword();
-	}
-
-	const uint32_t subchunkCount = stream.readDword();
-	asset->m_subchunks.resize(subchunkCount);
-
-	FileBufToPxInputStream inputStream(stream);
-	for (uint32_t i = 0; i < asset->m_subchunks.size(); ++i)
-	{
-		ExtPxSubchunk& subChunk = asset->m_subchunks[i];
-
-		// Subchunk transform
-		subChunk.transform.q.x = stream.readFloat();	subChunk.transform.q.y = stream.readFloat();	subChunk.transform.q.z = stream.readFloat();	subChunk.transform.q.w = stream.readFloat();
-		subChunk.transform.p.x = stream.readFloat();	subChunk.transform.p.y = stream.readFloat();	subChunk.transform.p.z = stream.readFloat();
-
-		// Subchunk scale
-		subChunk.geometry.scale.scale.x = stream.readFloat();	subChunk.geometry.scale.scale.y = stream.readFloat();	subChunk.geometry.scale.scale.z = stream.readFloat();
-		subChunk.geometry.scale.rotation.x = stream.readFloat();	subChunk.geometry.scale.rotation.y = stream.readFloat();	subChunk.geometry.scale.rotation.z = stream.readFloat();	subChunk.geometry.scale.rotation.w = stream.readFloat();
-
-		const uint32_t convexReuseIndex = stream.readDword();
-		if (isInvalidIndex(convexReuseIndex))
-		{
-			subChunk.geometry.convexMesh = physics.createConvexMesh(inputStream);
-		}
-		else
-		{
-			NVBLAST_ASSERT_WITH_MESSAGE(convexReuseIndex < i, "ExtPxAsset::deserialize: wrong convexReuseIndex.");
-			subChunk.geometry.convexMesh = asset->m_subchunks[convexReuseIndex].geometry.convexMesh;
-		}
-		if (!subChunk.geometry.convexMesh)
-		{
-			NVBLASTEXT_LOG_ERROR("ExtPxAsset::deserialize: failed to deserialize convex mesh.");
-			asset->release();
-			return nullptr;
-		}
-	}
-
-	return asset;
-}
-
-
-} // namespace Blast
-} // namespace Nv
diff --git a/NvBlast/sdk/extensions/physx/source/physics/NvBlastExtPxAssetImpl.h b/NvBlast/sdk/extensions/physx/source/physics/NvBlastExtPxAssetImpl.h
deleted file mode 100644
index fd95293..0000000
--- a/NvBlast/sdk/extensions/physx/source/physics/NvBlastExtPxAssetImpl.h
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTPXASSETIMPL_H
-#define NVBLASTEXTPXASSETIMPL_H
-
-#include "NvBlastExtPxAsset.h"
-#include "NvBlastExtArray.h"
-#include "NvBlastExtDefs.h"
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-
-using namespace physx;
-using namespace general_PxIOStream2;
-
-
-class ExtPxAssetImpl final : public ExtPxAsset
-{
-	NV_NOCOPY(ExtPxAssetImpl)
-
-public:
-	friend class ExtPxAsset;
-
-	/**
-	Enum which keeps track of the serialized data format.
-	*/
-	enum Version
-	{
-		/** Initial version */
-		Initial,
-
-		//	New formats must come before Count.  They should be given descriptive names with more information in comments.
-
-		/** The number of serialized formats. */
-		Count,
-
-		/** The current version.  This should always be Count-1 */
-		Current = Count - 1
-	};
-
-	//////// ctor ////////
-
-	ExtPxAssetImpl(const ExtPxAssetDesc& desc, TkFramework& framework);
-	ExtPxAssetImpl(TkAsset* tkAsset);
-
-	~ExtPxAssetImpl();
-
-
-	//////// interface ////////
-
-	virtual void					release() override;
-
-	virtual const TkAsset&			getTkAsset() const override
-	{
-		return *m_tkAsset;
-	}
-
-	virtual uint32_t				getChunkCount() const override
-	{
-		return m_chunks.size();
-	}
-
-	virtual const ExtPxChunk*		getChunks() const override
-	{
-		return m_chunks.begin();
-	}
-
-	virtual uint32_t				getSubchunkCount() const override
-	{
-		return m_subchunks.size();
-	}
-
-	virtual const ExtPxSubchunk*	getSubchunks() const override
-	{
-		return m_subchunks.begin();
-	}
-
-	virtual bool					serialize(PxFileBuf& stream, PxCooking& cooking) const override;
-
-
-	/*
-		Get the underlying array for the chunks. Used for serialization.
-	*/
-	ExtArray<ExtPxChunk>::type&		getChunksArray() { return m_chunks; }
-
-	/*
-	Get the underlying array for the subchunks. Used for serialization.
-	*/
-	ExtArray<ExtPxSubchunk>::type&	getSubchunksArray() { return m_subchunks; }
-
-private:
-	//////// serialization data ////////
-
-	struct DataHeader
-	{
-		uint32_t dataType;
-		uint32_t version;
-	};
-
-	enum { ClassID = NVBLASTEXT_FOURCC('B', 'P', 'X', 'A') }; // Blast PhysX Asset
-
-
-	 //////// data ////////
-
-	TkAsset*						m_tkAsset;
-	ExtArray<ExtPxChunk>::type		m_chunks;
-	ExtArray<ExtPxSubchunk>::type	m_subchunks;
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTEXTPXASSETIMPL_H
diff --git a/NvBlast/sdk/extensions/physx/source/physics/NvBlastExtPxFamilyImpl.cpp b/NvBlast/sdk/extensions/physx/source/physics/NvBlastExtPxFamilyImpl.cpp
deleted file mode 100644
index b2d3a47..0000000
--- a/NvBlast/sdk/extensions/physx/source/physics/NvBlastExtPxFamilyImpl.cpp
+++ /dev/null
@@ -1,294 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastExtPxFamilyImpl.h"
-#include "NvBlastExtPxActorImpl.h"
-#include "NvBlastExtPxAssetImpl.h"
-#include "NvBlastExtPxListener.h"
-#include "NvBlastExtPxManagerImpl.h"
-
-#include "NvBlastTkFamily.h"
-#include "NvBlastTkActor.h"
-#include "NvBlastTkJoint.h"
-
-#include "NvBlastAssert.h"
-
-#include "PxRigidDynamic.h"
-#include "PxScene.h"
-
-#include <algorithm>
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-
-ExtPxFamilyImpl::ExtPxFamilyImpl(ExtPxManagerImpl& manager, TkFamily& tkFamily, const ExtPxAsset& pxAsset)
-	:  m_manager(manager), m_tkFamily(tkFamily), m_pxAsset(pxAsset), m_pxShapeDescTemplate(nullptr), m_pxActorDescTemplate(nullptr), m_isSpawned(false)
-{
-	m_subchunkShapes.resize(static_cast<uint32_t>(m_pxAsset.getSubchunkCount()));
-
-	userData = nullptr;
-
-	m_manager.registerFamily(*this);
-}
-
-ExtPxFamilyImpl::~ExtPxFamilyImpl()
-{
-	m_manager.unregisterFamily(*this);
-
-	if (m_isSpawned)
-	{
-		m_tkFamily.removeListener(*this);
-
-		auto& actors = m_actorsBuffer;
-		actors.resize(m_actors.size());
-		uint32_t i = 0;
-		for (auto it = m_actors.getIterator(); !it.done(); ++it)
-		{
-			actors[i++] = *it;
-		}
-		destroyActors(actors.begin(), actors.size());
-	}
-
-	m_tkFamily.release();
-}
-
-void ExtPxFamilyImpl::release()
-{
-	NVBLASTEXT_DELETE(this, ExtPxFamilyImpl);
-}
-
-bool ExtPxFamilyImpl::spawn(const physx::PxTransform& pose, const physx::PxVec3& scale, const ExtPxSpawnSettings& settings)
-{
-	NVBLASTEXT_CHECK_ERROR(!m_isSpawned, "Family spawn: family already spawned. Was spawn() called twice?", return false);
-	NVBLASTEXT_CHECK_ERROR(settings.scene != nullptr, "Family creation: desc.scene is nullptr", return false);
-	NVBLASTEXT_CHECK_ERROR(settings.material != nullptr, "Family creation: desc.material is nullptr", return false);
-
-	m_initialTransform = pose;
-	m_spawnSettings = settings;
-
-	// get current tkActors (usually it's only 1, but it can be already in split state)
-	const uint32_t actorCount = (uint32_t)m_tkFamily.getActorCount();
-	m_newActorsBuffer.resize(actorCount);
-	m_tkFamily.getActors(m_newActorsBuffer.begin(), actorCount);
-
-	// calc max split count
-	uint32_t splitMaxActorCount = 0;
-	for (TkActor* actor : m_newActorsBuffer)
-	{
-		splitMaxActorCount = std::max<uint32_t>(splitMaxActorCount, actor->getSplitMaxActorCount());
-	}
-
-	// preallocate memory
-	m_newActorsBuffer.resize(splitMaxActorCount);
-	m_newActorCreateInfo.resize(splitMaxActorCount);
-	m_physXActorsBuffer.resize(splitMaxActorCount);
-	m_physXActorsBuffer.resize(splitMaxActorCount);
-	m_indicesScratch.reserve(splitMaxActorCount);
-
-	// fill initial actor create info
-	for (uint32_t i = 0; i < actorCount; ++i)
-	{
-		PxActorCreateInfo& pxActorInfo = m_newActorCreateInfo[i];
-		pxActorInfo.m_angularVelocity = PxVec3(PxZero);
-		pxActorInfo.m_linearVelocity = PxVec3(PxZero);
-		pxActorInfo.m_transform = pose;
-		pxActorInfo.m_scale = scale;
-	}
-
-	// create first actors in family
-	createActors(m_newActorsBuffer.begin(), m_newActorCreateInfo.begin(), actorCount);
-
-	// listen family for new actors
-	m_tkFamily.addListener(*this);
-
-	m_isSpawned = true;
-
-	return true;
-}
-
-bool ExtPxFamilyImpl::despawn()
-{
-	NVBLASTEXT_CHECK_ERROR(m_spawnSettings.scene != nullptr, "Family despawn: desc.scene is nullptr", return false);
-
-	auto& actors = m_actorsBuffer;
-	actors.resize(m_actors.size());
-	uint32_t i = 0;
-	for (auto it = m_actors.getIterator(); !it.done(); ++it)
-	{
-		actors[i++] = *it;
-	}
-	destroyActors(actors.begin(), actors.size());
-
-	return true;
-}
-
-void ExtPxFamilyImpl::receive(const TkEvent* events, uint32_t eventCount)
-{
-	auto& actorsToDelete = m_actorsBuffer;
-	actorsToDelete.clear();
-	uint32_t totalNewActorsCount = 0;
-
-	for (uint32_t i = 0; i < eventCount; ++i)
-	{
-		const TkEvent& e = events[i];
-		if (e.type == TkEvent::Split)
-		{
-			const TkSplitEvent* splitEvent = e.getPayload<TkSplitEvent>();
-
-			uint32_t newActorsCount = splitEvent->numChildren;
-
-			ExtPxActorImpl* parentActor = nullptr;
-			PxRigidDynamic* parentPxActor = nullptr;
-			if (splitEvent->parentData.userData)
-			{
-				parentActor = reinterpret_cast<ExtPxActorImpl*>(splitEvent->parentData.userData);
-				parentPxActor = &parentActor->getPhysXActor();
-			}
-
-			for (uint32_t j = totalNewActorsCount; j < totalNewActorsCount + newActorsCount; ++j)
-			{
-				m_newActorCreateInfo[j].m_transform = parentPxActor ? parentPxActor->getGlobalPose() : m_initialTransform;
-				
-				//TODO: Get the current scale of the actor!
-				m_newActorCreateInfo[j].m_scale = m_initialScale;
-
-				m_newActorCreateInfo[j].m_linearVelocity = parentPxActor ? parentPxActor->getLinearVelocity() : PxVec3(PxZero);
-				m_newActorCreateInfo[j].m_angularVelocity = parentPxActor ? parentPxActor->getAngularVelocity() : PxVec3(PxZero);
-
-				m_newActorsBuffer[j] = splitEvent->children[j - totalNewActorsCount];
-			}
-
-			totalNewActorsCount += newActorsCount;
-
-			if (parentActor)
-			{
-				actorsToDelete.pushBack(parentActor);
-			}
-		}
-	}
-
-	destroyActors(actorsToDelete.begin(), actorsToDelete.size());
-	if (totalNewActorsCount > 0)
-	{
-		uint32_t cappedNewActorsCount = totalNewActorsCount;
-		const uint32_t actorCountLimit = m_manager.getActorCountLimit();
-		const uint32_t totalActorCount = m_manager.getPxActorCount();
-		if (actorCountLimit > 0 && cappedNewActorsCount + totalActorCount > actorCountLimit)
-		{
-			cappedNewActorsCount = actorCountLimit > totalActorCount ? actorCountLimit - totalActorCount : 0;
-		}
-		createActors(m_newActorsBuffer.begin(), m_newActorCreateInfo.begin(), cappedNewActorsCount);
-		m_culledActors.reserve(m_culledActors.size() + totalNewActorsCount - cappedNewActorsCount);
-		for (uint32_t i = cappedNewActorsCount; i < totalNewActorsCount; ++i)
-		{
-			m_culledActors.pushBack(m_newActorsBuffer[i]);
-		}
-		totalNewActorsCount = cappedNewActorsCount;	// In case it's used below
-	}
-
-	for (uint32_t i = 0; i < eventCount; ++i)
-	{
-		const TkEvent& e = events[i];
-		if (e.type == TkEvent::JointUpdate)
-		{
-			const TkJointUpdateEvent* jointEvent = e.getPayload<TkJointUpdateEvent>();
-			NVBLAST_ASSERT(jointEvent->joint);
-			TkJoint& joint = *jointEvent->joint;
-
-			switch (jointEvent->subtype)
-			{
-			case TkJointUpdateEvent::External:
-				m_manager.createJoint(joint);
-				break;
-			case TkJointUpdateEvent::Changed:
-				m_manager.updateJoint(joint);
-				break;
-			case TkJointUpdateEvent::Unreferenced:
-				m_manager.destroyJoint(joint);
-				joint.release();
-				break;
-			}
-		}
-	}
-}
-
-void ExtPxFamilyImpl::createActors(TkActor** tkActors, const PxActorCreateInfo* pxActorInfos, uint32_t count)
-{
-	auto actorsToAdd = m_physXActorsBuffer.begin();
-	for (uint32_t i = 0; i < count; ++i)
-	{
-		ExtPxActorImpl* actor = NVBLASTEXT_NEW(ExtPxActorImpl)(this, tkActors[i], pxActorInfos[i]);
-		m_actors.insert(actor);
-		actorsToAdd[i] = &actor->getPhysXActor();
-		dispatchActorCreated(*actor);
-
-		// Handle incomplete joints
-		auto e = m_manager.m_incompleteJointMultiMap.find(tkActors[i]);
-		if (e != nullptr)
-		{
-			ExtArray<TkJoint*>::type joints = e->second;	// Copying the array
-			m_manager.m_incompleteJointMultiMap.erase(tkActors[i]);
-			for (uint32_t j = 0; j < joints.size(); ++j)
-			{
-				m_manager.updateJoint(*joints[j]);
-			}
-		}
-	}
-	m_spawnSettings.scene->addActors(actorsToAdd, static_cast<uint32_t>(count));
-}
-
-void ExtPxFamilyImpl::destroyActors(ExtPxActor** actors, uint32_t count)
-{
-	auto pxActorsToRemove = m_physXActorsBuffer.begin();
-	for (uint32_t i = 0; i < count; ++i)
-	{
-		pxActorsToRemove[i] = &actors[i]->getPhysXActor();
-	}
-	m_spawnSettings.scene->removeActors(pxActorsToRemove, static_cast<uint32_t>(count));
-
-	for (uint32_t i = 0; i < count; ++i)
-	{
-		ExtPxActorImpl* actor = (ExtPxActorImpl*)actors[i];
-		m_actors.erase(actor);
-		dispatchActorDestroyed(*actor);
-		NVBLASTEXT_DELETE(actor, ExtPxActorImpl);
-	}
-}
-
-void ExtPxFamilyImpl::dispatchActorCreated(ExtPxActor& actor)
-{
-	for (ExtPxListener* listener : m_listeners)
-		listener->onActorCreated(*this, actor);
-	m_manager.dispatchActorCreated(*this, actor);
-}
-
-void ExtPxFamilyImpl::dispatchActorDestroyed(ExtPxActor& actor)
-{
-	for (ExtPxListener* listener : m_listeners)
-		listener->onActorDestroyed(*this, actor);
-	m_manager.dispatchActorDestroyed(*this, actor);
-}
-
-void ExtPxFamilyImpl::postSplitUpdate()
-{
-	for (auto actor : m_culledActors)
-	{
-		actor->release();
-	}
-	m_culledActors.resize(0);
-}
-
-
-} // namespace Blast
-} // namespace Nv
diff --git a/NvBlast/sdk/extensions/physx/source/physics/NvBlastExtPxFamilyImpl.h b/NvBlast/sdk/extensions/physx/source/physics/NvBlastExtPxFamilyImpl.h
deleted file mode 100644
index 5c90346..0000000
--- a/NvBlast/sdk/extensions/physx/source/physics/NvBlastExtPxFamilyImpl.h
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTPXFAMILYIMPL_H
-#define NVBLASTEXTPXFAMILYIMPL_H
-
-#include "NvBlastExtPxFamily.h"
-#include "NvBlastExtArray.h"
-#include "NvBlastExtHashSet.h"
-#include "PxTransform.h"
-#include "NvBlastTkEvent.h"
-
-
-using namespace physx;
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-// Forward declarations
-class ExtPxManagerImpl;
-class ExtPxActorImpl;
-struct PxActorCreateInfo;
-
-
-class ExtPxFamilyImpl final : public ExtPxFamily, TkEventListener
-{
-	NV_NOCOPY(ExtPxFamilyImpl)
-
-public:
-	friend ExtPxActorImpl;
-	friend ExtPxManagerImpl;
-
-	//////// ctor ////////
-
-	ExtPxFamilyImpl(ExtPxManagerImpl& manager, TkFamily& tkFamily, const ExtPxAsset& pxAsset);
-	~ExtPxFamilyImpl();
-
-	virtual void release() override;
-
-
-	//////// ExtPxFamily interface ////////
-
-//	virtual bool							spawn(const PxTransform& pose, const ExtPxSpawnSettings& settings) override;
-	virtual bool							spawn(const physx::PxTransform& pose, const physx::PxVec3& scale, const ExtPxSpawnSettings& settings) override;
-	virtual bool							despawn() override;
-
-
-	virtual uint32_t						getActorCount() const override
-	{
-		return m_actors.size();
-	}
-
-	virtual uint32_t						getActors(ExtPxActor** buffer, uint32_t bufferSize) const override
-	{
-		uint32_t index = 0;
-		for (auto it = const_cast<ExtPxFamilyImpl*>(this)->m_actors.getIterator(); !it.done() && index < bufferSize; ++it)
-		{
-			buffer[index++] = *it;
-		}
-		return index;
-	}
-
-	virtual TkFamily&						getTkFamily() const override
-	{
-		return m_tkFamily;
-	}
-
-	virtual const physx::PxShape* const*	getSubchunkShapes() const override
-	{
-		return m_subchunkShapes.begin();
-	}
-
-	virtual const ExtPxAsset&				getPxAsset() const override
-	{
-		return m_pxAsset;
-	}
-
-	virtual void							setMaterial(PxMaterial& material) override
-	{
-		m_spawnSettings.material = &material;
-	}
-
-	virtual void							setPxShapeDescTemplate(const ExtPxShapeDescTemplate* pxShapeDesc) override
-	{
-		m_pxShapeDescTemplate = pxShapeDesc;
-	}
-
-	virtual const ExtPxShapeDescTemplate*	getPxShapeDescTemplate() const override
-	{
-		return m_pxShapeDescTemplate;
-	}
-
-	virtual void							setPxActorDesc(const ExtPxActorDescTemplate* pxActorDesc) override
-	{
-		m_pxActorDescTemplate = pxActorDesc;
-	}
-
-	virtual const ExtPxActorDescTemplate*	getPxActorDesc() const override
-	{
-		return m_pxActorDescTemplate;
-	}
-
-	virtual void							subscribe(ExtPxListener& listener) override
-	{
-		m_listeners.pushBack(&listener);
-	}
-
-	virtual void							unsubscribe(ExtPxListener& listener) override
-	{
-		m_listeners.findAndReplaceWithLast(&listener);
-	}
-
-	virtual void							postSplitUpdate() override;
-
-	//////// TkEventListener interface ////////
-
-	virtual void							receive(const TkEvent* events, uint32_t eventCount) override;
-
-
-	//////// events dispatch ////////
-
-	void									dispatchActorCreated(ExtPxActor& actor);
-	void									dispatchActorDestroyed(ExtPxActor& actor);
-
-
-private:
-	//////// private methods ////////
-
-	void									createActors(TkActor** tkActors, const PxActorCreateInfo* pxActorInfos, uint32_t count);
-	void									destroyActors(ExtPxActor** actors, uint32_t count);
-
-	//////// data ////////
-
-	ExtPxManagerImpl&						m_manager;
-	TkFamily&								m_tkFamily;
-	const ExtPxAsset&						m_pxAsset;
-	ExtPxSpawnSettings						m_spawnSettings;
-	const ExtPxShapeDescTemplate*			m_pxShapeDescTemplate;
-	const ExtPxActorDescTemplate*			m_pxActorDescTemplate;
-	bool									m_isSpawned;
-	PxTransform								m_initialTransform;
-	PxVec3									m_initialScale;
-	ExtHashSet<ExtPxActor*>::type			m_actors;
-	ExtArray<TkActor*>::type				m_culledActors;
-	ExtInlineArray<ExtPxListener*, 4>::type	m_listeners;
-	ExtArray<PxShape*>::type				m_subchunkShapes;
-	ExtArray<TkActor*>::type				m_newActorsBuffer;
-	ExtArray<PxActorCreateInfo>::type		m_newActorCreateInfo;
-	ExtArray<PxActor*>::type				m_physXActorsBuffer;
-	ExtArray<ExtPxActor*>::type				m_actorsBuffer;
-	ExtArray<uint32_t>::type				m_indicesScratch;
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTEXTPXFAMILYIMPL_H
diff --git a/NvBlast/sdk/extensions/physx/source/physics/NvBlastExtPxManagerImpl.cpp b/NvBlast/sdk/extensions/physx/source/physics/NvBlastExtPxManagerImpl.cpp
deleted file mode 100644
index 42266ee..0000000
--- a/NvBlast/sdk/extensions/physx/source/physics/NvBlastExtPxManagerImpl.cpp
+++ /dev/null
@@ -1,127 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastExtPxManagerImpl.h"
-#include "NvBlastExtPxAssetImpl.h"
-#include "NvBlastExtPxActorImpl.h"
-#include "NvBlastExtPxFamilyImpl.h"
-
-#include "NvBlastAssert.h"
-
-#include "NvBlastTkActor.h"
-#include "NvBlastTkFamily.h"
-#include "NvBlastTkGroup.h"
-#include "NvBlastTkJoint.h"
-
-#include "PxRigidDynamic.h"
-#include "PxJoint.h"
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-
-ExtPxManager* ExtPxManager::create(PxPhysics& physics, TkFramework& framework, ExtPxCreateJointFunction createFn, bool useUserData)
-{
-	return NVBLASTEXT_NEW(ExtPxManagerImpl)(physics, framework, createFn, useUserData);
-}
-
-void ExtPxManagerImpl::release()
-{
-	NVBLASTEXT_DELETE(this, ExtPxManagerImpl);
-}
-
-ExtPxFamily* ExtPxManagerImpl::createFamily(const ExtPxFamilyDesc& desc)
-{
-	NVBLASTEXT_CHECK_ERROR(desc.pxAsset != nullptr, "Family creation: pxAsset is nullptr.", return nullptr);
-
-	// create tk family
-	TkActorDesc tkActorDesc;
-	(&tkActorDesc)->NvBlastActorDesc::operator=(desc.actorDesc);
-	tkActorDesc.asset = &desc.pxAsset->getTkAsset();
-	TkActor* actor = m_framework.createActor(tkActorDesc);
-	NVBLASTEXT_CHECK_ERROR(actor != nullptr, "Family creation: tk actor creation failed.", return nullptr);
-
-	ExtPxFamilyImpl* family = NVBLASTEXT_NEW(ExtPxFamilyImpl)(*this, actor->getFamily(), *desc.pxAsset);
-
-	if (desc.group)
-	{
-		desc.group->addActor(*actor);
-	}
-
-	return family;
-}
-
-bool ExtPxManagerImpl::createJoint(TkJoint& joint)
-{
-	if (!joint.userData && m_createJointFn)
-	{
-		const TkJointData data = joint.getData();
-		ExtPxActorImpl* pxActor0 = data.actors[0] != nullptr ? reinterpret_cast<ExtPxActorImpl*>(data.actors[0]->userData) : nullptr;
-		ExtPxActorImpl* pxActor1 = data.actors[1] != nullptr ? reinterpret_cast<ExtPxActorImpl*>(data.actors[1]->userData) : nullptr;
-		NVBLAST_ASSERT(pxActor0 || pxActor1);
-		PxTransform lf0(data.attachPositions[0]);
-		PxTransform lf1(data.attachPositions[1]);
-		PxJoint* pxJoint = m_createJointFn(pxActor0,  lf0, pxActor1, lf1, m_physics, joint);
-		if (pxJoint)
-		{
-			joint.userData = pxJoint;
-			return true;
-		}
-	}
-	return false;
-}
-
-void ExtPxManagerImpl::updateJoint(TkJoint& joint)
-{
-	if (joint.userData)
-	{
-		const TkJointData& data = joint.getData();
-		ExtPxActorImpl* pxActors[2];
-		for (int i = 0; i < 2; ++i)
-		{
-			if (data.actors[i] != nullptr)
-			{
-				pxActors[i] = reinterpret_cast<ExtPxActorImpl*>(data.actors[i]->userData);
-				if (pxActors[i] == nullptr)
-				{
-					ExtArray<TkJoint*>::type& joints = m_incompleteJointMultiMap[data.actors[i]];
-					NVBLAST_ASSERT(joints.find(&joint) == joints.end());
-					joints.pushBack(&joint);
-					return;	// Wait until the TkActor is received to create this joint
-				}
-			}
-			else
-			{
-				pxActors[i] = nullptr;
-			}
-		}
-		NVBLAST_ASSERT(pxActors[0] || pxActors[1]);
-		PxJoint* pxJoint = reinterpret_cast<PxJoint*>(joint.userData);
-		pxJoint->setActors(pxActors[0] ? &pxActors[0]->getPhysXActor() : nullptr, pxActors[1] ? &pxActors[1]->getPhysXActor() : nullptr);
-	}
-}
-
-void ExtPxManagerImpl::destroyJoint(TkJoint& joint)
-{
-	if (joint.userData)
-	{
-		PxJoint* pxJoint = reinterpret_cast<PxJoint*>(joint.userData);
-		pxJoint->release();
-		joint.userData = nullptr;
-	}
-}
-
-
-
-} // namespace Blast
-} // namespace Nv
diff --git a/NvBlast/sdk/extensions/physx/source/physics/NvBlastExtPxManagerImpl.h b/NvBlast/sdk/extensions/physx/source/physics/NvBlastExtPxManagerImpl.h
deleted file mode 100644
index 1f5e510..0000000
--- a/NvBlast/sdk/extensions/physx/source/physics/NvBlastExtPxManagerImpl.h
+++ /dev/null
@@ -1,202 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTPXMANAGERIMPL_H
-#define NVBLASTEXTPXMANAGERIMPL_H
-
-#include "NvBlastExtPxManager.h"
-#include "NvBlastExtArray.h"
-#include "NvBlastExtHashMap.h"
-#include "NvBlastExtPxListener.h"
-#include "NvBlastExtPxFamily.h"
-
-#include "PxRigidDynamic.h"
-
-
-using namespace physx;
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-// Forward declarations
-class TkActor;
-
-class ExtPxManagerImpl final : public ExtPxManager
-{
-	NV_NOCOPY(ExtPxManagerImpl)
-
-public:
-	friend class ExtPxActorImpl;
-	friend class ExtPxFamilyImpl;
-
-	ExtPxManagerImpl(PxPhysics& physics, TkFramework&framework, ExtPxCreateJointFunction createFn, bool usePxUserData)
-		: m_physics(physics), m_framework(framework), m_createJointFn(createFn), m_usePxUserData(usePxUserData), m_actorCountLimit(0)
-	{
-	}
-
-	~ExtPxManagerImpl()
-	{
-	}
-
-	virtual void release() override;
-
-
-	//////// interface ////////
-
-	virtual ExtPxFamily*	createFamily(const ExtPxFamilyDesc& desc) override;
-
-	virtual bool			createJoint(TkJoint& joint) override;
-
-	virtual void			destroyJoint(TkJoint& joint) override;
-
-	virtual void			setCreateJointFunction(ExtPxCreateJointFunction createFn) override
-	{
-		m_createJointFn = createFn;
-	}
-
-	virtual uint32_t		getFamilyCount() const override
-	{
-		return m_tkFamiliesMap.size();
-	}
-
-	virtual uint32_t		getFamilies(ExtPxFamily** buffer, uint32_t bufferSize) const override
-	{
-		uint32_t index = 0;
-		for (auto it = const_cast<ExtPxManagerImpl*>(this)->m_tkFamiliesMap.getIterator(); !it.done() && index < bufferSize; ++it)
-		{
-			buffer[index++] = it->second;
-		}
-		return index;
-	}
-
-	virtual ExtPxFamily*	getFamilyFromTkFamily(TkFamily& family) const override
-	{
-		auto entry = m_tkFamiliesMap.find(&family);
-		return entry != nullptr ? entry->second : nullptr;
-	}
-
-	virtual ExtPxActor*		getActorFromPhysXActor(const PxRigidDynamic& pxActor) const override
-	{
-		auto it = m_physXActorsMap.find(&pxActor);
-		return it != nullptr ? it->second : nullptr;
-	}
-
-	virtual PxPhysics&		getPhysics() const override
-	{
-		return m_physics;
-	}
-
-	virtual TkFramework&	getFramework() const override
-	{
-		return m_framework;
-	}
-
-	virtual bool			isPxUserDataUsed() const override
-	{
-		return m_usePxUserData;
-	}
-
-	virtual void			subscribe(ExtPxListener& listener) override
-	{
-		m_listeners.pushBack(&listener);
-	}
-
-	virtual void			unsubscribe(ExtPxListener& listener) override
-	{
-		m_listeners.findAndReplaceWithLast(&listener);
-	}
-
-	virtual void			setActorCountLimit(uint32_t limit) override
-	{
-		m_actorCountLimit = limit;
-	}
-
-	virtual uint32_t		getActorCountLimit() override
-	{
-		return m_actorCountLimit;
-	}
-
-	virtual uint32_t		getPxActorCount() const override
-	{
-		return m_physXActorsMap.size();
-	}
-
-
-	//////// internal public methods ////////
-
-	void					registerActor(PxRigidDynamic* pxActor, ExtPxActor* actor)
-	{
-		if (m_usePxUserData)
-		{
-			pxActor->userData = actor;
-		}
-		m_physXActorsMap[pxActor] = actor;
-	}
-
-	void					unregisterActor(PxRigidDynamic* pxActor)
-	{
-		if (m_usePxUserData)
-		{
-			pxActor->userData = nullptr;
-		}
-		m_physXActorsMap.erase(pxActor);
-	}
-
-	void					registerFamily(ExtPxFamily& family)
-	{
-		m_tkFamiliesMap[&family.getTkFamily()] = &family;
-	}
-
-	void					unregisterFamily(ExtPxFamily& family)
-	{
-		m_tkFamiliesMap.erase(&family.getTkFamily());
-	}
-
-	void					updateJoint(TkJoint& joint);
-
-
-	//////// events dispatch ////////
-
-	void					dispatchActorCreated(ExtPxFamily& family, ExtPxActor& actor)
-	{
-		for (ExtPxListener* listener : m_listeners)
-			listener->onActorCreated(family, actor);
-	}
-
-	void					dispatchActorDestroyed(ExtPxFamily& family, ExtPxActor&actor)
-	{
-		for (ExtPxListener* listener : m_listeners)
-			listener->onActorDestroyed(family, actor);
-	}
-
-
-private:
-
-	//////// data ////////
-
-	PxPhysics&												m_physics;
-	TkFramework&											m_framework;
-	ExtPxCreateJointFunction								m_createJointFn;
-	bool													m_usePxUserData;
-	ExtInlineArray<ExtPxListener*, 8>::type					m_listeners;
-	ExtHashMap<const PxRigidDynamic*, ExtPxActor*>::type	m_physXActorsMap;
-	ExtHashMap<TkFamily*, ExtPxFamily*>::type				m_tkFamiliesMap;
-	ExtHashMap<TkActor*, ExtArray<TkJoint*>::type >::type	m_incompleteJointMultiMap;
-	uint32_t												m_actorCountLimit;
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTEXTPXMANAGERIMPL_H
diff --git a/NvBlast/sdk/extensions/physx/source/sync/NvBlastExtSync.cpp b/NvBlast/sdk/extensions/physx/source/sync/NvBlastExtSync.cpp
deleted file mode 100644
index 5f018d9..0000000
--- a/NvBlast/sdk/extensions/physx/source/sync/NvBlastExtSync.cpp
+++ /dev/null
@@ -1,235 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-
-#include "NvBlastExtSync.h"
-#include "NvBlastAssert.h"
-#include "NvBlast.h"
-#include "NvBlastExtDefs.h"
-#include "NvBlastExtPxManager.h"
-#include "NvBlastExtPxFamily.h"
-#include "NvBlastExtPxActor.h"
-#include "PxRigidDynamic.h"
-
-#include <chrono>
-using namespace std::chrono;
-
-namespace Nv
-{
-namespace Blast
-{
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//											ExtSyncImpl Definition
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-class ExtSyncImpl : public ExtSync
-{
-	NV_NOCOPY(ExtSyncImpl)
-
-public:
-	//////// ctor ////////
-
-	ExtSyncImpl();
-	
-	~ExtSyncImpl();
-
-
-	//////// TkEventListener interface ////////
-
-	virtual void		receive(const TkEvent* events, uint32_t eventCount) override;
-
-
-	//////// ExtSync interface ////////
-
-	virtual void		release() override;
-
-	virtual void		syncFamily(const TkFamily& family) override;
-	virtual void		syncFamily(const ExtPxFamily& family) override;
-
-	virtual uint32_t	getSyncBufferSize() const override;
-	virtual void		acquireSyncBuffer(const ExtSyncEvent*const*& buffer, uint32_t& size) const override;
-	virtual void		releaseSyncBuffer() override;
-
-	virtual void		applySyncBuffer(TkFramework& framework, const ExtSyncEvent** buffer, uint32_t size, TkGroup* groupForNewActors, ExtPxManager* manager) override;
-
-
-private:
-	//////// data ////////
-
-	std::vector<ExtSyncEvent*>		 m_syncEvents;
-};
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//											ExtSyncEvent Implementation
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-void ExtSyncEvent::release()
-{
-	NVBLASTEXT_DELETE(this, ExtSyncEvent);
-}
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//											ExtSyncImpl Implementation
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-ExtSync* ExtSync::create()
-{
-	return NVBLASTEXT_NEW(ExtSyncImpl) ();
-}
-
-void ExtSyncImpl::release()
-{
-	NVBLASTEXT_DELETE(this, ExtSyncImpl);
-}
-
-ExtSyncImpl::ExtSyncImpl()
-{
-}
-
-ExtSyncImpl::~ExtSyncImpl()
-{
-	releaseSyncBuffer();
-}
-
-void ExtSyncImpl::receive(const TkEvent* events, uint32_t eventCount)
-{
-	for (uint32_t i = 0; i < eventCount; ++i)
-	{
-		const TkEvent& tkEvent = events[i];
-		if (tkEvent.type == TkEvent::FractureCommand)
-		{
-			const TkFractureCommands* fracEvent = tkEvent.getPayload<TkFractureCommands>();
-			ExtSyncEventFracture* e = NVBLASTEXT_NEW(ExtSyncEventFracture) ();
-			e->timestamp = duration_cast<milliseconds>(steady_clock::now().time_since_epoch()).count();
-			e->familyID = fracEvent->tkActorData.family->getID();
-			e->bondFractures.resize(fracEvent->buffers.bondFractureCount);
-			e->chunkFractures.resize(fracEvent->buffers.chunkFractureCount);
-			memcpy(e->bondFractures.data(), fracEvent->buffers.bondFractures, e->bondFractures.size() * sizeof(NvBlastBondFractureData));
-			memcpy(e->chunkFractures.data(), fracEvent->buffers.chunkFractures, e->chunkFractures.size() * sizeof(NvBlastChunkFractureData));
-			m_syncEvents.push_back(e);
-		}
-	}
-}
-
-void ExtSyncImpl::syncFamily(const TkFamily& family)
-{
-	ExtSyncEventFamilySync* e = NVBLASTEXT_NEW(ExtSyncEventFamilySync) ();
-	e->timestamp = duration_cast<milliseconds>(steady_clock::now().time_since_epoch()).count();
-	e->familyID = family.getID();
-	const NvBlastFamily* familyLL = family.getFamilyLL();
-	const uint32_t size = NvBlastFamilyGetSize(familyLL, NvBlastTkFrameworkGet()->getLogFn());
-	e->family = std::vector<char>((char*)familyLL, (char*)familyLL + size);
-	m_syncEvents.push_back(e);
-}
-
-void ExtSyncImpl::syncFamily(const ExtPxFamily& family)
-{
-	const TkFamily& tkFamily = family.getTkFamily();
-
-	syncFamily(tkFamily);
-
-	ExtSyncEventPhysicsSync* e = NVBLASTEXT_NEW(ExtSyncEventPhysicsSync) ();
-	e->timestamp = duration_cast<milliseconds>(steady_clock::now().time_since_epoch()).count();
-	e->familyID = tkFamily.getID();
-	std::vector<ExtPxActor*> actors(family.getActorCount());
-	family.getActors(actors.data(), static_cast<uint32_t>(actors.size()));
-	e->data.reserve(actors.size());
-	for (ExtPxActor* actor : actors)
-	{
-		ExtSyncEventPhysicsSync::ActorData data;
-		data.transform = actor->getPhysXActor().getGlobalPose();
-		data.actorIndex = actor->getTkActor().getIndex();
-		e->data.push_back(data);
-	}
-
-	m_syncEvents.push_back(e);
-}
-
-uint32_t ExtSyncImpl::getSyncBufferSize() const
-{
-	return static_cast<uint32_t>(m_syncEvents.size());
-}
-
-void ExtSyncImpl::acquireSyncBuffer(const ExtSyncEvent* const*& buffer, uint32_t& size) const
-{
-	buffer = m_syncEvents.data();
-	size = static_cast<uint32_t>(m_syncEvents.size());
-}
-
-void ExtSyncImpl::releaseSyncBuffer()
-{
-	for (uint32_t i = 0; i < m_syncEvents.size(); ++i)
-	{
-		NVBLASTEXT_DELETE(m_syncEvents[i], ExtSyncEvent);
-	}
-	m_syncEvents.clear();
-}
-
-void ExtSyncImpl::applySyncBuffer(TkFramework& framework, const ExtSyncEvent** buffer, uint32_t size, TkGroup* groupForNewActors, ExtPxManager* manager)
-{
-	const TkType* familyType = framework.getType(TkTypeIndex::Family);
-	NVBLAST_ASSERT(familyType);
-
-	for (uint32_t i = 0; i < size; ++i)
-	{
-		const ExtSyncEvent* e = buffer[i];
-		const NvBlastID& id = e->familyID;
-		TkIdentifiable* object = framework.findObjectByID(id);
-		if (object && object->getType() == *familyType)
-		{
-			TkFamily* family = static_cast<TkFamily*>(object);
-
-			if (e->type == ExtSyncEventFracture::EVENT_TYPE)
-			{
-				const ExtSyncEventFracture* fractureEvent = e->getEvent<ExtSyncEventFracture>();
-				const NvBlastFractureBuffers commands =
-				{
-					static_cast<uint32_t>(fractureEvent->bondFractures.size()),
-					static_cast<uint32_t>(fractureEvent->chunkFractures.size()),
-					const_cast<NvBlastBondFractureData*>(fractureEvent->bondFractures.data()),
-					const_cast<NvBlastChunkFractureData*>(fractureEvent->chunkFractures.data())
-				};
-				family->applyFracture(&commands);
-			}
-			else if (e->type == ExtSyncEventFamilySync::EVENT_TYPE)
-			{
-				const ExtSyncEventFamilySync* familyEvent = e->getEvent<ExtSyncEventFamilySync>();
-				family->reinitialize((NvBlastFamily*)familyEvent->family.data(), groupForNewActors);
-			}
-			else if (e->type == ExtSyncEventPhysicsSync::EVENT_TYPE && manager)
-			{
-				const ExtSyncEventPhysicsSync* physicsEvent = e->getEvent<ExtSyncEventPhysicsSync>();
-				ExtPxFamily* pxFamily = manager->getFamilyFromTkFamily(*family);
-				if (pxFamily)
-				{
-					std::vector<ExtPxActor*> actors(pxFamily->getActorCount());
-					pxFamily->getActors(actors.data(), static_cast<uint32_t>(actors.size()));
-
-					for (auto data : physicsEvent->data)
-					{
-						for (ExtPxActor* physicsaActor : actors)
-						{
-							if (data.actorIndex == physicsaActor->getTkActor().getIndex())
-							{
-								physicsaActor->getPhysXActor().setGlobalPose(data.transform);
-							}
-						}
-					}
-				}
-			}
-		}
-	}
-}
-
-} // namespace Blast
-} // namespace Nv
diff --git a/NvBlast/sdk/extensions/serialization/include/NvBlastExtSerializationInterface.h b/NvBlast/sdk/extensions/serialization/include/NvBlastExtSerializationInterface.h
deleted file mode 100644
index e4f27e0..0000000
--- a/NvBlast/sdk/extensions/serialization/include/NvBlastExtSerializationInterface.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-/*
-	Include this file to get the C interface to serialization for all asset types (LL, Tk and Ext)
-*/
-#pragma once
-#include <ostream>
-#include "NvBlastTkAsset.h"
-#include "NvBlastExtPxAsset.h"
-
-#include "NvBlastExtSerializationLLInterface.h"
-
-namespace physx
-{
-	class PxPhysics;
-}
-
-NVBLAST_API void setPhysXSDK(physx::PxPhysics* physXSDK);
-
-NVBLAST_API Nv::Blast::TkAsset* deserializeTkAsset(const unsigned char* input, uint32_t size);
-NVBLAST_API Nv::Blast::TkAsset* deserializeTkAssetFromStream(std::istream &inputStream);
-NVBLAST_API bool serializeTkAssetIntoStream(const Nv::Blast::TkAsset *asset, std::ostream &outputStream);
-NVBLAST_API bool serializeTkAssetIntoNewBuffer(const Nv::Blast::TkAsset *asset, unsigned char **outBuffer, uint32_t &outSize);
-NVBLAST_API bool serializeTkAssetIntoExistingBuffer(const Nv::Blast::TkAsset *asset, unsigned char *buffer, uint32_t maxSize, uint32_t &usedSize);
-
-NVBLAST_API Nv::Blast::ExtPxAsset* deserializeExtPxAsset(const unsigned char* input, uint32_t size);
-NVBLAST_API Nv::Blast::ExtPxAsset* deserializeExtPxAssetFromStream(std::istream &inputStream);
-NVBLAST_API bool serializeExtPxAssetIntoStream(const Nv::Blast::ExtPxAsset *asset, std::ostream &outputStream);
-NVBLAST_API bool serializeExtPxAssetIntoNewBuffer(const Nv::Blast::ExtPxAsset *asset, unsigned char **outBuffer, uint32_t &outSize);
-NVBLAST_API bool serializeExtPxAssetIntoExistingBuffer(const Nv::Blast::ExtPxAsset *asset, unsigned char *buffer, uint32_t maxSize, uint32_t &usedSize);
diff --git a/NvBlast/sdk/extensions/serialization/include/NvBlastExtSerializationLLInterface.h b/NvBlast/sdk/extensions/serialization/include/NvBlastExtSerializationLLInterface.h
deleted file mode 100644
index d21c7ca..0000000
--- a/NvBlast/sdk/extensions/serialization/include/NvBlastExtSerializationLLInterface.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-/*
-Include this file to access the C API for serialization, for Low Level assets only.
-
-For Serialization of Tk and Ext assets, include only NvBlastExtSerializationInterface.h, which will include this file as well.
-
-*/
-#pragma once
-#include <ostream>
-#include "NvBlastPreprocessor.h"
-#include "NvBlastTypes.h"
-
-#include "NvBlastExtGlobals.h"
-
-/*
-	Set a global NvBlastAlloc signature allocation function that the deserialization will use when required.
-
-	NOTE: This will NOT be used when using the combined serialization library, as it will use the TkFramework's allocation and logging
-*/
-NVBLAST_API void setAllocator(NvBlastExtAlloc alloc);
-
-/*
-	Set a global NvBlastLog signature allocation function that the library will use when required.
-
-	NOTE: This will NOT be used when using the combined serialization library, as it will use the TkFramework's allocation and logging
-*/
-NVBLAST_API void setLog(NvBlastLog log);
-
-
-NVBLAST_API NvBlastAsset* deserializeAsset(const unsigned char* input, uint32_t size);
-NVBLAST_API NvBlastAsset* deserializeAssetFromStream(std::istream &inputStream);
-NVBLAST_API bool serializeAssetIntoStream(const NvBlastAsset *asset, std::ostream &outputStream);
-NVBLAST_API bool serializeAssetIntoNewBuffer(const NvBlastAsset *asset, unsigned char **outBuffer, uint32_t &outSize);
-NVBLAST_API bool serializeAssetIntoExistingBuffer(const NvBlastAsset *asset, unsigned char *buffer, uint32_t maxSize, uint32_t &usedSize);
diff --git a/NvBlast/sdk/extensions/serialization/source/BlastSerialization.capn b/NvBlast/sdk/extensions/serialization/source/BlastSerialization.capn
deleted file mode 100644
index 49b1dbb..0000000
--- a/NvBlast/sdk/extensions/serialization/source/BlastSerialization.capn
+++ /dev/null
@@ -1,162 +0,0 @@
-@0xaffe4498f275ee58;
-
-using Cxx = import "/capnp/c++.capnp";
-
-$Cxx.namespace("Nv::Blast::Serialization");
-
-struct Asset
-{
-	header @0 :NvBlastDataBlock;
-	
-	iD @1 :UUID;
-	
-	chunkCount @2 :UInt32;
-	
-	graph @3 :NvBlastSupportGraph;
-	
-	leafChunkCount @4 :UInt32;
-	
-	firstSubsupportChunkIndex @5 :UInt32;
-	
-	bondCount @6 :UInt32;
-	
-	chunks @7: List(NvBlastChunk);
-	
-	bonds @8: List(NvBlastBond);
-	
-	subtreeLeafChunkCounts @9: List(UInt32);
-	
-	chunkToGraphNodeMap @10: List(UInt32);
-}
-
-struct TkAsset
-{
-	assetLL @0 :Asset;
-	
-	jointDescs @1 :List(TkAssetJointDesc);
-	
-}
-
-struct ExtPxAsset
-{
-	asset @0 :TkAsset;
-	chunks @1 :List(ExtPxChunk);
-	subchunks @2 :List(ExtPxSubchunk);
-}
-
-struct ExtPxChunk
-{
-	firstSubchunkIndex @0 :UInt32;
-	subchunkCount @1 :UInt32;
-	isStatic @2 :Bool;
-}
-
-struct ExtPxSubchunk
-{
-	transform @0 :PxTransform;
-	geometry @1 :PxConvexMeshGeometry;
-}
-
-struct PxConvexMeshGeometry
-{
-	scale @0 :PxMeshScale;
-	convexMesh @1 :Data;
-	meshFlags @2 :UInt8;
-
-	enum Type
-	{
-		eSPHERE @0;
-		ePLANE @1;
-		eCAPSULE @2;
-		eBOX @3;
-		eCONVEXMESH @4;
-		eTRIANGLEMESH @5;
-		eHEIGHTFIELD @6;
-	}
-
-	type @3 :Type;
-}
-
-struct NvBlastDataBlock
-{
-	enum Type
-	{
-		assetDataBlock @0;
-		instanceDataBlock @1;
-	}
-	
-	dataType @0 :Type;
-	
-	formatVersion @1 :UInt32;
-	
-	size @2 :UInt32;
-}
-
-struct NvBlastChunk
-{
-	centroid @0 :List(Float32);
-	
-	volume @1 :Float32;
-	
-	parentChunkIndex @2 :UInt32;
-	firstChildIndex @3 :UInt32;
-	childIndexStop @4 :UInt32;
-	userData @5 :UInt32;
-}
-
-struct NvBlastBond
-{
-	normal @0 :List(Float32);
-	area @1 :Float32;
-	centroid @2 :List(Float32);
-	userData @3 :UInt32;
-}
-
-struct TkAssetJointDesc
-{
-	nodeIndices @0 :List(UInt32);
-	attachPositions @1 :List(PxVec3);
-}
-
-struct PxVec3
-{
-	x @0 :Float32;
-	y @1 :Float32;
-	z @2 :Float32;
-}
-
-struct PxQuat
-{
-	x @0 :Float32;
-	y @1 :Float32;
-	z @2 :Float32;
-	w @3 :Float32;
-}
-
-struct PxMeshScale
-{
-	scale @0 :PxVec3;
-	rotation @1 :PxQuat;
-}
-
-struct PxTransform
-{
-	q @0 :PxQuat;
-	p @1 :PxVec3;
-}
-
-struct NvBlastSupportGraph
-{
-	nodeCount @0 : UInt32;
-	
-	chunkIndices @1 : List(UInt32);
-	adjacencyPartition @2 : List(UInt32);
-	adjacentNodeIndices @3 : List(UInt32);
-	adjacentBondIndices @4 : List(UInt32);
-}
-
-struct UUID
-{
-	value @0 : Data;
-}
-
diff --git a/NvBlast/sdk/extensions/serialization/source/DTO/AssetDTO.cpp b/NvBlast/sdk/extensions/serialization/source/DTO/AssetDTO.cpp
deleted file mode 100644
index 8d035fc..0000000
--- a/NvBlast/sdk/extensions/serialization/source/DTO/AssetDTO.cpp
+++ /dev/null
@@ -1,187 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "AssetDTO.h"
-#include "NvBlastIDDTO.h"
-#include "NvBlastChunkDTO.h"
-#include "NvBlastBondDTO.h"
-#include "NvBlastAsset.h"
-#include "NvBlastExtSerializationLLImpl.h"
-#include "NvBlastExtGlobals.h"
-
-#if !defined(BLAST_LL_ALLOC)
-#include "NvBlastExtAllocator.h"
-#endif
-
-namespace Nv
-{
-	namespace Blast
-	{
-		bool AssetDTO::serialize(Nv::Blast::Serialization::Asset::Builder builder, const Nv::Blast::Asset * poco)
-		{
-			NvBlastIDDTO::serialize(builder.initID(), &poco->m_ID);
-		
-			builder.setLeafChunkCount(poco->m_leafChunkCount);
-		
-			builder.setFirstSubsupportChunkIndex(poco->m_firstSubsupportChunkIndex);
-		
-			capnp::List<Nv::Blast::Serialization::NvBlastChunk>::Builder chunks = builder.initChunks(poco->m_chunkCount);
-		
-			builder.setChunkCount(poco->m_chunkCount);
-		
-			NVBLAST_ASSERT_WITH_MESSAGE(builder.getChunkCount() == poco->m_chunkCount, "WTF");
-		
-			for (uint32_t i = 0; i < poco->m_chunkCount; i++)
-			{
-				NvBlastChunk& chunk = poco->getChunks()[i];
-		
-				NvBlastChunkDTO::serialize(chunks[i], &chunk);
-			}
-		
-			NVBLAST_ASSERT_WITH_MESSAGE(builder.getChunkCount() == poco->m_chunkCount, "WTF");
-		
-			capnp::List<Nv::Blast::Serialization::NvBlastBond>::Builder bonds = builder.initBonds(poco->m_bondCount);
-		
-			builder.setBondCount(poco->m_bondCount);
-		
-			for (uint32_t i = 0; i < poco->m_bondCount; i++)
-			{
-				NvBlastBond& bond = poco->getBonds()[i];
-		
-				NvBlastBondDTO::serialize(bonds[i], &bond);
-			}
-		
-			kj::ArrayPtr<uint32_t> stlcArray(poco->getSubtreeLeafChunkCounts(), poco->m_chunkCount);
-			builder.initSubtreeLeafChunkCounts(poco->m_chunkCount);
-			builder.setSubtreeLeafChunkCounts(stlcArray);
-		
-			kj::ArrayPtr<uint32_t> ctgnArray(poco->getChunkToGraphNodeMap(), poco->m_chunkCount);
-			builder.setChunkToGraphNodeMap(ctgnArray);
-		
-			Nv::Blast::Serialization::NvBlastSupportGraph::Builder graphBulder = builder.initGraph();
-		
-			graphBulder.setNodeCount(poco->m_graph.m_nodeCount);
-		
-			uint32_t* ciPtr = poco->m_graph.getChunkIndices();
-		
-			kj::ArrayPtr<const uint32_t> ciArray(ciPtr, poco->m_graph.m_nodeCount);
-			graphBulder.setChunkIndices(ciArray);
-		
-			kj::ArrayPtr<const uint32_t> adjPart(poco->m_graph.getAdjacencyPartition(), poco->m_graph.m_nodeCount + 1);
-			graphBulder.setAdjacencyPartition(adjPart);
-		
-			NVBLAST_ASSERT(graphBulder.getAdjacencyPartition().size() == poco->m_graph.m_nodeCount + 1);
-		
-			kj::ArrayPtr<const uint32_t> nodeIndices(poco->m_graph.getAdjacentNodeIndices(), poco->m_bondCount * 2);
-			graphBulder.setAdjacentNodeIndices(nodeIndices);
-		
-			NVBLAST_ASSERT(graphBulder.getAdjacentNodeIndices().size() == poco->m_bondCount * 2);
-		
-			kj::ArrayPtr<const uint32_t> bondIndices(poco->m_graph.getAdjacentBondIndices(), poco->m_bondCount * 2);
-			graphBulder.setAdjacentBondIndices(bondIndices);
-		
-			return true;
-		}
-		
-		Nv::Blast::Asset* AssetDTO::deserialize(Nv::Blast::Serialization::Asset::Reader reader)
-		{
-			NvBlastID EmptyId = {};
-
-			NvBlastExtAlloc allocFn = gAlloc;
-			NvBlastLog logFn = gLog;
-
-#if !defined(BLAST_LL_ALLOC)
-			allocFn = ExtAllocator::alignedAlloc16;
-			logFn = NvBlastTkFrameworkGet()->getLogFn();
-#endif
-
-			void* mem = allocFn(reader.totalSize().wordCount * sizeof(uint64_t));
-
-			auto asset = Nv::Blast::initializeAsset(mem, EmptyId, reader.getChunkCount(), reader.getGraph().getNodeCount(), reader.getLeafChunkCount(), reader.getFirstSubsupportChunkIndex(), reader.getBondCount(),
-				logFn);
-		
-			bool result = deserializeInto(reader, asset);
-		
-			return result ? asset : nullptr;
-		}
-		
-		bool AssetDTO::deserializeInto(Nv::Blast::Serialization::Asset::Reader reader, Nv::Blast::Asset * poco)
-		{
-			NvBlastIDDTO::deserializeInto(reader.getID(), &poco->m_ID);
-		
-			NvBlastBond* bonds = poco->getBonds();
-		
-			uint32_t bondCount = reader.getBondCount();
-			for (uint32_t i = 0; i < bondCount; i++)
-			{
-				auto bondReader = reader.getBonds()[i];
-		
-				NvBlastBondDTO::deserializeInto(bondReader, &bonds[i]);
-			}
-		
-			NvBlastChunk* chunks = poco->getChunks();
-		
-			uint32_t chunkCount = reader.getChunkCount();
-			for (uint32_t i = 0; i < chunkCount; i++)
-			{
-				auto chunkReader = reader.getChunks()[i];
-		
-				NvBlastChunkDTO::deserializeInto(chunkReader, &chunks[i]);
-			}
-		
-			poco->m_graph.m_nodeCount = reader.getGraph().getNodeCount();
-		
-			NVBLAST_ASSERT(reader.getSubtreeLeafChunkCounts().size() == poco->m_chunkCount);
-			for (uint32_t i = 0; i < poco->m_chunkCount; i++)
-			{
-				poco->getSubtreeLeafChunkCounts()[i] = reader.getSubtreeLeafChunkCounts()[i];
-			}
-		
-			for (uint32_t i = 0; i < chunkCount; i++)
-			{
-				poco->getChunkToGraphNodeMap()[i] = reader.getChunkToGraphNodeMap()[i];
-			}
-		
-			uint32_t* ciPtr = poco->m_graph.getChunkIndices();
-		
-			NVBLAST_ASSERT(reader.getGraph().getChunkIndices().size() == poco->m_graph.m_nodeCount);
-			for (uint32_t i = 0; i < poco->m_graph.m_nodeCount; i++)
-			{
-				ciPtr[i] = reader.getGraph().getChunkIndices()[i];
-			}
-		
-			uint32_t* adjPartition = poco->m_graph.getAdjacencyPartition();
-			uint32_t idx = 0;
-		
-			for (uint32_t adjPartIndex : reader.getGraph().getAdjacencyPartition())
-			{
-				adjPartition[idx++] = adjPartIndex;
-			}
-		
-			uint32_t* adjNodes = poco->m_graph.getAdjacentNodeIndices();
-			idx = 0;
-		
-			for (uint32_t adjNodeIndex : reader.getGraph().getAdjacentNodeIndices())
-			{
-				adjNodes[idx++] = adjNodeIndex;
-			}
-		
-			uint32_t* adjBonds = poco->m_graph.getAdjacentBondIndices();
-			idx = 0;
-		
-			for (uint32_t adjBondIndex : reader.getGraph().getAdjacentBondIndices())
-			{
-				adjBonds[idx++] = adjBondIndex;
-			}
-		
-			return true;
-		}
-	}
-}
diff --git a/NvBlast/sdk/extensions/serialization/source/DTO/AssetDTO.h b/NvBlast/sdk/extensions/serialization/source/DTO/AssetDTO.h
deleted file mode 100644
index c090b5f..0000000
--- a/NvBlast/sdk/extensions/serialization/source/DTO/AssetDTO.h
+++ /dev/null
@@ -1,16 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#pragma once
-#include "DTOMacros.h"
-#include "NvBlastAsset.h"
-#include "generated/NvBlastExtSerializationLL.capn.h"
-
-DTO_CLASS_LL(Asset, Nv::Blast::Asset, Nv::Blast::Serialization::Asset)
diff --git a/NvBlast/sdk/extensions/serialization/source/DTO/DTOMacros.h b/NvBlast/sdk/extensions/serialization/source/DTO/DTOMacros.h
deleted file mode 100644
index a234aec..0000000
--- a/NvBlast/sdk/extensions/serialization/source/DTO/DTOMacros.h
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#pragma once
-
-#define DTO_CLASS(_NAME, _POCO, _SERIALIZER)											\
-namespace Nv {																			\
-namespace Blast {																		\
-class _NAME ## DTO																		\
-{																						\
-public:																					\
-	static class physx::PxCooking* Cooking;												\
-	static class physx::PxPhysics* Physics;												\
-																						\
-	static bool serialize(_SERIALIZER::Builder builder, const _POCO * poco);			\
- 	static _POCO* deserialize(_SERIALIZER::Reader reader);								\
- 	static bool deserializeInto(_SERIALIZER::Reader reader, _POCO * poco);				\
-};																						\
-}																						\
-}																						\
-																						\
-
-#define DTO_CLASS_LL(_NAME, _POCO, _SERIALIZER)											\
-namespace Nv {																			\
-namespace Blast {																		\
-class _NAME ## DTO																		\
-{																						\
-public:																					\
-																						\
-	static bool serialize(_SERIALIZER::Builder builder, const _POCO * poco);			\
- 	static _POCO* deserialize(_SERIALIZER::Reader reader);								\
- 	static bool deserializeInto(_SERIALIZER::Reader reader, _POCO * poco);				\
-};																						\
-}																						\
-}																						\
-																						\
-
diff --git a/NvBlast/sdk/extensions/serialization/source/DTO/ExtPxAssetDTO.cpp b/NvBlast/sdk/extensions/serialization/source/DTO/ExtPxAssetDTO.cpp
deleted file mode 100644
index cf4cadc..0000000
--- a/NvBlast/sdk/extensions/serialization/source/DTO/ExtPxAssetDTO.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "ExtPxAssetDTO.h"
-#include "TkAssetDTO.h"
-#include "ExtPxChunkDTO.h"
-#include "ExtPxSubchunkDTO.h"
-#include "physics/NvBlastExtPxAssetImpl.h"
-#include "NvBlastAssert.h"
-
-namespace Nv
-{
-	namespace Blast
-	{
-		bool ExtPxAssetDTO::serialize(Nv::Blast::Serialization::ExtPxAsset::Builder builder, const Nv::Blast::ExtPxAsset * poco)
-		{
-			TkAssetDTO::serialize(builder.getAsset(), &poco->getTkAsset());
-		
-			auto chunks = builder.initChunks(poco->getChunkCount());
-		
-			for (uint32_t i = 0; i <poco->getChunkCount(); i++)
-			{
-				ExtPxChunkDTO::serialize(chunks[i], &poco->getChunks()[i]);
-			}
-		
-			auto subchunks = builder.initSubchunks(poco->getSubchunkCount());
-		
-			for (uint32_t i = 0; i < poco->getSubchunkCount(); i++)
-			{
-				ExtPxSubchunkDTO::serialize(subchunks[i], &poco->getSubchunks()[i]);
-			}
-			
-			return true;
-		}
-		
-		Nv::Blast::ExtPxAsset* ExtPxAssetDTO::deserialize(Nv::Blast::Serialization::ExtPxAsset::Reader reader)
-		{
-			auto tkAsset = TkAssetDTO::deserialize(reader.getAsset());
-		
-			Nv::Blast::ExtPxAssetImpl* asset = reinterpret_cast<Nv::Blast::ExtPxAssetImpl*>(Nv::Blast::ExtPxAsset::create(tkAsset));
-		
-			NVBLAST_ASSERT(asset != nullptr);
-		
-			auto chunks = asset->getChunksArray();
-		
-			chunks.resize(reader.getChunks().size());
-			for (uint32_t i = 0; i < reader.getChunks().size(); i++)
-			{
-				ExtPxChunkDTO::deserializeInto(reader.getChunks()[i], &chunks[i]);
-			}
-		
-			auto subchunks = asset->getSubchunksArray();
-		
-			subchunks.resize(reader.getSubchunks().size());
-			for (uint32_t i = 0; i < reader.getSubchunks().size(); i++)
-			{
-				ExtPxSubchunkDTO::deserializeInto(reader.getSubchunks()[i], &subchunks[i]);
-			}
-		
-			return asset;
-		}
-		
-		bool ExtPxAssetDTO::deserializeInto(Nv::Blast::Serialization::ExtPxAsset::Reader reader, Nv::Blast::ExtPxAsset * poco)
-		{
-			reader = reader;
-			poco = nullptr;
-			//NOTE: Because of the way this is structured, can't do this.
-			return false;
-		}
-	}
-}
diff --git a/NvBlast/sdk/extensions/serialization/source/DTO/ExtPxAssetDTO.h b/NvBlast/sdk/extensions/serialization/source/DTO/ExtPxAssetDTO.h
deleted file mode 100644
index a35d38a..0000000
--- a/NvBlast/sdk/extensions/serialization/source/DTO/ExtPxAssetDTO.h
+++ /dev/null
@@ -1,16 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#pragma once
-#include "NvBlastBondDTO.h"
-#include "NvBlastExtPxAsset.h"
-#include "generated/NvBlastExtSerialization.capn.h"
-
-DTO_CLASS(ExtPxAsset, Nv::Blast::ExtPxAsset, Nv::Blast::Serialization::ExtPxAsset)
diff --git a/NvBlast/sdk/extensions/serialization/source/DTO/ExtPxChunkDTO.cpp b/NvBlast/sdk/extensions/serialization/source/DTO/ExtPxChunkDTO.cpp
deleted file mode 100644
index e096bc1..0000000
--- a/NvBlast/sdk/extensions/serialization/source/DTO/ExtPxChunkDTO.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "ExtPxChunkDTO.h"
-
-namespace Nv
-{
-	namespace Blast
-	{
-		bool ExtPxChunkDTO::serialize(Nv::Blast::Serialization::ExtPxChunk::Builder builder, const Nv::Blast::ExtPxChunk * poco)
-		{
-			builder.setFirstSubchunkIndex(poco->firstSubchunkIndex);
-			builder.setSubchunkCount(poco->subchunkCount);
-			builder.setIsStatic(poco->isStatic);
-		
-			return true;
-		}
-		
-		Nv::Blast::ExtPxChunk* ExtPxChunkDTO::deserialize(Nv::Blast::Serialization::ExtPxChunk::Reader reader)
-		{
-			reader = reader;
-			//TODO: Allocate with ExtContext and return
-		
-			return nullptr;
-		}
-		
-		bool ExtPxChunkDTO::deserializeInto(Nv::Blast::Serialization::ExtPxChunk::Reader reader, Nv::Blast::ExtPxChunk * poco)
-		{
-			poco->firstSubchunkIndex = reader.getFirstSubchunkIndex();
-			poco->subchunkCount = reader.getSubchunkCount();
-			poco->isStatic = reader.getIsStatic();
-		
-			return true;
-		}
-	}
-}
\ No newline at end of file
diff --git a/NvBlast/sdk/extensions/serialization/source/DTO/ExtPxChunkDTO.h b/NvBlast/sdk/extensions/serialization/source/DTO/ExtPxChunkDTO.h
deleted file mode 100644
index 1ff36df..0000000
--- a/NvBlast/sdk/extensions/serialization/source/DTO/ExtPxChunkDTO.h
+++ /dev/null
@@ -1,16 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#pragma once
-#include "DTOMacros.h"
-#include "NvBlastExtPxAsset.h"
-#include "generated/NvBlastExtSerialization.capn.h"
-
-DTO_CLASS(ExtPxChunk, Nv::Blast::ExtPxChunk, Nv::Blast::Serialization::ExtPxChunk)
diff --git a/NvBlast/sdk/extensions/serialization/source/DTO/ExtPxSubchunkDTO.cpp b/NvBlast/sdk/extensions/serialization/source/DTO/ExtPxSubchunkDTO.cpp
deleted file mode 100644
index cc2be96..0000000
--- a/NvBlast/sdk/extensions/serialization/source/DTO/ExtPxSubchunkDTO.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "ExtPxSubchunkDTO.h"
-#include "PxTransformDTO.h"
-#include "PxConvexMeshGeometryDTO.h"
-
-namespace Nv
-{
-	namespace Blast
-	{
-		bool ExtPxSubchunkDTO::serialize(Nv::Blast::Serialization::ExtPxSubchunk::Builder builder, const Nv::Blast::ExtPxSubchunk * poco)
-		{
-			PxTransformDTO::serialize(builder.getTransform(), &poco->transform);
-			PxConvexMeshGeometryDTO::serialize(builder.getGeometry(), &poco->geometry);
-		
-			return true;
-		}
-		
-		Nv::Blast::ExtPxSubchunk* ExtPxSubchunkDTO::deserialize(Nv::Blast::Serialization::ExtPxSubchunk::Reader reader)
-		{
-			reader = reader;
-			//TODO: Allocate with ExtContext and return
-		
-			return nullptr;
-		}
-		
-		bool ExtPxSubchunkDTO::deserializeInto(Nv::Blast::Serialization::ExtPxSubchunk::Reader reader, Nv::Blast::ExtPxSubchunk * poco)
-		{
-			PxTransformDTO::deserializeInto(reader.getTransform(), &poco->transform);
-		
-			return true;
-		}
-		
-	}
-}
diff --git a/NvBlast/sdk/extensions/serialization/source/DTO/ExtPxSubchunkDTO.h b/NvBlast/sdk/extensions/serialization/source/DTO/ExtPxSubchunkDTO.h
deleted file mode 100644
index 91f78e0..0000000
--- a/NvBlast/sdk/extensions/serialization/source/DTO/ExtPxSubchunkDTO.h
+++ /dev/null
@@ -1,16 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#pragma once
-#include "NvBlastExtPxAsset.h"
-#include "generated/NvBlastExtSerialization.capn.h"
-#include "DTOMacros.h"
-
-DTO_CLASS(ExtPxSubchunk, Nv::Blast::ExtPxSubchunk, Nv::Blast::Serialization::ExtPxSubchunk)
diff --git a/NvBlast/sdk/extensions/serialization/source/DTO/NvBlastBondDTO.cpp b/NvBlast/sdk/extensions/serialization/source/DTO/NvBlastBondDTO.cpp
deleted file mode 100644
index 27cbb11..0000000
--- a/NvBlast/sdk/extensions/serialization/source/DTO/NvBlastBondDTO.cpp
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastBondDTO.h"
-#include "NvBlastAssert.h"
-
-namespace Nv
-{
-	namespace Blast
-	{
-		
-		bool NvBlastBondDTO::serialize(Nv::Blast::Serialization::NvBlastBond::Builder builder, const NvBlastBond * poco)
-		{
-			NVBLAST_ASSERT(poco != nullptr);
-		
-			kj::ArrayPtr<const float> normArray(poco->normal, 3);
-		
-			builder.setNormal(normArray);
-		
-			builder.setArea(poco->area);
-		
-			kj::ArrayPtr<const float> centArray(poco->centroid, 3);
-		
-			builder.setCentroid(centArray);
-		
-			builder.setUserData(poco->userData);
-		
-			return true;
-		}
-		
-		NvBlastBond* NvBlastBondDTO::deserialize(Nv::Blast::Serialization::NvBlastBond::Reader reader)
-		{
-			//FIXME
-			reader = reader;
-			//TODO: Allocate with ExtContext and return
-			return nullptr;
-		}
-		
-		bool NvBlastBondDTO::deserializeInto(Nv::Blast::Serialization::NvBlastBond::Reader reader, NvBlastBond * poco)
-		{
-			poco->area = reader.getArea();
-		
-			poco->centroid[0] = reader.getCentroid()[0];
-			poco->centroid[1] = reader.getCentroid()[1];
-			poco->centroid[2] = reader.getCentroid()[2];
-		
-			poco->normal[0] = reader.getNormal()[0];
-			poco->normal[1] = reader.getNormal()[1];
-			poco->normal[2] = reader.getNormal()[2];
-		
-			poco->userData = reader.getUserData();
-		
-			return true;
-		}
-	}
-}
diff --git a/NvBlast/sdk/extensions/serialization/source/DTO/NvBlastBondDTO.h b/NvBlast/sdk/extensions/serialization/source/DTO/NvBlastBondDTO.h
deleted file mode 100644
index 8b67bd7..0000000
--- a/NvBlast/sdk/extensions/serialization/source/DTO/NvBlastBondDTO.h
+++ /dev/null
@@ -1,16 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#pragma once
-#include "DTOMacros.h"
-#include "NvBlastTypes.h"
-#include "generated/NvBlastExtSerializationLL.capn.h"
-
-DTO_CLASS_LL(NvBlastBond, NvBlastBond, Nv::Blast::Serialization::NvBlastBond)
diff --git a/NvBlast/sdk/extensions/serialization/source/DTO/NvBlastChunkDTO.cpp b/NvBlast/sdk/extensions/serialization/source/DTO/NvBlastChunkDTO.cpp
deleted file mode 100644
index 38814ed..0000000
--- a/NvBlast/sdk/extensions/serialization/source/DTO/NvBlastChunkDTO.cpp
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastChunkDTO.h"
-#include "NvBlastAssert.h"
-
-namespace Nv
-{
-	namespace Blast
-	{
-		bool NvBlastChunkDTO::serialize(Nv::Blast::Serialization::NvBlastChunk::Builder builder, const NvBlastChunk* poco)
-		{
-			NVBLAST_ASSERT(poco != nullptr);
-		
-			kj::ArrayPtr<const float> centArray(poco->centroid, 3);
-			builder.setCentroid(centArray);
-		
-			builder.setVolume(poco->volume);
-		
-			builder.setParentChunkIndex(poco->parentChunkIndex);
-			builder.setFirstChildIndex(poco->firstChildIndex);
-			builder.setChildIndexStop(poco->childIndexStop);
-			builder.setUserData(poco->userData);
-		
-			return true;
-		}
-		
-		NvBlastChunk* NvBlastChunkDTO::deserialize(Nv::Blast::Serialization::NvBlastChunk::Reader reader)
-		{
-			//FIXME
-			reader = reader;
-		
-			return nullptr;
-		}
-		
-		bool NvBlastChunkDTO::deserializeInto(Nv::Blast::Serialization::NvBlastChunk::Reader reader, NvBlastChunk* target)
-		{
-			NVBLAST_ASSERT(target != nullptr);
-		
-			target->centroid[0] = reader.getCentroid()[0];
-			target->centroid[1] = reader.getCentroid()[1];
-			target->centroid[2] = reader.getCentroid()[2];
-		
-			target->childIndexStop = reader.getChildIndexStop();
-			target->firstChildIndex = reader.getFirstChildIndex();
-			target->parentChunkIndex = reader.getParentChunkIndex();
-			target->userData = reader.getUserData();
-			target->volume = reader.getVolume();
-		
-			return true;
-		}
-	}
-}
diff --git a/NvBlast/sdk/extensions/serialization/source/DTO/NvBlastChunkDTO.h b/NvBlast/sdk/extensions/serialization/source/DTO/NvBlastChunkDTO.h
deleted file mode 100644
index 5fec498..0000000
--- a/NvBlast/sdk/extensions/serialization/source/DTO/NvBlastChunkDTO.h
+++ /dev/null
@@ -1,18 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#pragma once
-#include "DTOMacros.h"
-#include "NvBlastTypes.h"
-#include "generated/NvBlastExtSerializationLL.capn.h"
-
-
-DTO_CLASS_LL(NvBlastChunk, NvBlastChunk, Nv::Blast::Serialization::NvBlastChunk)
-
diff --git a/NvBlast/sdk/extensions/serialization/source/DTO/NvBlastIDDTO.cpp b/NvBlast/sdk/extensions/serialization/source/DTO/NvBlastIDDTO.cpp
deleted file mode 100644
index e540cd8..0000000
--- a/NvBlast/sdk/extensions/serialization/source/DTO/NvBlastIDDTO.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastIDDTO.h"
-#include "NvBlastTypes.h"
-#include "NvBlastAssert.h"
-#include "generated/NvBlastExtSerializationLL.capn.h"
-
-
-namespace Nv
-{
-	namespace Blast
-	{
-		
-		bool NvBlastIDDTO::serialize(Nv::Blast::Serialization::UUID::Builder builder, const NvBlastID * poco)
-		{
-			capnp::Data::Reader idArrayReader((unsigned char *)poco->data, 16);
-			builder.setValue(idArrayReader);
-		
-			return true;
-		}
-		
-		NvBlastID* NvBlastIDDTO::deserialize(Nv::Blast::Serialization::UUID::Reader reader)
-		{
-			//FIXME
-			reader = reader;
-			//TODO: Allocate with ExtContext and return
-		
-			return nullptr;
-		}
-		
-		bool NvBlastIDDTO::deserializeInto(Nv::Blast::Serialization::UUID::Reader reader, NvBlastID * poco)
-		{
-			NVBLAST_ASSERT_WITH_MESSAGE(reader.getValue().size() == 16, "BlastID must be 16 bytes");
-		
-			memcpy(poco, reader.getValue().begin(), 16);
-		
-			return true;
-		}
-	}
-}
\ No newline at end of file
diff --git a/NvBlast/sdk/extensions/serialization/source/DTO/NvBlastIDDTO.h b/NvBlast/sdk/extensions/serialization/source/DTO/NvBlastIDDTO.h
deleted file mode 100644
index afe6cf0..0000000
--- a/NvBlast/sdk/extensions/serialization/source/DTO/NvBlastIDDTO.h
+++ /dev/null
@@ -1,16 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#pragma once
-#include "NvBlastTypes.h"
-#include "generated/NvBlastExtSerializationLL.capn.h"
-#include "DTOMacros.h"
-
-DTO_CLASS_LL(NvBlastID, NvBlastID, ::Nv::Blast::Serialization::UUID)
diff --git a/NvBlast/sdk/extensions/serialization/source/DTO/PxConvexMeshGeometryDTO.cpp b/NvBlast/sdk/extensions/serialization/source/DTO/PxConvexMeshGeometryDTO.cpp
deleted file mode 100644
index 1c46f9e..0000000
--- a/NvBlast/sdk/extensions/serialization/source/DTO/PxConvexMeshGeometryDTO.cpp
+++ /dev/null
@@ -1,127 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "PxConvexMeshGeometryDTO.h"
-#include "PxMeshScaleDTO.h"
-#include "NvBlastAssert.h"
-#include "NvBlastExtKJPxInputStream.h"
-#include "NvBlastExtKJPxOutputStream.h"
-#include "PxConvexMeshDesc.h"
-#include "NvBlastExtSerialization.h"
-#include "PxVec3.h"
-#include <algorithm>
-#include "PxPhysics.h"
-
-
-namespace Nv
-{
-	namespace Blast
-	{
-		physx::PxCooking* PxConvexMeshGeometryDTO::Cooking = nullptr;
-		physx::PxPhysics* PxConvexMeshGeometryDTO::Physics = nullptr;
-
-		bool PxConvexMeshGeometryDTO::serialize(Nv::Blast::Serialization::PxConvexMeshGeometry::Builder builder, const physx::PxConvexMeshGeometry * poco)
-		{
-			PxMeshScaleDTO::serialize(builder.getScale(), &poco->scale);
-		
-			//TODO: Use cooking.cookConvexMesh to cook the mesh to a stream - then get that backing buffer and put it into the Data field
-		
-			physx::PxConvexMeshDesc desc;
-			desc.points.data = poco->convexMesh->getVertices();
-			desc.points.count = poco->convexMesh->getNbVertices();
-			desc.points.stride = sizeof(physx::PxVec3);
-		
-			std::vector<uint32_t> indicesScratch;
-			std::vector<physx::PxHullPolygon> hullPolygonsScratch;
-		
-			hullPolygonsScratch.resize(poco->convexMesh->getNbPolygons());
-		
-			uint32_t indexCount = 0;
-			for (uint32_t i = 0; i < hullPolygonsScratch.size(); i++)
-			{
-				physx::PxHullPolygon polygon;
-				poco->convexMesh->getPolygonData(i, polygon);
-				if (polygon.mNbVerts)
-				{
-					indexCount = std::max<uint32_t>(indexCount, polygon.mIndexBase + polygon.mNbVerts);
-				}
-			}
-			indicesScratch.resize(indexCount);
-		
-			for (uint32_t i = 0; i < hullPolygonsScratch.size(); i++)
-			{
-				physx::PxHullPolygon polygon;
-				poco->convexMesh->getPolygonData(i, polygon);
-				for (uint32_t j = 0; j < polygon.mNbVerts; j++)
-				{
-					indicesScratch[polygon.mIndexBase + j] = poco->convexMesh->getIndexBuffer()[polygon.mIndexBase + j];
-				}
-		
-				hullPolygonsScratch[i] = polygon;
-			}
-		
-			desc.indices.count = indexCount;
-			desc.indices.data = indicesScratch.data();
-			desc.indices.stride = sizeof(uint32_t);
-		
-			desc.polygons.count = poco->convexMesh->getNbPolygons();
-			desc.polygons.data = hullPolygonsScratch.data();
-			desc.polygons.stride = sizeof(physx::PxHullPolygon);
-		
-		
-			std::vector<unsigned char> buffer;
-			buffer.resize(16 * 1024 * 1024); // No idea how much memory is needed! Allocate 16MB
-			kj::ArrayPtr<unsigned char> bufferArray(buffer.data(), buffer.size());
-		
-			Nv::Blast::ExtKJPxOutputStream outputStream(bufferArray);
-		
-			bool cookResult = Cooking->cookConvexMesh(desc, outputStream);
-		
-			if (!cookResult)
-			{
-				return false;
-			}
-		
-			kj::ArrayPtr<unsigned char> cookedBuffer(outputStream.getBuffer().begin(), outputStream.getWrittenBytes());
-		
-			builder.setConvexMesh(cookedBuffer);
-		
-		//	builder.getConvexMesh().
-		
-			return true;
-		}
-		
-		physx::PxConvexMeshGeometry* PxConvexMeshGeometryDTO::deserialize(Nv::Blast::Serialization::PxConvexMeshGeometry::Reader reader)
-		{
-			NVBLAST_ASSERT(PxConvexMeshGeometryDTO::Cooking != nullptr);
-		
-			reader = reader;
-		
-			return nullptr;
-		}
-		
-		bool PxConvexMeshGeometryDTO::deserializeInto(Nv::Blast::Serialization::PxConvexMeshGeometry::Reader reader, physx::PxConvexMeshGeometry * poco)
-		{
-			NVBLAST_ASSERT(PxConvexMeshGeometryDTO::Cooking != nullptr);
-		
-			PxMeshScaleDTO::deserializeInto(reader.getScale(), &poco->scale);
-		
-			Nv::Blast::ExtKJPxInputStream inputStream(reader.getConvexMesh());
-		
-			//NOTE: Naive approach, no shared convex hulls
-			poco->convexMesh = Physics->createConvexMesh(inputStream);
-		
-			return false;
-		}
-		
-		
-		
-	}
-}
diff --git a/NvBlast/sdk/extensions/serialization/source/DTO/PxConvexMeshGeometryDTO.h b/NvBlast/sdk/extensions/serialization/source/DTO/PxConvexMeshGeometryDTO.h
deleted file mode 100644
index 27b3754..0000000
--- a/NvBlast/sdk/extensions/serialization/source/DTO/PxConvexMeshGeometryDTO.h
+++ /dev/null
@@ -1,17 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#pragma once
-#include "DTOMacros.h"
-#include "generated/NvBlastExtSerialization.capn.h"
-#include "PxConvexMeshGeometry.h"
-#include "PxCooking.h"
-
-DTO_CLASS(PxConvexMeshGeometry, physx::PxConvexMeshGeometry, Nv::Blast::Serialization::PxConvexMeshGeometry)
diff --git a/NvBlast/sdk/extensions/serialization/source/DTO/PxMeshScaleDTO.cpp b/NvBlast/sdk/extensions/serialization/source/DTO/PxMeshScaleDTO.cpp
deleted file mode 100644
index 8fee6ad..0000000
--- a/NvBlast/sdk/extensions/serialization/source/DTO/PxMeshScaleDTO.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "PxMeshScaleDTO.h"
-#include "PxVec3DTO.h"
-#include "PxQuatDTO.h"
-
-namespace Nv
-{
-	namespace Blast
-	{
-		bool PxMeshScaleDTO::serialize(Nv::Blast::Serialization::PxMeshScale::Builder builder, const physx::PxMeshScale * poco)
-		{
-			PxVec3DTO::serialize(builder.getScale(), &poco->scale);
-			PxQuatDTO::serialize(builder.getRotation(), &poco->rotation);
-		
-			return true;
-		}
-		
-		physx::PxMeshScale* PxMeshScaleDTO::deserialize(Nv::Blast::Serialization::PxMeshScale::Reader reader)
-		{
-			reader = reader;
-			return nullptr;
-		}
-		
-		bool PxMeshScaleDTO::deserializeInto(Nv::Blast::Serialization::PxMeshScale::Reader reader, physx::PxMeshScale * poco)
-		{
-			PxVec3DTO::deserializeInto(reader.getScale(), &poco->scale);
-			PxQuatDTO::deserializeInto(reader.getRotation(), &poco->rotation);
-		
-			return true;
-		}
-	}
-}
-
diff --git a/NvBlast/sdk/extensions/serialization/source/DTO/PxMeshScaleDTO.h b/NvBlast/sdk/extensions/serialization/source/DTO/PxMeshScaleDTO.h
deleted file mode 100644
index 7b758c8..0000000
--- a/NvBlast/sdk/extensions/serialization/source/DTO/PxMeshScaleDTO.h
+++ /dev/null
@@ -1,17 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#pragma once
-#include "DTOMacros.h"
-#include "PxMeshScale.h"
-#include "generated/NvBlastExtSerialization.capn.h"
-#include "PxCooking.h"
-
-DTO_CLASS(PxMeshScale, physx::PxMeshScale, Nv::Blast::Serialization::PxMeshScale)
diff --git a/NvBlast/sdk/extensions/serialization/source/DTO/PxQuatDTO.cpp b/NvBlast/sdk/extensions/serialization/source/DTO/PxQuatDTO.cpp
deleted file mode 100644
index 8faeaa6..0000000
--- a/NvBlast/sdk/extensions/serialization/source/DTO/PxQuatDTO.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "PxQuatDTO.h"
-
-namespace Nv
-{
-	namespace Blast
-	{
-		
-		bool PxQuatDTO::serialize(Nv::Blast::Serialization::PxQuat::Builder builder, const physx::PxQuat * poco)
-		{
-			builder.setX(poco->x);
-			builder.setY(poco->y);
-			builder.setZ(poco->z);
-			builder.setW(poco->w);
-		
-			return true;
-		}
-		
-		physx::PxQuat* PxQuatDTO::deserialize(Nv::Blast::Serialization::PxQuat::Reader reader)
-		{
-			reader = reader;
-			return nullptr;
-		}
-		
-		bool PxQuatDTO::deserializeInto(Nv::Blast::Serialization::PxQuat::Reader reader, physx::PxQuat * poco)
-		{
-			poco->x = reader.getX();
-			poco->y = reader.getY();
-			poco->z = reader.getZ();
-			poco->w = reader.getW();
-		
-			return true;
-		}
-		
-	}
-}
diff --git a/NvBlast/sdk/extensions/serialization/source/DTO/PxQuatDTO.h b/NvBlast/sdk/extensions/serialization/source/DTO/PxQuatDTO.h
deleted file mode 100644
index 460d6c5..0000000
--- a/NvBlast/sdk/extensions/serialization/source/DTO/PxQuatDTO.h
+++ /dev/null
@@ -1,17 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#pragma once
-#include "DTOMacros.h"
-#include "PxQuat.h"
-#include "generated/NvBlastExtSerialization.capn.h"
-#include "PxCooking.h"
-
-DTO_CLASS(PxQuat, physx::PxQuat, Nv::Blast::Serialization::PxQuat)
diff --git a/NvBlast/sdk/extensions/serialization/source/DTO/PxTransformDTO.cpp b/NvBlast/sdk/extensions/serialization/source/DTO/PxTransformDTO.cpp
deleted file mode 100644
index 20a7cbb..0000000
--- a/NvBlast/sdk/extensions/serialization/source/DTO/PxTransformDTO.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "PxTransformDTO.h"
-#include "PxQuatDTO.h"
-#include "PxVec3DTO.h"
-
-namespace Nv
-{
-	namespace Blast
-	{
-		
-		bool PxTransformDTO::serialize(Nv::Blast::Serialization::PxTransform::Builder builder, const physx::PxTransform * poco)
-		{
-			PxQuatDTO::serialize(builder.getQ(), &poco->q);
-			PxVec3DTO::serialize(builder.getP(), &poco->p);
-		
-			return true;
-		}
-		
-		physx::PxTransform* PxTransformDTO::deserialize(Nv::Blast::Serialization::PxTransform::Reader reader)
-		{
-			reader = reader;
-			return nullptr;
-		}
-		
-		bool PxTransformDTO::deserializeInto(Nv::Blast::Serialization::PxTransform::Reader reader, physx::PxTransform * poco)
-		{
-			PxQuatDTO::deserializeInto(reader.getQ(), &poco->q);
-			PxVec3DTO::deserializeInto(reader.getP(), &poco->p);
-		
-			return true;
-		}
-	}
-}
diff --git a/NvBlast/sdk/extensions/serialization/source/DTO/PxTransformDTO.h b/NvBlast/sdk/extensions/serialization/source/DTO/PxTransformDTO.h
deleted file mode 100644
index 49a6b73..0000000
--- a/NvBlast/sdk/extensions/serialization/source/DTO/PxTransformDTO.h
+++ /dev/null
@@ -1,17 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#pragma once
-#include "DTOMacros.h"
-#include "PxTransform.h"
-#include "generated/NvBlastExtSerialization.capn.h"
-#include "PxCooking.h"
-
-DTO_CLASS(PxTransform, physx::PxTransform, Nv::Blast::Serialization::PxTransform)
diff --git a/NvBlast/sdk/extensions/serialization/source/DTO/PxVec3DTO.cpp b/NvBlast/sdk/extensions/serialization/source/DTO/PxVec3DTO.cpp
deleted file mode 100644
index 9827cd0..0000000
--- a/NvBlast/sdk/extensions/serialization/source/DTO/PxVec3DTO.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "PxVec3DTO.h"
-#include "NvBlastAssert.h"
-
-namespace Nv
-{
-	namespace Blast
-	{
-		bool PxVec3DTO::serialize(Nv::Blast::Serialization::PxVec3::Builder builder, const physx::PxVec3 * poco)
-		{
-			NVBLAST_ASSERT(poco != nullptr);
-		
-			builder.setX(poco->x);
-			builder.setY(poco->y);
-			builder.setZ(poco->z);
-		
-			return true;
-		}
-		
-		physx::PxVec3* PxVec3DTO::deserialize(Nv::Blast::Serialization::PxVec3::Reader reader)
-		{
-			//TODO: Allocate using ExtContext and return
-			reader = reader;
-			return nullptr;
-		}
-		
-		bool PxVec3DTO::deserializeInto(Nv::Blast::Serialization::PxVec3::Reader reader, physx::PxVec3* target)
-		{
-			target->x = reader.getX();
-			target->y = reader.getY();
-			target->z = reader.getZ();
-		
-			return true;
-		}
-	}
-}
diff --git a/NvBlast/sdk/extensions/serialization/source/DTO/PxVec3DTO.h b/NvBlast/sdk/extensions/serialization/source/DTO/PxVec3DTO.h
deleted file mode 100644
index 8a04c8b..0000000
--- a/NvBlast/sdk/extensions/serialization/source/DTO/PxVec3DTO.h
+++ /dev/null
@@ -1,17 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#pragma once
-#include "DTOMacros.h"
-#include "generated/NvBlastExtSerialization.capn.h"
-#include "PxVec3.h"
-#include "PxCooking.h"
-
-DTO_CLASS(PxVec3, physx::PxVec3, Nv::Blast::Serialization::PxVec3)
diff --git a/NvBlast/sdk/extensions/serialization/source/DTO/TkAssetDTO.cpp b/NvBlast/sdk/extensions/serialization/source/DTO/TkAssetDTO.cpp
deleted file mode 100644
index acc55ba..0000000
--- a/NvBlast/sdk/extensions/serialization/source/DTO/TkAssetDTO.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "TkAssetDTO.h"
-#include "AssetDTO.h"
-#include "TkAssetJointDescDTO.h"
-#include <vector>
-#include "NvBlastTkFramework.h"
-
-
-
-namespace Nv
-{
-	namespace Blast
-	{
-		bool TkAssetDTO::serialize(Nv::Blast::Serialization::TkAsset::Builder builder, const Nv::Blast::TkAsset * poco)
-		{
-			const Asset* assetLL = reinterpret_cast<const Nv::Blast::Asset*>(poco->getAssetLL());
-		
-			Nv::Blast::AssetDTO::serialize(builder.getAssetLL(), assetLL);
-		
-			uint32_t jointDescCount = poco->getJointDescCount();
-		
-			capnp::List<Nv::Blast::Serialization::TkAssetJointDesc>::Builder jointDescs = builder.initJointDescs(jointDescCount);
-		
-			for (uint32_t i = 0; i < jointDescCount; i++)
-			{
-				TkAssetJointDescDTO::serialize(jointDescs[i], &poco->getJointDescs()[i]);
-			}
-		
-			return true;
-		}
-		
-		Nv::Blast::TkAsset* TkAssetDTO::deserialize(Nv::Blast::Serialization::TkAsset::Reader reader)
-		{
-			const NvBlastAsset* assetLL = reinterpret_cast<const NvBlastAsset*>(AssetDTO::deserialize(reader.getAssetLL()));
-			
-			std::vector<Nv::Blast::TkAssetJointDesc> jointDescs;
-			jointDescs.resize(reader.getJointDescs().size());
-		
-			for (uint32_t i = 0; i < jointDescs.size(); i++)
-			{
-				TkAssetJointDescDTO::deserializeInto(reader.getJointDescs()[i], &jointDescs[i]);
-			}
-		
-			// Make sure to set ownsAsset to true - this is serialization and no one else owns it.
-			Nv::Blast::TkAsset* asset = NvBlastTkFrameworkGet()->createAsset(assetLL, jointDescs.data(), jointDescs.size(), true);
-		
-			return asset;
-		}
-		
-		bool TkAssetDTO::deserializeInto(Nv::Blast::Serialization::TkAsset::Reader reader, Nv::Blast::TkAsset * poco)
-		{
-			reader = reader;
-			poco = nullptr;
-			// NOTE: Because of the way TkAsset is currently structured, this won't work.
-			return false;
-		}
-	}
-}
diff --git a/NvBlast/sdk/extensions/serialization/source/DTO/TkAssetDTO.h b/NvBlast/sdk/extensions/serialization/source/DTO/TkAssetDTO.h
deleted file mode 100644
index 1b21eba..0000000
--- a/NvBlast/sdk/extensions/serialization/source/DTO/TkAssetDTO.h
+++ /dev/null
@@ -1,17 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#pragma once
-#include "DTOMacros.h"
-#include "NvBlastTkAsset.h"
-#include "generated/NvBlastExtSerialization.capn.h"
-#include "PxCooking.h"
-
-DTO_CLASS(TkAsset, Nv::Blast::TkAsset, Nv::Blast::Serialization::TkAsset)
diff --git a/NvBlast/sdk/extensions/serialization/source/DTO/TkAssetJointDescDTO.cpp b/NvBlast/sdk/extensions/serialization/source/DTO/TkAssetJointDescDTO.cpp
deleted file mode 100644
index 9118d19..0000000
--- a/NvBlast/sdk/extensions/serialization/source/DTO/TkAssetJointDescDTO.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "TkAssetJointDescDTO.h"
-#include "PxVec3DTO.h"
-
-
-namespace Nv
-{
-	namespace Blast
-	{
-		
-		bool TkAssetJointDescDTO::serialize(Nv::Blast::Serialization::TkAssetJointDesc::Builder builder, const Nv::Blast::TkAssetJointDesc * poco)
-		{
-			kj::ArrayPtr<const uint32_t> nodeIndices(poco->nodeIndices, 2);
-			builder.setNodeIndices(nodeIndices);
-		
-			for (int i = 0; i < 2; i++)
-			{
-				PxVec3DTO::serialize(builder.getAttachPositions()[i], &poco->attachPositions[i]);
-			}
-		
-			return true;
-		}
-		
-		Nv::Blast::TkAssetJointDesc* TkAssetJointDescDTO::deserialize(Nv::Blast::Serialization::TkAssetJointDesc::Reader reader)
-		{
-			//TODO: Allocate with ExtContent and return
-		
-			reader = reader;
-		
-			return nullptr;
-		}
-		
-		bool TkAssetJointDescDTO::deserializeInto(Nv::Blast::Serialization::TkAssetJointDesc::Reader reader, Nv::Blast::TkAssetJointDesc * poco)
-		{
-			PxVec3DTO::deserializeInto(reader.getAttachPositions()[0], &poco->attachPositions[0]);
-			PxVec3DTO::deserializeInto(reader.getAttachPositions()[1], &poco->attachPositions[1]);
-		
-			poco->nodeIndices[0] = reader.getNodeIndices()[0];
-			poco->nodeIndices[1] = reader.getNodeIndices()[1];
-		
-			return true;
-		}
-	}
-}
\ No newline at end of file
diff --git a/NvBlast/sdk/extensions/serialization/source/DTO/TkAssetJointDescDTO.h b/NvBlast/sdk/extensions/serialization/source/DTO/TkAssetJointDescDTO.h
deleted file mode 100644
index 88364bd..0000000
--- a/NvBlast/sdk/extensions/serialization/source/DTO/TkAssetJointDescDTO.h
+++ /dev/null
@@ -1,17 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#pragma once
-#include "DTOMacros.h"
-#include "NvBlastTkAsset.h"
-#include "generated/NvBlastExtSerialization.capn.h"
-#include "PxCooking.h"
-
-DTO_CLASS(TkAssetJointDesc, Nv::Blast::TkAssetJointDesc, Nv::Blast::Serialization::TkAssetJointDesc)
diff --git a/NvBlast/sdk/extensions/serialization/source/NvBlastExtGlobals.h b/NvBlast/sdk/extensions/serialization/source/NvBlastExtGlobals.h
deleted file mode 100644
index dd50afd..0000000
--- a/NvBlast/sdk/extensions/serialization/source/NvBlastExtGlobals.h
+++ /dev/null
@@ -1,10 +0,0 @@
-#pragma once
-
-/**
-Function pointer type for allocation - has same signature as stdlib malloc.
-*/
-typedef void*	(*NvBlastExtAlloc)(size_t size);
-
-extern NvBlastExtAlloc gAlloc;
-extern NvBlastLog gLog;
-
diff --git a/NvBlast/sdk/extensions/serialization/source/NvBlastExtInputStream.cpp b/NvBlast/sdk/extensions/serialization/source/NvBlastExtInputStream.cpp
deleted file mode 100644
index 7ef9b62..0000000
--- a/NvBlast/sdk/extensions/serialization/source/NvBlastExtInputStream.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastExtInputStream.h"
-
-
-Nv::Blast::ExtInputStream::ExtInputStream(std::istream &inputStream):
-	m_inputStream(inputStream)
-{
-
-}
-
-
-size_t Nv::Blast::ExtInputStream::tryRead(void* buffer, size_t /*minBytes*/, size_t maxBytes)
-{
-	m_inputStream.read((char *) buffer, maxBytes);
-
-	if (m_inputStream.fail())
-	{
-		// Throw exception, log error
-//		NVBLASTEXT_LOG_ERROR("Failure when reading from stream");
-	}
-
-	// Since we're using a blocking read above, if we don't have maxBytes we're probably done
-	if ((size_t) m_inputStream.gcount() < maxBytes)
-	{
-//		NVBLASTEXT_LOG_ERROR("Failed to read requested number of bytes during blocking read.");
-	}
-
-	return m_inputStream.gcount();
-}
diff --git a/NvBlast/sdk/extensions/serialization/source/NvBlastExtInputStream.h b/NvBlast/sdk/extensions/serialization/source/NvBlastExtInputStream.h
deleted file mode 100644
index 9b19d9c..0000000
--- a/NvBlast/sdk/extensions/serialization/source/NvBlastExtInputStream.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#pragma once
-#include "kj/io.h"
-#include <istream>
-
-namespace Nv
-{
-	namespace Blast
-	{
-		class ExtInputStream : public kj::InputStream
-		{
-			public:
-				ExtInputStream() = delete;
-				ExtInputStream(std::istream &inputStream);
-
-				// Returns a read of maxBytes. This is supposed to be happy doing partial reads, but currently isn't. 
-				virtual size_t tryRead(void* buffer, size_t minBytes, size_t maxBytes) override;
-
-			private:
-				std::istream &m_inputStream;
-		};
-	}
-}
\ No newline at end of file
diff --git a/NvBlast/sdk/extensions/serialization/source/NvBlastExtKJPxInputStream.cpp b/NvBlast/sdk/extensions/serialization/source/NvBlastExtKJPxInputStream.cpp
deleted file mode 100644
index 9af13a9..0000000
--- a/NvBlast/sdk/extensions/serialization/source/NvBlastExtKJPxInputStream.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastExtKJPxInputStream.h"
-
-namespace Nv
-{
-	namespace Blast
-	{
-		ExtKJPxInputStream::ExtKJPxInputStream(capnp::Data::Reader inReader) :
-			dataReader(inReader),
-			inputStream(nullptr)
-		{
-			kj::ArrayPtr<const unsigned char> buffer(inReader.begin(), inReader.size());
-
-			inputStream = std::make_shared<kj::ArrayInputStream>(buffer);
-		}
-
-		uint32_t ExtKJPxInputStream::read(void* dest, uint32_t count)
-		{
-			return inputStream->tryRead(dest, count, count);
-		}
-	}
-}
-
diff --git a/NvBlast/sdk/extensions/serialization/source/NvBlastExtKJPxInputStream.h b/NvBlast/sdk/extensions/serialization/source/NvBlastExtKJPxInputStream.h
deleted file mode 100644
index 452892d..0000000
--- a/NvBlast/sdk/extensions/serialization/source/NvBlastExtKJPxInputStream.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#pragma once
-#include "PxIO.h"
-#include "capnp/common.h"
-#include "kj/io.h"
-#include <memory>
-#include "generated/NvBlastExtSerialization.capn.h"
-
-namespace Nv
-{
-	namespace Blast
-	{
-		/*
-		A wrapper around a Capn Proto Data reader.
-
-		Since it needs to behave like a stream, it's internally wrapped in a stream.
-
-		*/
-		class ExtKJPxInputStream : public physx::PxInputStream
-		{
-		public:
-			ExtKJPxInputStream(capnp::Data::Reader inReader);
-			~ExtKJPxInputStream() = default;
-
-			virtual uint32_t read(void* dest, uint32_t count) override;
-
-		private:
-			capnp::Data::Reader dataReader;
-			std::shared_ptr<kj::ArrayInputStream> inputStream;
-		};
-	}
-}
diff --git a/NvBlast/sdk/extensions/serialization/source/NvBlastExtKJPxOutputStream.cpp b/NvBlast/sdk/extensions/serialization/source/NvBlastExtKJPxOutputStream.cpp
deleted file mode 100644
index 0f17a01..0000000
--- a/NvBlast/sdk/extensions/serialization/source/NvBlastExtKJPxOutputStream.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastExtKJPxOutputStream.h"
-
-namespace Nv
-{
-	namespace Blast
-	{
-		ExtKJPxOutputStream::ExtKJPxOutputStream(kj::ArrayPtr<unsigned char> inBuffer) :
-			writtenBytes(0),
-			Buffer(inBuffer),
-			outputStream(nullptr)
-		{
-			outputStream = std::make_shared<kj::ArrayOutputStream>(inBuffer);
-		}
-
-		uint32_t ExtKJPxOutputStream::write(const void* src, uint32_t count)
-		{
-			outputStream->write(src, count);
-
-			writtenBytes += count;
-
-			return count;
-		}
-	}
-}
-
diff --git a/NvBlast/sdk/extensions/serialization/source/NvBlastExtKJPxOutputStream.h b/NvBlast/sdk/extensions/serialization/source/NvBlastExtKJPxOutputStream.h
deleted file mode 100644
index 0ed563f..0000000
--- a/NvBlast/sdk/extensions/serialization/source/NvBlastExtKJPxOutputStream.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#pragma once
-#include "PxIO.h"
-#include "kj/common.h"
-#include <memory>
-#include "kj/io.h"
-
-namespace Nv
-{
-	namespace Blast
-	{
-		class ExtKJPxOutputStream : public physx::PxOutputStream
-		{
-		public:
-			ExtKJPxOutputStream(kj::ArrayPtr<unsigned char> inBuffer);
-			~ExtKJPxOutputStream() = default;
-
-			virtual uint32_t write(const void* src, uint32_t count) override;
-
-			uint32_t getWrittenBytes() { return writtenBytes; }
-
-			kj::ArrayPtr<unsigned char> getBuffer() { return Buffer; }
-
-		private:
-			uint32_t writtenBytes;
-
-			kj::ArrayPtr<unsigned char> Buffer;
-			std::shared_ptr<kj::ArrayOutputStream> outputStream;
-		};
-	}
-}
diff --git a/NvBlast/sdk/extensions/serialization/source/NvBlastExtOutputStream.cpp b/NvBlast/sdk/extensions/serialization/source/NvBlastExtOutputStream.cpp
deleted file mode 100644
index cf6e31f..0000000
--- a/NvBlast/sdk/extensions/serialization/source/NvBlastExtOutputStream.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastExtOutputStream.h"
-
-
-
-Nv::Blast::ExtOutputStream::ExtOutputStream(std::ostream &outputStream):
-	m_outputStream(outputStream)
-{
-
-}
-
-void Nv::Blast::ExtOutputStream::write(const void* buffer, size_t size)
-{
-	m_outputStream.write((char *) buffer, size);
-}
diff --git a/NvBlast/sdk/extensions/serialization/source/NvBlastExtOutputStream.h b/NvBlast/sdk/extensions/serialization/source/NvBlastExtOutputStream.h
deleted file mode 100644
index ba0044e..0000000
--- a/NvBlast/sdk/extensions/serialization/source/NvBlastExtOutputStream.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#pragma once
-#include "kj/io.h"
-#include <ostream>
-
-namespace Nv
-{
-	namespace Blast
-	{
-		class ExtOutputStream : public kj::OutputStream
-		{
-
-		public:
-			ExtOutputStream() = delete;
-			ExtOutputStream(std::ostream &outputStream);
-
-			virtual void write(const void* buffer, size_t size) override;
-		private:
-			std::ostream &m_outputStream;
-		};
-	}
-}
diff --git a/NvBlast/sdk/extensions/serialization/source/NvBlastExtSerialization.capn b/NvBlast/sdk/extensions/serialization/source/NvBlastExtSerialization.capn
deleted file mode 100644
index ddc439a..0000000
--- a/NvBlast/sdk/extensions/serialization/source/NvBlastExtSerialization.capn
+++ /dev/null
@@ -1,95 +0,0 @@
-# Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-#
-# NVIDIA CORPORATION and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto.  Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-@0xaffe4498f275ee58;
-
-using Cxx = import "/capnp/c++.capnp";
-
-using LL = import "NvBlastExtSerializationLL.capn";
-
-$Cxx.namespace("Nv::Blast::Serialization");
-
-struct TkAsset
-{
-	assetLL @0 :LL.Asset;
-	
-	jointDescs @1 :List(TkAssetJointDesc);
-}
-
-struct ExtPxAsset
-{
-	asset @0 :TkAsset;
-	chunks @1 :List(ExtPxChunk);
-	subchunks @2 :List(ExtPxSubchunk);
-}
-
-struct ExtPxChunk
-{
-	firstSubchunkIndex @0 :UInt32;
-	subchunkCount @1 :UInt32;
-	isStatic @2 :Bool;
-}
-
-struct ExtPxSubchunk
-{
-	transform @0 :PxTransform;
-	geometry @1 :PxConvexMeshGeometry;
-}
-
-struct PxConvexMeshGeometry
-{
-	scale @0 :PxMeshScale;
-	convexMesh @1 :Data;
-	meshFlags @2 :UInt8;
-
-	enum Type
-	{
-		eSPHERE @0;
-		ePLANE @1;
-		eCAPSULE @2;
-		eBOX @3;
-		eCONVEXMESH @4;
-		eTRIANGLEMESH @5;
-		eHEIGHTFIELD @6;
-	}
-
-	type @3 :Type;
-}
-
-struct TkAssetJointDesc
-{
-	nodeIndices @0 :List(UInt32);
-	attachPositions @1 :List(PxVec3);
-}
-
-struct PxVec3
-{
-	x @0 :Float32;
-	y @1 :Float32;
-	z @2 :Float32;
-}
-
-struct PxQuat
-{
-	x @0 :Float32;
-	y @1 :Float32;
-	z @2 :Float32;
-	w @3 :Float32;
-}
-
-struct PxMeshScale
-{
-	scale @0 :PxVec3;
-	rotation @1 :PxQuat;
-}
-
-struct PxTransform
-{
-	q @0 :PxQuat;
-	p @1 :PxVec3;
-}
diff --git a/NvBlast/sdk/extensions/serialization/source/NvBlastExtSerialization.cpp b/NvBlast/sdk/extensions/serialization/source/NvBlastExtSerialization.cpp
deleted file mode 100644
index 28a1553..0000000
--- a/NvBlast/sdk/extensions/serialization/source/NvBlastExtSerialization.cpp
+++ /dev/null
@@ -1,146 +0,0 @@
-#include "NvBlastExtSerialization.h"
-#include "BlastSerialization.h"
-#include <memory>
-#include "PxPhysicsVersion.h"
-#include "PxConvexMeshGeometryDTO.h"
-#include "NvBlastExtDefs.h"
-
-
-// This is terrible.
-physx::PxPhysics* g_Physics = nullptr;
-
-
-std::shared_ptr<physx::PxCooking> getCooking()
-{
-	physx::PxCookingParams cookingParams(g_Physics->getTolerancesScale());
-	cookingParams.buildGPUData = true;
-
-	std::shared_ptr<physx::PxCooking> m_Cooking = std::shared_ptr<physx::PxCooking>(PxCreateCooking(PX_PHYSICS_VERSION, g_Physics->getFoundation(), cookingParams), [=](physx::PxCooking* cooking)
-	{
-		cooking->release();
-	});
-
-	NVBLASTEXT_CHECK_ERROR(m_Cooking, "Error: failed to create PhysX Cooking\n", return nullptr);
-
-	return m_Cooking;
-}
-
-
-extern "C"
-{
-	NVBLAST_API void setPhysXSDK(physx::PxPhysics* physXSDK)
-	{
-		g_Physics = physXSDK;
-	}
-
-	NVBLAST_API NvBlastAsset* deserializeAsset(const unsigned char* input, uint32_t size)
-	{
-		return Nv::Blast::BlastSerialization<Nv::Blast::Asset, Nv::Blast::Serialization::Asset::Reader, Nv::Blast::Serialization::Asset::Builder>::deserialize(input, size);
-	}
-
-	NVBLAST_API NvBlastAsset* deserializeAssetFromStream(std::istream &inputStream)
-	{
-		return Nv::Blast::BlastSerialization<Nv::Blast::Asset, Nv::Blast::Serialization::Asset::Reader, Nv::Blast::Serialization::Asset::Builder>::deserializeFromStream(inputStream);
-	}
-	
-	NVBLAST_API bool serializeAssetIntoStream(const NvBlastAsset *asset, std::ostream &outputStream)
-	{
-		return Nv::Blast::BlastSerialization<Nv::Blast::Asset, Nv::Blast::Serialization::Asset::Reader, Nv::Blast::Serialization::Asset::Builder>::serializeIntoStream(reinterpret_cast<const Nv::Blast::Asset *>(asset), outputStream);
-	}
-
-	NVBLAST_API bool serializeAssetIntoNewBuffer(const NvBlastAsset *asset, unsigned char **outBuffer, uint32_t &outSize)
-	{
-		return Nv::Blast::BlastSerialization<Nv::Blast::Asset, Nv::Blast::Serialization::Asset::Reader, Nv::Blast::Serialization::Asset::Builder>::serializeIntoNewBuffer(reinterpret_cast<const Nv::Blast::Asset *>(asset), outBuffer, outSize);
-	}
-
-	NVBLAST_API bool serializeAssetIntoExistingBuffer(const NvBlastAsset *asset, unsigned char *buffer, uint32_t maxSize, uint32_t &usedSize)
-	{
-		return Nv::Blast::BlastSerialization<Nv::Blast::Asset, Nv::Blast::Serialization::Asset::Reader, Nv::Blast::Serialization::Asset::Builder>::serializeIntoExistingBuffer(reinterpret_cast<const Nv::Blast::Asset *>(asset), buffer, maxSize, usedSize);
-	}
-
-	//////////////////////////////////////////////////////////////////////////
-	// TkAsset
-	//////////////////////////////////////////////////////////////////////////
-
-	NVBLAST_API Nv::Blast::TkAsset* deserializeTkAsset(const unsigned char* input, uint32_t size)
-	{
-		return Nv::Blast::BlastSerialization<Nv::Blast::TkAsset, Nv::Blast::Serialization::TkAsset::Reader, Nv::Blast::Serialization::TkAsset::Builder>::deserialize(input, size);
-	}
-
-	NVBLAST_API Nv::Blast::TkAsset* deserializeTkAssetFromStream(std::istream &inputStream)
-	{
-		return Nv::Blast::BlastSerialization<Nv::Blast::TkAsset, Nv::Blast::Serialization::TkAsset::Reader, Nv::Blast::Serialization::TkAsset::Builder>::deserializeFromStream(inputStream);
-	}
-
-	NVBLAST_API bool serializeTkAssetIntoStream(const Nv::Blast::TkAsset *asset, std::ostream &outputStream)
-	{
-		return Nv::Blast::BlastSerialization<Nv::Blast::TkAsset, Nv::Blast::Serialization::TkAsset::Reader, Nv::Blast::Serialization::TkAsset::Builder>::serializeIntoStream(reinterpret_cast<const Nv::Blast::TkAsset *>(asset), outputStream);
-	}
-
-	NVBLAST_API bool serializeTkAssetIntoNewBuffer(const Nv::Blast::TkAsset *asset, unsigned char **outBuffer, uint32_t &outSize)
-	{
-		return Nv::Blast::BlastSerialization<Nv::Blast::TkAsset, Nv::Blast::Serialization::TkAsset::Reader, Nv::Blast::Serialization::TkAsset::Builder>::serializeIntoNewBuffer(reinterpret_cast<const Nv::Blast::TkAsset *>(asset), outBuffer, outSize);
-	}
-
-	NVBLAST_API bool serializeTkAssetIntoExistingBuffer(const Nv::Blast::TkAsset *asset, unsigned char *buffer, uint32_t maxSize, uint32_t &usedSize)
-	{
-		return Nv::Blast::BlastSerialization<Nv::Blast::TkAsset, Nv::Blast::Serialization::TkAsset::Reader, Nv::Blast::Serialization::TkAsset::Builder>::serializeIntoExistingBuffer(reinterpret_cast<const Nv::Blast::TkAsset *>(asset), buffer, maxSize, usedSize);
-	}
-
-	//////////////////////////////////////////////////////////////////////////
-	// ExtPxAsset
-	//////////////////////////////////////////////////////////////////////////
-
-	NVBLAST_API Nv::Blast::ExtPxAsset* deserializeExtPxAsset(const unsigned char* input, uint32_t size)
-	{
-		NVBLAST_ASSERT(g_Physics != nullptr);
-
-		return Nv::Blast::BlastSerialization<Nv::Blast::ExtPxAsset, Nv::Blast::Serialization::ExtPxAsset::Reader, Nv::Blast::Serialization::ExtPxAsset::Builder>::deserialize(input, size);
-	}
-
-	NVBLAST_API Nv::Blast::ExtPxAsset* deserializeExtPxAssetFromStream(std::istream &inputStream)
-	{
-		NVBLAST_ASSERT(g_Physics != nullptr);
-
-		return Nv::Blast::BlastSerialization<Nv::Blast::ExtPxAsset, Nv::Blast::Serialization::ExtPxAsset::Reader, Nv::Blast::Serialization::ExtPxAsset::Builder>::deserializeFromStream(inputStream);
-	}
-
-	NVBLAST_API bool serializeExtPxAssetIntoStream(const Nv::Blast::ExtPxAsset *asset, std::ostream &outputStream)
-	{
-		NVBLAST_ASSERT(g_Physics != nullptr);
-
-		auto cooking = getCooking();
-
-		PxConvexMeshGeometryDTO::Cooking = cooking.get();
-		PxConvexMeshGeometryDTO::Physics = g_Physics;
-
-		return Nv::Blast::BlastSerialization<Nv::Blast::ExtPxAsset, Nv::Blast::Serialization::ExtPxAsset::Reader, Nv::Blast::Serialization::ExtPxAsset::Builder>::serializeIntoStream(reinterpret_cast<const Nv::Blast::ExtPxAsset *>(asset), outputStream);
-	}
-
-	NVBLAST_API bool serializeExtPxAssetIntoNewBuffer(const Nv::Blast::ExtPxAsset *asset, unsigned char **outBuffer, uint32_t &outSize)
-	{
-		NVBLAST_ASSERT(g_Physics != nullptr);
-
-		auto cooking = getCooking();
-
-		PxConvexMeshGeometryDTO::Cooking = cooking.get();
-		PxConvexMeshGeometryDTO::Physics = g_Physics;
-
-		return Nv::Blast::BlastSerialization<Nv::Blast::ExtPxAsset, Nv::Blast::Serialization::ExtPxAsset::Reader, Nv::Blast::Serialization::ExtPxAsset::Builder>::serializeIntoNewBuffer(reinterpret_cast<const Nv::Blast::ExtPxAsset *>(asset), outBuffer, outSize);
-	}
-
-	NVBLAST_API bool serializeExtPxAssetIntoExistingBuffer(const Nv::Blast::ExtPxAsset *asset, unsigned char *buffer, uint32_t maxSize, uint32_t &usedSize)
-	{
-		NVBLAST_ASSERT(g_Physics != nullptr);
-
-		auto cooking = getCooking();
-
-		PxConvexMeshGeometryDTO::Cooking = cooking.get();
-		PxConvexMeshGeometryDTO::Physics = g_Physics;
-
-		return Nv::Blast::BlastSerialization<Nv::Blast::ExtPxAsset, Nv::Blast::Serialization::ExtPxAsset::Reader, Nv::Blast::Serialization::ExtPxAsset::Builder>::serializeIntoExistingBuffer(reinterpret_cast<const Nv::Blast::ExtPxAsset *>(asset), buffer, maxSize, usedSize);
-	}
-
-
-}
-
diff --git a/NvBlast/sdk/extensions/serialization/source/NvBlastExtSerialization.h b/NvBlast/sdk/extensions/serialization/source/NvBlastExtSerialization.h
deleted file mode 100644
index 5d44554..0000000
--- a/NvBlast/sdk/extensions/serialization/source/NvBlastExtSerialization.h
+++ /dev/null
@@ -1,172 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#pragma once
-#include "kj/io.h"
-#include "capnp/serialize.h"
-#include "generated/NvBlastExtSerializationLL.capn.h"
-#include <vector>
-#include "NvBlastExtInputStream.h"
-#include "NvBlastExtOutputStream.h"
-
-#if !defined(BLAST_LL_ALLOC)
-#include "NvBlastExtAllocator.h"
-#endif
-#include "NvBlastExtGlobals.h"
-
-namespace Nv
-{
-	namespace Blast
-	{
-		template<typename TAsset, typename TSerializationReader, typename TSerializationBuilder>
-		class ExtSerialization
-		{
-		public:
-			static TAsset* deserialize(const unsigned char* input, uint32_t size);
-			static TAsset* deserializeFromStream(std::istream &inputStream);
-
-			static bool serializeIntoExistingBuffer(const TAsset *asset, unsigned char *buffer, uint32_t maxSize, uint32_t &usedSize);
-			static bool serializeIntoNewBuffer(const TAsset *asset, unsigned char **outBuffer, uint32_t &outSize);
-			static bool serializeIntoStream(const TAsset *asset, std::ostream &outputStream);
-
-		private:
-
-			static void serializeMessageIntoNewBuffer(capnp::MallocMessageBuilder& message, unsigned char ** outBuffer, uint32_t &outSize);
-
-			// Specialized
-			static bool serializeIntoBuilder(TSerializationBuilder& assetBuilder, const TAsset* asset);
-			static bool serializeIntoMessage(capnp::MallocMessageBuilder& message, const TAsset* asset);
-			static TAsset* deserializeFromStreamReader(capnp::InputStreamMessageReader &message);
-		};
-
-		template<typename TAsset, typename TSerializationReader, typename TSerializationBuilder>
-		TAsset* ExtSerialization<TAsset, TSerializationReader, TSerializationBuilder>::deserialize(const unsigned char* input, uint32_t size)
-		{
-			kj::ArrayPtr<const unsigned char> source(input, size);
-
-			kj::ArrayInputStream inputStream(source);
-
-			std::vector<uint64_t> scratch;
-			scratch.resize(size);
-			kj::ArrayPtr<capnp::word> scratchArray((capnp::word*) scratch.data(), size);
-
-			capnp::InputStreamMessageReader message(inputStream, capnp::ReaderOptions(), scratchArray);
-
-			return deserializeFromStreamReader(message);
-		}
-
-		template<typename TAsset, typename TSerializationReader, typename TSerializationBuilder>
-		TAsset* ExtSerialization<TAsset, TSerializationReader, TSerializationBuilder>::deserializeFromStream(std::istream &inputStream)
-		{
-			Nv::Blast::ExtInputStream readStream(inputStream);
-
-			capnp::InputStreamMessageReader message(readStream);
-
-			return deserializeFromStreamReader(message);
-		}
-
-		template<typename TAsset, typename TSerializationReader, typename TSerializationBuilder>
-		bool ExtSerialization<TAsset, TSerializationReader, TSerializationBuilder>::serializeIntoExistingBuffer(const TAsset *asset, unsigned char *buffer, uint32_t maxSize, uint32_t &usedSize)
-		{
-			capnp::MallocMessageBuilder message;
-
-			bool result = serializeIntoMessage(message, asset);
-
-			if (result == false)
-			{
-				usedSize = 0;
-				return false;
-			}
-
-			uint32_t messageSize = computeSerializedSizeInWords(message) * sizeof(uint64_t);
-
-			if (maxSize < messageSize)
-			{
-				NvBlastLog logFn = gLog;
-
-#if !defined(BLAST_LL_ALLOC)
-				logFn = NvBlastTkFrameworkGet()->getLogFn();
-#endif
-
-				NVBLAST_LOG_ERROR(logFn, "When attempting to serialize into an existing buffer, the provided buffer was too small.");
-				usedSize = 0;
-				return false;
-			}
-
-			kj::ArrayPtr<unsigned char> outputBuffer(buffer, maxSize);
-			kj::ArrayOutputStream outputStream(outputBuffer);
-
-			capnp::writeMessage(outputStream, message);
-
-			usedSize = messageSize;;
-			return true;
-		}
-
-		template<typename TAsset, typename TSerializationReader, typename TSerializationBuilder>
-		bool ExtSerialization<TAsset, TSerializationReader, TSerializationBuilder>::serializeIntoNewBuffer(const TAsset *asset, unsigned char **outBuffer, uint32_t &outSize)
-		{
-			capnp::MallocMessageBuilder message;
-
-			bool result = serializeIntoMessage(message, asset);
-
-			if (result == false)
-			{
-				*outBuffer = nullptr;
-				outSize = 0;
-				return false;
-			}
-
-			serializeMessageIntoNewBuffer(message, outBuffer, outSize);
-
-			return true;
-		}
-
-		template<typename TAsset, typename TSerializationReader, typename TSerializationBuilder>
-		bool ExtSerialization<TAsset, TSerializationReader, TSerializationBuilder>::serializeIntoStream(const TAsset *asset, std::ostream &outputStream)
-		{
-			capnp::MallocMessageBuilder message;
-
-			bool result = serializeIntoMessage(message, asset);
-
-			if (result == false)
-			{
-				return false;
-			}
-
-			Nv::Blast::ExtOutputStream blastOutputStream(outputStream);
-
-			writeMessage(blastOutputStream, message);
-
-			return true;
-		}
-
-		template<typename TAsset, typename TSerializationReader, typename TSerializationBuilder>
-		void ExtSerialization<TAsset, TSerializationReader, TSerializationBuilder>::serializeMessageIntoNewBuffer(capnp::MallocMessageBuilder& message, unsigned char ** outBuffer, uint32_t &outSize)
-		{
-			uint32_t messageSize = computeSerializedSizeInWords(message) * sizeof(uint64_t);
-
-			NvBlastExtAlloc allocFn = gAlloc;
-
-#if !defined(BLAST_LL_ALLOC)
-			allocFn = ExtAllocator::alignedAlloc16;
-#endif
-
-			unsigned char* buffer = static_cast<unsigned char *>(allocFn(messageSize));
-
-			kj::ArrayPtr<unsigned char> outputBuffer(buffer, messageSize);
-			kj::ArrayOutputStream outputStream(outputBuffer);
-
-			capnp::writeMessage(outputStream, message);
-
-			*outBuffer = buffer;
-			outSize = messageSize;
-		}
-	}
-}
diff --git a/NvBlast/sdk/extensions/serialization/source/NvBlastExtSerializationImpl.h b/NvBlast/sdk/extensions/serialization/source/NvBlastExtSerializationImpl.h
deleted file mode 100644
index 7f9fbc9..0000000
--- a/NvBlast/sdk/extensions/serialization/source/NvBlastExtSerializationImpl.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#pragma once
-
-#include "NvBlastExtSerialization.h"
-#include "NvBlastTkAsset.h"
-#include "NvBlastExtPxAsset.h"
-#include "TkAssetDTO.h"
-#include "ExtPxAssetDTO.h"
-
-namespace Nv
-{
-	namespace Blast
-	{
-		/*
-		Specializations here - one set for each top level asset. (TkAsset, ExtPxAsset)
-		*/
-		
-	
-		// TkAsset
-		template<>
-		NV_INLINE bool ExtSerialization<Nv::Blast::TkAsset, Nv::Blast::Serialization::TkAsset::Reader, Nv::Blast::Serialization::TkAsset::Builder>::serializeIntoBuilder(Nv::Blast::Serialization::TkAsset::Builder& assetBuilder, const Nv::Blast::TkAsset* asset)
-		{
-			return TkAssetDTO::serialize(assetBuilder, asset);
-		}
-		
-		template<>
-		NV_INLINE Nv::Blast::TkAsset* ExtSerialization<Nv::Blast::TkAsset, Nv::Blast::Serialization::TkAsset::Reader, Nv::Blast::Serialization::TkAsset::Builder>::deserializeFromStreamReader(capnp::InputStreamMessageReader &message)
-		{
-			Nv::Blast::Serialization::TkAsset::Reader reader = message.getRoot<Nv::Blast::Serialization::TkAsset>();
-		
-			return TkAssetDTO::deserialize(reader);
-		}
-		
-		template<>
-		NV_INLINE bool ExtSerialization<Nv::Blast::TkAsset, Nv::Blast::Serialization::TkAsset::Reader, Nv::Blast::Serialization::TkAsset::Builder>::serializeIntoMessage(capnp::MallocMessageBuilder& message, const Nv::Blast::TkAsset* asset)
-		{
-			Nv::Blast::Serialization::TkAsset::Builder assetBuilder = message.initRoot<Nv::Blast::Serialization::TkAsset>();
-		
-			return serializeIntoBuilder(assetBuilder, asset);
-		}
-		
-		
-		//ExtPxAsset
-		template<>
-		NV_INLINE bool ExtSerialization<Nv::Blast::ExtPxAsset, Nv::Blast::Serialization::ExtPxAsset::Reader, Nv::Blast::Serialization::ExtPxAsset::Builder>::serializeIntoBuilder(Nv::Blast::Serialization::ExtPxAsset::Builder& assetBuilder, const Nv::Blast::ExtPxAsset* asset)
-		{
-			return ExtPxAssetDTO::serialize(assetBuilder, asset);
-		}
-		
-		template<>
-		NV_INLINE Nv::Blast::ExtPxAsset* ExtSerialization<Nv::Blast::ExtPxAsset, Nv::Blast::Serialization::ExtPxAsset::Reader, Nv::Blast::Serialization::ExtPxAsset::Builder>::deserializeFromStreamReader(capnp::InputStreamMessageReader &message)
-		{
-			Nv::Blast::Serialization::ExtPxAsset::Reader reader = message.getRoot<Nv::Blast::Serialization::ExtPxAsset>();
-		
-			return ExtPxAssetDTO::deserialize(reader);
-		}
-		
-		template<>
-		NV_INLINE bool ExtSerialization<Nv::Blast::ExtPxAsset, Nv::Blast::Serialization::ExtPxAsset::Reader, Nv::Blast::Serialization::ExtPxAsset::Builder>::serializeIntoMessage(capnp::MallocMessageBuilder& message, const Nv::Blast::ExtPxAsset* asset)
-		{
-			Nv::Blast::Serialization::ExtPxAsset::Builder assetBuilder = message.initRoot<Nv::Blast::Serialization::ExtPxAsset>();
-		
-			return serializeIntoBuilder(assetBuilder, asset);
-		}
-	}
-}
diff --git a/NvBlast/sdk/extensions/serialization/source/NvBlastExtSerializationInterface.cpp b/NvBlast/sdk/extensions/serialization/source/NvBlastExtSerializationInterface.cpp
deleted file mode 100644
index bebee5b..0000000
--- a/NvBlast/sdk/extensions/serialization/source/NvBlastExtSerializationInterface.cpp
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastExtSerializationImpl.h"
-#include <memory>
-#include "PxPhysicsVersion.h"
-#include "PxConvexMeshGeometryDTO.h"
-#include "NvBlastExtDefs.h"
-#include "PxPhysics.h"
-#include "NvBlastAssert.h"
-
-
-// This is terrible.
-physx::PxPhysics* g_Physics = nullptr;
-
-using namespace Nv::Blast;
-
-std::shared_ptr<physx::PxCooking> getCooking()
-{
-	physx::PxCookingParams cookingParams(g_Physics->getTolerancesScale());
-	cookingParams.buildGPUData = true;
-
-	std::shared_ptr<physx::PxCooking> m_Cooking = std::shared_ptr<physx::PxCooking>(PxCreateCooking(PX_PHYSICS_VERSION, g_Physics->getFoundation(), cookingParams), [=](physx::PxCooking* cooking)
-	{
-		cooking->release();
-	});
-
-	NVBLASTEXT_CHECK_ERROR(m_Cooking, "Error: failed to create PhysX Cooking\n", return nullptr);
-
-	return m_Cooking;
-}
-
-
-extern "C"
-{
-	NVBLAST_API void setPhysXSDK(physx::PxPhysics* physXSDK)
-	{
-		g_Physics = physXSDK;
-	}
-
-	//////////////////////////////////////////////////////////////////////////
-	// TkAsset
-	//////////////////////////////////////////////////////////////////////////
-
-	NVBLAST_API Nv::Blast::TkAsset* deserializeTkAsset(const unsigned char* input, uint32_t size)
-	{
-		return Nv::Blast::ExtSerialization<Nv::Blast::TkAsset, Nv::Blast::Serialization::TkAsset::Reader, Nv::Blast::Serialization::TkAsset::Builder>::deserialize(input, size);
-	}
-
-	NVBLAST_API Nv::Blast::TkAsset* deserializeTkAssetFromStream(std::istream &inputStream)
-	{
-		return Nv::Blast::ExtSerialization<Nv::Blast::TkAsset, Nv::Blast::Serialization::TkAsset::Reader, Nv::Blast::Serialization::TkAsset::Builder>::deserializeFromStream(inputStream);
-	}
-
-	NVBLAST_API bool serializeTkAssetIntoStream(const Nv::Blast::TkAsset *asset, std::ostream &outputStream)
-	{
-		return Nv::Blast::ExtSerialization<Nv::Blast::TkAsset, Nv::Blast::Serialization::TkAsset::Reader, Nv::Blast::Serialization::TkAsset::Builder>::serializeIntoStream(reinterpret_cast<const Nv::Blast::TkAsset *>(asset), outputStream);
-	}
-
-	NVBLAST_API bool serializeTkAssetIntoNewBuffer(const Nv::Blast::TkAsset *asset, unsigned char **outBuffer, uint32_t &outSize)
-	{
-		return Nv::Blast::ExtSerialization<Nv::Blast::TkAsset, Nv::Blast::Serialization::TkAsset::Reader, Nv::Blast::Serialization::TkAsset::Builder>::serializeIntoNewBuffer(reinterpret_cast<const Nv::Blast::TkAsset *>(asset), outBuffer, outSize);
-	}
-
-	NVBLAST_API bool serializeTkAssetIntoExistingBuffer(const Nv::Blast::TkAsset *asset, unsigned char *buffer, uint32_t maxSize, uint32_t &usedSize)
-	{
-		return Nv::Blast::ExtSerialization<Nv::Blast::TkAsset, Nv::Blast::Serialization::TkAsset::Reader, Nv::Blast::Serialization::TkAsset::Builder>::serializeIntoExistingBuffer(reinterpret_cast<const Nv::Blast::TkAsset *>(asset), buffer, maxSize, usedSize);
-	}
-
-	//////////////////////////////////////////////////////////////////////////
-	// ExtPxAsset
-	//////////////////////////////////////////////////////////////////////////
-
-	NVBLAST_API Nv::Blast::ExtPxAsset* deserializeExtPxAsset(const unsigned char* input, uint32_t size)
-	{
-		NVBLAST_ASSERT(g_Physics != nullptr);
-
-		return Nv::Blast::ExtSerialization<Nv::Blast::ExtPxAsset, Nv::Blast::Serialization::ExtPxAsset::Reader, Nv::Blast::Serialization::ExtPxAsset::Builder>::deserialize(input, size);
-	}
-
-	NVBLAST_API Nv::Blast::ExtPxAsset* deserializeExtPxAssetFromStream(std::istream &inputStream)
-	{
-		NVBLAST_ASSERT(g_Physics != nullptr);
-
-		return Nv::Blast::ExtSerialization<Nv::Blast::ExtPxAsset, Nv::Blast::Serialization::ExtPxAsset::Reader, Nv::Blast::Serialization::ExtPxAsset::Builder>::deserializeFromStream(inputStream);
-	}
-
-	NVBLAST_API bool serializeExtPxAssetIntoStream(const Nv::Blast::ExtPxAsset *asset, std::ostream &outputStream)
-	{
-		NVBLAST_ASSERT(g_Physics != nullptr);
-
-		auto cooking = getCooking();
-
-		PxConvexMeshGeometryDTO::Cooking = cooking.get();
-		PxConvexMeshGeometryDTO::Physics = g_Physics;
-
-		return Nv::Blast::ExtSerialization<Nv::Blast::ExtPxAsset, Nv::Blast::Serialization::ExtPxAsset::Reader, Nv::Blast::Serialization::ExtPxAsset::Builder>::serializeIntoStream(reinterpret_cast<const Nv::Blast::ExtPxAsset *>(asset), outputStream);
-	}
-
-	NVBLAST_API bool serializeExtPxAssetIntoNewBuffer(const Nv::Blast::ExtPxAsset *asset, unsigned char **outBuffer, uint32_t &outSize)
-	{
-		NVBLAST_ASSERT(g_Physics != nullptr);
-
-		auto cooking = getCooking();
-
-		PxConvexMeshGeometryDTO::Cooking = cooking.get();
-		PxConvexMeshGeometryDTO::Physics = g_Physics;
-
-		return Nv::Blast::ExtSerialization<Nv::Blast::ExtPxAsset, Nv::Blast::Serialization::ExtPxAsset::Reader, Nv::Blast::Serialization::ExtPxAsset::Builder>::serializeIntoNewBuffer(reinterpret_cast<const Nv::Blast::ExtPxAsset *>(asset), outBuffer, outSize);
-	}
-
-	NVBLAST_API bool serializeExtPxAssetIntoExistingBuffer(const Nv::Blast::ExtPxAsset *asset, unsigned char *buffer, uint32_t maxSize, uint32_t &usedSize)
-	{
-		NVBLAST_ASSERT(g_Physics != nullptr);
-
-		auto cooking = getCooking();
-
-		PxConvexMeshGeometryDTO::Cooking = cooking.get();
-		PxConvexMeshGeometryDTO::Physics = g_Physics;
-
-		return Nv::Blast::ExtSerialization<Nv::Blast::ExtPxAsset, Nv::Blast::Serialization::ExtPxAsset::Reader, Nv::Blast::Serialization::ExtPxAsset::Builder>::serializeIntoExistingBuffer(reinterpret_cast<const Nv::Blast::ExtPxAsset *>(asset), buffer, maxSize, usedSize);
-	}
-
-
-}
-
diff --git a/NvBlast/sdk/extensions/serialization/source/NvBlastExtSerializationLL.capn b/NvBlast/sdk/extensions/serialization/source/NvBlastExtSerializationLL.capn
deleted file mode 100644
index 026056f..0000000
--- a/NvBlast/sdk/extensions/serialization/source/NvBlastExtSerializationLL.capn
+++ /dev/null
@@ -1,89 +0,0 @@
-# Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-#
-# NVIDIA CORPORATION and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto.  Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-@0x9a4a58fac38375e0;
-
-using Cxx = import "/capnp/c++.capnp";
-
-$Cxx.namespace("Nv::Blast::Serialization");
-
-struct Asset
-{
-	header @0 :NvBlastDataBlock;
-	
-	iD @1 :UUID;
-	
-	chunkCount @2 :UInt32;
-	
-	graph @3 :NvBlastSupportGraph;
-	
-	leafChunkCount @4 :UInt32;
-	
-	firstSubsupportChunkIndex @5 :UInt32;
-	
-	bondCount @6 :UInt32;
-	
-	chunks @7: List(NvBlastChunk);
-	
-	bonds @8: List(NvBlastBond);
-	
-	subtreeLeafChunkCounts @9: List(UInt32);
-	
-	chunkToGraphNodeMap @10: List(UInt32);
-}
-
-struct NvBlastDataBlock
-{
-	enum Type
-	{
-		assetDataBlock @0;
-		instanceDataBlock @1;
-	}
-	
-	dataType @0 :Type;
-	
-	formatVersion @1 :UInt32;
-	
-	size @2 :UInt32;
-}
-
-struct NvBlastChunk
-{
-	centroid @0 :List(Float32);
-	
-	volume @1 :Float32;
-	
-	parentChunkIndex @2 :UInt32;
-	firstChildIndex @3 :UInt32;
-	childIndexStop @4 :UInt32;
-	userData @5 :UInt32;
-}
-
-struct NvBlastBond
-{
-	normal @0 :List(Float32);
-	area @1 :Float32;
-	centroid @2 :List(Float32);
-	userData @3 :UInt32;
-}
-
-struct NvBlastSupportGraph
-{
-	nodeCount @0 : UInt32;
-	
-	chunkIndices @1 : List(UInt32);
-	adjacencyPartition @2 : List(UInt32);
-	adjacentNodeIndices @3 : List(UInt32);
-	adjacentBondIndices @4 : List(UInt32);
-}
-
-struct UUID
-{
-	value @0 : Data;
-}
-
diff --git a/NvBlast/sdk/extensions/serialization/source/NvBlastExtSerializationLLImpl.h b/NvBlast/sdk/extensions/serialization/source/NvBlastExtSerializationLLImpl.h
deleted file mode 100644
index d7595ba..0000000
--- a/NvBlast/sdk/extensions/serialization/source/NvBlastExtSerializationLLImpl.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#pragma once
-
-#include "NvBlastExtSerialization.h"
-#include "NvBlastAsset.h"
-#include "AssetDTO.h"
-
-namespace Nv
-{
-	namespace Blast
-	{
-		/*
-		Specializations here - LL asset only
-		*/
-		
-		// Asset
-		template<>
-		NV_INLINE bool ExtSerialization<Nv::Blast::Asset, Nv::Blast::Serialization::Asset::Reader, Nv::Blast::Serialization::Asset::Builder>::serializeIntoBuilder(Nv::Blast::Serialization::Asset::Builder& assetBuilder, const Nv::Blast::Asset* asset)
-		{
-			return AssetDTO::serialize(assetBuilder, asset);
-		}
-		
-		template<>
-		NV_INLINE Nv::Blast::Asset* ExtSerialization<Nv::Blast::Asset, Nv::Blast::Serialization::Asset::Reader, Nv::Blast::Serialization::Asset::Builder>::deserializeFromStreamReader(capnp::InputStreamMessageReader &message)
-		{
-			Nv::Blast::Serialization::Asset::Reader reader = message.getRoot<Nv::Blast::Serialization::Asset>();
-		
-			return AssetDTO::deserialize(reader);
-		}
-		
-		template<>
-		NV_INLINE bool ExtSerialization<Nv::Blast::Asset, Nv::Blast::Serialization::Asset::Reader, Nv::Blast::Serialization::Asset::Builder>::serializeIntoMessage(capnp::MallocMessageBuilder& message, const Nv::Blast::Asset* asset)
-		{
-			Nv::Blast::Serialization::Asset::Builder assetBuilder = message.initRoot<Nv::Blast::Serialization::Asset>();
-		
-			return serializeIntoBuilder(assetBuilder, asset);
-		}
-	}
-}
diff --git a/NvBlast/sdk/extensions/serialization/source/NvBlastExtSerializationLLInterface.cpp b/NvBlast/sdk/extensions/serialization/source/NvBlastExtSerializationLLInterface.cpp
deleted file mode 100644
index 26d8667..0000000
--- a/NvBlast/sdk/extensions/serialization/source/NvBlastExtSerializationLLInterface.cpp
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastExtSerializationLLInterface.h"
-#include "NvBlastExtSerializationLLImpl.h"
-#include <memory>
-#include "NvBlastExtSerialization.h"
-#include "NvBlastAsset.h"
-#include <iostream>
-#include "NvBlastExtGlobals.h"
-
-
-NvBlastExtAlloc gAlloc = nullptr;
-NvBlastLog gLog = nullptr;
-
-extern "C"
-{
-	NVBLAST_API void setAllocator(NvBlastExtAlloc alloc)
-	{
-		gAlloc = alloc;
-	}
-
-	NVBLAST_API void setLog(NvBlastLog log)
-	{
-		gLog = log;
-	}
-
-	NVBLAST_API NvBlastAsset* deserializeAsset(const unsigned char* input, uint32_t size)
-	{
-#if defined(BLAST_LL_ALLOC)
-		if (gAlloc == nullptr || gLog == nullptr)
-		{
-			std::cerr << "Must set allocator and log when using low level serialization library. See setAllocator() and setLog() functions." << std::endl;
-			return nullptr;
-		}
-#endif
-
-		return Nv::Blast::ExtSerialization<Nv::Blast::Asset, Nv::Blast::Serialization::Asset::Reader, Nv::Blast::Serialization::Asset::Builder>::deserialize(input, size);
-	}
-
-	NVBLAST_API NvBlastAsset* deserializeAssetFromStream(std::istream &inputStream)
-	{
-#if defined(BLAST_LL_ALLOC)
-		if (gAlloc == nullptr || gLog == nullptr)
-		{
-			std::cerr << "Must set allocator and log when using low level serialization library. See setAllocator() and setLog() functions." << std::endl;
-			return nullptr;
-		}
-#endif
-
-		return Nv::Blast::ExtSerialization<Nv::Blast::Asset, Nv::Blast::Serialization::Asset::Reader, Nv::Blast::Serialization::Asset::Builder>::deserializeFromStream(inputStream);
-	}
-	
-	NVBLAST_API bool serializeAssetIntoStream(const NvBlastAsset *asset, std::ostream &outputStream)
-	{
-#if defined(BLAST_LL_ALLOC)
-		if (gAlloc == nullptr || gLog == nullptr)
-		{
-			std::cerr << "Must set allocator and log when using low level serialization library. See setAllocator() and setLog() functions." << std::endl;
-			return false;
-		}
-#endif
-
-		return Nv::Blast::ExtSerialization<Nv::Blast::Asset, Nv::Blast::Serialization::Asset::Reader, Nv::Blast::Serialization::Asset::Builder>::serializeIntoStream(reinterpret_cast<const Nv::Blast::Asset *>(asset), outputStream);
-	}
-
-	NVBLAST_API bool serializeAssetIntoNewBuffer(const NvBlastAsset *asset, unsigned char **outBuffer, uint32_t &outSize)
-	{
-#if defined(BLAST_LL_ALLOC)
-		if (gAlloc == nullptr || gLog == nullptr)
-		{
-			std::cerr << "Must set allocator and log when using low level serialization library. See setAllocator() and setLog() functions." << std::endl;
-			return false;
-		}
-#endif
-
-		return Nv::Blast::ExtSerialization<Nv::Blast::Asset, Nv::Blast::Serialization::Asset::Reader, Nv::Blast::Serialization::Asset::Builder>::serializeIntoNewBuffer(reinterpret_cast<const Nv::Blast::Asset *>(asset), outBuffer, outSize);
-	}
-
-	NVBLAST_API bool serializeAssetIntoExistingBuffer(const NvBlastAsset *asset, unsigned char *buffer, uint32_t maxSize, uint32_t &usedSize)
-	{
-#if defined(BLAST_LL_ALLOC)
-		if (gAlloc == nullptr || gLog == nullptr)
-		{
-			std::cerr << "Must set allocator and log when using low level serialization library. See setAllocator() and setLog() functions." << std::endl;
-			return false;
-		}
-#endif
-
-		return Nv::Blast::ExtSerialization<Nv::Blast::Asset, Nv::Blast::Serialization::Asset::Reader, Nv::Blast::Serialization::Asset::Builder>::serializeIntoExistingBuffer(reinterpret_cast<const Nv::Blast::Asset *>(asset), buffer, maxSize, usedSize);
-	}
-
-}
-
diff --git a/NvBlast/sdk/extensions/shaders/include/NvBlastExtDamageShaders.h b/NvBlast/sdk/extensions/shaders/include/NvBlastExtDamageShaders.h
deleted file mode 100644
index 385bf52..0000000
--- a/NvBlast/sdk/extensions/shaders/include/NvBlastExtDamageShaders.h
+++ /dev/null
@@ -1,111 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTEXTDAMAGESHADERS_H
-#define NVBLASTEXTDAMAGESHADERS_H
-
-#include "NvBlastTypes.h"
-#include "NvBlastPreprocessor.h"
-
-/**
-A few example damage shader implementations.
-*/
-
-
-///////////////////////////////////////////////////////////////////////////////
-//  Common Material 
-///////////////////////////////////////////////////////////////////////////////
-
-/**
-Specific parameters for the material functions here present.
-
-Material function implementers may choose their own set.
-*/
-struct NvBlastExtMaterial
-{
-	float	singleChunkThreshold;		//!<	subsupport chunks only take damage surpassing this value
-	float	graphChunkThreshold;		//!<	support chunks only take damage surpassing this value
-	float	bondTangentialThreshold;	//!<	bond only take damage surpassing this value
-	float	bondNormalThreshold;		//!<	currently unused - forward damage propagation
-	float	damageAttenuation;			//!<	factor of damage attenuation while forwarding
-};
-
-
-///////////////////////////////////////////////////////////////////////////////
-//  Radial Damage
-///////////////////////////////////////////////////////////////////////////////
-
-/**
-Radial Damage Desc
-*/
-struct NvBlastExtRadialDamageDesc
-{
-	float	compressive;	//!<	compressive (radial) damage component
-	float	position[3];	//!<	origin of damage action
-	float	minRadius;		//!<	inner radius of damage action
-	float	maxRadius;		//!<	outer radius of damage action
-};
-
-/**
-Radial Falloff and Radial Cutter damage for both graph and subgraph shaders.
-
-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 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);
-
-
-///////////////////////////////////////////////////////////////////////////////
-//  Shear Damage
-///////////////////////////////////////////////////////////////////////////////
-
-/**
-Shear Damage Desc
-*/
-struct NvBlastExtShearDamageDesc
-{
-	float	shear[3];		//!<	directional damage component
-	float	position[3];	//!<	origin of damage action
-};
-
-/**
-Shear Damage Shaders
-
-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 NvBlastExtShearGraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastGraphShaderActor* actor, const NvBlastProgramParams* params);
-NVBLAST_API void NvBlastExtShearSubgraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastSubgraphShaderActor* actor, const NvBlastProgramParams* params);
-
-
-#endif // NVBLASTEXTDAMAGESHADERS_H
diff --git a/NvBlast/sdk/extensions/shaders/source/NvBlastExtRadialShaders.cpp b/NvBlast/sdk/extensions/shaders/source/NvBlastExtRadialShaders.cpp
deleted file mode 100644
index 00d1010..0000000
--- a/NvBlast/sdk/extensions/shaders/source/NvBlastExtRadialShaders.cpp
+++ /dev/null
@@ -1,205 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastExtDamageShaders.h"
-#include "NvBlastIndexFns.h"
-#include "NvBlastMath.h"
-#include "NvBlastGeometry.h"
-#include "NvBlastAssert.h"
-#include "NvBlast.h"
-#include "stdlib.h" // for abs() on linux
-
-using namespace Nv::Blast;
-using namespace Nv::Blast::VecMath;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//													Profiles
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-typedef float(*ProfileFunction)(float, float, float, float);
-
-float falloffProfile(float min, float max, float x, float f = 1.0f)
-{
-	if (x > max) return 0.0f;
-	if (x < min) return f;
-
-	float y = 1.0f - (x - min) / (max - min);
-	return y * f;
-}
-
-float cutterProfile(float min, float max, float x, float f = 1.0f)
-{
-	if (x > max || x < min) return 0.0f;
-
-	return f;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//												Radial Graph Shader Template
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-template <ProfileFunction profile>
-void RadialProfileGraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastGraphShaderActor* actor, const NvBlastProgramParams* 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 float* familyBondHealths = actor->familyBondHealths;
-
-	const NvBlastExtRadialDamageDesc* damageData = reinterpret_cast<const NvBlastExtRadialDamageDesc*>(params->damageDescBuffer);
-	const uint32_t damageCount = params->damageDescCount;
-
-	uint32_t outCount = 0;
-
-	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];
-
-					float totalBondDamage = 0.0f;
-
-					for (uint32_t damageIndex = 0; damageIndex < damageCount; damageIndex++)
-					{
-						const NvBlastExtRadialDamageDesc& damage = damageData[damageIndex];
-
-						float relativePosition[3];
-						sub(damage.position, bond.centroid, relativePosition);
-						float distance = sqrtf(dot(relativePosition, relativePosition));
-
-						float dir[3];
-						normal(relativePosition, dir);
-
-						totalBondDamage += profile(damage.minRadius, damage.maxRadius, distance, damage.compressive);
-					}
-
-					if (totalBondDamage > 0.0f)
-					{
-						NvBlastBondFractureData& outCommand = commandBuffers->bondFractures[outCount++];
-						outCommand.nodeIndex0 = currentNodeIndex;
-						outCommand.nodeIndex1 = adjacentNodeIndex;
-						outCommand.health = totalBondDamage;
-					}
-				}
-			}
-		}
-		currentNodeIndex = graphNodeIndexLinks[currentNodeIndex];
-	}
-
-	commandBuffers->bondFractureCount = outCount;
-	commandBuffers->chunkFractureCount = 0;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//											Radial Single Shader Template
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-template <ProfileFunction profile>
-void RadialProfileSubgraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastSubgraphShaderActor* actor, const NvBlastProgramParams* params)
-{
-	uint32_t chunkFractureCount = 0;
-	const uint32_t chunkIndex = actor->chunkIndex;
-	const NvBlastChunk* assetChunks = actor->assetChunks;
-	const NvBlastChunk& chunk = assetChunks[chunkIndex];
-
-	float totalDamage = 0.0f;
-	for (uint32_t i = 0; i < params->damageDescCount; ++i)
-	{
-		const NvBlastExtRadialDamageDesc& damage = reinterpret_cast<const NvBlastExtRadialDamageDesc*>(params->damageDescBuffer)[i];
-
-		float relativePosition[3];
-		sub(damage.position, chunk.centroid, relativePosition);
-		float distance = sqrtf(dot(relativePosition, relativePosition));
-
-		totalDamage += profile(damage.minRadius, damage.maxRadius, distance, damage.compressive);
-	}
-
-	if (totalDamage > 0.0f)
-	{
-		NvBlastChunkFractureData& frac = commandBuffers->chunkFractures[chunkFractureCount++];
-		frac.chunkIndex = chunkIndex;
-		frac.health = totalDamage;
-	}
-
-	commandBuffers->bondFractureCount = 0;
-	commandBuffers->chunkFractureCount = chunkFractureCount;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//												Shader Instantiation
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-void NvBlastExtFalloffGraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastGraphShaderActor* actor, const NvBlastProgramParams* params)
-{
-	RadialProfileGraphShader<falloffProfile>(commandBuffers, actor, params);
-}
-
-void NvBlastExtFalloffSubgraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastSubgraphShaderActor* actor, const NvBlastProgramParams* params)
-{
-	RadialProfileSubgraphShader<falloffProfile>(commandBuffers, actor, params);
-}
-
-void NvBlastExtCutterGraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastGraphShaderActor* actor, const NvBlastProgramParams* params)
-{
-	RadialProfileGraphShader<cutterProfile>(commandBuffers, actor, params);
-}
-
-void NvBlastExtCutterSubgraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastSubgraphShaderActor* actor, const NvBlastProgramParams* params)
-{
-	RadialProfileSubgraphShader<cutterProfile>(commandBuffers, actor, params);
-}
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//												Helper Functions
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-bool NvBlastExtDamageActorRadialFalloff(NvBlastActor* actor, NvBlastFractureBuffers* buffers, const NvBlastExtRadialDamageDesc* damageDescBuffer, uint32_t damageDescCount, const NvBlastExtMaterial* material, NvBlastLog logFn, NvBlastTimers* timers)
-{
-	NvBlastDamageProgram program =
-	{
-		NvBlastExtFalloffGraphShader,
-		NvBlastExtFalloffSubgraphShader
-	};
-
-	NvBlastProgramParams params =
-	{
-		damageDescBuffer,
-		damageDescCount,
-		material
-	};
-
-	NvBlastActorGenerateFracture(buffers, actor, program, &params, logFn, timers);
-	if (buffers->bondFractureCount > 0 || buffers->chunkFractureCount > 0)
-	{
-		NvBlastActorApplyFracture(nullptr, actor, buffers, logFn, timers);
-		return true;
-	}
-
-	return false;
-}
\ No newline at end of file
diff --git a/NvBlast/sdk/extensions/shaders/source/NvBlastExtShearShaders.cpp b/NvBlast/sdk/extensions/shaders/source/NvBlastExtShearShaders.cpp
deleted file mode 100644
index 26707e1..0000000
--- a/NvBlast/sdk/extensions/shaders/source/NvBlastExtShearShaders.cpp
+++ /dev/null
@@ -1,149 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastExtDamageShaders.h"
-#include "NvBlastIndexFns.h"
-#include "NvBlastMath.h"
-#include "NvBlastGeometry.h"
-#include "NvBlastAssert.h"
-#include "stdlib.h" // for abs() on linux
-
-using namespace Nv::Blast;
-using namespace Nv::Blast::VecMath;
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//													Graph Shader
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-void NvBlastExtShearGraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastGraphShaderActor* actor, const NvBlastProgramParams* params)
-{
-	const NvBlastExtMaterial* materialProperties = reinterpret_cast<const NvBlastExtMaterial*>(params->material);
-	const float graphChunkThreshold = materialProperties->graphChunkThreshold;
-	const float bondTangentialThreshold = materialProperties->bondTangentialThreshold;
-	const float damageAttenuation = 1.0f - materialProperties->damageAttenuation;
-
-	uint32_t chunkFractureCount = 0;
-	uint32_t chunkFractureCountMax = commandBuffers->chunkFractureCount;
-	uint32_t bondFractureCount = 0;
-	uint32_t bondFractureCountMax = commandBuffers->bondFractureCount;
-
-	for (uint32_t i = 0; i < params->damageDescCount; ++i)
-	{
-		const NvBlastExtShearDamageDesc& damage = 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 float* familyBondHealths = actor->familyBondHealths;
-
-		uint32_t closestNode = findNodeByPositionLinked(damage.position, firstGraphNodeIndex, graphNodeIndexLinks, adjacencyPartition, adjacentNodeIndices, adjacentBondIndices, assetBonds, familyBondHealths);
-		NVBLAST_ASSERT(!isInvalidIndex(closestNode));
-
-		float damageDir[3];
-		float damageMag = VecMath::normal(damage.shear, damageDir);
-
-		uint32_t nodeIndex = closestNode;
-		float maxDist = 0.0f;
-		uint32_t nextNode = invalidIndex<uint32_t>();
-
-		if (damageMag > graphChunkThreshold && chunkFractureCount < chunkFractureCountMax)
-		{
-			NvBlastChunkFractureData& frac = commandBuffers->chunkFractures[chunkFractureCount++];
-			frac.chunkIndex = chunkIndices[nodeIndex];
-			frac.health = damageMag * 2;
-		}
-
-		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 neighbourIndex = adjacentNodeIndices[adjacentNodeIndex];
-				const uint32_t bondIndex = adjacentBondIndices[adjacentNodeIndex];
-				const NvBlastBond& bond = assetBonds[bondIndex];
-
-				if (!(familyBondHealths[bondIndex] > 0.0f))
-					continue;
-
-				float shear = 1 * abs(1 - abs(VecMath::dot(damage.shear, bond.normal)));
-
-				float d[3]; VecMath::sub(bond.centroid, damage.position, d);
-				float ahead = VecMath::dot(d, damage.shear);
-				if (ahead > maxDist)
-				{
-					maxDist = ahead;
-					nextNode = neighbourIndex;
-				}
-
-				if (shear > bondTangentialThreshold && bondFractureCount < bondFractureCountMax)
-				{
-					NvBlastBondFractureData& frac = commandBuffers->bondFractures[bondFractureCount++];
-					frac.userdata = bond.userData;
-					frac.nodeIndex0 = nodeIndex;
-					frac.nodeIndex1 = neighbourIndex;
-					frac.health = shear;
-				}
-			}
-
-			if (nodeIndex == nextNode)
-				break;
-
-			nodeIndex = nextNode;
-
-			damageMag *= damageAttenuation;
-		} while (!isInvalidIndex(nextNode));
-	}
-
-	commandBuffers->bondFractureCount = bondFractureCount;
-	commandBuffers->chunkFractureCount = chunkFractureCount;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//													Single Shader
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-void NvBlastExtShearSubgraphShader(NvBlastFractureBuffers* commandBuffers, const NvBlastSubgraphShaderActor* actor, const NvBlastProgramParams* params)
-{
-	const NvBlastExtMaterial* materialProperties = reinterpret_cast<const NvBlastExtMaterial*>(params->material);
-
-	uint32_t chunkFractureCount = 0;
-
-	float totalDamage = 0.0f;
-	for (uint32_t i = 0; i < params->damageDescCount; ++i)
-	{
-		const NvBlastExtShearDamageDesc& damage = reinterpret_cast<const NvBlastExtShearDamageDesc*>(params->damageDescBuffer)[i];
-
-		float damageDir[3];
-		float damageMag = VecMath::normal(damage.shear, damageDir);
-
-		if (damageMag > materialProperties->singleChunkThreshold)
-		{
-			totalDamage += damageMag * 2;
-		}
-	}
-
-	if (totalDamage > 0.0f)
-	{
-		NvBlastChunkFractureData& frac = commandBuffers->chunkFractures[chunkFractureCount++];
-		frac.chunkIndex = actor->chunkIndex;
-		frac.health = totalDamage;
-	}
-
-	commandBuffers->bondFractureCount = 0;
-	commandBuffers->chunkFractureCount = chunkFractureCount;
-}
diff --git a/NvBlast/sdk/lowlevel/include/NvBlast.h b/NvBlast/sdk/lowlevel/include/NvBlast.h
deleted file mode 100644
index d4c91a7..0000000
--- a/NvBlast/sdk/lowlevel/include/NvBlast.h
+++ /dev/null
@@ -1,807 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLAST_H
-#define NVBLAST_H
-
-
-#include "NvBlastTypes.h"
-
-
-///////////////////////////////////////////////////////////////////////////////
-//	NvBlastAsset functions
-///////////////////////////////////////////////////////////////////////////////
-///@{
-
-/**
-Calculates the memory requirements for an asset based upon its descriptor.  Use this function
-when building an asset with NvBlastCreateAsset.
-
-\param[in] desc		Asset descriptor (see NvBlastAssetDesc).
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return the memory size (in bytes) required for the asset, or zero if desc is invalid.
-*/
-NVBLAST_API size_t NvBlastGetAssetMemorySize(const NvBlastAssetDesc* desc, NvBlastLog logFn);
-
-
-/**
-Returns the number of bytes of scratch memory that the user must supply to NvBlastCreateAsset,
-based upon the descriptor that will be passed into that function.
-
-\param[in] desc		The asset descriptor that will be passed into NvBlastCreateAsset.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the number of bytes of scratch memory required for a call to NvBlastCreateAsset with that descriptor.
-*/
-NVBLAST_API size_t NvBlastGetRequiredScratchForCreateAsset(const NvBlastAssetDesc* desc, NvBlastLog logFn);
-
-
-/**
-Asset-building function.
-
-Constructs an NvBlastAsset in-place at the address given by the user.  The address must point to a block
-of memory of at least the size given by NvBlastGetAssetMemorySize(desc, logFn), and must be 16-byte aligned.
-
-Support chunks (marked in the NvBlastChunkDesc struct) must provide full coverage over the asset.
-This means that from any leaf chunk to the root node, exactly one chunk must be support.  If this condition
-is not met the function fails to create an asset.
-
-Any bonds described by NvBlastBondDesc descriptors that reference non-support chunks will be removed.  
-Duplicate bonds will be removed as well (bonds that are between the same chunk pairs).
-
-Chunks in the asset should be arranged such that sibling chunks (chunks with the same parent) are contiguous.
-Chunks are also should be arranged such that leaf chunks (chunks with no children) are at the end of the chunk list.
-If chunks aren't arranged properly the function fails to create an asset.
-
-\param[in] mem		Pointer to block of memory of at least the size given by NvBlastGetAssetMemorySize(desc, logFn).  Must be 16-byte aligned.
-\param[in] desc		Asset descriptor (see NvBlastAssetDesc).
-\param[in] scratch	User-supplied scratch memory of size NvBlastGetRequiredScratchForCreateAsset(desc) bytes.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return pointer to new NvBlastAsset (will be the same address as mem), or NULL if unsuccessful.
-*/
-NVBLAST_API NvBlastAsset* NvBlastCreateAsset(void* mem, const NvBlastAssetDesc* desc, void* scratch, NvBlastLog logFn);
-
-
-/**
-Calculates the memory requirements for a family based upon an asset.  Use this function
-when building a family with NvBlastAssetCreateFamily.
-
-\param[in] asset	Asset used to build the family (see NvBlastAsset).
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return the memory size (in bytes) required for the family, or zero if asset is invalid.
-*/
-NVBLAST_API size_t NvBlastAssetGetFamilyMemorySize(const NvBlastAsset* asset, NvBlastLog logFn);
-
-
-/**
-Family-building function.
-
-Constructs an NvBlastFamily in-place at the address given by the user.  The address must point to a block
-of memory of at least the size given by NvBlastAssetGetFamilyMemorySize(asset, logFn), and must be 16-byte aligned.
-
-\param[in] mem		Pointer to block of memory of at least the size given by NvBlastAssetGetFamilyMemorySize(asset, logFn).  Must be 16-byte aligned.
-\param[in] asset	Asset to instance.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return the family.
-*/
-NVBLAST_API NvBlastFamily* NvBlastAssetCreateFamily(void* mem, const NvBlastAsset* asset, NvBlastLog logFn);
-
-
-/**
-Retrieve the asset ID.
-
-\param[in] asset	The given asset.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return the ID of the asset.
-*/
-NVBLAST_API NvBlastID NvBlastAssetGetID(const NvBlastAsset* asset, NvBlastLog logFn);
-
-
-/**
-Set an asset's ID
-
-\param[in] asset	The given asset.
-\param[in] id		A pointer to the id to copy into the asset.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	true iff the id is successfully set.
-*/
-NVBLAST_API bool NvBlastAssetSetID(NvBlastAsset* asset, const NvBlastID* id, NvBlastLog logFn);
-
-
-/**
-Retrieve the data format version for the given asset
-
-\param[in] asset	The asset.  Cannot be NULL.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the data format version (NvBlastAssetDataFormat).
-*/
-NVBLAST_API uint32_t NvBlastAssetGetFormatVersion(const NvBlastAsset* asset, NvBlastLog logFn);
-
-
-/**
-Retrieve the memory size (in bytes) of the given data asset
-
-\param[in] asset	The asset.  Cannot be NULL.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the memory size of the asset (in bytes).
-*/
-NVBLAST_API uint32_t NvBlastAssetGetSize(const NvBlastAsset* asset, NvBlastLog logFn);
-
-
-/**
-Get the number of chunks in the given asset.
-
-\param[in] asset	The asset.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the number of chunks in the asset.
-*/
-NVBLAST_API uint32_t NvBlastAssetGetChunkCount(const NvBlastAsset* asset, NvBlastLog logFn);
-
-
-/**
-Get the number of leaf chunks in the given asset.
-
-\param[in] asset	The asset.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the number of leaf chunks in the asset.
-*/
-NVBLAST_API uint32_t NvBlastAssetGetLeafChunkCount(const NvBlastAsset* asset, NvBlastLog logFn);
-
-
-/**
-Get the first subsupport chunk index in the given asset.  Chunks are sorted such that subsupport chunks
-come last.  This is the first subsupport chunk index.  Equals to total chunk count if there are no subsupport
-chunks.
-
-\param[in] asset	The asset.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the first subsupport chunk index in the asset.
-*/
-NVBLAST_API uint32_t NvBlastAssetGetFirstSubsupportChunkIndex(const NvBlastAsset* asset, NvBlastLog logFn);
-
-
-/**
-Get the number of bonds in the given asset.
-
-\param[in] asset	The asset.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the number of bonds in the asset.
-*/
-NVBLAST_API uint32_t NvBlastAssetGetBondCount(const NvBlastAsset* asset, NvBlastLog logFn);
-
-
-/**
-Access the support graph for the given asset.
-
-\param[in] asset	The asset.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	a struct of support graph for the given asset.
-*/
-NVBLAST_API const NvBlastSupportGraph NvBlastAssetGetSupportGraph(const NvBlastAsset* asset, NvBlastLog logFn);
-
-
-/**
-Access a map from chunk index to graph node index.
-Returned map is valid in the domain [0, NvBlastAssetGetChunkCount(asset, logFn)).
-Non-support chunks are mapped to the invalid index 0xFFFFFFFF.
-
-\param[in] asset	The asset.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	an array of uint32_t values defining the map, of size NvBlastAssetGetChunkCount(asset, logFn).
-*/
-NVBLAST_API const uint32_t* NvBlastAssetGetChunkToGraphNodeMap(const NvBlastAsset* asset, NvBlastLog logFn);
-
-
-/**
-Access an array of chunks of the given asset.
-
-\param[in] asset	The asset.
-\param[in] logFn	User - supplied message function(see NvBlastLog definition).May be NULL.
-
-\return	a pointer to an array of chunks of the asset.
-*/
-NVBLAST_API const NvBlastChunk* NvBlastAssetGetChunks(const NvBlastAsset* asset, NvBlastLog logFn);
-
-
-/**
-Access an array of bonds of the given asset.
-
-\param[in] asset	The asset.
-\param[in] logFn	User - supplied message function(see NvBlastLog definition).May be NULL.
-
-\return	a pointer to an array of bonds of the asset.
-*/
-NVBLAST_API const NvBlastBond* NvBlastAssetGetBonds(const NvBlastAsset* asset, NvBlastLog logFn);
-
-
-/**
-A buffer size sufficient to serialize an actor instanced from a given asset.
-This function is faster than NvBlastActorGetSerializationSize, and can be used to create a reusable buffer
-for actor serialization.
-
-\param[in] asset	The asset.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return the required buffer size in bytes.
-*/
-NVBLAST_API uint32_t NvBlastAssetGetActorSerializationSizeUpperBound(const NvBlastAsset* asset, NvBlastLog logFn);
-
-///@} End NvBlastAsset functions
-
-
-///////////////////////////////////////////////////////////////////////////////
-//	NvBlastAsset helper functions
-///////////////////////////////////////////////////////////////////////////////
-///@{
-
-/**
-Function to ensure (check and update) support coverage of chunks.
-
-Support chunks (marked in the NvBlastChunkDesc struct) must provide full coverage over the asset.
-This means that from any leaf chunk to the root node, exactly one chunk must be support.  If this condition
-is not met, the actual support chunks will be adjusted accordingly.
-
-Chunk order depends on support coverage, so this function should be called before chunk reordering.
-
-\param[in]  chunkDescs			Array of chunk descriptors of size chunkCount. It will be updated accordingly.
-\param[in]  chunkCount			The number of chunk descriptors.
-\param[in]	scratch				User-supplied scratch storage, must point to chunkCount valid bytes of memory.
-\param[in]  logFn				User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	true iff coverage was already exact.
-*/
-NVBLAST_API bool NvBlastEnsureAssetExactSupportCoverage(NvBlastChunkDesc* chunkDescs, uint32_t chunkCount, void* scratch, NvBlastLog logFn);
-
-
-/**
-Build chunk reorder map. 
-
-NvBlastCreateAsset function requires NvBlastChunkDesc array to be in correct oder:
-
-1. Root chunks (chunks with invalid parent index) must be first in the asset's chunk list.
-2. Chunks in the asset should be arranged such that sibling chunks (chunks with the same parent) are contiguous.
-3. Chunks are also should be arranged such that upper-support chunks (support chunks and their parent chunks) should go first in 
-chunk list.
-
-This function builds chunk reorder map which can be used to order chunk descs. Reordering chunk's descriptors 
-according to generated map places them in correct order for NvBlastCreateAsset to succeed.
-
-Iff chunks are already ordered correctly, function returns 'true' and identity chunk reorder map. Otherwise 'false' is returned.
-
-\param[out] chunkReorderMap	User-supplied map of size chunkCount to fill. For every chunk index this array will contain new chunk position (index).
-\param[in]  chunkDescs		Array of chunk descriptors of size chunkCount.
-\param[in]  chunkCount		The number of chunk descriptors.
-\param[in]	scratch			User-supplied scratch storage, must point to 2 * chunkCount * sizeof(uint32_t) valid bytes of memory.
-\param[in]  logFn			User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	true iff the chunks did not require reordering (chunkReorderMap is the identity map).
-*/
-NVBLAST_API bool NvBlastBuildAssetDescChunkReorderMap(uint32_t* chunkReorderMap, const NvBlastChunkDesc* chunkDescs, uint32_t chunkCount, void* scratch, NvBlastLog logFn);
-
-
-/**
-Apply chunk reorder map.
-
-Function applies reorder map on NvBlastChunkDesc and NvBlastBondDesc arrays. It reorders chunks, replaces their 'parentChunkIndex' field
-with new indices. Bonds are kept in the same order, but their 'chunkIndices' field is updated with proper indices.
-
-@see NvBlastBuildAssetDescChunkReorderMap
-
-\param[out] reorderedChunkDescs	User-supplied array of size chunkCount to fill with new reordered NvBlastChunkDesc's.
-\param[in]  chunkDescs			Array of chunk descriptors of size chunkCount.
-\param[in]  chunkCount			The number of chunk descriptors.
-\param[in]  bondDescs			Array of bond descriptors of size chunkCount. It will be updated accordingly.
-\param[in]  bondCount			The number of bond descriptors.
-\param[in]  chunkReorderMap		Chunk reorder map to use, must be of size chunkCount.
-\param[in]	logFn				User-supplied message function (see NvBlastLog definition).  May be NULL.
-*/
-NVBLAST_API void NvBlastApplyAssetDescChunkReorderMap
-(
-	NvBlastChunkDesc* reorderedChunkDescs,
-	const NvBlastChunkDesc* chunkDescs,
-	uint32_t chunkCount,
-	NvBlastBondDesc* bondDescs,
-	uint32_t bondCount,
-	const uint32_t* chunkReorderMap,
-	NvBlastLog logFn
-);
-
-
-/**
-Apply chunk reorder map.
-
-Function applies reorder map on NvBlastChunkDesc and NvBlastBondDesc arrays. It reorders chunks, replaces their 'parentChunkIndex' field
-with new indices. Bonds are kept in the same order, but their 'chunkIndices' field is updated with proper indices.
-
-This overload of function reorders chunks in place.
-
-@see NvBlastBuildAssetDescChunkReorderMap
-
-\param[in]  chunkDescs			Array of chunk descriptors of size chunkCount. It will be updated accordingly.
-\param[in]  chunkCount			The number of chunk descriptors.
-\param[in]  bondDescs			Array of bond descriptors of size chunkCount. It will be updated accordingly.
-\param[in]  bondCount			The number of bond descriptors.
-\param[in]  chunkReorderMap		Chunk reorder map to use, must be of size chunkCount.
-\param[in]	scratch				User-supplied scratch storage, must point to chunkCount * sizeof(NvBlastChunkDesc) valid bytes of memory.
-\param[in]	logFn				User-supplied message function (see NvBlastLog definition).  May be NULL.
-*/
-NVBLAST_API void NvBlastApplyAssetDescChunkReorderMapInplace(NvBlastChunkDesc* chunkDescs, uint32_t chunkCount, NvBlastBondDesc* bondDescs, uint32_t bondCount, const uint32_t* chunkReorderMap, void* scratch, NvBlastLog logFn);
-
-
-/**
-Build and apply chunk reorder map. 
-
-Function basically calls NvBlastBuildAssetDescChunkReorderMap and NvBlastApplyAssetDescChunkReorderMap. Used for Convenience.
-
-\param[in]  chunkDescs			Array of chunk descriptors of size chunkCount. It will be updated accordingly.
-\param[in]  chunkCount			The number of chunk descriptors.
-\param[in]  bondDescs			Array of bond descriptors of size chunkCount. It will be updated accordingly.
-\param[in]  bondCount			The number of bond descriptors.
-\param[in]  chunkReorderMap		Chunk reorder map to fill, must be of size chunkCount.
-\param[in]	scratch				User-supplied scratch storage, must point to chunkCount * sizeof(NvBlastChunkDesc) valid bytes of memory.
-\param[in]  logFn				User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	true iff the chunks did not require reordering (chunkReorderMap is the identity map).
-*/
-NVBLAST_API bool NvBlastReorderAssetDescChunks(NvBlastChunkDesc* chunkDescs, uint32_t chunkCount, NvBlastBondDesc* bondDescs, uint32_t bondCount, uint32_t* chunkReorderMap, void* scratch, NvBlastLog logFn);
-
-///@} End NvBlastAsset helper functions
-
-
-///////////////////////////////////////////////////////////////////////////////
-//	NvBlastFamily functions
-///////////////////////////////////////////////////////////////////////////////
-///@{
-
-/**
-Retrieve the data format version for the given family.
-
-\param[in] family	The family.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return the family format version.
-*/
-NVBLAST_API uint32_t NvBlastFamilyGetFormatVersion(const NvBlastFamily* family, NvBlastLog logFn);
-
-
-/**
-Set asset to the family. It should be the same asset as the one family was created from (same ID).
-
-\param[in] family	The family.
-\param[in] asset	Asset to instance.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-*/
-NVBLAST_API void NvBlastFamilySetAsset(NvBlastFamily* family, const NvBlastAsset* asset, NvBlastLog logFn);
-
-
-/**
-Retrieve the size (in bytes) of the given family.
-
-\param[in] family	The family.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return the size of the family (in bytes).
-*/
-NVBLAST_API uint32_t NvBlastFamilyGetSize(const NvBlastFamily* family, NvBlastLog logFn);
-
-
-/**
-Retrieve the asset ID of the given family.
-
-\param[in] family	The family.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return the ID of the asset associated with the family.
-*/
-NVBLAST_API NvBlastID NvBlastFamilyGetAssetID(const NvBlastFamily* family, NvBlastLog logFn);
-
-
-/**
-Returns the number of bytes of scratch memory that the user must supply to NvBlastFamilyCreateFirstActor.
-
-\param[in] family	The family from which the first actor will be instanced.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the number of bytes of scratch memory required for a call to NvBlastFamilyCreateFirstActor.
-*/
-NVBLAST_API size_t NvBlastFamilyGetRequiredScratchForCreateFirstActor(const NvBlastFamily* family, NvBlastLog logFn);
-
-
-/**
-Instance the family's asset into a new, unfractured actor.
-
-\param[in] family	Family in which to create a new actor.  The family must have no other actors in it.  (See NvBlastAssetCreateFamily.)
-\param[in] desc		Actor descriptor (see NvBlastActorDesc).
-\param[in] scratch	User-supplied scratch memory of size NvBlastFamilyGetRequiredScratchForCreateFirstActor(asset) bytes, where 'asset' is the NvBlastAsset from which the family was created.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return pointer to new NvBlastActor if successful (the actor was successfully inserted into the family), or NULL if unsuccessful.
-*/
-NVBLAST_API NvBlastActor* NvBlastFamilyCreateFirstActor(NvBlastFamily* family, const NvBlastActorDesc* desc, void* scratch, NvBlastLog logFn);
-
-
-/**
-Retrieve the number of active actors associated with the given family.
-
-\param[in] family	The family.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return the number of active actors in the family.
-*/
-NVBLAST_API uint32_t NvBlastFamilyGetActorCount(const NvBlastFamily* family, NvBlastLog logFn);
-
-
-/**
-Deserialize a single Actor from a buffer into the given family.  The actor will be inserted if it
-is compatible with the current family state.  That is, it must not share any chunks or internal
-IDs with the actors already present in the family.
-
-\param[in] family	Family in which to deserialize the actor.
-\param[in] buffer	User-supplied buffer containing the actor to deserialize.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return the deserialized actor if successful, NULL otherwise.
-*/
-NVBLAST_API NvBlastActor* NvBlastFamilyDeserializeActor(NvBlastFamily* family, const void* buffer, NvBlastLog logFn);
-
-
-/**
-Retrieve the active actors associated with the given family.
-
-\param[out] actors		User-supplied array to be filled with the returned actor pointers.
-\param[out] actorsSize	The size of the actors array.  To receive all actor pointers, the size must be at least that given by NvBlastFamilyGetActorCount(family).
-\param[in] family		The family.
-\param[in] logFn		User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the number of actor pointers written to actors.  This will not exceed actorsSize.
-*/
-NVBLAST_API uint32_t NvBlastFamilyGetActors(NvBlastActor** actors, uint32_t actorsSize, const NvBlastFamily* family, NvBlastLog logFn);
-
-
-/**
-Retrieve the actor associated with the given chunk.
-
-\param[in] family		The family.
-\param[in] chunkIndex	The index of chunk.
-\param[in] logFn		User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	pointer to actor associated with given chunk.  NULL if there is no such actor.
-*/
-NVBLAST_API NvBlastActor* NvBlastFamilyGetChunkActor(const NvBlastFamily* family, uint32_t chunkIndex, NvBlastLog logFn);
-
-
-/**
-Retrieve the max active actor count family could have.
-
-\param[in] family		The family.
-\param[in] logFn		User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the max number of active actors family could have.
-*/
-NVBLAST_API uint32_t NvBlastFamilyGetMaxActorCount(const NvBlastFamily* family, NvBlastLog logFn);
-
-///@} End NvBlastFamily functions
-
-
-///////////////////////////////////////////////////////////////////////////////////////
-//	NvBlastActor accessor, serialization, and deactivation functions
-///////////////////////////////////////////////////////////////////////////////////////
-///@{
-
-/**
-Get the number of visible chunks for this actor.  May be used in conjunction with NvBlastActorGetVisibleChunkIndices.
-
-\param[in] actor	The actor.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the number of visible chunk indices for the actor.
-*/
-NVBLAST_API uint32_t NvBlastActorGetVisibleChunkCount(const NvBlastActor* actor, NvBlastLog logFn);
-
-
-/**
-Retrieve a list of visible chunk indices for the actor into the given array.
-
-\param[in] visibleChunkIndices		User-supplied array to be filled in with indices of visible chunks for this actor.
-\param[in] visibleChunkIndicesSize	The size of the visibleChunkIndices array.  To receive all visible chunk indices, the size must be at least that given by NvBlastActorGetVisibleChunkCount(actor).
-\param[in] actor					The actor.
-\param[in] logFn					User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the number of indices written to visibleChunkIndices.  This will not exceed visibleChunkIndicesSize.
-*/
-NVBLAST_API uint32_t NvBlastActorGetVisibleChunkIndices(uint32_t* visibleChunkIndices, uint32_t visibleChunkIndicesSize, const NvBlastActor* actor, NvBlastLog logFn);
-
-
-/**
-Get the number of graph nodes for this actor.  May be used in conjunction with NvBlastActorGetGraphNodeIndices.
-
-\param[in] actor	The actor.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the number of graph node indices for the actor.
-*/
-NVBLAST_API uint32_t NvBlastActorGetGraphNodeCount(const NvBlastActor* actor, NvBlastLog logFn);
-
-
-/**
-Retrieve a list of graph node indices for the actor into the given array.
-
-\param[in] graphNodeIndices		User-supplied array to be filled in with indices of graph nodes for this actor.
-\param[in] graphNodeIndicesSize	The size of the graphNodeIndices array.  To receive all graph node indices, the size must be at least that given by NvBlastActorGetGraphNodeCount(actor).
-\param[in] actor				The actor.
-\param[in] logFn				User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the number of indices written to graphNodeIndices.  This will not exceed graphNodeIndicesSize.
-*/
-NVBLAST_API uint32_t NvBlastActorGetGraphNodeIndices(uint32_t* graphNodeIndices, uint32_t graphNodeIndicesSize, const NvBlastActor* actor, NvBlastLog logFn);
-
-
-/**
-Access the bond health data for an actor.
-
-This function returns a pointer to the head of an array of bond healths (floats).  This array is the same for any actor that
-has been created from repeated fracturing of the same original instance of an asset (in the same instance family).
-
-The indices obtained from NvBlastSupportGraph::adjacentBondIndices in the asset may be used to access this array.
-
-The size of the array returned is NvBlastAssetGetBondCount(asset, logFn), where 'asset' is the NvBlastAsset
-that was used to create the actor.
-
-This array is valid as long as any actor in the instance family for the input actor exists.
-
-If the input actor is invalid, NULL will be returned.
-
-\param[in] actor	The actor.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the array of bond healths for the actor's instance family, or NULL if the actor is invalid.
-*/
-NVBLAST_API const float* NvBlastActorGetBondHealths(const NvBlastActor* actor, NvBlastLog logFn);
-
-
-/**
-The buffer size needed to serialize a single actor.  This will give the exact size needed.  For an upper bound
-on the buffer size needed for any actor instanced from an NvBlastAsset, use NvBlastAssetGetActorSerializationSizeUpperBound.
-
-\param[in] actor	The actor.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return the required buffer size in bytes.
-*/
-NVBLAST_API uint32_t NvBlastActorGetSerializationSize(const NvBlastActor* actor, NvBlastLog logFn);
-
-
-/**
-Serialize a single actor to a buffer.
-
-\param[out] buffer		User-supplied buffer, must be at least of size given by NvBlastActorGetSerializationSize(actor).
-\param[in] bufferSize	The size of the user-supplied buffer.
-\param[in] actor		The actor.
-\param[in] logFn		User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return the number of bytes written to the buffer, or 0 if there is an error (such as an under-sized buffer).
-*/
-NVBLAST_API uint32_t NvBlastActorSerialize(void* buffer, uint32_t bufferSize, const NvBlastActor* actor, NvBlastLog logFn);
-
-
-/**
-Access to an actor's family.
-
-\param[in] actor	The actor.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return the family with which the actor is associated.
-*/
-NVBLAST_API NvBlastFamily* NvBlastActorGetFamily(const NvBlastActor* actor, NvBlastLog logFn);
-
-
-/**
-Access to an actor's internal index.
-
-\param[in] actor	The actor.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return actor's internal index in family.
-*/
-NVBLAST_API uint32_t NvBlastActorGetIndex(const NvBlastActor* actor, NvBlastLog logFn);
-
-
-/**
-Deactivate an actor within its family.  Conceptually this is "destroying" the actor, however memory will not be released until the family is released.
-
-\param[in] actor	Points to a user-supplied actor struct.  May be NULL, in which case this function no-ops.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return true iff successful (actor was active).
-*/
-NVBLAST_API bool NvBlastActorDeactivate(NvBlastActor* actor, NvBlastLog logFn);
-
-///@} End NvBlastActor accessor, serialization, and deactivation functions
-
-
-///////////////////////////////////////////////////////////////////////////////
-//	NvBlastActor damage and fracturing functions
-///////////////////////////////////////////////////////////////////////////////
-///@{
-
-/**
-Creates fracture commands for the actor using a damage program and program parameters (material and damage descriptions).
-
-\param[in,out]	commandBuffers		Target buffers to hold generated commands.
-									To avoid data loss, provide an entry for every support chunk and every bond in the original actor.
-\param[in]		actor				The NvBlastActor to create fracture commands for.
-\param[in]		program				A NvBlastDamageProgram containing damage shaders.
-\param[in]		programParams		Parameters for the NvBlastDamageProgram.
-\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.
-
-Interpretation of NvBlastFractureBuffers:
-As input:
-	Counters denote available entries for FractureData.
-	Chunk and Bond userdata are not used.
-	Health values are not used.
-
-As output:
-	Counters denote valid entires in FractureData arrays.
-	Chunks and Bond userdata reflect the respective userdata set during asset initialization, where implemented by the material function.
-	Health values denote how much damage is to be applied.
-*/
-NVBLAST_API void NvBlastActorGenerateFracture
-(
-	NvBlastFractureBuffers* commandBuffers,
-	const NvBlastActor* actor,
-	const NvBlastDamageProgram program, 
-	const NvBlastProgramParams* programParams,
-	NvBlastLog logFn, 
-	NvBlastTimers* timers
-);
-
-
-/**
-Applies the direct fracture and breaks graph bonds/edges as necessary.
-Chunks damaged beyond their respective health fracture their children recursively, creating a NvBlastChunkFractureData for each.
-
-\param[in,out]	eventBuffers		Target buffers to hold applied fracture events. May be NULL, in which case events are not reported.
-									To avoid data loss, provide an entry for every lower-support chunk and every bond in the original actor.
-\param[in,out]	actor				The NvBlastActor to apply fracture to.
-\param[in]		commands			The fracture commands to process.
-\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.
-
-Interpretation of NvBlastFractureBuffers:
-commands:
-	Counters denote the number of command entries to process.
-	Chunk and Bond userdata are not used.
-	Health values denote the amount of damage to apply, as a positive value.
-
-eventBuffers as input:
-	Counters denote available entries for FractureData.
-	Chunk and Bond userdata are not used.
-	Health values are not used.
-
-eventBuffers as output:
-	Counters denote valid entires in FractureData arrays.
-	Chunks and Bond userdata reflect the respective userdata set during asset initialization.
-	Health values denote how much health is remaining for the damaged element. 
-	Broken elements report a negative value corresponding to the superfluous health damage.
-
-commands and eventBuffers may point to the same memory.
-*/
-NVBLAST_API void NvBlastActorApplyFracture
-(
-	NvBlastFractureBuffers* eventBuffers,
-	NvBlastActor* actor,
-	const NvBlastFractureBuffers* commands,
-	NvBlastLog logFn,
-	NvBlastTimers* timers
-);
-
-
-/**
-Releases the oldActor and creates its children newActors if necessary.
-
-\param[out]		result				The list of deleted and created NvBlastActor objects.
-\param[in]		actor				The actor to split.
-\param[in]		newActorsMaxCount	Number of available NvBlastActor slots. In the worst case, one NvBlastActor may be created for every chunk in the asset.
-\param[in]		scratch				Scratch Memory used during processing. NvBlastActorGetRequiredScratchForSplit provides the necessary size.
-\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	1..n:	new actors were created
-\return	0:		oldActor is unchanged
-*/
-NVBLAST_API uint32_t NvBlastActorSplit
-(
-	NvBlastActorSplitEvent* result, 
-	NvBlastActor* actor,
-	uint32_t newActorsMaxCount,
-	void* scratch,
-	NvBlastLog logFn,
-	NvBlastTimers* timers
-);
-
-
-/**
-Returns the number of bytes of scratch memory that the user must supply to NvBlastActorSplit,
-based upon the actor that will be passed into that function.
-
-\param[in] actor	The actor that will be passed into NvBlastActorSplit.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the number of bytes of scratch memory required for a call to NvBlastActorSplit with that actor.
-*/
-NVBLAST_API size_t NvBlastActorGetRequiredScratchForSplit(const NvBlastActor* actor, NvBlastLog logFn);
-
-
-/**
-Returns the upper-bound number of actors which can be created by calling NvBlastActorSplit with that actor, this
-value can't exceed chunk count.
-
-\param[in] actor	The actor.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the upper-bound number of actors which can be created by calling NvBlastActorSplit with that actor.
-*/
-NVBLAST_API uint32_t NvBlastActorGetMaxActorCountForSplit(const NvBlastActor* actor, NvBlastLog logFn);
-
-
-/**
-Determines if the actor can fracture further.
-
-\param[in] actor	The actor potentially being fractured.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return true if any result can be expected from fracturing the actor. false if no further change to the actor is possible.
-*/
-NVBLAST_API bool NvBlastActorCanFracture(const NvBlastActor* actor, NvBlastLog logFn);
-
-///@} End NvBlastActor damage and fracturing functions
-
-
-///////////////////////////////////////////////////////////////////////////////
-//	NvBlastTimers functions and helpers
-///////////////////////////////////////////////////////////////////////////////
-///@{
-
-/**
-Resets all values in the given NvBlastTimers struct to zero.
-
-\param[in]	timers	The NvBlastTimers to set to zero.
-*/
-NVBLAST_API void NvBlastTimersReset(NvBlastTimers* timers);
-
-
-/**
-Convert a tick value from NvBlastTimers to seconds.
-
-\param[in]	ticks	The tick value.
-
-\return the seconds correposnding to the input tick value.
-*/
-NVBLAST_API double NvBlastTicksToSeconds(int64_t ticks);
-
-///@} End NvBlastTimers functions and helpers
-
-
-#endif // ifndef NVBLAST_H
diff --git a/NvBlast/sdk/lowlevel/include/NvBlastPreprocessor.h b/NvBlast/sdk/lowlevel/include/NvBlastPreprocessor.h
deleted file mode 100644
index 25a8516..0000000
--- a/NvBlast/sdk/lowlevel/include/NvBlastPreprocessor.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTPREPROCESSOR_H
-#define NVBLASTPREPROCESSOR_H
-
-
-#include "NvPreprocessor.h"
-
-
-/** Blast API declaration */
-#define NVBLAST_API NV_C_EXPORT NV_DLL_EXPORT
-
-
-/**
-Macros for more convenient logging
-*/
-#define NVBLAST_LOG_ERROR(_logFn, _msg)		if (_logFn != nullptr) { _logFn(NvBlastMessage::Error, _msg, __FILE__, __LINE__); } ((void)0)
-#define NVBLAST_LOG_WARNING(_logFn, _msg)	if (_logFn != nullptr) { _logFn(NvBlastMessage::Warning, _msg, __FILE__, __LINE__); } ((void)0)
-#define NVBLAST_LOG_INFO(_logFn, _msg)		if (_logFn != nullptr) { _logFn(NvBlastMessage::Info, _msg, __FILE__, __LINE__); } ((void)0)
-#define NVBLAST_LOG_DEBUG(_logFn, _msg)		if (_logFn != nullptr) { _logFn(NvBlastMessage::Debug, _msg, __FILE__, __LINE__); } ((void)0)
-
-
-#endif // ifndef NVBLASTPREPROCESSOR_H
diff --git a/NvBlast/sdk/lowlevel/include/NvBlastProfiler.h b/NvBlast/sdk/lowlevel/include/NvBlastProfiler.h
deleted file mode 100644
index cd60b4f..0000000
--- a/NvBlast/sdk/lowlevel/include/NvBlastProfiler.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTPROFILER_H
-#define NVBLASTPROFILER_H
-
-#include "NvBlastPreprocessor.h"
-
-namespace physx {
-	class PxProfilerCallback;
-}
-
-struct NvBlastProfilerDetail
-{
-	enum Level
-	{
-		LOW,
-		MEDIUM,
-		HIGH
-	};
-};
-
-/**
-Profiler features are only active in checked, debug and profile builds.
-*/
-
-/**
-Set a callback to PVD or another PxProfilerCallback based profiler.
-*/
-NVBLAST_API void NvBlastProfilerSetCallback(physx::PxProfilerCallback* pcb);
-
-/**
-Enable events for platform specific profiler tools. Currently supported:
-Nsight, PS4, Xbox One
-*/
-NVBLAST_API void NvBlastProfilerEnablePlatform(bool);
-
-/**
-Sets the depth of reported profile zones.
-Higher levels (more nesting) of instrumentation can have a significant impact.
-Defaults to NvBlastProfilerDetail::Level::LOW.
-*/
-NVBLAST_API void NvBlastProfilerSetDetail(NvBlastProfilerDetail::Level);
-
-#endif
diff --git a/NvBlast/sdk/lowlevel/include/NvBlastTypes.h b/NvBlast/sdk/lowlevel/include/NvBlastTypes.h
deleted file mode 100644
index d711842..0000000
--- a/NvBlast/sdk/lowlevel/include/NvBlastTypes.h
+++ /dev/null
@@ -1,632 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTTYPES_H
-#define NVBLASTTYPES_H
-
-
-#include "NvBlastPreprocessor.h"
-#include <stdint.h>
-
-
-///////////////////////////////////////////////////////////////////////////////
-//	NvBlast common types
-///////////////////////////////////////////////////////////////////////////////
-///@{
-
-/**
-Types of log messages.
-*/
-struct NvBlastMessage
-{
-	enum Type
-	{
-		Error,		//!< Error messages
-		Warning,	//!< Warning messages
-		Info,		//!< Information messages
-		Debug		//!< Used only in debug version of dll
-	};
-};
-
-
-/**
-Function pointer type for logging.
-
-When a function with this signature is passed into Blast functions with an NvBlastLog argument,
-Blast will use it to report errors, warnings, and other information.
-*/
-typedef void(*NvBlastLog)(int type, const char* msg, const char* file, int line);
-
-
-/**
-ID used to identify assets.
-*/
-struct NvBlastID
-{
-	char data[16];
-};
-
-
-/**
-Time spent (in ticks) in various parts of Blast.
-These values may be filled in during the execution of various API functions.
-To convert to seconds, use NvBlastTicksToSeconds(ticks).
-
-In profile build configurations, if a pointer to an instance of this struct is passed into
-Blast functions with an NvBlastTimers argument, then Blast will add to appropriate fields
-the time measured in corresponding sections of code.  The user must clear the timer fields
-with NvBlastTimersReset to initialize or reset.
-*/
-struct NvBlastTimers
-{
-	int64_t  material;		//!< Time spent in material function
-	int64_t  fracture;		//!< Time spent applying damage
-	int64_t  island;		//!< Time spent discovering islands
-	int64_t  partition;		//!< Time spent partitioning the graph
-	int64_t  visibility;	//!< Time spent updating visibility
-};
-
-
-/**
-Generic data block header for all data blocks.
-*/
-struct NvBlastDataBlock
-{
-	/**
-	Enum of data block types
-	*/
-	enum Type
-	{
-		AssetDataBlock,
-		FamilyDataBlock,
-
-		Count
-	};
-
-
-	/**
-	A data type keeps value from Type enum
-	*/
-	uint32_t	dataType;
-
-	/**
-	A number which is incremented every time the data layout changes. Depending on dataType corresponding	data 
-	format is kept. See NvBlastAssetDataFormat, NvBlastFamilyDataFormat enum.
-	*/
-	uint32_t	formatVersion;
-
-	/**
-	The size of the family, including this header.
-
-	Memory sizes are restricted to 32-bit representable values.
-	*/
-	uint32_t	size;
-
-	/**
-	Reserved to be possibly used in future versions
-	*/
-	uint32_t	reserved;
-};
-
-///@} End NvBlast common types
-
-
-///////////////////////////////////////////////////////////////////////////////
-//	NvBlastAsset related types
-///////////////////////////////////////////////////////////////////////////////
-///@{
-
-
-/**
-Struct-enum which keeps track of the asset data format.
-*/
-struct NvBlastAssetDataFormat
-{
-	enum Version
-	{
-		/** Initial version */
-		Initial,
-
-		//	New formats must come before Count.  They should be given descriptive names with more information in comments.
-
-		/** The number of asset formats. */
-		Count,
-
-		/** The current version.  This should always be Count-1 */
-		Current = Count - 1
-	};
-};
-
-
-/**
-Represents a piece of a destructible asset which may be realized as an entity with a physical and graphical component.
-
-Chunks may form a hierarchical decomposition of the asset.  They contain parent and child chunk index information which
-defines the hierarchy.  The parent and child chunk indices are their positions with the NvBlastAsset::chunks array.
-
-Child chunk indices are contiguous, starting at firstChildIndex and ending with childIndexStop - 1.
-*/
-struct NvBlastChunk
-{
-	/**
-	Central position for the chunk's volume
-	*/
-	float		centroid[3];
-
-	/**
-	Volume of the chunk
-	*/
-	float		volume;
-
-	/**
-	Index of parent (UINT32_MAX denotes no parent)
-	*/
-	uint32_t	parentChunkIndex;
-
-	/**
-	Index of first child
-	*/
-	uint32_t	firstChildIndex;
-
-	/**
-	Stop for child indices
-	*/
-	uint32_t	childIndexStop;
-
-	/**
-	Field for user to associate with external data
-	*/
-	uint32_t	userData;
-};
-
-
-/**
-Represents the interface between two chunks.  At most one bond is created for a chunk pair.
-The convention regarding the normal direction is based upon the chunk indices,
-pointing from the lower-indexed chunk to the higher-indexed chunk.
-*/
-struct NvBlastBond
-{
-	/**
-	Interface average normal
-	*/
-	float		normal[3];
-
-	/**
-	Area of interface
-	*/
-	float		area;
-
-	/**
-	Central position on the interface between chunks
-	*/
-	float		centroid[3];
-
-	/**
-	Extra data associated with bond, e.g. whether or not to create a joint
-	*/
-	uint32_t	userData;
-};
-
-
-/**
-Describes the connectivity between support chunks via bonds.
-
-Vertices in the support graph are termed "nodes," and represent particular chunks (NvBlastChunk) in an NvBlastAsset.
-The indexing for nodes is not the same as that for chunks.  Only some chunks are represented by nodes in the graph,
-and these chunks are called "support chunks."
-
-Adjacent node indices and adjacent bond indices are stored for each node, and therefore each bond is represented twice in this graph,
-going from node[i] -> node[j] and from node[j] -> node[i].  Therefore the size of the adjacentNodeIndices and adjacentBondIndices
-arrays are twice the number of bonds stored in the corresponding NvBlastAsset. 
-
-The graph is used as follows.  Given a NvBlastSupportGraph "graph" and node index i, (0 <= i < graph.nodeCount), one may find all
-adjacent bonds and nodes using:
-
-	// adj is the lookup value in graph.adjacentNodeIndices and graph.adjacentBondIndices
-	for (uint32_t adj = graph.adjacencyPartition[i]; adj < graph.adjacencyPartition[i+1]; ++adj)
-	{
-		// An adjacent node:
-		uint32_t adjacentNodeIndex = graph.adjacentNodeIndices[adj];
-	
-		// The corresponding bond (that connects node index i with node indexed adjacentNodeIndex:
-		uint32_t adjacentBondIndex = graph.adjacentBondIndices[adj];
-	}
-
-For a graph node with index i, the corresponding asset chunk index is found using graph.chunkIndices[i].  The reverse mapping
-(obtaining a graph node index from an asset chunk index) can be done using the
-
-	NvBlastAssetGetChunkToGraphNodeMap(asset, logFn)
-
-function.  See the documentation for its use.  The returned "node index" for a non-support chunk is the invalid value 0xFFFFFFFF.
-*/
-struct NvBlastSupportGraph
-{
-	/**
-	Total number of nodes in the support graph.
-	*/
-	uint32_t	nodeCount;
-
-	/**
-	Indices of chunks represented by the nodes, an array of size nodeCount.
-	*/
-	uint32_t*	chunkIndices;
-
-	/**
-	Partitions both the adjacentNodeIndices and the adjacentBondIndices arrays into subsets corresponding to each node.
-	The size of this array is nodeCount+1.
-	For 0 <= i < nodeCount, adjacencyPartition[i] is the index of the first element in adjacentNodeIndices (or adjacentBondIndices) for nodes adjacent to the node with index i.
-	adjacencyPartition[nodeCount] is the size of the adjacentNodeIndices and adjacentBondIndices arrays.
-	This allows one to easily count the number of nodes adjacent to a node with index i, using adjacencyPartition[i+1] - adjacencyPartition[i].
-	*/
-	uint32_t*	adjacencyPartition;
-
-	/**
-	Array composed of subarrays holding the indices of nodes adjacent to a given node.  The subarrays may be accessed through the adjacencyPartition array.
-	*/
-	uint32_t*	adjacentNodeIndices;
-
-	/**
-	Array composed of subarrays holding the indices of bonds (NvBlastBond) for a given node.  The subarrays may be accessed through the adjacencyPartition array.
-	*/
-	uint32_t*	adjacentBondIndices;
-};
-
-
-/**
-Asset (opaque)
-
-Static destructible data, used to create actor familes.
-
-Pointer to this struct can be created with NvBlastCreateAsset.
-
-The NvBlastAsset includes a ID which may be used to match it with physics and graphics data.
-*/
-struct NvBlastAsset {};
-
-
-/**
-Chunk descriptor used to build an asset.  See NvBlastAssetDesc.
-*/
-struct NvBlastChunkDesc
-{
-	enum Flags
-	{
-		NoFlags = 0,
-
-		/** If this flag is set then the chunk will become a support chunk, unless an ancestor chunk is also marked as support. */
-		SupportFlag = (1 << 0)
-	};
-
-	/** Central position in chunk. */
-	float		centroid[3];
-
-	/** Volume of chunk. */
-	float		volume;
-
-	/** Index of this chunk's parent.  If this is a root chunk, then this value must be UINT32_MAX. */
-	uint32_t	parentChunkIndex;
-
-	/** See Flags enum for possible flags. */
-	uint32_t	flags;
-
-	/** User-supplied data which will be accessible to the user in chunk fracture events. */
-	uint32_t	userData;
-};
-
-
-/**
-Chunk bond descriptor used to build an asset.  See NvBlastAssetDesc.
-*/
-struct NvBlastBondDesc
-{
-	/** The indices of the chunks linked by this bond.  They must be different support chunk indices. */
-	uint32_t	chunkIndices[2];
-
-	/** Bond data (see NvBlastBond). */
-	NvBlastBond	bond;
-};
-
-
-/**
-Asset descriptor, used to build an asset with NvBlastCreateAsset
-
-A valid asset descriptor must have a non-zero chunkCount and valid chunkDescs.
-
-The user may create an asset with no bonds (e.g. a single-chunk asset).  In this case bondCount should be
-zero and bondDescs is ignored.
-*/
-struct NvBlastAssetDesc
-{
-	/** The number of chunk descriptors. */
-	uint32_t				chunkCount;
-
-	/** Array of chunk descriptors of size chunkCount. */
-	const NvBlastChunkDesc*	chunkDescs;
-
-	/** The number of bond descriptors. */
-	uint32_t				bondCount;
-
-	/** Array of bond descriptors of size bondCount. */
-	const NvBlastBondDesc*	bondDescs;
-};
-
-///@} End NvBlastAsset related types
-
-
-///////////////////////////////////////////////////////////////////////////////
-//	NvBlastActor related types
-///////////////////////////////////////////////////////////////////////////////
-///@{
-
-
-/**
-Struct-enum which keeps track of the family data format.
-*/
-struct NvBlastFamilyDataFormat
-{
-	enum Version
-	{
-		/** Initial version */
-		Initial,
-
-		//	New formats must come before Count.  They should be given descriptive names with more information in comments.
-
-		/** The number of family formats. */
-		Count,
-
-		/** The current version.  This should always be Count-1 */
-		Current = Count - 1
-	};
-};
-
-
-/**
-Family (opaque)
-
-a family can be created by the NvBlastAssetCreateFamily function and released 
-by the NvBlastFamilyRelease.  Family is needed to create first actor.  All the following
-actors which can be created with NvBlastActorSplit function (as a result of fracture) will share the same family
-block.  NvBlastFamilyGetActorCount can be used to know if family can be safely released.
-*/
-struct NvBlastFamily {};
-
-
-/**
-Actor (opaque)
-
-Actors can be generated by the NvBlastFamilyCreateFirstActor
-and NvBlastActorSplit functions.  Opaque NvBlastActor pointers reference data within the family
-generated during NvBlastFamilyCreateFirstActor, and represent the actor in all actor-related API
-functions.
-*/
-struct NvBlastActor {};
-
-
-/**
-Actor descriptor, used to create an instance of an NvBlastAsset with NvBlastFamilyCreateFirstActor
-
-See NvBlastFamilyCreateFirstActor.
-*/
-struct NvBlastActorDesc
-{
-	/**
-	Initial health of all bonds, if initialBondHealths is NULL (see initialBondHealths).
-	*/
-	float			uniformInitialBondHealth;
-
-	/**
-	Initial bond healths.  If not NULL, this array must be of length NvBlastAssetGetChunkCount(asset, logFn).
-	If NULL, uniformInitialBondHealth must be set.
-	*/
-	const float*	initialBondHealths;
-
-	/**
-	Initial health of all lower-support chunks, if initialSupportChunkHealths is NULL (see initialSupportChunkHealths).
-	*/
-	float			uniformInitialLowerSupportChunkHealth;
-
-	/**
-	Initial health of all support chunks.  If not NULL, this must be of length
-	NvBlastAssetGetSupportGraph(asset, logFn).nodeCount. The elements in the initialSupportChunkHealth
-	array will correspond to the chunk indices in the NvBlastAssetGetSupportGraph(asset, logFn).chunkIndices
-	array.  Every descendent of a support chunk will have its health initialized to its ancestor support
-	chunk's health, so this initializes all lower-support chunk healths.
-	If NULL, uniformInitialLowerSupportChunkHealth must be set.
-	*/
-	const float*	initialSupportChunkHealths;
-};
-
-///@} End NvBlastActor related types
-
-
-///////////////////////////////////////////////////////////////////////////////
-//	Types used for damage and fracturing
-///////////////////////////////////////////////////////////////////////////////
-///@{
-
-
-/**
-Fracture Data for Chunks
-
-Data interpretation varies depending on the function used. 
-@see NvBlastActorGenerateFracture NvBlastActorApplyFracture NvBlastFractureBuffers
-*/
-struct NvBlastChunkFractureData
-{
-	uint32_t	userdata;	//!<	chunk's user data
-	uint32_t	chunkIndex;	//!<	asset chunk index
-	float		health;		//!<	health value (damage or remains)
-};
-
-
-/**
-Fracture Data for Bonds
-
-Data interpretation varies depending on the function used.
-@see NvBlastActorGenerateFracture NvBlastActorApplyFracture NvBlastFractureBuffers
-*/
-struct NvBlastBondFractureData
-{
-	uint32_t	userdata;	//!<	bond's user data
-	uint32_t	nodeIndex0;	//!<	graph node index of bond
-	uint32_t	nodeIndex1;	//!<	pair graph node index of bond
-	float		health;		//!<	health value (damage or remains)
-};
-
-
-/**
-Memory to be used by fracture functions.
-
-Used as input and output target.
-@see NvBlastActorGenerateFracture NvBlastActorApplyFracture
-*/
-struct NvBlastFractureBuffers
-{
-	uint32_t					bondFractureCount;		//!<	available elements in bondFractures
-	uint32_t					chunkFractureCount;		//!<	available elements in chunkFractures
-	NvBlastBondFractureData*	bondFractures;			//!<	memory to be filled by fracture functions
-	NvBlastChunkFractureData*	chunkFractures;			//!<	memory to be filled by fracture functions
-};
-
-
-/**
-Description of a NvBlastActorSplit result.
-This tells the user about changes in the actor, or creation of children.
-*/
-struct NvBlastActorSplitEvent
-{
-	NvBlastActor*	deletedActor;	//!<	deleted actor or nullptr if actor has not changed
-	NvBlastActor**	newActors;		//!<	list of created actors
-};
-
-
-/**
-A single actor's representation used by NvBlastGraphShaderFunction.
-*/
-struct NvBlastGraphShaderActor
-{
-	uint32_t			firstGraphNodeIndex;	//!<	Entry index for graphNodeIndexLinks
-	const uint32_t*		graphNodeIndexLinks;	//!<	Linked index list of connected nodes.  Traversable with nextIndex = graphNodeIndexLinks[currentIndex], terminates with 0xFFFFFFFF.
-	const uint32_t*		chunkIndices;			//!<	Graph's map from node index to support chunk index.
-	const uint32_t*		adjacencyPartition;		//!<	See NvBlastSupportGraph::adjacencyPartition.
-	const uint32_t*		adjacentNodeIndices;	//!<	See NvBlastSupportGraph::adjacentNodeIndices.
-	const uint32_t*		adjacentBondIndices;	//!<	See NvBlastSupportGraph::adjacentBondIndices.
-	const NvBlastBond*	assetBonds;				//!<	NvBlastBonds geometry in the NvBlastAsset.
-	const float*		familyBondHealths;		//!<	Actual bond health values for broken bond detection.
-};
-
-
-/**
-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 NvBlastProgramParams
-{
-	const void*	damageDescBuffer;	//!<	array of damage descriptions
-	uint32_t	damageDescCount;	//!<	number of damage descriptions in array
-	const void*	material;			//!<	pointer to material
-};
-
-
-/**
-A single actor's representation used by NvBlastSubgraphShaderFunction.
-*/
-struct NvBlastSubgraphShaderActor
-{
-	uint32_t			chunkIndex;		//!<	Index of chunk represented by this actor.
-	const NvBlastChunk*	assetChunks;	//!<	NvBlastChunks geometry in the NvBlastAsset.
-};
-
-
-/**
-Damage shader for actors with more then one node in support graph.
-
-From a an input actor data (NvBlastGraphShaderActor) and user custom data (params),
-creates a list of NvBlastFractureCommand to be applied to the respective NvBlastActor.
-
-\param[in,out]	commandBuffers			The resulting health damage to apply.
-										Typically requires an array of size (number of support chunks) + (number of bonds) of the processed asset
-										but may depend on the actual implementation.
-\param[in]		actor					The actor representation used for creating commands.
-\param[in]		params					A set of parameters defined by the damage shader implementer.
-
-Interpretation of NvBlastFractureBuffers:
-As input:
-Counters denote available entries for FractureData.
-Chunk and Bond userdata are not used.
-Health values are not used.
-
-As output:
-Counters denote valid entires in FractureData arrays.
-Chunks and Bond userdata reflect the respective userdata set during asset initialization.
-Health values denote how much damage is to be applied.
-
-@see NvBlastFractureBuffers NvBlastGraphShaderActor
-*/
-typedef void(*NvBlastGraphShaderFunction)(NvBlastFractureBuffers* commandBuffers, const NvBlastGraphShaderActor* actor, const NvBlastProgramParams* params);
-
-
-/**
-Damage shader for actors with single chunk.
-
-From a an input actor data (NvBlastSubgraphShaderActor) and user custom data (params),
-creates a list of NvBlastFractureCommand to be applied to the respective NvBlastActor.
-
-\param[in,out]	commandBuffers			The resulting health damage to apply.
-										Typically requires an array of size (number of support chunks) + (number of bonds) of the processed asset
-										but may depend on the actual implementation.
-\param[in]		actor					The actor representation used for creating commands.
-\param[in]		params					A set of parameters defined by the damage shader implementer.
-
-Interpretation of NvBlastFractureBuffers:
-As input:
-Counters denote available entries for FractureData.
-Chunk and Bond userdata are not used.
-Health values are not used.
-
-As output:
-Counters denote valid entires in FractureData arrays.
-Chunks and Bond userdata reflect the respective userdata set during asset initialization.
-Health values denote how much damage is to be applied.
-
-@see NvBlastFractureBuffers NvBlastSubgraphShaderActor
-*/
-typedef void(*NvBlastSubgraphShaderFunction)(NvBlastFractureBuffers* commandBuffers, const NvBlastSubgraphShaderActor* actor, const NvBlastProgramParams* params);
-
-
-/**
-Damage Program. 
-
-Contains both graph and subgraph shader. When used on actor appropriate shader will be called.
-Any shader can be nullptr to be skipped.
-
-@see NvBlastGraphShaderFunction NvBlastSubgraphShaderFunction
-*/
-struct NvBlastDamageProgram
-{
-	NvBlastGraphShaderFunction		graphShaderFunction;
-	NvBlastSubgraphShaderFunction	subgraphShaderFunction;
-};
-
-
-///@} End of types used for damage and fracturing
-
-
-#endif // ifndef NVBLASTTYPES_H
diff --git a/NvBlast/sdk/lowlevel/include/NvPreprocessor.h b/NvBlast/sdk/lowlevel/include/NvPreprocessor.h
deleted file mode 100644
index 07a3ebc..0000000
--- a/NvBlast/sdk/lowlevel/include/NvPreprocessor.h
+++ /dev/null
@@ -1,540 +0,0 @@
-// This code contains NVIDIA Confidential Information and is disclosed to you
-// under a form of NVIDIA software license agreement provided separately to you.
-//
-// Notice
-// NVIDIA Corporation and its licensors retain all intellectual property and
-// proprietary rights in and to this software and related documentation and
-// any modifications thereto. Any use, reproduction, disclosure, or
-// distribution of this software and related documentation without an express
-// license agreement from NVIDIA Corporation is strictly prohibited.
-//
-// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
-// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
-// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
-// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
-//
-// Information and code furnished is believed to be accurate and reliable.
-// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
-// information or for any infringement of patents or other rights of third parties that may
-// result from its use. No license is granted by implication or otherwise under any patent
-// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
-// This code supersedes and replaces all information previously supplied.
-// NVIDIA Corporation products are not authorized for use as critical
-// components in life support devices or systems without express written approval of
-// NVIDIA Corporation.
-//
-// Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
-// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
-// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
-
-#ifndef NV_NVFOUNDATION_NVPREPROCESSOR_H
-#define NV_NVFOUNDATION_NVPREPROCESSOR_H
-
-#include <stddef.h>
-
-/** \addtogroup foundation
-  @{
-*/
-
-/*
-The following preprocessor identifiers specify compiler, OS, and architecture.
-All definitions have a value of 1 or 0, use '#if' instead of '#ifdef'.
-*/
-
-/**
-Compiler defines, see http://sourceforge.net/p/predef/wiki/Compilers/
-*/
-#if defined(_MSC_VER)
-#if _MSC_VER >= 1900
-#define NV_VC 14
-#elif _MSC_VER >= 1800
-#define NV_VC 12
-#elif _MSC_VER >= 1700
-#define NV_VC 11
-#elif _MSC_VER >= 1600
-#define NV_VC 10
-#elif _MSC_VER >= 1500
-#define NV_VC 9
-#else
-#error "Unknown VC version"
-#endif
-#elif defined(__clang__)
-#define NV_CLANG 1
-#elif defined(__SNC__)
-#define NV_SNC 1
-#elif defined(__ghs__)
-#define NV_GHS 1
-#elif defined(__GNUC__) // note: __clang__, __SNC__, or __ghs__ imply __GNUC__
-#define NV_GCC 1
-#else
-#error "Unknown compiler"
-#endif
-
-/**
-Operating system defines, see http://sourceforge.net/p/predef/wiki/OperatingSystems/
-*/
-#if defined(WINAPI_FAMILY) && WINAPI_FAMILY == WINAPI_PARTITION_APP
-#define NV_WINRT 1 // Windows Runtime, either on Windows RT or Windows 8
-#elif defined(XBOXONE) || defined(_XBOX_ONE)
-#define NV_XBOXONE 1
-#elif defined(_WIN64) // note: XBOXONE implies _WIN64
-#define NV_WIN64 1
-#elif defined(_M_PPC)
-#define NV_X360 1
-#elif defined(_WIN32) // note: _M_PPC implies _WIN32
-#define NV_WIN32 1
-#elif defined(__ANDROID__)
-#define NV_ANDROID 1
-#elif defined(__linux__) // note: __ANDROID__ implies __linux__
-#define NV_LINUX 1
-#elif defined(__APPLE__) && (defined(__arm__) || defined(__arm64__))
-#define NV_IOS 1
-#elif defined(__APPLE__)
-#define NV_OSX 1
-#elif defined(__CELLOS_LV2__)
-#define NV_PS3 1
-#elif defined(__ORBIS__)
-#define NV_PS4 1
-#elif defined(__SNC__) && defined(__arm__)
-#define NV_PSP2 1
-#elif defined(__ghs__)
-#define NV_WIIU 1
-#else
-#error "Unknown operating system"
-#endif
-
-/**
-Architecture defines, see http://sourceforge.net/p/predef/wiki/Architectures/
-*/
-#if defined(__x86_64__) || defined(_M_X64) // ps4 compiler defines _M_X64 without value
-#define NV_X64 1
-#elif defined(__i386__) || defined(_M_IX86)
-#define NV_X86 1
-#elif defined(__arm64__) || defined(__aarch64__)
-#define NV_A64 1
-#elif defined(__arm__) || defined(_M_ARM)
-#define NV_ARM 1
-#elif defined(__SPU__)
-#define NV_SPU 1
-#elif defined(__ppc__) || defined(_M_PPC) || defined(__CELLOS_LV2__)
-#define NV_PPC 1
-#else
-#error "Unknown architecture"
-#endif
-
-/**
-SIMD defines
-*/
-#if defined(__i386__) || defined(_M_IX86) || defined(__x86_64__) || defined(_M_X64)
-#define NV_SSE2 1
-#endif
-#if defined(_M_ARM) || defined(__ARM_NEON__)
-#define NV_NEON 1
-#endif
-#if defined(_M_PPC) || defined(__CELLOS_LV2__)
-#define NV_VMX 1
-#endif
-
-/**
-define anything not defined on this platform to 0
-*/
-#ifndef NV_VC
-#define NV_VC 0
-#endif
-#ifndef NV_CLANG
-#define NV_CLANG 0
-#endif
-#ifndef NV_SNC
-#define NV_SNC 0
-#endif
-#ifndef NV_GHS
-#define NV_GHS 0
-#endif
-#ifndef NV_GCC
-#define NV_GCC 0
-#endif
-#ifndef NV_WINRT
-#define NV_WINRT 0
-#endif
-#ifndef NV_XBOXONE
-#define NV_XBOXONE 0
-#endif
-#ifndef NV_WIN64
-#define NV_WIN64 0
-#endif
-#ifndef NV_X360
-#define NV_X360 0
-#endif
-#ifndef NV_WIN32
-#define NV_WIN32 0
-#endif
-#ifndef NV_ANDROID
-#define NV_ANDROID 0
-#endif
-#ifndef NV_LINUX
-#define NV_LINUX 0
-#endif
-#ifndef NV_IOS
-#define NV_IOS 0
-#endif
-#ifndef NV_OSX
-#define NV_OSX 0
-#endif
-#ifndef NV_PS3
-#define NV_PS3 0
-#endif
-#ifndef NV_PS4
-#define NV_PS4 0
-#endif
-#ifndef NV_PSP2
-#define NV_PSP2 0
-#endif
-#ifndef NV_WIIU
-#define NV_WIIU 0
-#endif
-#ifndef NV_X64
-#define NV_X64 0
-#endif
-#ifndef NV_X86
-#define NV_X86 0
-#endif
-#ifndef NV_A64
-#define NV_A64 0
-#endif
-#ifndef NV_ARM
-#define NV_ARM 0
-#endif
-#ifndef NV_SPU
-#define NV_SPU 0
-#endif
-#ifndef NV_PPC
-#define NV_PPC 0
-#endif
-#ifndef NV_SSE2
-#define NV_SSE2 0
-#endif
-#ifndef NV_NEON
-#define NV_NEON 0
-#endif
-#ifndef NV_VMX
-#define NV_VMX 0
-#endif
-
-/*
-define anything not defined through the command line to 0
-*/
-#ifndef NV_DEBUG
-#define NV_DEBUG 0
-#endif
-#ifndef NV_CHECKED
-#define NV_CHECKED 0
-#endif
-#ifndef NV_PROFILE
-#define NV_PROFILE 0
-#endif
-#ifndef NV_NVTX
-#define NV_NVTX 0
-#endif
-#ifndef NV_DOXYGEN
-#define NV_DOXYGEN 0
-#endif
-
-/**
-family shortcuts
-*/
-// compiler
-#define NV_GCC_FAMILY (NV_CLANG || NV_SNC || NV_GHS || NV_GCC)
-// os
-#define NV_WINDOWS_FAMILY (NV_WINRT || NV_WIN32 || NV_WIN64)
-#define NV_MICROSOFT_FAMILY (NV_XBOXONE || NV_X360 || NV_WINDOWS_FAMILY)
-#define NV_LINUX_FAMILY (NV_LINUX || NV_ANDROID)
-#define NV_APPLE_FAMILY (NV_IOS || NV_OSX)                  // equivalent to #if __APPLE__
-#define NV_UNIX_FAMILY (NV_LINUX_FAMILY || NV_APPLE_FAMILY) // shortcut for unix/posix platforms
-// architecture
-#define NV_INTEL_FAMILY (NV_X64 || NV_X86)
-#define NV_ARM_FAMILY (NV_ARM || NV_A64)
-#define NV_P64_FAMILY (NV_X64 || NV_A64) // shortcut for 64-bit architectures
-
-// shortcut for PS3 PPU
-#define NV_PPU (NV_PS3&& NV_PPC)
-
-/**
-Assert macro
-*/
-#ifndef NV_ENABLE_ASSERTS
-#if NV_DEBUG && !defined(__CUDACC__)
-#define NV_ENABLE_ASSERTS 1
-#else
-#define NV_ENABLE_ASSERTS 0
-#endif
-#endif
-
-/**
-DLL export macros
-*/
-#ifndef NV_C_EXPORT
-#if NV_WINDOWS_FAMILY || NV_LINUX || NV_PS4 || NV_XBOXONE
-#define NV_C_EXPORT extern "C"
-#else
-#define NV_C_EXPORT
-#endif
-#endif
-
-#if NV_UNIX_FAMILY && __GNUC__ >= 4
-#define NV_UNIX_EXPORT __attribute__((visibility("default")))
-#else
-#define NV_UNIX_EXPORT
-#endif
-
-#if NV_WINDOWS_FAMILY
-#define NV_DLL_EXPORT __declspec(dllexport)
-#define NV_DLL_IMPORT __declspec(dllimport)
-#else
-#define NV_DLL_EXPORT NV_UNIX_EXPORT
-#define NV_DLL_IMPORT
-#endif
-
-/**
-Define API function declaration
-
-NV_FOUNDATION_DLL=1 - used by the DLL library (PhysXCommon) to export the API
-NV_FOUNDATION_DLL=0 - for windows configurations where the NV_FOUNDATION_API is linked through standard static linking
-no definition       - this will allow DLLs and libraries to use the exported API from PhysXCommon
-
-*/
-
-#if NV_WINDOWS_FAMILY && !NV_ARM_FAMILY || NV_WINRT
-#ifndef NV_FOUNDATION_DLL
-#define NV_FOUNDATION_API NV_DLL_IMPORT
-#elif NV_FOUNDATION_DLL
-#define NV_FOUNDATION_API NV_DLL_EXPORT
-#endif
-#elif NV_UNIX_FAMILY
-#ifdef NV_FOUNDATION_DLL
-#define NV_FOUNDATION_API NV_UNIX_EXPORT
-#endif
-#endif
-
-#ifndef NV_FOUNDATION_API
-#define NV_FOUNDATION_API
-#endif
-
-/**
-Calling convention
-*/
-#ifndef NV_CALL_CONV
-#if NV_MICROSOFT_FAMILY
-#define NV_CALL_CONV __cdecl
-#else
-#define NV_CALL_CONV
-#endif
-#endif
-
-/**
-Pack macros - disabled on SPU because they are not supported
-*/
-#if NV_VC
-#define NV_PUSH_PACK_DEFAULT __pragma(pack(push, 8))
-#define NV_POP_PACK __pragma(pack(pop))
-#elif NV_GCC_FAMILY && !NV_SPU
-#define NV_PUSH_PACK_DEFAULT _Pragma("pack(push, 8)")
-#define NV_POP_PACK _Pragma("pack(pop)")
-#else
-#define NV_PUSH_PACK_DEFAULT
-#define NV_POP_PACK
-#endif
-
-/**
-Inline macro
-*/
-#define NV_INLINE inline
-#if NV_MICROSOFT_FAMILY
-#pragma inline_depth(255)
-#endif
-
-/**
-Force inline macro
-*/
-#if NV_VC
-#define NV_FORCE_INLINE __forceinline
-#elif NV_LINUX // Workaround; Fedora Core 3 do not agree with force inline and NvcPool
-#define NV_FORCE_INLINE inline
-#elif NV_GCC_FAMILY
-#define NV_FORCE_INLINE inline __attribute__((always_inline))
-#else
-#define NV_FORCE_INLINE inline
-#endif
-
-/**
-Noinline macro
-*/
-#if NV_MICROSOFT_FAMILY
-#define NV_NOINLINE __declspec(noinline)
-#elif NV_GCC_FAMILY
-#define NV_NOINLINE __attribute__((noinline))
-#else
-#define NV_NOINLINE
-#endif
-
-/**
-Restrict macro
-*/
-#if defined(__CUDACC__)
-#define NV_RESTRICT __restrict__
-#else
-#define NV_RESTRICT __restrict
-#endif
-
-/**
-Noalias macro
-*/
-#if NV_MICROSOFT_FAMILY
-#define NV_NOALIAS __declspec(noalias)
-#else
-#define NV_NOALIAS
-#endif
-
-/**
-Alignment macros
-
-NV_ALIGN_PREFIX and NV_ALIGN_SUFFIX can be used for type alignment instead of aligning individual variables as follows:
-NV_ALIGN_PREFIX(16)
-struct A {
-...
-} NV_ALIGN_SUFFIX(16);
-This declaration style is parsed correctly by Visual Assist.
-
-*/
-#ifndef NV_ALIGN
-#if NV_MICROSOFT_FAMILY
-#define NV_ALIGN(alignment, decl) __declspec(align(alignment)) decl
-#define NV_ALIGN_PREFIX(alignment) __declspec(align(alignment))
-#define NV_ALIGN_SUFFIX(alignment)
-#elif NV_GCC_FAMILY
-#define NV_ALIGN(alignment, decl) decl __attribute__((aligned(alignment)))
-#define NV_ALIGN_PREFIX(alignment)
-#define NV_ALIGN_SUFFIX(alignment) __attribute__((aligned(alignment)))
-#else
-#define NV_ALIGN(alignment, decl)
-#define NV_ALIGN_PREFIX(alignment)
-#define NV_ALIGN_SUFFIX(alignment)
-#endif
-#endif
-
-/**
-Deprecated macro
-- To deprecate a function: Place NV_DEPRECATED at the start of the function header (leftmost word).
-- To deprecate a 'typedef', a 'struct' or a 'class': Place NV_DEPRECATED directly after the keywords ('typdef',
-'struct', 'class').
-
-Use these macro definitions to create warnings for deprecated functions
-#define NV_DEPRECATED __declspec(deprecated) // Microsoft
-#define NV_DEPRECATED __attribute__((deprecated())) // GCC
-*/
-#define NV_DEPRECATED
-
-/**
-General defines
-*/
-
-// static assert
-#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) || defined(__ORBIS__)
-#define NV_COMPILE_TIME_ASSERT(exp) typedef char NvCompileTimeAssert_Dummy[(exp) ? 1 : -1] __attribute__((unused))
-#else
-#define NV_COMPILE_TIME_ASSERT(exp) typedef char NvCompileTimeAssert_Dummy[(exp) ? 1 : -1]
-#endif
-
-#if NV_GCC_FAMILY && !NV_SNC && !NV_GHS
-#define NV_OFFSET_OF(X, Y) __builtin_offsetof(X, Y)
-#else
-#define NV_OFFSET_OF(X, Y) offsetof(X, Y)
-#endif
-
-#define NV_OFFSETOF_BASE 0x100 // casting the null ptr takes a special-case code path, which we don't want
-#define NV_OFFSET_OF_RT(Class, Member)                                                                                 \
-	(reinterpret_cast<size_t>(&reinterpret_cast<Class*>(NV_OFFSETOF_BASE)->Member) - size_t(NV_OFFSETOF_BASE))
-
-// check that exactly one of NDEBUG and _DEBUG is defined
-#if !defined(NDEBUG) ^ defined(_DEBUG)
-#error Exactly one of NDEBUG and _DEBUG needs to be defined!
-#endif
-
-// make sure NV_CHECKED is defined in all _DEBUG configurations as well
-#if !defined(NV_CHECKED) && defined(NV_DEBUG)
-#error NV_CHECKED must be defined when NV_DEBUG is defined
-#endif
-
-#ifdef __CUDACC__
-#define NV_CUDA_CALLABLE __host__ __device__
-#else
-#define NV_CUDA_CALLABLE
-#endif
-
-// avoid unreferenced parameter warning
-// preferred solution: omit the parameter's name from the declaration
-template <class T>
-NV_CUDA_CALLABLE NV_INLINE void NV_UNUSED(T const&)
-{
-}
-
-// Ensure that the application hasn't tweaked the pack value to less than 8, which would break
-// matching between the API headers and the binaries
-// This assert works on win32/win64/360/ps3, but may need further specialization on other platforms.
-// Some GCC compilers need the compiler flag -malign-double to be set.
-// Apparently the apple-clang-llvm compiler doesn't support malign-double.
-#if NV_PS4 || NV_APPLE_FAMILY
-struct NvPackValidation
-{
-	char _;
-	long a;
-};
-#elif NV_ANDROID
-struct NvPackValidation
-{
-	char _;
-	double a;
-};
-#else
-struct NvPackValidation
-{
-	char _;
-	long long a;
-};
-#endif
-#if !NV_APPLE_FAMILY
-NV_COMPILE_TIME_ASSERT(NV_OFFSET_OF(NvPackValidation, a) == 8);
-#endif
-
-// use in a cpp file to suppress LNK4221
-#if NV_VC
-#define NV_DUMMY_SYMBOL                                                                                                \
-	namespace                                                                                                          \
-	{                                                                                                                  \
-	char NvDummySymbol;                                                                                                \
-	}
-#else
-#define NV_DUMMY_SYMBOL
-#endif
-
-#if NV_GCC_FAMILY && !NV_GHS
-#define NV_WEAK_SYMBOL __attribute__((weak)) // this is to support SIMD constant merging in template specialization
-#else
-#define NV_WEAK_SYMBOL
-#endif
-
-// Macro for avoiding default assignment and copy, because doing this by inheritance can increase class size on some
-// platforms.
-#define NV_NOCOPY(Class)                                                                                               \
-	\
-protected:                                                                                                             \
-	Class(const Class&);                                                                                               \
-	Class& operator=(const Class&);
-
-#define NV_STRINGIZE_HELPER(X) #X
-#define NV_STRINGIZE(X) NV_STRINGIZE_HELPER(X)
-
-#define NV_CONCAT_HELPER(X, Y) X##Y
-#define NV_CONCAT(X, Y) NV_CONCAT_HELPER(X, Y)
-
-/** @} */
-#endif // #ifndef NV_NVFOUNDATION_NVPREPROCESSOR_H
diff --git a/NvBlast/sdk/lowlevel/source/NvBlastActor.cpp b/NvBlast/sdk/lowlevel/source/NvBlastActor.cpp
deleted file mode 100644
index b93c47a..0000000
--- a/NvBlast/sdk/lowlevel/source/NvBlastActor.cpp
+++ /dev/null
@@ -1,1316 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastActor.h"
-#include "NvBlastFamilyGraph.h"
-#include "NvBlastChunkHierarchy.h"
-#include "NvBlastIndexFns.h"
-#include "NvBlastDLink.h"
-#include "NvBlastGeometry.h"
-#include "NvBlastTime.h"
-#include <float.h>
-#include <algorithm>
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-//////// Local helper functions ////////
-
-#if NVBLAST_CHECK_PARAMS
-/**
-Helper function to validate fracture buffer values being meaningful.
-*/
-static inline bool isValid(const NvBlastFractureBuffers* buffers)
-{
-	if (buffers->chunkFractureCount != 0 && buffers->chunkFractures == nullptr)
-		return false;
-
-	if (buffers->bondFractureCount != 0 && buffers->bondFractures == nullptr)
-		return false;
-
-	return true;
-}
-#endif
-
-//////// Actor static methods ////////
-
-size_t Actor::createRequiredScratch(const NvBlastFamily* family)
-{
-#if NVBLAST_CHECK_PARAMS
-	if (family == nullptr || reinterpret_cast<const FamilyHeader*>(family)->m_asset == nullptr)
-	{
-		NVBLAST_ALWAYS_ASSERT();
-		return 0;
-	}
-#endif
-	
-	const Asset& solverAsset = *reinterpret_cast<const FamilyHeader*>(family)->m_asset;
-	return FamilyGraph::findIslandsRequiredScratch(solverAsset.m_graph.m_nodeCount);
-}
-
-
-Actor* Actor::create(NvBlastFamily* family, const NvBlastActorDesc* desc, void* scratch, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(family != nullptr, logFn, "Actor::create: NULL family pointer input.", return nullptr);
-	NVBLAST_CHECK(reinterpret_cast<FamilyHeader*>(family)->m_asset != nullptr, logFn, "Actor::create: family has NULL asset.", return nullptr);
-	NVBLAST_CHECK(reinterpret_cast<FamilyHeader*>(family)->m_asset->m_graph.m_nodeCount != 0, logFn, "Actor::create: family's asset has no support chunks.", return nullptr);
-	NVBLAST_CHECK(desc != nullptr, logFn, "Actor::create: NULL desc pointer input.", return nullptr);
-	NVBLAST_CHECK(scratch != nullptr, logFn, "Actor::create: NULL scratch input.", return nullptr);
-
-	FamilyHeader* header = reinterpret_cast<FamilyHeader*>(family);
-
-	if (header->m_actorCount > 0)
-	{
-		NVBLAST_LOG_ERROR(logFn, "Actor::create: input family is not empty.");
-		return nullptr;
-	}
-
-	const Asset& solverAsset = *static_cast<const Asset*>(header->m_asset);
-	const Nv::Blast::SupportGraph& graph = solverAsset.m_graph;
-
-	// Lower support chunk healths - initialize
-	float* lowerSupportChunkHealths = header->getLowerSupportChunkHealths();
-	if (desc->initialSupportChunkHealths != nullptr)	// Health array given
-	{
-		const uint32_t* supportChunkIndices = graph.getChunkIndices();
-		for (uint32_t supportChunkNum = 0; supportChunkNum < graph.m_nodeCount; ++supportChunkNum)
-		{
-			const float initialHealth = desc->initialSupportChunkHealths[supportChunkNum];
-			for (Asset::DepthFirstIt i(solverAsset, supportChunkIndices[supportChunkNum]); (bool)i; ++i)
-			{
-				lowerSupportChunkHealths[solverAsset.getContiguousLowerSupportIndex((uint32_t)i)] = initialHealth;
-			}
-		}
-	}
-	else	// Use uniform initialization
-	{
-		const uint32_t lowerSupportChunkCount = solverAsset.getLowerSupportChunkCount();
-		for (uint32_t i = 0; i < lowerSupportChunkCount; ++i)
-		{
-			lowerSupportChunkHealths[i] = desc->uniformInitialLowerSupportChunkHealth;
-		}
-	}
-
-	// Bond healths - initialize
-	const uint32_t bondCount = solverAsset.getBondCount();
-	float* bondHealths = header->getBondHealths();
-	if (desc->initialBondHealths != nullptr)	// Health array given
-	{
-		memcpy(bondHealths, desc->initialBondHealths, bondCount * sizeof(float));
-	}
-	else	// Use uniform initialization
-	{
-		for (uint32_t bondNum = 0; bondNum < bondCount; ++bondNum)
-		{
-			bondHealths[bondNum] = desc->uniformInitialBondHealth;
-		}
-	}
-
-	// Get first actor - NOTE: we don't send an event for this!  May need to do so for consistency.
-	Actor* actor = header->borrowActor(0);	// Using actor[0]
-
-	// Fill in actor fields
-	actor->m_firstGraphNodeIndex = 0;
-	actor->m_graphNodeCount = graph.m_nodeCount;
-	actor->m_leafChunkCount = solverAsset.m_leafChunkCount;
-
-	// Graph node index links - initialize to chain
-	uint32_t* graphNodeLinks = header->getGraphNodeIndexLinks();
-	for (uint32_t i = 0; i < graph.m_nodeCount - 1; ++i)
-	{
-		graphNodeLinks[i] = i + 1;
-	}
-	graphNodeLinks[graph.m_nodeCount - 1] = invalidIndex<uint32_t>();
-
-	// Update visible chunks (we assume that all chunks belong to one actor at the beginning)
-	actor->updateVisibleChunksFromGraphNodes();
-
-	// Initialize instance graph with this actor
-	header->getFamilyGraph()->initialize(actor->getIndex(), &graph);
-
-	// Call findIslands to set up the internal instance graph data
-	header->getFamilyGraph()->findIslands(actor->getIndex(), scratch, &graph);
-
-	return actor;
-}
-
-
-//////// Actor member methods ////////
-
-uint32_t Actor::damageBond(uint32_t nodeIndex0, uint32_t nodeIndex1, float healthDamage)
-{
-	const uint32_t bondIndex = getGraph()->findBond(nodeIndex0, nodeIndex1);
-	damageBond(nodeIndex0, nodeIndex1, bondIndex, healthDamage);
-	return bondIndex;
-}
-
-
-void Actor::damageBond(uint32_t nodeIndex0, uint32_t nodeIndex1, uint32_t bondIndex, float healthDamage)
-{
-	if (bondIndex == invalidIndex<uint32_t>())
-	{
-		NVBLAST_ALWAYS_ASSERT();
-		return;
-	}
-
-	float* bondHealths = getBondHealths();
-	if (bondHealths[bondIndex] > 0 && healthDamage > 0.0f)
-	{
-		// Subtract health
-		bondHealths[bondIndex] -= healthDamage;
-
-		// Was removed?
-		if (bondHealths[bondIndex] <= 0)
-		{
-			// Notify graph that bond was removed
-			getFamilyGraph()->notifyEdgeRemoved(getIndex(), nodeIndex0, nodeIndex1, bondIndex, getGraph());
-			bondHealths[bondIndex] = 0;	// Doing this for single-actor serialization consistency; should not actually be necessary
-		}
-	}
-}
-
-
-uint32_t Actor::damageBond(const NvBlastBondFractureData& cmd)
-{
-	NVBLAST_ASSERT(!isInvalidIndex(cmd.nodeIndex1));
-	return damageBond(cmd.nodeIndex0, cmd.nodeIndex1, cmd.health);
-}
-
-
-void Actor::generateFracture(NvBlastFractureBuffers* commandBuffers, const NvBlastDamageProgram& program, const NvBlastProgramParams* programParams, 
-	NvBlastLog logFn, NvBlastTimers* timers) const
-{
-	NVBLAST_CHECK(commandBuffers != nullptr, logFn, "Actor::generateFracture: NULL commandBuffers pointer input.", return);
-	NVBLAST_CHECK(isValid(commandBuffers), logFn, "NvBlastActorGenerateFracture: commandBuffers memory is NULL but size is > 0.",
-		commandBuffers->bondFractureCount = 0; commandBuffers->chunkFractureCount = 0; return);
-
-#if NVBLAST_CHECK_PARAMS
-	if (commandBuffers->bondFractureCount == 0 && commandBuffers->chunkFractureCount == 0)
-	{
-		NVBLAST_LOG_WARNING(logFn, "NvBlastActorGenerateFracture: commandBuffers do not provide any space.");
-		return;
-	}
-#endif
-
-#if NV_PROFILE
-	Time time;
-#else
-	NV_UNUSED(timers);
-#endif
-
-	const SupportGraph* graph = getGraph();
-
-	const uint32_t graphNodeCount = getGraphNodeCount();
-	if (graphNodeCount > 1 && program.graphShaderFunction != nullptr)
-	{
-		const NvBlastGraphShaderActor shaderActor = {
-			getFirstGraphNodeIndex(),
-			getGraphNodeIndexLinks(),
-			graph->getChunkIndices(),
-			graph->getAdjacencyPartition(),
-			graph->getAdjacentNodeIndices(),
-			graph->getAdjacentBondIndices(),
-			getBonds(),
-			getBondHealths()
-		};
-
-		program.graphShaderFunction(commandBuffers, &shaderActor, programParams);
-	}
-	else if (graphNodeCount <= 1 && program.subgraphShaderFunction != nullptr)
-	{
-		const NvBlastSubgraphShaderActor shaderActor = {
-			// The conditional (visible vs. support chunk) is needed because we allow single-child chunk chains
-			// This makes it possible that an actor with a single support chunk will have a different visible chunk (ancestor of the support chunk)
-			graphNodeCount == 1 ? graph->getChunkIndices()[getFirstGraphNodeIndex()] : getFirstVisibleChunkIndex(),
-			getChunks()
-		};
-
-		program.subgraphShaderFunction(commandBuffers, &shaderActor, programParams);
-	}
-	else
-	{
-		commandBuffers->bondFractureCount = 0;
-		commandBuffers->chunkFractureCount = 0;
-	}
-
-#if NV_PROFILE
-	if (timers != nullptr)
-	{
-		timers->material += time.getElapsedTicks();
-	}
-#endif
-}
-
-
-void Actor::fractureSubSupportNoEvents(uint32_t chunkIndex, uint32_t suboffset, float healthDamage, float* chunkHealths, const NvBlastChunk* chunks)
-{
-	const NvBlastChunk& chunk = chunks[chunkIndex];
-	uint32_t numChildren = chunk.childIndexStop - chunk.firstChildIndex;
-
-	if (numChildren > 0)
-	{
-		healthDamage /= numChildren;
-		for (uint32_t childIndex = chunk.firstChildIndex; childIndex < chunk.childIndexStop; childIndex++)
-		{
-			float& health = chunkHealths[childIndex - suboffset];
-			if (health > 0.0f)
-			{
-				float remainingDamage = healthDamage - health;
-				health -= healthDamage;
-
-				NVBLAST_ASSERT(chunks[childIndex].parentChunkIndex == chunkIndex);
-
-				if (health <= 0.0f && remainingDamage > 0.0f)
-				{
-					fractureSubSupportNoEvents(childIndex, suboffset, remainingDamage, chunkHealths, chunks);
-				}
-			}
-		}
-	}
-}
-
-
-void Actor::fractureSubSupport(uint32_t chunkIndex, uint32_t suboffset, float healthDamage, float* chunkHealths, const NvBlastChunk* chunks, NvBlastChunkFractureData* outBuffer, uint32_t* currentIndex, const uint32_t maxCount)
-{
-	const NvBlastChunk& chunk = chunks[chunkIndex];
-	uint32_t numChildren = chunk.childIndexStop - chunk.firstChildIndex;
-
-	if (numChildren > 0)
-	{
-		healthDamage /= numChildren;
-		for (uint32_t childIndex = chunk.firstChildIndex; childIndex < chunk.childIndexStop; childIndex++)
-		{
-			float& health = chunkHealths[childIndex - suboffset];
-			if (health > 0.0f)
-			{
-				float remainingDamage = healthDamage - health;
-				health -= healthDamage;
-
-				NVBLAST_ASSERT(chunks[childIndex].parentChunkIndex == chunkIndex);
-
-				if (*currentIndex < maxCount)
-				{
-					NvBlastChunkFractureData& event = outBuffer[*currentIndex];
-					event.userdata = chunks[childIndex].userData;
-					event.chunkIndex = childIndex;
-					event.health = health;
-				}
-				(*currentIndex)++;
-
-				if (health <= 0.0f && remainingDamage > 0.0f)
-				{
-					fractureSubSupport(childIndex, suboffset, remainingDamage, chunkHealths, chunks, outBuffer, currentIndex, maxCount);
-				}
-			}
-		}
-	}
-
-}
-
-
-void Actor::fractureNoEvents(uint32_t chunkFractureCount, const NvBlastChunkFractureData* chunkFractures)
-{
-	const Asset& asset = *getAsset();
-	const SupportGraph& graph = *getGraph();
-	const uint32_t* graphAdjacencyPartition = graph.getAdjacencyPartition();
-	const uint32_t* graphAdjacentNodeIndices = graph.getAdjacentNodeIndices();
-	float* bondHealths = getBondHealths();
-	float* chunkHealths = getLowerSupportChunkHealths();
-	float* subChunkHealths = getSubsupportChunkHealths();
-	const NvBlastChunk* chunks = getChunks();
-
-	for (uint32_t i = 0; i < chunkFractureCount; ++i)
-	{
-		const NvBlastChunkFractureData& command = chunkFractures[i];
-		const uint32_t chunkIndex = command.chunkIndex;
-		const uint32_t chunkHealthIndex = asset.getContiguousLowerSupportIndex(chunkIndex);
-		NVBLAST_ASSERT(!isInvalidIndex(chunkHealthIndex));
-		if (isInvalidIndex(chunkHealthIndex))
-		{
-			continue;
-		}
-		float& health = chunkHealths[chunkHealthIndex];
-		if (health > 0.0f && command.health > 0.0f)
-		{
-			const uint32_t nodeIndex = asset.getChunkToGraphNodeMap()[chunkIndex];
-			if (getGraphNodeCount() > 1 && !isInvalidIndex(nodeIndex))
-			{
-				for (uint32_t adjacentIndex = graphAdjacencyPartition[nodeIndex]; adjacentIndex < graphAdjacencyPartition[nodeIndex + 1]; adjacentIndex++)
-				{
-
-					const uint32_t bondIndex = graph.findBond(nodeIndex, graphAdjacentNodeIndices[adjacentIndex]);
-					NVBLAST_ASSERT(!isInvalidIndex(bondIndex));
-					if (bondHealths[bondIndex] > 0.0f)
-					{
-						bondHealths[bondIndex] = 0.0f;
-					}
-				}
-				getFamilyGraph()->notifyNodeRemoved(getIndex(), nodeIndex, &graph);
-			}
-
-			health -= command.health;
-
-			const float remainingDamage = -health;
-
-			if (remainingDamage > 0.0f) // node chunk has been damaged beyond its health
-			{
-				uint32_t firstSubOffset = getFirstSubsupportChunkIndex();
-				fractureSubSupportNoEvents(chunkIndex, firstSubOffset, remainingDamage, subChunkHealths, chunks);
-			}
-		}
-	}
-}
-
-
-void Actor::fractureWithEvents(uint32_t chunkFractureCount, const NvBlastChunkFractureData* commands, NvBlastChunkFractureData* events, uint32_t eventsSize, uint32_t* count)
-{
-	const Asset& asset = *getAsset();
-	const SupportGraph& graph = *getGraph();
-	const uint32_t* graphAdjacencyPartition = graph.getAdjacencyPartition();
-	const uint32_t* graphAdjacentNodeIndices = graph.getAdjacentNodeIndices();
-	float* bondHealths = getBondHealths();
-	float* chunkHealths = getLowerSupportChunkHealths();
-	float* subChunkHealths = getSubsupportChunkHealths();
-	const NvBlastChunk* chunks = getChunks();
-
-	for (uint32_t i = 0; i < chunkFractureCount; ++i)
-	{
-		const NvBlastChunkFractureData& command = commands[i];
-		const uint32_t chunkIndex = command.chunkIndex;
-		const uint32_t chunkHealthIndex = asset.getContiguousLowerSupportIndex(chunkIndex);
-		NVBLAST_ASSERT(!isInvalidIndex(chunkHealthIndex));
-		if (isInvalidIndex(chunkHealthIndex))
-		{
-			continue;
-		}
-		float& health = chunkHealths[chunkHealthIndex];
-		if (health > 0.0f && command.health > 0.0f)
-		{
-			const uint32_t nodeIndex = asset.getChunkToGraphNodeMap()[chunkIndex];
-			if (getGraphNodeCount() > 1 && !isInvalidIndex(nodeIndex))
-			{
-				for (uint32_t adjacentIndex = graphAdjacencyPartition[nodeIndex]; adjacentIndex < graphAdjacencyPartition[nodeIndex + 1]; adjacentIndex++)
-				{
-					const uint32_t bondIndex = graph.findBond(nodeIndex, graphAdjacentNodeIndices[adjacentIndex]);
-					NVBLAST_ASSERT(!isInvalidIndex(bondIndex));
-					if (bondHealths[bondIndex] > 0.0f)
-					{
-						bondHealths[bondIndex] = 0.0f;
-					}
-				}
-				getFamilyGraph()->notifyNodeRemoved(getIndex(), nodeIndex, &graph);
-			}
-
-			health -= command.health;
-
-			if (*count < eventsSize)
-			{
-				NvBlastChunkFractureData& outEvent = events[*count];
-				outEvent.userdata = chunks[chunkIndex].userData;
-				outEvent.chunkIndex = chunkIndex;
-				outEvent.health = health;
-			}
-			(*count)++;
-
-			const float remainingDamage = -health;
-
-			if (remainingDamage > 0.0f) // node chunk has been damaged beyond its health
-			{
-				uint32_t firstSubOffset = getFirstSubsupportChunkIndex();
-				fractureSubSupport(chunkIndex, firstSubOffset, remainingDamage, subChunkHealths, chunks, events, count, eventsSize);
-			}
-		}
-	}
-}
-
-
-void Actor::fractureInPlaceEvents(uint32_t chunkFractureCount, NvBlastChunkFractureData* inoutbuffer, uint32_t eventsSize, uint32_t* count)
-{
-	const Asset& asset = *getAsset();
-	const SupportGraph& graph = *getGraph();
-	const uint32_t* graphAdjacencyPartition = graph.getAdjacencyPartition();
-	const uint32_t* graphAdjacentNodeIndices = graph.getAdjacentNodeIndices();
-	float* bondHealths = getBondHealths();
-	float* chunkHealths = getLowerSupportChunkHealths();
-	float* subChunkHealths = getSubsupportChunkHealths();
-	const NvBlastChunk* chunks = getChunks();
-
-	//
-	// First level Chunk Fractures
-	//
-
-	for (uint32_t i = 0; i < chunkFractureCount; ++i)
-	{
-		const NvBlastChunkFractureData& command = inoutbuffer[i];
-		const uint32_t chunkIndex = command.chunkIndex;
-		const uint32_t chunkHealthIndex = asset.getContiguousLowerSupportIndex(chunkIndex);
-		NVBLAST_ASSERT(!isInvalidIndex(chunkHealthIndex));
-		if (isInvalidIndex(chunkHealthIndex))
-		{
-			continue;
-		}
-		float& health = chunkHealths[chunkHealthIndex];
-		if (health > 0.0f && command.health > 0.0f)
-		{
-			const uint32_t nodeIndex = asset.getChunkToGraphNodeMap()[chunkIndex];
-			if (getGraphNodeCount() > 1 && !isInvalidIndex(nodeIndex))
-			{
-				for (uint32_t adjacentIndex = graphAdjacencyPartition[nodeIndex]; adjacentIndex < graphAdjacencyPartition[nodeIndex + 1]; adjacentIndex++)
-				{
-					const uint32_t bondIndex = graph.findBond(nodeIndex, graphAdjacentNodeIndices[adjacentIndex]);
-					NVBLAST_ASSERT(!isInvalidIndex(bondIndex));
-					if (bondHealths[bondIndex] > 0.0f)
-					{
-						bondHealths[bondIndex] = 0.0f;
-					}
-				}
-				getFamilyGraph()->notifyNodeRemoved(getIndex(), nodeIndex, &graph);
-			}
-
-			health -= command.health;
-
-			NvBlastChunkFractureData& outEvent = inoutbuffer[(*count)++];
-			outEvent.userdata = chunks[chunkIndex].userData;
-			outEvent.chunkIndex = chunkIndex;
-			outEvent.health = health;
-		}
-	}
-
-	//
-	// Hierarchical Chunk Fractures
-	//
-
-	uint32_t commandedChunkFractures = *count;
-
-	for (uint32_t i = 0; i < commandedChunkFractures; ++i)
-	{
-		NvBlastChunkFractureData& event = inoutbuffer[i];
-		const uint32_t chunkIndex = event.chunkIndex;
-
-		const float remainingDamage = -event.health;
-		if (remainingDamage > 0.0f) // node chunk has been damaged beyond its health
-		{
-			uint32_t firstSubOffset = getFirstSubsupportChunkIndex();
-			fractureSubSupport(chunkIndex, firstSubOffset, remainingDamage, subChunkHealths, chunks, inoutbuffer, count, eventsSize);
-		}
-	}
-}
-
-
-void Actor::applyFracture(NvBlastFractureBuffers* eventBuffers, const NvBlastFractureBuffers* commands, NvBlastLog logFn, NvBlastTimers* timers)
-{
-	NVBLAST_CHECK(commands != nullptr, logFn, "Actor::applyFracture: NULL commands pointer input.", return);
-	NVBLAST_CHECK(isValid(commands), logFn, "Actor::applyFracture: commands memory is NULL but size is > 0.", return);
-	NVBLAST_CHECK(eventBuffers == nullptr || isValid(eventBuffers), logFn, "NvBlastActorApplyFracture: eventBuffers memory is NULL but size is > 0.",
-		eventBuffers->bondFractureCount = 0; eventBuffers->chunkFractureCount = 0; return);
-
-#if NVBLAST_CHECK_PARAMS
-	if (eventBuffers != nullptr && eventBuffers->bondFractureCount == 0 && eventBuffers->chunkFractureCount == 0)
-	{
-		NVBLAST_LOG_WARNING(logFn, "NvBlastActorApplyFracture: eventBuffers do not provide any space.");
-		return;
-	}
-#endif
-
-#if NV_PROFILE
-	Time time;
-#else
-	NV_UNUSED(timers);
-#endif
-
-	//
-	// Chunk Fracture
-	//
-
-	if (eventBuffers == nullptr || eventBuffers->chunkFractures == nullptr)
-	{
-		// immediate hierarchical fracture
-		fractureNoEvents(commands->chunkFractureCount, commands->chunkFractures);
-	}
-	else if (eventBuffers->chunkFractures != commands->chunkFractures)
-	{
-		// immediate hierarchical fracture
-		uint32_t count = 0;
-		fractureWithEvents(commands->chunkFractureCount, commands->chunkFractures, eventBuffers->chunkFractures, eventBuffers->chunkFractureCount, &count);
-
-		if (count > eventBuffers->chunkFractureCount)
-		{
-			NVBLAST_LOG_WARNING(logFn, "NvBlastActorApplyFracture: eventBuffers too small. Chunk events were lost.");
-		}
-		else
-		{
-			eventBuffers->chunkFractureCount = count;
-		}
-	}
-	else if (eventBuffers->chunkFractures == commands->chunkFractures)
-	{
-		// compacting first
-		uint32_t count = 0;
-		fractureInPlaceEvents(commands->chunkFractureCount, commands->chunkFractures, eventBuffers->chunkFractureCount, &count);
-
-		if (count > eventBuffers->chunkFractureCount)
-		{
-			NVBLAST_LOG_WARNING(logFn, "NvBlastActorApplyFracture: eventBuffers too small. Chunk events were lost.");
-		}
-		else
-		{
-			eventBuffers->chunkFractureCount = count;
-		}
-	}
-
-	//
-	// Bond Fracture
-	//
-
-	uint32_t outCount = 0;
-	const uint32_t eventBufferSize = eventBuffers ? eventBuffers->bondFractureCount : 0;
-
-	NvBlastBond* bonds = getBonds();
-	float* bondHealths = getBondHealths();
-	for (uint32_t i = 0; i < commands->bondFractureCount; ++i)
-	{
-		const NvBlastBondFractureData& frac = commands->bondFractures[i];
-
-		const uint32_t bondIndex = damageBond(frac.nodeIndex0, frac.nodeIndex1, frac.health);
-
-		if (!isInvalidIndex(bondIndex))
-		{
-			if (eventBuffers && eventBuffers->bondFractures)
-			{
-				if (outCount < eventBufferSize)
-				{
-					NvBlastBondFractureData& outEvent = eventBuffers->bondFractures[outCount];
-					outEvent.userdata = bonds[bondIndex].userData;
-					outEvent.nodeIndex0 = frac.nodeIndex0;
-					outEvent.nodeIndex1 = frac.nodeIndex1;
-					outEvent.health = bondHealths[bondIndex];
-				}
-			}
-			outCount++;
-		}
-	}
-
-	if (eventBuffers && eventBuffers->bondFractures)
-	{
-		if (outCount > eventBufferSize)
-		{
-			NVBLAST_LOG_WARNING(logFn, "NvBlastActorApplyFracture: eventBuffers too small. Bond events were lost.");
-		}
-		else
-		{
-			eventBuffers->bondFractureCount = outCount;
-		}
-	}
-
-#if NV_PROFILE
-	if (timers != nullptr)
-	{
-		timers->fracture += time.getElapsedTicks();
-	}
-#endif
-
-}
-
-
-size_t Actor::splitRequiredScratch() const
-{
-	return FamilyGraph::findIslandsRequiredScratch(getGraph()->m_nodeCount);
-}
-
-
-uint32_t Actor::split(NvBlastActorSplitEvent* result, uint32_t newActorsMaxCount, void* scratch, NvBlastLog logFn, NvBlastTimers* timers)
-{
-	NVBLAST_CHECK(result != nullptr, logFn, "Actor::split: NULL result pointer input.", return 0);
-	NVBLAST_CHECK(newActorsMaxCount > 0 && result->newActors != nullptr, logFn, "NvBlastActorSplit: no space for results provided.", return 0);
-	NVBLAST_CHECK(scratch != nullptr, logFn, "Actor::split: NULL scratch pointer input.", return 0);
-
-#if NV_PROFILE
-	Time time;
-#else
-	NV_UNUSED(timers);
-#endif
-
-	Actor** newActors = reinterpret_cast<Actor**>(result->newActors);
-
-	uint32_t actorsCount = 0;
-
-	if (getGraphNodeCount() <= 1)
-	{
-		uint32_t chunkHealthIndex = isSingleSupportChunk() ? getIndex() : getFirstVisibleChunkIndex() - getFirstSubsupportChunkIndex() + getGraph()->m_nodeCount;
-
-		float* chunkHealths = getLowerSupportChunkHealths();
-		if (chunkHealths[chunkHealthIndex] <= 0.0f)
-		{
-			actorsCount = partitionSingleLowerSupportChunk(newActors, newActorsMaxCount, logFn);
-
-			for (uint32_t i = 0; i < actorsCount; ++i)
-			{
-				Actor* newActor = newActors[i];
-				uint32_t firstVisible = newActor->getFirstVisibleChunkIndex();
-				uint32_t firstSub = newActor->getFirstSubsupportChunkIndex();
-				uint32_t nodeCount = newActor->getGraph()->m_nodeCount;
-				uint32_t newActorIndex = newActor->getIndex();
-				uint32_t healthIndex = newActor->isSubSupportChunk() ? firstVisible - firstSub + nodeCount : newActorIndex;
-
-				if (chunkHealths[healthIndex] <= 0.0f)
-				{
-					uint32_t brittleActors = newActors[i]->partitionSingleLowerSupportChunk(&newActors[actorsCount], newActorsMaxCount - actorsCount, logFn);
-					actorsCount += brittleActors;
-
-					if (brittleActors > 0)
-					{
-						actorsCount--;
-						newActors[i] = newActors[actorsCount];
-						i--;
-					}
-				}
-			}
-		}
-
-
-#if NV_PROFILE
-		if (timers != nullptr)
-		{
-			timers->partition += time.getElapsedTicks();
-		}
-#endif
-	}
-	else
-	{
-		findIslands(scratch);
-
-#if NV_PROFILE
-		if (timers != nullptr)
-		{
-			timers->island += time.getElapsedTicks();
-		}
-#endif
-
-		actorsCount = partitionMultipleGraphNodes(newActors, newActorsMaxCount, logFn);
-
-		if (actorsCount > 1)
-		{
-#if NV_PROFILE
-			if (timers != nullptr)
-			{
-				timers->partition += time.getElapsedTicks();
-			}
-#endif
-
-			// Recalculate visible chunk lists if the graph nodes have been redistributed
-			for (uint32_t i = 0; i < actorsCount; ++i)
-			{
-				newActors[i]->updateVisibleChunksFromGraphNodes();
-			}
-
-#if NV_PROFILE
-			if (timers != nullptr)
-			{
-				timers->visibility += time.getElapsedTicks();
-			}
-#endif
-
-			for (uint32_t i = 0; i < actorsCount; ++i)
-			{
-				Actor* newActor = newActors[i];
-				float* chunkHealths = newActor->getLowerSupportChunkHealths();
-				uint32_t firstVisible = newActor->getFirstVisibleChunkIndex();
-				uint32_t firstSub = newActor->getFirstSubsupportChunkIndex();
-				uint32_t nodeCount = newActor->getGraph()->m_nodeCount;
-				uint32_t newActorIndex = newActor->getIndex();
-				uint32_t healthIndex = newActor->isSubSupportChunk() ? firstVisible - firstSub + nodeCount : newActorIndex;
-
-				if (newActors[i]->getGraphNodeCount() <= 1)
-				{
-					// this relies on visibility updated, subsupport actors only have m_firstVisibleChunkIndex to identify the chunk
-					if (chunkHealths[healthIndex] <= 0.0f)
-					{
-						uint32_t brittleActors = newActors[i]->partitionSingleLowerSupportChunk(&newActors[actorsCount], newActorsMaxCount - actorsCount, logFn);
-						actorsCount += brittleActors;
-
-						if (brittleActors > 0)
-						{
-							actorsCount--;
-							newActors[i] = newActors[actorsCount];
-							i--;
-						}
-					}
-				}
-			}
-
-#if NV_PROFILE
-			if (timers != nullptr)
-			{
-				timers->partition += time.getElapsedTicks();
-			}
-#endif
-		}
-		else
-		{
-			actorsCount = 0;
-		}
-	}
-
-	result->deletedActor = actorsCount == 0 ? nullptr : this;
-
-	return actorsCount;
-}
-	
-	
-uint32_t Actor::findIslands(void* scratch)
-{
-	return getFamilyHeader()->getFamilyGraph()->findIslands(getIndex(), scratch, &getAsset()->m_graph);
-}
-
-
-uint32_t Actor::partitionMultipleGraphNodes(Actor** newActors, uint32_t newActorsSize, NvBlastLog logFn)
-{
-	NVBLAST_ASSERT(newActorsSize == 0 || newActors != nullptr);
-
-	// Check for single subsupport chunk, no partitioning
-	if (m_graphNodeCount <= 1)
-	{
-		NVBLAST_LOG_WARNING(logFn, "Nv::Blast::Actor::partitionMultipleGraphNodes: actor is a single lower-support chunk, and cannot be partitioned by this function.");
-		return 0;
-	}
-
-	FamilyHeader* header = getFamilyHeader();
-	NVBLAST_ASSERT(header != nullptr);	// If m_actorEntryDataIndex is valid, this should be too
-
-	// Get the links for the graph nodes
-	uint32_t* graphNodeIndexLinks = header->getGraphNodeIndexLinks();
-
-	// Get the graph chunk indices and leaf chunk counts
-	const Asset* asset = getAsset();
-	const uint32_t* graphChunkIndices = asset->m_graph.getChunkIndices();
-	const uint32_t* subtreeLeafChunkCounts = asset->getSubtreeLeafChunkCounts();
-
-	// Distribute graph nodes to new actors
-	uint32_t newActorCount = 0;
-	const uint32_t thisActorIndex = getIndex();
-	m_leafChunkCount = 0;
-	const uint32_t* islandIDs = header->getFamilyGraph()->getIslandIds();
-	uint32_t lastGraphNodeIndex = invalidIndex<uint32_t>();
-	uint32_t nextGraphNodeIndex = invalidIndex<uint32_t>();
-	bool overflow = false;
-	for (uint32_t graphNodeIndex = m_firstGraphNodeIndex; !isInvalidIndex(graphNodeIndex); graphNodeIndex = nextGraphNodeIndex)
-	{
-		nextGraphNodeIndex = graphNodeIndexLinks[graphNodeIndex];
-		const uint32_t islandID = islandIDs[graphNodeIndex];
-
-		if (islandID == thisActorIndex)
-		{
-			m_leafChunkCount += subtreeLeafChunkCounts[graphChunkIndices[graphNodeIndex]];
-			lastGraphNodeIndex = graphNodeIndex;
-			continue;	// Leave the chunk in this actor
-		}
-
-		// Remove link from this actor
-		if (isInvalidIndex(lastGraphNodeIndex))
-		{
-			m_firstGraphNodeIndex = nextGraphNodeIndex;
-		}
-		else
-		{
-			graphNodeIndexLinks[lastGraphNodeIndex] = nextGraphNodeIndex;
-		}
-		graphNodeIndexLinks[graphNodeIndex] = invalidIndex<uint32_t>();
-		--m_graphNodeCount;
-
-		// See if the chunk had been removed
-		if (islandID == invalidIndex<uint32_t>())
-		{
-			continue;
-		}
-
-		// Get new actor if the islandID is valid
-		Actor* newActor = header->borrowActor(islandID);
-
-		// Check new actor to see if we're adding the first chunk
-		if (isInvalidIndex(newActor->m_firstGraphNodeIndex))
-		{
-			// See if we can fit it in the output list
-			if (newActorCount < newActorsSize)
-			{
-				newActors[newActorCount++] = newActor;
-			}
-			else
-			{
-				overflow = true;
-			}
-		}
-
-		// Put link in new actor
-		graphNodeIndexLinks[graphNodeIndex] = newActor->m_firstGraphNodeIndex;
-		newActor->m_firstGraphNodeIndex = graphNodeIndex;
-		++newActor->m_graphNodeCount;
-		// Add to the actor's leaf chunk count
-		newActor->m_leafChunkCount += subtreeLeafChunkCounts[graphChunkIndices[graphNodeIndex]];
-	}
-
-	if (m_graphNodeCount > 0)
-	{
-		// There are still chunks in this actor.  See if we can fit this in the output list.
-		if (newActorCount < newActorsSize)
-		{
-			newActors[newActorCount++] = this;
-		}
-		else
-		{
-			overflow = true;
-		}
-	}
-	else
-	{
-		// No more chunks; release this actor.
-		release();
-	}
-
-	if (overflow)
-	{
-		NVBLAST_LOG_WARNING(logFn, "Nv::Blast::Actor::partitionMultipleGraphNodes: input newActors array could not hold all actors generated.");
-	}
-
-	return newActorCount;
-}
-
-
-uint32_t Actor::partitionSingleLowerSupportChunk(Actor** newActors, uint32_t newActorsSize, NvBlastLog logFn)
-{
-	NVBLAST_ASSERT(newActorsSize == 0 || newActors != nullptr);
-
-	// Ensure this is a single subsupport chunk, no partitioning
-	if (m_graphNodeCount > 1)
-	{
-		NVBLAST_LOG_WARNING(logFn, "Nv::Blast::Actor::partitionSingleLowerSupportChunk: actor is not a single lower-support chunk, and cannot be partitioned by this function.");
-		return 0;
-	}
-
-	FamilyHeader* header = getFamilyHeader();
-
-	// The conditional (visible vs. support chunk) is needed because we allow single-child chunk chains
-	// This makes it possible that an actor with a single support chunk will have a different visible chunk (ancestor of the support chunk)
-	const uint32_t chunkIndex = m_graphNodeCount == 0 ? m_firstVisibleChunkIndex : getGraph()->getChunkIndices()[m_firstGraphNodeIndex];
-	NVBLAST_ASSERT(isInvalidIndex(header->getVisibleChunkIndexLinks()[chunkIndex].m_adj[1]));
-
-	const NvBlastChunk& chunk = header->m_asset->getChunks()[chunkIndex];
-	uint32_t childCount = chunk.childIndexStop - chunk.firstChildIndex;
-
-	// Warn if we cannot fit all child chunks in the output list
-	if (childCount > newActorsSize)
-	{
-		NVBLAST_LOG_WARNING(logFn, "Nv::Blast::Actor::partitionSingleLowerSupportChunk: input newActors array will not hold all actors generated.");
-		childCount = newActorsSize;
-	}
-
-	// Return if no chunks will be created.
-	if (childCount == 0)
-	{
-		return 0;
-	}
-
-	// Activate a new actor for every child chunk
-	const Asset* asset = getAsset();
-	const NvBlastChunk* chunks = asset->getChunks();
-	const uint32_t firstChildIndex = chunks[chunkIndex].firstChildIndex;
-	for (uint32_t i = 0; i < childCount; ++i)
-	{
-		const uint32_t childIndex = firstChildIndex + i;
-		NVBLAST_ASSERT(childIndex >= asset->m_firstSubsupportChunkIndex);
-		const uint32_t actorIndex = asset->m_graph.m_nodeCount + (childIndex - asset->m_firstSubsupportChunkIndex);
-		NVBLAST_ASSERT(!header->isActorActive(actorIndex));
-		newActors[i] = header->borrowActor(actorIndex);
-		newActors[i]->m_firstVisibleChunkIndex = childIndex;
-		newActors[i]->m_visibleChunkCount = 1;
-		newActors[i]->m_leafChunkCount = asset->getSubtreeLeafChunkCounts()[childIndex];
-	}
-
-	// Release this actor
-	release();
-
-	return childCount;
-}
-
-
-void Actor::updateVisibleChunksFromGraphNodes()
-{
-	// Only apply this to upper-support chunk actors
-	if (m_graphNodeCount == 0)
-	{
-		return;
-	}
-
-	const Asset* asset = getAsset();
-
-	const uint32_t thisActorIndex = getIndex();
-
-	// Get various arrays
-	FamilyHeader* header = getFamilyHeader();
-	Actor* actors = header->getActors();
-	IndexDLink<uint32_t>* visibleChunkIndexLinks = header->getVisibleChunkIndexLinks();
-	uint32_t* chunkActorIndices = header->getChunkActorIndices();
-	const Nv::Blast::SupportGraph& graph = asset->m_graph;
-	const uint32_t* graphChunkIndices = graph.getChunkIndices();
-	const NvBlastChunk* chunks = asset->getChunks();
-	const uint32_t upperSupportChunkCount = asset->getUpperSupportChunkCount();
-
-	// Iterate over all graph nodes and update visible chunk list
-	const uint32_t* graphNodeIndexLinks = header->getGraphNodeIndexLinks();
-	for (uint32_t graphNodeIndex = m_firstGraphNodeIndex; !isInvalidIndex(graphNodeIndex); graphNodeIndex = graphNodeIndexLinks[graphNodeIndex])
-	{
-		updateVisibleChunksFromSupportChunk<Actor>(actors, visibleChunkIndexLinks, chunkActorIndices, thisActorIndex, graphChunkIndices[graphNodeIndex], chunks, upperSupportChunkCount);
-	}
-}
-
-} // namespace Blast
-} // namespace Nv
-
-
-// API implementation
-
-extern "C"
-{
-
-NvBlastActor* NvBlastFamilyCreateFirstActor(NvBlastFamily* family, const NvBlastActorDesc* desc, void* scratch, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(family != nullptr, logFn, "NvBlastFamilyCreateFirstActor: NULL family input.", return nullptr);
-	NVBLAST_CHECK(desc != nullptr, logFn, "NvBlastFamilyCreateFirstActor: NULL desc input.", return nullptr);
-	NVBLAST_CHECK(scratch != nullptr, logFn, "NvBlastFamilyCreateFirstActor: NULL scratch input.", return nullptr);
-
-	return Nv::Blast::Actor::create(family, desc, scratch, logFn);
-}
-
-
-size_t NvBlastFamilyGetRequiredScratchForCreateFirstActor(const NvBlastFamily* family, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(family != nullptr, logFn, "NvBlastFamilyGetRequiredScratchForCreateFirstActor: NULL family input.", return 0);
-	NVBLAST_CHECK(reinterpret_cast<const Nv::Blast::FamilyHeader*>(family)->m_asset != nullptr, 
-		logFn, "NvBlastFamilyGetRequiredScratchForCreateFirstActor: family has NULL asset.", return 0);
-
-	return Nv::Blast::Actor::createRequiredScratch(family);
-}
-
-
-bool NvBlastActorDeactivate(NvBlastActor* actor, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(actor != nullptr, logFn, "NvBlastActorDeactivate: NULL actor input.", return false);
-
-	Nv::Blast::Actor& a = *static_cast<Nv::Blast::Actor*>(actor);
-
-	if (!a.isActive())
-	{
-		NVBLAST_LOG_WARNING(logFn, "NvBlastActorDeactivate: inactive actor input.");
-	}
-
-	return a.release();
-}
-
-
-uint32_t NvBlastActorGetVisibleChunkCount(const NvBlastActor* actor, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(actor != nullptr, logFn, "NvBlastActorGetVisibleChunkCount: NULL actor input.", return 0);
-
-	const Nv::Blast::Actor& a = *static_cast<const Nv::Blast::Actor*>(actor);
-
-	if (!a.isActive())
-	{
-		NVBLAST_LOG_ERROR(logFn, "NvBlastActorGetVisibleChunkCount: inactive actor input.");
-		return 0;
-	}
-
-	return a.getVisibleChunkCount();
-}
-
-
-uint32_t NvBlastActorGetVisibleChunkIndices(uint32_t* visibleChunkIndices, uint32_t visibleChunkIndicesSize, const NvBlastActor* actor, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(visibleChunkIndices != nullptr, logFn, "NvBlastActorGetVisibleChunkIndices: NULL visibleChunkIndices pointer input.",	return 0);
-	NVBLAST_CHECK(actor != nullptr, logFn, "NvBlastActorGetVisibleChunkIndices: NULL actor pointer input.", return 0);
-
-	const Nv::Blast::Actor& a = *static_cast<const Nv::Blast::Actor*>(actor);
-
-	if (!a.isActive())
-	{
-		NVBLAST_LOG_ERROR(logFn, "NvBlastActorGetVisibleChunkIndices: inactive actor pointer input.");
-		return 0;
-	}
-
-	// Iterate through visible chunk list and write to supplied array
-	uint32_t indexCount = 0;
-	for (Nv::Blast::Actor::VisibleChunkIt i = a; indexCount < visibleChunkIndicesSize && (bool)i; ++i)
-	{
-		visibleChunkIndices[indexCount++] = (uint32_t)i;
-	}
-
-	return indexCount;
-}
-
-
-uint32_t NvBlastActorGetGraphNodeCount(const NvBlastActor* actor, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(actor != nullptr, logFn, "NvBlastActorGetGraphNodeCount: NULL actor pointer input.", return 0);
-
-	const Nv::Blast::Actor& a = *static_cast<const Nv::Blast::Actor*>(actor);
-
-	if (!a.isActive())
-	{
-		NVBLAST_LOG_ERROR(logFn, "NvBlastActorGetGraphNodeCount: inactive actor pointer input.");
-		return 0;
-	}
-
-	return a.getGraphNodeCount();
-}
-
-
-uint32_t NvBlastActorGetGraphNodeIndices(uint32_t* graphNodeIndices, uint32_t graphNodeIndicesSize, const NvBlastActor* actor, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(graphNodeIndices != nullptr, logFn, "NvBlastActorGetGraphNodeIndices: NULL graphNodeIndices pointer input.", return 0);
-	NVBLAST_CHECK(actor != nullptr, logFn, "NvBlastActorGetGraphNodeIndices: NULL actor pointer input.", return 0);
-
-	const Nv::Blast::Actor& a = *static_cast<const Nv::Blast::Actor*>(actor);
-
-	if (!a.isActive())
-	{
-		NVBLAST_LOG_ERROR(logFn, "NvBlastActorGetGraphNodeIndices: inactive actor pointer input.");
-		return 0;
-	}
-
-	// Iterate through graph node list and write to supplied array
-	uint32_t indexCount = 0;
-	for (Nv::Blast::Actor::GraphNodeIt i = a; indexCount < graphNodeIndicesSize && (bool)i; ++i)
-	{
-		graphNodeIndices[indexCount++] = (uint32_t)i;
-	}
-
-	return indexCount;
-}
-
-
-const float* NvBlastActorGetBondHealths(const NvBlastActor* actor, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(actor != nullptr, logFn, "NvBlastActorGetBondHealths: NULL actor pointer input.", return nullptr);
-
-	const Nv::Blast::Actor& a = *static_cast<const Nv::Blast::Actor*>(actor);
-
-	if (!a.isActive())
-	{
-		NVBLAST_LOG_ERROR(logFn, "NvBlastActorGetBondHealths: inactive actor pointer input.");
-		return nullptr;
-	}
-
-	return a.getFamilyHeader()->getBondHealths();
-}
-
-
-NvBlastFamily* NvBlastActorGetFamily(const NvBlastActor* actor, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(actor != nullptr, logFn, "NvBlastActorGetFamily: NULL actor pointer input.", return nullptr);
-
-	const Nv::Blast::Actor& a = *static_cast<const Nv::Blast::Actor*>(actor);
-
-	if (!a.isActive())
-	{
-		NVBLAST_LOG_ERROR(logFn, "NvBlastActorGetFamily: inactive actor pointer input.");
-		return nullptr;
-	}
-
-	return reinterpret_cast<NvBlastFamily*>(a.getFamilyHeader());
-}
-
-
-uint32_t NvBlastActorGetIndex(const NvBlastActor* actor, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(actor != nullptr, logFn, "NvBlastActorGetIndex: NULL actor pointer input.", return Nv::Blast::invalidIndex<uint32_t>());
-
-	const Nv::Blast::Actor& a = *static_cast<const Nv::Blast::Actor*>(actor);
-
-	if (!a.isActive())
-	{
-		NVBLAST_LOG_ERROR(logFn, "NvBlastActorGetIndex: actor is not active.");
-		return Nv::Blast::invalidIndex<uint32_t>();
-	}
-
-	return a.getIndex();
-}
-
-
-void NvBlastActorGenerateFracture
-(
-	NvBlastFractureBuffers* commandBuffers,
-	const NvBlastActor* actor,
-	const NvBlastDamageProgram program,
-	const NvBlastProgramParams* programParams,
-	NvBlastLog logFn,
-	NvBlastTimers* timers
-)
-{
-	NVBLAST_CHECK(commandBuffers != nullptr, logFn, "NvBlastActorGenerateFracture: NULL commandBuffers pointer input.", return);
-	NVBLAST_CHECK(actor != nullptr, logFn, "NvBlastActorGenerateFracture: NULL actor pointer input.", return);
-
-	const Nv::Blast::Actor& a = *static_cast<const Nv::Blast::Actor*>(actor);
-
-	if (!a.isActive())
-	{
-		NVBLAST_LOG_ERROR(logFn, "NvBlastActorGenerateFracture: actor is not active.");
-		commandBuffers->bondFractureCount = 0;
-		commandBuffers->chunkFractureCount = 0;
-		return;
-	}
-
-	a.generateFracture(commandBuffers, program, programParams, logFn, timers);
-}
-
-
-void NvBlastActorApplyFracture
-(
-	NvBlastFractureBuffers* eventBuffers,
-	NvBlastActor* actor,
-	const NvBlastFractureBuffers* commands,
-	NvBlastLog logFn,
-	NvBlastTimers* timers
-)
-{
-	NVBLAST_CHECK(actor != nullptr, logFn, "NvBlastActorApplyFracture: NULL actor pointer input.", return);
-	NVBLAST_CHECK(commands != nullptr, logFn, "NvBlastActorApplyFracture: NULL commands pointer input.", return);
-	NVBLAST_CHECK(Nv::Blast::isValid(commands), logFn, "NvBlastActorApplyFracture: commands memory is NULL but size is > 0.", return);
-
-	Nv::Blast::Actor& a = *static_cast<Nv::Blast::Actor*>(actor);
-
-	if (!a.isActive())
-	{
-		NVBLAST_LOG_ERROR(logFn, "NvBlastActorApplyFracture: actor is not active.");
-		if (eventBuffers != nullptr)
-		{
-			eventBuffers->bondFractureCount = 0;
-			eventBuffers->chunkFractureCount = 0;
-		}
-		return;
-	}
-
-	a.applyFracture(eventBuffers, commands, logFn, timers);
-}
-
-
-size_t NvBlastActorGetRequiredScratchForSplit(const NvBlastActor* actor, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(actor != nullptr, logFn, "NvBlastActorGetRequiredScratchForSplit: NULL actor input.", return 0);
-
-	const Nv::Blast::Actor& a = *static_cast<const Nv::Blast::Actor*>(actor);
-
-	if (!a.isActive())
-	{
-		NVBLAST_LOG_ERROR(logFn, "NvBlastActorGetRequiredScratchForSplit: actor is not active.");
-		return 0;
-	}
-
-	return a.splitRequiredScratch();
-}
-
-
-uint32_t NvBlastActorGetMaxActorCountForSplit(const NvBlastActor* actor, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(actor != nullptr, logFn, "NvBlastActorGetMaxActorCountForSplit: NULL actor input.", return 0);
-
-	const Nv::Blast::Actor& a = *static_cast<const Nv::Blast::Actor*>(actor);
-
-	if (!a.isActive())
-	{
-		NVBLAST_LOG_ERROR(logFn, "NvBlastActorGetMaxActorCountForSplit: actor is not active.");
-		return 0;
-	}
-
-	return a.getLeafChunkCount() + 1; // GWD-167 workaround (+1)
-}
-
-
-uint32_t NvBlastActorSplit
-(
-	NvBlastActorSplitEvent* result,
-	NvBlastActor* actor,
-	uint32_t newActorsMaxCount,
-	void* scratch,
-	NvBlastLog logFn,
-	NvBlastTimers* timers
-)
-{
-	NVBLAST_CHECK(result != nullptr, logFn, "NvBlastActorSplit: NULL result pointer input.", return 0);
-	NVBLAST_CHECK(newActorsMaxCount > 0 && result->newActors != nullptr, logFn, "NvBlastActorSplit: no space for results provided.", return 0);
-	NVBLAST_CHECK(actor != nullptr, logFn, "NvBlastActorSplit: NULL actor pointer input.", return 0);
-	NVBLAST_CHECK(scratch != nullptr, logFn, "NvBlastActorSplit: NULL scratch pointer input.", return 0);
-
-	Nv::Blast::Actor& a = *static_cast<Nv::Blast::Actor*>(actor);
-
-	if (!a.isActive())
-	{
-		NVBLAST_LOG_ERROR(logFn, "NvBlastActorGetIndex: actor is not active.");
-		return 0;
-	}
-
-	return a.split(result, newActorsMaxCount, scratch, logFn, timers);
-}
-
-
-bool NvBlastActorCanFracture(const NvBlastActor* actor, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(actor != nullptr, logFn, "NvBlastActorCanFracture: NULL actor input.", return false);
-
-	const Nv::Blast::Actor& a = *static_cast<const Nv::Blast::Actor*>(actor);
-
-	if (!a.isActive())
-	{
-		NVBLAST_LOG_ERROR(logFn, "NvBlastActorCanFracture: actor is not active.");
-		return false;
-	}
-
-	bool canFracture = true;
-
-	uint32_t graphNodeCount = a.getGraphNodeCount();
-	if (graphNodeCount < 2)
-	{
-		uint32_t chunkHealthIndex = graphNodeCount == 0 ?
-			a.getFirstVisibleChunkIndex() - a.getFirstSubsupportChunkIndex() + a.getGraph()->m_nodeCount :
-			a.getFirstGraphNodeIndex();
-		canFracture = (a.getLowerSupportChunkHealths()[chunkHealthIndex] > 0.0f);
-	}
-
-	return canFracture;
-}
-
-
-} // extern "C"
-
-
-// deprecated API, still used in tests
-uint32_t NvBlastActorClosestChunk(const float point[4], const NvBlastActor* actor, NvBlastLog logFn)
-{
-	const Nv::Blast::Actor& a = *static_cast<const Nv::Blast::Actor*>(actor);
-
-	if (a.isSubSupportChunk())
-	{
-		NVBLAST_LOG_WARNING(logFn, "NvBlastActorClosestChunk: not a graph actor.");
-		return Nv::Blast::invalidIndex<uint32_t>();
-	}
-
-	uint32_t closestNode = Nv::Blast::findNodeByPositionLinked(
-		point,
-		a.getFirstGraphNodeIndex(),
-		a.getFamilyHeader()->getGraphNodeIndexLinks(),
-		a.getAsset()->m_graph.getAdjacencyPartition(),
-		a.getAsset()->m_graph.getAdjacentNodeIndices(),
-		a.getAsset()->m_graph.getAdjacentBondIndices(),
-		a.getAsset()->getBonds(),
-		a.getFamilyHeader()->getBondHealths()
-		);
-
-	return a.getAsset()->m_graph.getChunkIndices()[closestNode];
-}
diff --git a/NvBlast/sdk/lowlevel/source/NvBlastActor.h b/NvBlast/sdk/lowlevel/source/NvBlastActor.h
deleted file mode 100644
index 42879e7..0000000
--- a/NvBlast/sdk/lowlevel/source/NvBlastActor.h
+++ /dev/null
@@ -1,732 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTACTOR_H
-#define NVBLASTACTOR_H
-
-
-#include "NvBlastAsset.h"
-#include "NvBlastDLink.h"
-#include "NvBlastIteratorBase.h"
-#include "NvBlastSupportGraph.h"
-
-#include <cstring>
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-// Forward declarations
-class FamilyGraph;
-struct FamilyHeader;
-
-/**
-Internal implementation of solver actor.
-
-These objects are stored within the family in a single array.  A pointer to a Actor class will be given
-to the user through the NvBlastActor opaque type.
-*/
-class Actor : public NvBlastActor
-{
-	friend struct FamilyHeader;
-
-	friend void updateVisibleChunksFromSupportChunk<>(Actor*, IndexDLink<uint32_t>*, uint32_t*, uint32_t, uint32_t, const NvBlastChunk*, uint32_t);
-
-public:
-	Actor() : m_familyOffset(0), m_firstVisibleChunkIndex(UINT32_MAX), m_visibleChunkCount(0), m_firstGraphNodeIndex(UINT32_MAX), m_graphNodeCount(0), m_leafChunkCount(0) {}
-
-	//////// Accessors ////////
-
-	/**
-	Find the family (see FamilyHeader) that this actor belongs to.
-
-	\return	a pointer to the FamilyHeader for this actor.
-	*/
-	FamilyHeader*		getFamilyHeader() const;
-
-	/**
-	Utility to get the asset this actor is associated with, through its family.
-
-	\return	the asset associated with this actor.
-	*/
-	const Asset*		getAsset() const;
-
-	/**
-	Since this object is not deleted (unless the family is deleted), we use m_familyOffset
-	to determine if the actor is valid, or "active."  When no actors in an instance return isActive(),
-	it should be safe to delete the family.
-
-	\return true iff this actor is valid for use (active).
-	*/
-	bool				isActive() const;
-
-	/**
-	Whether or not this actor represents a subsupport chunk.  If the actor contains a subsupport chunk, then it can have only that chunk.
-
-	\return true iff this actor contains a chunk which is a descendant of a support chunk.
-	*/
-	bool				isSubSupportChunk() const;
-
-	/**
-	Whether or not this actor represents a single support chunk.  If the actor contains a single support chunk, it can have no other
-	chunks associated with it.
-
-	\return true iff this actor contains exactly one support chunk.
-	*/
-	bool				isSingleSupportChunk() const;
-
-	/**
-	Utility to calculate actor index.
-
-	\return the index of this actor in the FamilyHeader's getActors() array.
-	*/
-	uint32_t			getIndex() const;
-
-	/**
-	The number of visible chunks.  This is calculated from updateVisibleChunksFromGraphNodes().
-	See also getFirstVisibleChunkIndex.
-
-	\return the number of chunks in the actor's visible chunk index list.
-	*/
-	uint32_t			getVisibleChunkCount() const;
-
-	/**
-	Access to visible chunk linked list for this actor.  The index returned is that of a link in the FamilyHeader's getVisibleChunkIndexLinks().
-
-	\return the index of the head of the visible chunk linked list.
-	*/
-	uint32_t			getFirstVisibleChunkIndex() const;
-
-	/**
-	The number of graph nodes, corresponding to support chunks, for this actor.
-	See also getFirstGraphNodeIndex.
-
-	\return the number of graph nodes in the actor's graph node index list.
-	*/
-	uint32_t			getGraphNodeCount() const;
-
-	/**
-	The number of leaf chunks for this actor.
-
-	\return number of leaf chunks for this actor.
-	*/
-	uint32_t			getLeafChunkCount() const;
-
-	/**
-	Access to graph node linked list for this actor.  The index returned is that of a link in the FamilyHeader's getGraphNodeIndexLinks().
-
-	\return the index of the head of the graph node linked list.
-	*/
-	uint32_t			getFirstGraphNodeIndex() const;
-
-	/**
-	Access to the index of the first subsupport chunk.
-
-	\return the index of the first subsupport chunk.
-	*/
-	uint32_t			getFirstSubsupportChunkIndex() const;
-
-	/**
-	Access to the support graph.
-
-	\return the support graph associated with this actor.
-	*/
-	const SupportGraph*	getGraph() const;
-
-	/**
-	Access the instance graph for islands searching.
-
-	Return the dynamic data generated for the support graph.  (See FamilyGraph.)
-	This is used to store current connectivity information based upon bond and chunk healths, as well as cached intermediate data for faster incremental updates.
-	*/
-	FamilyGraph*		getFamilyGraph() const;
-
-	/**
-	Access to the chunks, of type NvBlastChunk.
-
-	\return an array of size m_chunkCount.
-	*/
-	NvBlastChunk*		getChunks() const;
-
-	/**
-	Access to the bonds, of type NvBlastBond.
-
-	\return an array of size m_bondCount.
-	*/
-	NvBlastBond*		getBonds() const;
-
-	/**
-	Access to the health for each support chunk and subsupport chunk, of type float.
-
-	Use getAsset()->getContiguousLowerSupportIndex() to map lower-support chunk indices into the range of indices valid for this array.
-
-	\return a float array of chunk healths.
-	*/
-	float*				getLowerSupportChunkHealths() const;
-
-	/**
-	Access to the start of the subsupport chunk health array.
-
-	\return the array of health values associated with all descendants of support chunks.
-	*/
-	float*				getSubsupportChunkHealths() const;
-
-	/**
-	Bond health for the interfaces between two chunks, of type float.  Since the bond is shared by two chunks, the same bond health is used for chunk[i] -> chunk[j] as for chunk[j] -> chunk[i].
-
-	\return the array of healths associated with all bonds in the support graph.
-	*/
-	float*				getBondHealths() const;
-
-	/**
-	Graph node index links, of type uint32_t.  The successor to index[i] is m_graphNodeIndexLinksOffset[i].  A value of invalidIndex<uint32_t>() indicates no successor.
-
-	getGraphNodeIndexLinks returns an array of size m_asset->m_graphNodeCount.
-	*/
-	const uint32_t*		getGraphNodeIndexLinks() const;
-
-
-	//////// Iterators ////////
-
-	/**
-	Visible chunk iterator.  Usage:
-
-	Given a solver actor a,
-
-	for (Actor::VisibleChunkIt i = a; (bool)i; ++i)
-	{
-		uint32_t visibleChunkIndex = (uint32_t)i;
-
-		// visibleChunkIndex references the asset index list
-	}
-
-	*/
-	class VisibleChunkIt : public DListIt<uint32_t>
-	{
-	public:
-		/** Constructed from an actor. */
-		VisibleChunkIt(const Actor& actor);
-	};
-
-	/**
-	Graph node iterator.  Usage:
-
-	Given a solver actor a,
-
-	for (Actor::GraphNodeIt i = a; (bool)i; ++i)
-	{
-	uint32_t graphNodeIndex = (uint32_t)i;
-
-	// graphNodeIndex references the asset's graph node index list
-	}
-
-	*/
-	class GraphNodeIt : public LListIt<uint32_t>
-	{
-	public:
-		/** Constructed from an actor. */
-		GraphNodeIt(const Actor& actor);
-	};
-
-
-	//////// Operations ////////
-
-	/**
-	Create an actor from a descriptor (creates a family).  This actor will represent an unfractured instance of the asset.
-	The asset must be in a valid state, for example each chunk hierarchy in it must contain at least one support chunk (a single
-	support chunk in a hierarchy corresponds to the root chunk).  This will always be the case for assets created by NvBlastCreateAsset.
-
-	\param[in] family	Family in which to create a new actor.  The family must be valid and have no other actors in it.  (See createFamily.)
-	\param[in] desc		Actor initialization data, must be a valid pointer.
-	\param[in] scratch	User-supplied scratch memory of size createRequiredScratch(desc) bytes.
-	\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-	\return the new actor if the input is valid (by the conditions described above), NULL otherwise.
-	*/
-	static Actor*		create(NvBlastFamily* family, const NvBlastActorDesc* desc, void* scratch, NvBlastLog logFn);
-
-	/**
-	Returns the size of the scratch space (in bytes) required to be passed into the create function, based upon
-	the family that will be passed to the create function.
-
-	\param[in] family	The family being instanced.
-
-	\return the number of bytes required.
-	*/
-	static size_t		createRequiredScratch(const NvBlastFamily* family);
-
-	/**
-	Deserialize a single Actor from a buffer.  An actor family must given, into which
-	the actor will be inserted if it is compatible.  That is, it must not share any chunks or internal
-	IDs with the actors already present in the block.
-
-	\param[in] family	Family in which to deserialize the actor.
-	\param[in] buffer	Buffer containing the serialized actor data.
-	\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-	\return the deserialized actor if successful, NULL otherwise.
-	*/
-	static Actor*		deserialize(NvBlastFamily* family, const void* buffer, NvBlastLog logFn);
-
-	/**
-	Serialize actor into single-actor buffer.
-
-	\param[out] buffer		User-supplied buffer, must be at least of size given by NvBlastActorGetSerializationSize(actor).
-	\param[in] bufferSize	The size of the user-supplied buffer.  The buffer size must be less than 4GB.  If NvBlastActorGetSerializationSize(actor) >= 4GB, this actor cannot be serialized with this method.
-	\param[in] logFn		User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-	\return the number of bytes written to the buffer, or 0 if there is an error (such as an under-sized buffer).
-	*/
-	uint32_t			serialize(void* buffer, uint32_t bufferSize, NvBlastLog logFn) const;
-
-	/**
-	Calculate the space required to serialize this actor.
-
-	\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-	\return the required buffer size in bytes.
-	*/
-	uint32_t			serializationRequiredStorage(NvBlastLog logFn) const;
-
-	/**
-	Release this actor's association with a family, if any.  This actor should be considered deleted
-	after this function is called.
-
-	\return true if release was successful (actor was active).
-	*/
-	bool				release();
-
-
-	//////// Damage and fracturing methods ////////
-
-	/**
-	Damage bond between two chunks by health amount (instance graph also will be notified in case bond is broken after).
-	*/
-	uint32_t			damageBond(uint32_t nodeIndex0, uint32_t nodeIndex1, float healthDamage);
-
-	/**
-	TODO: document
-	*/
-	void				damageBond(uint32_t nodeIndex0, uint32_t nodeIndex1, uint32_t bondIndex, float healthDamage);
-
-	/**
-	TODO: document
-	*/
-	uint32_t			damageBond(const NvBlastBondFractureData& cmd);
-
-	/**
-	See NvBlastActorGenerateFracture
-	*/
-	void				generateFracture(NvBlastFractureBuffers* commandBuffers, const NvBlastDamageProgram& program, const NvBlastProgramParams* programParams, NvBlastLog logFn, NvBlastTimers* timers) const;
-
-	/**
-	Hierarchically distribute damage to child chunks.
-
-	\param chunkIndex		asset chunk index to hierarchically damage
-	\param suboffset		index of the first sub-support health
-	\param healthDamage		damage strength to apply
-	\param chunkHealths		instance chunk healths
-	\param chunks			asset chunk collection
-	*/
-	void				fractureSubSupportNoEvents(uint32_t chunkIndex, uint32_t suboffset, float healthDamage, float* chunkHealths, const NvBlastChunk* chunks);
-
-	/**
-	Hierarchically distribute damage to child chunks, recording a fracture event for each health damage applied.
-
-	If outBuffer is too small, events are dropped but the chunks are still damaged.
-
-	\param chunkIndex		asset chunk index to hierarchically damage
-	\param suboffset		index of the first sub-support health
-	\param healthDamage		damage strength to apply
-	\param chunkHealths		instance chunk healths
-	\param chunks			asset chunk collection
-	\param outBuffer		target buffer for fracture events
-	\param currentIndex		current position in outBuffer - returns the number of damaged chunks
-	\param maxCount			capacity of outBuffer
-	*/
-	void				fractureSubSupport(uint32_t chunkIndex, uint32_t suboffset, float healthDamage, float* chunkHealths, const NvBlastChunk* chunks, NvBlastChunkFractureData* outBuffer, uint32_t* currentIndex, const uint32_t maxCount);
-
-	/**
-	Apply chunk fracture commands hierarchically.
-
-	\param chunkFractureCount	number of chunk fracture commands to apply
-	\param chunkFractures		array of chunk fracture commands
-	*/
-	void				fractureNoEvents(uint32_t chunkFractureCount, const NvBlastChunkFractureData* chunkFractures);
-
-	/**
-	Apply chunk fracture commands hierarchically, recording a fracture event for each health damage applied.
-
-	If events array is too small, events are dropped but the chunks are still damaged.
-
-	\param chunkFractureCount	number of chunk fracture commands to apply
-	\param commands				array of chunk fracture commands
-	\param events				target buffer for fracture events
-	\param eventsSize			number of available entries in 'events'
-	\param count				returns the number of damaged chunks
-	*/
-	void				fractureWithEvents(uint32_t chunkFractureCount, const NvBlastChunkFractureData* commands, NvBlastChunkFractureData* events, uint32_t eventsSize, uint32_t* count);
-
-	/**
-	Apply chunk fracture commands hierarchically, recording a fracture event for each health damage applied.
-
-	In-Place version: fracture commands are replaced by fracture events.
-
-	If inoutbuffer array is too small, events are dropped but the chunks are still damaged.
-
-	\param chunkFractureCount	number of chunk fracture commands to apply
-	\param inoutbuffer			array of chunk fracture commands to be replaced by events
-	\param eventsSize			number of available entries in inoutbuffer
-	\param count				returns the number of damaged chunks
-	*/
-	void				fractureInPlaceEvents(uint32_t chunkFractureCount, NvBlastChunkFractureData* inoutbuffer, uint32_t eventsSize, uint32_t* count);
-
-	/**
-	See NvBlastActorApplyFracture
-	*/
-	void				applyFracture(NvBlastFractureBuffers* eventBuffers, const NvBlastFractureBuffers* commands, NvBlastLog logFn, NvBlastTimers* timers);
-
-	/**
-	The scratch space required to call the findIslands function, or the split function, in bytes.
-	
-	\return the number of bytes required.
-	*/
-	size_t				splitRequiredScratch() const;
-
-	/**
-	See NvBlastActorSplit
-	*/
-	uint32_t			split(NvBlastActorSplitEvent* result, uint32_t newActorsMaxCount, void* scratch, NvBlastLog logFn, NvBlastTimers* timers);
-
-	/**
-	Perform islands search.  Bonds which are broken when their health values drop to zero (or below) may lead
-	to new islands of chunks which need to be split into new actors.  This function labels all nodes in the instance
-	graph (see FamilyGraph) with a unique index per island that may be used as actor indices for new islands.
-
-	\param[in] scratch	User-supplied scratch memory of size splitRequiredScratch().
-
-	\return	the number of new islands found.
-	*/
-	uint32_t			findIslands(void* scratch);
-
-	/**
-	Partition this actor into smaller pieces.
-
-	If this actor represents a single support or subsupport chunk, then after this operation
-	this actor will released if child chunks are created (see Return value), and its pointer no longer valid for use (unless it appears in the newActors list).
-
-	This function will not split a leaf chunk actor.  In that case, the actor is not destroyed and this function returns 0.
-
-	\param[in] newActors		user-supplied array of actor pointers to hold the actors generated from this partitioning.
-								This array must be of size equal to the number of leaf chunks in the asset, to guarantee
-								that all actors are reported.  (See AssetDataHeader::m_leafChunkCount.)
-	\param[in] newActorsSize	The size of the user-supplied newActors array.
-	\param[in] logFn			User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-	\return	the number of new actors created.  If greater than newActorsSize, some actors are not reported in the newActors array.
-	*/
-	uint32_t			partition(Actor** newActors, uint32_t newActorsSize, NvBlastLog logFn);
-
-	/**
-	Recalculate the visible chunk list for this actor based upon it graph node list (does not modify subsupport chunk actors)
-	*/
-	void				updateVisibleChunksFromGraphNodes();
-
-	/**
-	Partition this actor into smaller pieces if it is a single lower-support chunk actor.  Use this function on single support or sub-support chunks.
-
-	After this operation, if successful (child chunks created, see Return value), this actor will released, and its pointer no longer valid for use.
-
-	This function will not split a leaf chunk actor.  In that case, the actor is not destroyed and this function returns 0.
-
-	\param[in] newActors		User-supplied array of actor pointers to hold the actors generated from this partitioning.  Note: this actor will be released.
-								This array must be of size equal to the lower-support chunk's child count, to guarantee that all actors are reported.
-	\param[in] newActorsSize	The size of the user-supplied newActors array.
-	\param[in] logFn			User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-	\return the number of new actors created.
-	*/
-	uint32_t			partitionSingleLowerSupportChunk(Actor** newActors, uint32_t newActorsSize, NvBlastLog logFn);
-
-	/**
-	Partition this actor into smaller pieces.  Use this function if this actor contains more than one support chunk. 
-
-	After this operation, if successful, this actor will released, and its pointer no longer valid for use (unless it appears in the newActors list).
-
-	\param[in] newActors		User-supplied array of actor pointers to hold the actors generated from this partitioning.  Note: this actor will not be released,
-								but will hold a subset of the graph nodes that it had before the function was called.
-								This array must be of size equal to the number of graph nodes in the asset, to guarantee
-								that all actors are reported.
-	\param[in] newActorsSize	The size of the user-supplied newActors array.
-	\param[in] logFn			User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-	\return the number of new actors created.
-	*/
-	uint32_t			partitionMultipleGraphNodes(Actor** newActors, uint32_t newActorsSize, NvBlastLog logFn);
-
-private:
-
-	//////// Data ////////
-
-	/**
-	Offset to block of memory which holds the data associated with all actors in this actor's lineage.
-	This offset is positive.  The block address is this object's pointer _minus_ the m_familyOffset.
-	This value is initialized to 0, which denotes an invalid actor.  Actors should be obtained through
-	the FamilyHeader::borrowActor API, which will create a valid offset, and
-	the FamilyHeader::returnActor API, which will zero the offset.
-	*/
-	uint32_t	m_familyOffset;
-
-	/**
-	The index of the head of a doubly-linked list of visible chunk indices.  If m_firstVisibleChunkIndex == invalidIndex<uint32_t>(),
-	then there are no visible chunks.
-	*/
-	uint32_t	m_firstVisibleChunkIndex;
-
-	/**
-	The number of elements in the visible chunk list.
-	*/
-	uint32_t	m_visibleChunkCount;
-
-	/**
-	The index of the head of a singly-linked list of graph node indices.  If m_firstGraphNodeIndex == invalidIndex<uint32_t>(),
-	then there are no graph nodes.
-	*/
-	uint32_t	m_firstGraphNodeIndex;
-
-	/**
-	The number of elements in the graph node list.
-	*/
-	uint32_t	m_graphNodeCount;
-
-	/**
-	The number of leaf chunks in this actor.
-	*/
-	uint32_t	m_leafChunkCount;
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-#include "NvBlastFamily.h"
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-//////// Actor inline methods ////////
-
-NV_INLINE FamilyHeader* Actor::getFamilyHeader() const
-{
-	NVBLAST_ASSERT(isActive());
-	return (FamilyHeader*)((uintptr_t)this - (uintptr_t)m_familyOffset);
-}
-
-
-NV_INLINE const Asset* Actor::getAsset() const
-{
-	return getFamilyHeader()->m_asset;
-}
-
-
-NV_INLINE bool Actor::isActive() const
-{
-	return m_familyOffset != 0;
-}
-
-
-NV_INLINE bool Actor::isSubSupportChunk() const
-{
-	return m_graphNodeCount == 0;
-}
-
-
-NV_INLINE bool Actor::isSingleSupportChunk() const
-{
-	return m_graphNodeCount == 1;
-}
-
-
-NV_INLINE uint32_t Actor::getIndex() const
-{
-	NVBLAST_ASSERT(isActive());
-	const FamilyHeader* header = getFamilyHeader();
-	NVBLAST_ASSERT(header != nullptr);
-	const size_t index = this - header->getActors();
-	NVBLAST_ASSERT(index <= UINT32_MAX);
-	return (uint32_t)index;
-}
-
-
-NV_INLINE uint32_t Actor::getVisibleChunkCount() const
-{
-	return m_visibleChunkCount;
-}
-
-
-NV_INLINE uint32_t Actor::getFirstVisibleChunkIndex() const
-{
-	return m_firstVisibleChunkIndex;
-}
-
-
-NV_INLINE uint32_t Actor::getGraphNodeCount() const
-{
-	return m_graphNodeCount;
-}
-
-
-NV_INLINE uint32_t Actor::getLeafChunkCount() const
-{
-	return m_leafChunkCount;
-}
-
-
-NV_INLINE uint32_t Actor::getFirstGraphNodeIndex() const
-{
-	return m_firstGraphNodeIndex;
-}
-
-NV_INLINE uint32_t Actor::getFirstSubsupportChunkIndex() const
-{
-	return getAsset()->m_firstSubsupportChunkIndex;
-}
-
-NV_INLINE const SupportGraph* Actor::getGraph() const
-{
-	return &getAsset()->m_graph;
-}
-
-NV_INLINE FamilyGraph* Actor::getFamilyGraph() const
-{
-	return getFamilyHeader()->getFamilyGraph();
-}
-
-NV_INLINE NvBlastChunk* Actor::getChunks() const
-{
-	return getAsset()->getChunks();
-}
-
-NV_INLINE NvBlastBond* Actor::getBonds() const
-{
-	return getAsset()->getBonds();
-}
-
-NV_INLINE float* Actor::getLowerSupportChunkHealths() const
-{
-	return getFamilyHeader()->getLowerSupportChunkHealths();
-}
-
-NV_INLINE float*	Actor::getSubsupportChunkHealths() const
-{
-	return getFamilyHeader()->getSubsupportChunkHealths();
-}
-
-NV_INLINE float* Actor::getBondHealths() const
-{
-	return getFamilyHeader()->getBondHealths();
-}
-
-NV_INLINE const uint32_t* Actor::getGraphNodeIndexLinks() const
-{
-	return getFamilyHeader()->getGraphNodeIndexLinks();
-}
-
-
-NV_INLINE bool Actor::release()
-{
-	// Do nothing if this actor is not currently active.
-	if (!isActive())
-	{
-		return false;
-	}
-
-	FamilyHeader* header = getFamilyHeader();
-
-	// Clear the graph node list
-	uint32_t* graphNodeIndexLinks = getFamilyHeader()->getGraphNodeIndexLinks();
-	while (!isInvalidIndex(m_firstGraphNodeIndex))
-	{
-		const uint32_t graphNodeIndex = m_firstGraphNodeIndex;
-		m_firstGraphNodeIndex = graphNodeIndexLinks[m_firstGraphNodeIndex];
-		graphNodeIndexLinks[graphNodeIndex] = invalidIndex<uint32_t>();
-		--m_graphNodeCount;
-	}
-	NVBLAST_ASSERT(m_graphNodeCount == 0);
-
-	const Asset* asset = getAsset();
-
-	// Clear the visible chunk list
-	IndexDLink<uint32_t>* visibleChunkIndexLinks = header->getVisibleChunkIndexLinks();
-	uint32_t* chunkActorIndices = header->getChunkActorIndices();
-	while (!isInvalidIndex(m_firstVisibleChunkIndex))
-	{
-		// Descendants of the visible actor may be accessed again if the actor is deserialized.  Clear subtree.
-		for (Asset::DepthFirstIt i(*asset, m_firstVisibleChunkIndex, true); (bool)i; ++i)
-		{
-			chunkActorIndices[(uint32_t)i] = invalidIndex<uint32_t>();
-		}
-		IndexDList<uint32_t>().removeListHead(m_firstVisibleChunkIndex, visibleChunkIndexLinks);
-		--m_visibleChunkCount;
-	}
-	NVBLAST_ASSERT(m_visibleChunkCount == 0);
-
-	// Clear the leaf chunk count
-	m_leafChunkCount = 0;
-
-	// This invalidates the actor and decrements the reference count
-	header->returnActor(*this);
-
-	return true;
-}
-
-
-NV_INLINE uint32_t Actor::partition(Actor** newActors, uint32_t newActorsSize, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(newActorsSize == 0 || newActors != nullptr, logFn, "Nv::Blast::Actor::partition: NULL newActors pointer array input with non-zero newActorCount.", return 0);
-
-	// Call one of two partition functions depending on the actor's support status
-	return m_graphNodeCount <= 1 ?
-		partitionSingleLowerSupportChunk(newActors, newActorsSize, logFn) :	// This actor will partition into subsupport chunks
-		partitionMultipleGraphNodes(newActors, newActorsSize, logFn);		// This actor will partition into support chunks
-}
-
-
-//////// Actor::VisibleChunkIt inline methods ////////
-
-NV_INLINE Actor::VisibleChunkIt::VisibleChunkIt(const Actor& actor) : DListIt<uint32_t>(actor.m_firstVisibleChunkIndex, actor.getFamilyHeader()->getVisibleChunkIndexLinks())
-{
-}
-
-
-//////// Actor::GraphNodeIt inline methods ////////
-
-NV_INLINE Actor::GraphNodeIt::GraphNodeIt(const Actor& actor) : LListIt<uint32_t>(actor.m_firstGraphNodeIndex, actor.getFamilyHeader()->getGraphNodeIndexLinks())
-{
-}
-
-} // namespace Blast
-} // namespace Nv
-
-
-/**
-Returns the closest chunk asset index for a supported actor.
-Helper functions still used in tests. 
-Has become obsolete with introduction of chunkMap and its inverse.
-*/
-uint32_t NvBlastActorClosestChunk(const float point[4], const NvBlastActor* actor, NvBlastLog logFn);
-
-
-#endif // ifndef NVBLASTACTOR_H
diff --git a/NvBlast/sdk/lowlevel/source/NvBlastActorSerializationBlock.cpp b/NvBlast/sdk/lowlevel/source/NvBlastActorSerializationBlock.cpp
deleted file mode 100644
index e496a69..0000000
--- a/NvBlast/sdk/lowlevel/source/NvBlastActorSerializationBlock.cpp
+++ /dev/null
@@ -1,575 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-
-#include "NvBlastActor.h"
-#include "NvBlastActorSerializationBlock.h"
-#include "NvBlastFamilyGraph.h"
-
-#include <algorithm>
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-//////// Actor static methods for serialization ////////
-
-Actor* Actor::deserialize(NvBlastFamily* family, const void* buffer, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(family != nullptr, logFn, "Actor::deserialize: NULL family pointer input.", return nullptr);
-
-	const ActorSerializationHeader* serHeader = reinterpret_cast<const ActorSerializationHeader*>(buffer);
-	if (serHeader->m_formatVersion != ActorSerializationFormat::Current)
-	{
-		NVBLAST_LOG_ERROR(logFn, "Actor::deserialize: wrong data format.  Serialization data must be converted to current version.");
-		return nullptr;
-	}
-
-	FamilyHeader* header = reinterpret_cast<FamilyHeader*>(family);
-	const Asset* asset = header->m_asset;
-	const Nv::Blast::SupportGraph& graph = asset->m_graph;
-	const uint32_t* graphChunkIndices = graph.getChunkIndices();
-	const uint32_t* graphAdjacencyPartition = graph.getAdjacencyPartition();
-	const uint32_t* graphAdjacentNodeIndices = graph.getAdjacentNodeIndices();
-	const uint32_t* graphAdjacentBondIndices = graph.getAdjacentBondIndices();
-
-	Actor* actor = nullptr;
-	const uint32_t actorIndex = serHeader->m_index;
-
-	if (serHeader->m_index < header->getActorBufferSize())
-	{
-		if (!header->getActors()[actorIndex].isActive())
-		{
-			actor = header->borrowActor(serHeader->m_index);
-		}
-	}
-
-	if (actor == nullptr)
-	{
-		NVBLAST_LOG_ERROR(logFn, "Actor::deserialize: invalid actor index in serialized data.  Actor not created.");
-		return nullptr;
-	}
-
-	// Commonly used data
-	uint32_t* chunkActorIndices = header->getChunkActorIndices();
-	FamilyGraph* familyGraph = header->getFamilyGraph();
-
-#if NVBLAST_CHECK_PARAMS
-	{
-		const uint32_t* serVisibleChunkIndices = serHeader->getVisibleChunkIndices();
-		for (uint32_t i = 0; i < serHeader->m_visibleChunkCount; ++i)
-		{
-			const uint32_t visibleChunkIndex = serVisibleChunkIndices[i];
-			if (!isInvalidIndex(chunkActorIndices[visibleChunkIndex]))
-			{
-				NVBLAST_LOG_ERROR(logFn, "Actor::deserialize: visible chunk already has an actor in family.  Actor not created.");
-				header->returnActor(*actor);
-				return nullptr;
-			}
-		}
-	}
-#endif
-
-	// Visible chunk indices and chunk actor indices
-	{
-		// Add visible chunks, set chunk subtree ownership
-		const uint32_t* serVisibleChunkIndices = serHeader->getVisibleChunkIndices();
-		IndexDLink<uint32_t>* visibleChunkIndexLinks = header->getVisibleChunkIndexLinks();
-		for (uint32_t i = serHeader->m_visibleChunkCount; i--;)	// Reverse-order, so the resulting linked list is in the original order
-		{
-			const uint32_t visibleChunkIndex = serVisibleChunkIndices[i];
-			NVBLAST_ASSERT(isInvalidIndex(visibleChunkIndexLinks[visibleChunkIndex].m_adj[0]) && isInvalidIndex(visibleChunkIndexLinks[visibleChunkIndex].m_adj[1]));
-			IndexDList<uint32_t>().insertListHead(actor->m_firstVisibleChunkIndex, visibleChunkIndexLinks, visibleChunkIndex);
-			for (Asset::DepthFirstIt j(*asset, visibleChunkIndex, true); (bool)j; ++j)
-			{
-				NVBLAST_ASSERT(isInvalidIndex(chunkActorIndices[(uint32_t)j]));
-				chunkActorIndices[(uint32_t)j] = actorIndex;
-			}
-		}
-		actor->m_visibleChunkCount = serHeader->m_visibleChunkCount;
-	}
-
-	// Graph node indices, leaf chunk count, and and island IDs
-	{
-		// Add graph nodes
-		const uint32_t* serGraphNodeIndices = serHeader->getGraphNodeIndices();
-		uint32_t* graphNodeIndexLinks = header->getGraphNodeIndexLinks();
-		uint32_t* islandIDs = familyGraph->getIslandIds();
-		for (uint32_t i = serHeader->m_graphNodeCount; i--;)	// Reverse-order, so the resulting linked list is in the original order
-		{
-			const uint32_t graphNodeIndex = serGraphNodeIndices[i];
-			NVBLAST_ASSERT(isInvalidIndex(graphNodeIndexLinks[graphNodeIndex]));
-			graphNodeIndexLinks[graphNodeIndex] = actor->m_firstGraphNodeIndex;
-			actor->m_firstGraphNodeIndex = graphNodeIndex;
-			islandIDs[graphNodeIndex] = actorIndex;
-		}
-		actor->m_graphNodeCount = serHeader->m_graphNodeCount;
-		actor->m_leafChunkCount = serHeader->m_leafChunkCount;
-	}
-
-	// Lower support chunk healths
-	{
-		const float* serLowerSupportChunkHealths = serHeader->getLowerSupportChunkHealths();
-		float* subsupportHealths = header->getSubsupportChunkHealths();
-		const uint32_t subsupportChunkCount = asset->getUpperSupportChunkCount();
-		if (actor->m_graphNodeCount > 0)
-		{
-			uint32_t serLowerSupportChunkCount = 0;
-			float* graphNodeHealths = header->getLowerSupportChunkHealths();
-			for (Nv::Blast::Actor::GraphNodeIt i = *actor; (bool)i; ++i)
-			{
-				const uint32_t graphNodeIndex = (uint32_t)i;
-				graphNodeHealths[graphNodeIndex] = serLowerSupportChunkHealths[serLowerSupportChunkCount++];
-				const uint32_t supportChunkIndex = graphChunkIndices[graphNodeIndex];
-				Asset::DepthFirstIt j(*asset, supportChunkIndex);
-				NVBLAST_ASSERT((bool)j);
-				++j;	// Skip first (support) chunk, it's already been handled
-				for (; (bool)j; ++j)
-				{
-					subsupportHealths[(uint32_t)j] = serLowerSupportChunkHealths[serLowerSupportChunkCount++];
-				}
-			}
-		}
-		else	// Single subsupport chunk
-		if (!isInvalidIndex(actor->m_firstVisibleChunkIndex))
-		{
-			NVBLAST_ASSERT(actor->m_firstVisibleChunkIndex >= subsupportChunkCount);
-			subsupportHealths[actor->m_firstVisibleChunkIndex - subsupportChunkCount] = *serLowerSupportChunkHealths;
-		}
-	}
-
-	// Bond healths
-	uint32_t serBondCount = 0;
-	{
-		const float* serBondHealths = serHeader->getBondHealths();
-		float* bondHealths = header->getBondHealths();
-		for (Nv::Blast::Actor::GraphNodeIt i = *actor; (bool)i; ++i)
-		{
-			const uint32_t graphNodeIndex = (uint32_t)i;
-			for (uint32_t adjacentIndex = graphAdjacencyPartition[graphNodeIndex]; adjacentIndex < graphAdjacencyPartition[graphNodeIndex + 1]; ++adjacentIndex)
-			{
-				const uint32_t adjacentNodeIndex = graphAdjacentNodeIndices[adjacentIndex];
-				if (adjacentNodeIndex > graphNodeIndex)	// So as not to double-count
-				{
-					// Only count if the adjacent node belongs to this actor
-					const uint32_t adjacentChunkIndex = graphChunkIndices[adjacentNodeIndex];
-					if (chunkActorIndices[adjacentChunkIndex] == actorIndex)
-					{
-						const uint32_t adjacentBondIndex = graphAdjacentBondIndices[adjacentIndex];
-						bondHealths[adjacentBondIndex] = serBondHealths[serBondCount++];
-					}
-				}
-			}
-		}
-	}
-
-	// Fast routes
-	{
-		const uint32_t* serFastRoute = serHeader->getFastRoute();
-		uint32_t* fastRoute = header->getFamilyGraph()->getFastRoute();
-		for (Nv::Blast::Actor::GraphNodeIt i = *actor; (bool)i; ++i)
-		{
-			fastRoute[(uint32_t)i] = *serFastRoute++;
-		}
-	}
-
-	// Hop counts
-	{
-		const uint32_t* serHopCounts = serHeader->getHopCounts();
-		uint32_t* hopCounts = header->getFamilyGraph()->getHopCounts();
-		for (Nv::Blast::Actor::GraphNodeIt i = *actor; (bool)i; ++i)
-		{
-			hopCounts[(uint32_t)i] = *serHopCounts++;
-		}
-	}
-
-	// Edge removed array
-	if (serBondCount > 0)
-	{
-		uint32_t serBondIndex = 0;
-		const FixedBoolArray* serEdgeRemovedArray = serHeader->getEdgeRemovedArray();
-		FixedBoolArray* edgeRemovedArray = familyGraph->getIsEdgeRemoved();
-		for (Nv::Blast::Actor::GraphNodeIt i = *actor; (bool)i; ++i)
-		{
-			const uint32_t graphNodeIndex = (uint32_t)i;
-			for (uint32_t adjacentIndex = graphAdjacencyPartition[graphNodeIndex]; adjacentIndex < graphAdjacencyPartition[graphNodeIndex + 1]; ++adjacentIndex)
-			{
-				const uint32_t adjacentNodeIndex = graphAdjacentNodeIndices[adjacentIndex];
-				if (adjacentNodeIndex > graphNodeIndex)	// So as not to double-count
-				{
-					// Only count if the adjacent node belongs to this actor
-					const uint32_t adjacentChunkIndex = graphChunkIndices[adjacentNodeIndex];
-					if (chunkActorIndices[adjacentChunkIndex] == actorIndex)
-					{
-						if (!serEdgeRemovedArray->test(serBondIndex))
-						{
-							const uint32_t adjacentBondIndex = graphAdjacentBondIndices[adjacentIndex];
-							edgeRemovedArray->reset(adjacentBondIndex);
-						}
-						++serBondIndex;
-					}
-				}
-			}
-		}
-	}
-
-	return actor;
-}
-
-
-//////// Actor member methods for serialization ////////
-
-uint32_t Actor::serialize(void* buffer, uint32_t bufferSize, NvBlastLog logFn) const
-{
-	// Set up pointers and such
-	const Asset* asset = getAsset();
-	const Nv::Blast::SupportGraph& graph = asset->m_graph;
-	const uint32_t* graphChunkIndices = graph.getChunkIndices();
-	const uint32_t* graphAdjacencyPartition = graph.getAdjacencyPartition();
-	const uint32_t* graphAdjacentNodeIndices = graph.getAdjacentNodeIndices();
-	const uint32_t* graphAdjacentBondIndices = graph.getAdjacentBondIndices();
-	const FamilyHeader* header = getFamilyHeader();
-	const uint32_t* chunkActorIndices = header->getChunkActorIndices();
-	const uint32_t thisActorIndex = getIndex();
-
-	// Make sure there are no dirty nodes
-	if (m_graphNodeCount)
-	{
-		const uint32_t* firstDirtyNodeIndices = header->getFamilyGraph()->getFirstDirtyNodeIndices();
-		if (!isInvalidIndex(firstDirtyNodeIndices[thisActorIndex]))
-		{
-			NVBLAST_LOG_ERROR(logFn, "Nv::Blast::Actor::serialize: instance graph has dirty nodes.  Call Nv::Blast::Actor::findIslands before serializing.");
-			return 0;
-		}
-	}
-
-	uint64_t offset = 0;
-
-	// Header
-	ActorSerializationHeader* serHeader = reinterpret_cast<ActorSerializationHeader*>(buffer);
-	offset = align16(sizeof(ActorSerializationHeader));
-	if (offset > bufferSize)
-	{
-		return 0;	// Buffer size insufficient
-	}
-	serHeader->m_formatVersion = ActorSerializationFormat::Current;
-	serHeader->m_size = 0;	// Will be updated below
-	serHeader->m_index = thisActorIndex;
-	serHeader->m_visibleChunkCount = m_visibleChunkCount;
-	serHeader->m_graphNodeCount = m_graphNodeCount;
-	serHeader->m_leafChunkCount = m_leafChunkCount;
-
-	// Visible chunk indices
-	{
-		serHeader->m_visibleChunkIndicesOffset = (uint32_t)offset;
-		offset = align16(offset + m_visibleChunkCount*sizeof(uint32_t));
-		if (offset > bufferSize)
-		{
-			NVBLAST_LOG_ERROR(logFn, "Nv::Blast::Actor::Actor::serialize: buffer size exceeded.");
-			return 0;	// Buffer size insufficient
-		}
-		uint32_t* serVisibleChunkIndices = serHeader->getVisibleChunkIndices();
-		uint32_t serVisibleChunkCount = 0;
-		for (Nv::Blast::Actor::VisibleChunkIt i = *this; (bool)i; ++i)
-		{
-			NVBLAST_ASSERT(serVisibleChunkCount < m_visibleChunkCount);
-			serVisibleChunkIndices[serVisibleChunkCount++] = (uint32_t)i;
-		}
-		NVBLAST_ASSERT(serVisibleChunkCount == m_visibleChunkCount);
-	}
-
-	// Graph node indices
-	{
-		serHeader->m_graphNodeIndicesOffset = (uint32_t)offset;
-		offset = align16(offset + m_graphNodeCount*sizeof(uint32_t));
-		if (offset > bufferSize)
-		{
-			NVBLAST_LOG_ERROR(logFn, "Nv::Blast::Actor::serialize: buffer size exceeded.");
-			return 0;	// Buffer size insufficient
-		}
-		uint32_t* serGraphNodeIndices = serHeader->getGraphNodeIndices();
-		uint32_t serGraphNodeCount = 0;
-		for (Nv::Blast::Actor::GraphNodeIt i = *this; (bool)i; ++i)
-		{
-			NVBLAST_ASSERT(serGraphNodeCount < m_graphNodeCount);
-			serGraphNodeIndices[serGraphNodeCount++] = (uint32_t)i;
-		}
-		NVBLAST_ASSERT(serGraphNodeCount == m_graphNodeCount);
-	}
-
-	// Lower support chunk healths
-	{
-		serHeader->m_lowerSupportChunkHealthsOffset = (uint32_t)offset;
-		float* serLowerSupportChunkHealths = serHeader->getLowerSupportChunkHealths();
-		const float* subsupportHealths = header->getSubsupportChunkHealths();
-		const uint32_t subsupportChunkCount = asset->getUpperSupportChunkCount();
-		if (m_graphNodeCount > 0)
-		{
-			uint32_t serLowerSupportChunkCount = 0;
-			const float* graphNodeHealths = header->getLowerSupportChunkHealths();
-			for (Nv::Blast::Actor::GraphNodeIt i = *this; (bool)i; ++i)
-			{
-				const uint32_t graphNodeIndex = (uint32_t)i;
-				serLowerSupportChunkHealths[serLowerSupportChunkCount++] = graphNodeHealths[graphNodeIndex];
-				offset += sizeof(float);
-				const uint32_t supportChunkIndex = graphChunkIndices[graphNodeIndex];
-				Asset::DepthFirstIt j(*asset, supportChunkIndex);
-				NVBLAST_ASSERT((bool)j);
-				++j;	// Skip first (support) chunk, it's already been handled
-				for (; (bool)j; ++j)
-				{
-					if (offset >= bufferSize)
-					{
-						NVBLAST_LOG_ERROR(logFn, "Nv::Blast::Actor::serialize: buffer size exceeded.");
-						return 0;	// Buffer size insufficient
-					}
-					serLowerSupportChunkHealths[serLowerSupportChunkCount++] = subsupportHealths[(uint32_t)j - subsupportChunkCount];
-					offset += sizeof(float);
-				}
-			}
-		}
-		else	// Single subsupport chunk
-		if (!isInvalidIndex(m_firstVisibleChunkIndex))
-		{
-			NVBLAST_ASSERT(m_firstVisibleChunkIndex >= subsupportChunkCount);
-			if (offset >= bufferSize)
-			{
-				NVBLAST_LOG_ERROR(logFn, "Nv::Blast::Actor::serialize: buffer size exceeded.");
-				return 0;	// Buffer size insufficient
-			}
-			*serLowerSupportChunkHealths = subsupportHealths[m_firstVisibleChunkIndex - subsupportChunkCount];
-			offset += sizeof(float);
-		}
-	}
-	offset = align16(offset);
-
-	// Bond healths
-	uint32_t serBondCount = 0;
-	{
-		serHeader->m_bondHealthsOffset = (uint32_t)offset;
-		float* serBondHealths = serHeader->getBondHealths();
-		const float* bondHealths = header->getBondHealths();
-		for (Nv::Blast::Actor::GraphNodeIt i = *this; (bool)i; ++i)
-		{
-			const uint32_t graphNodeIndex = (uint32_t)i;
-			for (uint32_t adjacentIndex = graphAdjacencyPartition[graphNodeIndex]; adjacentIndex < graphAdjacencyPartition[graphNodeIndex + 1]; ++adjacentIndex)
-			{
-				const uint32_t adjacentNodeIndex = graphAdjacentNodeIndices[adjacentIndex];
-				if (adjacentNodeIndex > graphNodeIndex)	// So as not to double-count
-				{
-					// Only count if the adjacent node belongs to this actor
-					const uint32_t adjacentChunkIndex = graphChunkIndices[adjacentNodeIndex];
-					if (chunkActorIndices[adjacentChunkIndex] == thisActorIndex)
-					{
-						if (offset >= bufferSize)
-						{
-							NVBLAST_LOG_ERROR(logFn, "Nv::Blast::Actor::serialize: buffer size exceeded.");
-							return 0;	// Buffer size insufficient
-						}
-						const uint32_t adjacentBondIndex = graphAdjacentBondIndices[adjacentIndex];
-						serBondHealths[serBondCount++] = bondHealths[adjacentBondIndex];
-						offset += sizeof(float);
-					}
-				}
-			}
-		}
-	}
-	offset = align16(offset);
-
-	// Fast routes
-	{
-		serHeader->m_fastRouteOffset = (uint32_t)offset;
-		offset = align16(offset + m_graphNodeCount*sizeof(uint32_t));
-		if (offset > bufferSize)
-		{
-			NVBLAST_LOG_ERROR(logFn, "Nv::Blast::Actor::serialize: buffer size exceeded.");
-			return 0;	// Buffer size insufficient
-		}
-		uint32_t* serFastRoute = serHeader->getFastRoute();
-		const uint32_t* fastRoute = header->getFamilyGraph()->getFastRoute();
-		for (Nv::Blast::Actor::GraphNodeIt i = *this; (bool)i; ++i)
-		{
-			*serFastRoute++ = fastRoute[(uint32_t)i];
-		}
-	}
-
-	// Hop counts
-	{
-		serHeader->m_hopCountsOffset = (uint32_t)offset;
-		offset = align16(offset + m_graphNodeCount*sizeof(uint32_t));
-		if (offset > bufferSize)
-		{
-			NVBLAST_LOG_ERROR(logFn, "Nv::Blast::Actor::serialize: buffer size exceeded.");
-			return 0;	// Buffer size insufficient
-		}
-		uint32_t* serHopCounts = serHeader->getHopCounts();
-		const uint32_t* hopCounts = header->getFamilyGraph()->getHopCounts();
-		for (Nv::Blast::Actor::GraphNodeIt i = *this; (bool)i; ++i)
-		{
-			*serHopCounts++ = hopCounts[(uint32_t)i];
-		}
-	}
-
-	// Edge removed array
-	if (serBondCount > 0)
-	{
-		serHeader->m_edgeRemovedArrayOffset = (uint32_t)offset;
-		offset = align16(offset + FixedBoolArray::requiredMemorySize(serBondCount));
-		if (offset > bufferSize)
-		{
-			NVBLAST_LOG_ERROR(logFn, "Nv::Blast::Actor::serialize: buffer size exceeded.");
-			return 0;	// Buffer size insufficient
-		}
-		uint32_t serBondIndex = 0;
-		FixedBoolArray* serEdgeRemovedArray = serHeader->getEdgeRemovedArray();
-		new (serEdgeRemovedArray)FixedBoolArray(serBondCount);
-		serEdgeRemovedArray->fill();	// Reset bits as we find bonds
-		const FixedBoolArray* edgeRemovedArray = header->getFamilyGraph()->getIsEdgeRemoved();
-		for (Nv::Blast::Actor::GraphNodeIt i = *this; (bool)i; ++i)
-		{
-			const uint32_t graphNodeIndex = (uint32_t)i;
-			for (uint32_t adjacentIndex = graphAdjacencyPartition[graphNodeIndex]; adjacentIndex < graphAdjacencyPartition[graphNodeIndex + 1]; ++adjacentIndex)
-			{
-				const uint32_t adjacentNodeIndex = graphAdjacentNodeIndices[adjacentIndex];
-				if (adjacentNodeIndex > graphNodeIndex)	// So as not to double-count
-				{
-					// Only count if the adjacent node belongs to this actor
-					const uint32_t adjacentChunkIndex = graphChunkIndices[adjacentNodeIndex];
-					if (chunkActorIndices[adjacentChunkIndex] == thisActorIndex)
-					{
-						const uint32_t adjacentBondIndex = graphAdjacentBondIndices[adjacentIndex];
-						if (!edgeRemovedArray->test(adjacentBondIndex))
-						{
-							serEdgeRemovedArray->reset(serBondIndex);
-						}
-						++serBondIndex;
-					}
-				}
-			}
-		}
-	}
-
-	// Finally record size
-	serHeader->m_size = static_cast<uint32_t>(offset);
-
-	return serHeader->m_size;
-}
-
-
-uint32_t Actor::serializationRequiredStorage(NvBlastLog logFn) const
-{
-	const Asset* asset = getAsset();
-	const Nv::Blast::SupportGraph& graph = asset->m_graph;
-	const uint32_t* graphChunkIndices = graph.getChunkIndices();
-	const uint32_t* graphAdjacencyPartition = graph.getAdjacencyPartition();
-	const uint32_t* graphAdjacentNodeIndices = graph.getAdjacentNodeIndices();
-	const uint32_t* graphNodeIndexLinks = getFamilyHeader()->getGraphNodeIndexLinks();
-	const uint32_t* chunkActorIndices = getFamilyHeader()->getChunkActorIndices();
-	const uint32_t thisActorIndex = getIndex();
-
-	// Lower-support chunk count and bond counts for this actor need to be calculated.  Iterate over all support chunks to count these.
-	uint32_t lowerSupportChunkCount = 0;
-	uint32_t bondCount = 0;
-	if (m_graphNodeCount > 0)
-	{
-		for (uint32_t graphNodeIndex = m_firstGraphNodeIndex; !isInvalidIndex(graphNodeIndex); graphNodeIndex = graphNodeIndexLinks[graphNodeIndex])
-		{
-			// Update bond count
-			const uint32_t supportChunkIndex = graphChunkIndices[graphNodeIndex];
-			for (uint32_t adjacentIndex = graphAdjacencyPartition[graphNodeIndex]; adjacentIndex < graphAdjacencyPartition[graphNodeIndex + 1]; ++adjacentIndex)
-			{
-				const uint32_t adjacentNodeIndex = graphAdjacentNodeIndices[adjacentIndex];
-				if (adjacentNodeIndex > graphNodeIndex)	// So as not to double-count
-				{
-					// Only count if the adjacent node belongs to this actor
-					const uint32_t adjacentChunkIndex = graphChunkIndices[adjacentNodeIndex];
-					if (chunkActorIndices[adjacentChunkIndex] == thisActorIndex)
-					{
-						++bondCount;
-					}
-				}
-			}
-
-			// Update lower-support chunk count
-			for (Asset::DepthFirstIt i(*asset, supportChunkIndex); (bool)i; ++i)
-			{
-				++lowerSupportChunkCount;
-			}
-		}
-	}
-	else	// Subsupport chunk
-	{
-		++lowerSupportChunkCount;
-	}
-
-	const uint64_t dataSize = getActorSerializationSize(m_visibleChunkCount, lowerSupportChunkCount, m_graphNodeCount, bondCount);
-
-	if (dataSize > UINT32_MAX)
-	{
-		NVBLAST_LOG_WARNING(logFn, "Nv::Blast::Actor::serializationRequiredStorage: Serialization block size exceeds 4GB.  Returning 0.\n");
-		return 0;
-	}
-
-	return static_cast<uint32_t>(dataSize);
-}
-
-} // namespace Blast
-} // namespace Nv
-
-
-// API implementation
-
-extern "C"
-{
-
-uint32_t NvBlastActorGetSerializationSize(const NvBlastActor* actor, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(actor != nullptr, logFn, "NvBlastActorGetSerializationSize: NULL actor pointer input.", return 0);
-
-	const Nv::Blast::Actor& a = *static_cast<const Nv::Blast::Actor*>(actor);
-
-	if (!a.isActive())
-	{
-		NVBLAST_LOG_ERROR(logFn, "NvBlastActorGetSerializationSize: inactive actor pointer input.");
-		return 0;
-	}
-
-	return a.serializationRequiredStorage(logFn);
-}
-
-
-uint32_t NvBlastActorSerialize(void* buffer, uint32_t bufferSize, const NvBlastActor* actor, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(buffer != nullptr, logFn, "NvBlastActorSerialize: NULL buffer pointer input.", return 0);
-	NVBLAST_CHECK(actor != nullptr, logFn, "NvBlastActorSerialize: NULL actor pointer input.", return 0);
-
-	const Nv::Blast::Actor& a = *static_cast<const Nv::Blast::Actor*>(actor);
-
-	if (!a.isActive())
-	{
-		NVBLAST_LOG_ERROR(logFn, "NvBlastActorSerialize: inactive actor pointer input.");
-		return 0;
-	}
-
-	return a.serialize(buffer, bufferSize, logFn);
-}
-
-
-NvBlastActor* NvBlastFamilyDeserializeActor(NvBlastFamily* family, const void* buffer, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(family != nullptr, logFn, "NvBlastFamilyDeserializeActor: NULL family input.  No actor deserialized.", return nullptr);
-	NVBLAST_CHECK(buffer != nullptr, logFn, "NvBlastFamilyDeserializeActor: NULL buffer pointer input.  No actor deserialized.", return nullptr);
-
-	return Nv::Blast::Actor::deserialize(family, buffer, logFn);
-}
-
-} // extern "C"
diff --git a/NvBlast/sdk/lowlevel/source/NvBlastActorSerializationBlock.h b/NvBlast/sdk/lowlevel/source/NvBlastActorSerializationBlock.h
deleted file mode 100644
index 1388a74..0000000
--- a/NvBlast/sdk/lowlevel/source/NvBlastActorSerializationBlock.h
+++ /dev/null
@@ -1,151 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTACTORSERIALIZATIONBLOCK_H
-#define NVBLASTACTORSERIALIZATIONBLOCK_H
-
-
-#include "NvBlastFixedBoolArray.h"
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-/**
-Struct-enum which keeps track of the actor serialization format.
-*/
-struct ActorSerializationFormat
-{
-	enum Version
-	{
-		/** Initial version */
-		Initial,
-
-		//	New formats must come before Count.  They should be given descriptive names with more information in comments.
-
-		/** The number of serialization formats. */
-		Count,
-
-		/** The current version.  This should always be Count-1 */
-		Current = Count - 1
-	};
-};
-
-
-/**
-Data header at the beginning of a NvBlastActor serialization block
-
-The block address may be cast to a valid ActorSerializationHeader pointer.
-
-Serialization state is only valid if partition has been called since the last call to findIslands().
-*/
-struct ActorSerializationHeader
-{
-	/**
-	A number which is incremented every time the data layout changes.
-	*/
-	uint32_t	m_formatVersion;
-
-	/**
-	The size of the serialization block, including this header.
-
-	Memory sizes are restricted to 32-bit representable values.
-	*/
-	uint32_t	m_size;
-
-	/**
-	The index of the actor within its family.
-	*/
-	uint32_t	m_index;
-
-	/**
-	The number of elements in the visible chunk indices list.
-	*/
-	uint32_t	m_visibleChunkCount;
-
-	/**
-	The number of elements in the graph node indices list.
-	*/
-	uint32_t	m_graphNodeCount;
-
-	/**
-	The number of leaf chunks in this actor.
-	*/
-	uint32_t	m_leafChunkCount;
-
-	/**
-	Visible chunk indices, of type uint32_t.
-	*/
-	NvBlastBlockArrayData(uint32_t, m_visibleChunkIndicesOffset, getVisibleChunkIndices, m_visibleChunkCount);
-
-	/**
-	Graph node indices, of type uint32_t.
-	*/
-	NvBlastBlockArrayData(uint32_t, m_graphNodeIndicesOffset, getGraphNodeIndices, m_graphNodeCount);
-
-	/**
-	Healths for lower support chunks in this actor, in breadth-first order from the support chunks associated with the graph nodes.  Type float.
-	*/
-	NvBlastBlockData(float, m_lowerSupportChunkHealthsOffset, getLowerSupportChunkHealths);
-
-	/**
-	Healths for bonds associated with support chunks in this actor, in order of graph adjacency from associated graph nodes, i < j only.  Type float.
-	*/
-	NvBlastBlockData(float, m_bondHealthsOffset, getBondHealths);
-
-	/**
-	Fast route in instance graph calculated for each graph node in this actor, of type uint32_t.
-	*/
-	NvBlastBlockArrayData(uint32_t, m_fastRouteOffset, getFastRoute, m_graphNodeCount);
-
-	/**
-	Hop counts in instance graph calculated for each graph node in this actor, of type uint32_t.
-	*/
-	NvBlastBlockArrayData(uint32_t, m_hopCountsOffset, getHopCounts, m_graphNodeCount);
-
-	/**
-	"Edge removed" bits for bonds associated with support chunks in this actor, in order of graph adjacency from associated graph nodes, i < j only.  Type FixedBoolArray.
-	*/
-	NvBlastBlockData(FixedBoolArray, m_edgeRemovedArrayOffset, getEdgeRemovedArray);
-};
-
-
-//////// Global functions ////////
-
-/**
-A buffer size sufficient to serialize an actor with a given visible chunk count, lower support chunk count, graph node count, and bond count.
-
-\param[in] visibleChunkCount		The number of visible chunks
-\param[in] lowerSupportChunkCount	The number of lower-support chunks in the asset.
-\param[in] graphNodeCount			The number of graph nodes in the asset.
-\param[in] bondCount				The number of graph bonds in the asset.
-
-\return the required buffer size in bytes.
-*/
-NV_INLINE size_t getActorSerializationSize(uint32_t visibleChunkCount, uint32_t lowerSupportChunkCount, uint32_t graphNodeCount, uint32_t bondCount)
-{
-	// Family offsets
-	const size_t visibleChunkIndicesOffset = align16(sizeof(ActorSerializationHeader));								// size = visibleChunkCount*sizeof(uint32_t)
-	const size_t graphNodeIndicesOffset = align16(visibleChunkIndicesOffset + visibleChunkCount*sizeof(uint32_t));	// size = graphNodeCount*sizeof(uint32_t)
-	const size_t lowerSupportHealthsOffset = align16(graphNodeIndicesOffset + graphNodeCount*sizeof(uint32_t));		// size = lowerSupportChunkCount*sizeof(float)
-	const size_t bondHealthsOffset = align16(lowerSupportHealthsOffset + lowerSupportChunkCount*sizeof(float));		// size = bondCount*sizeof(float)
-	const size_t fastRouteOffset = align16(bondHealthsOffset + bondCount*sizeof(float));							// size = graphNodeCount*sizeof(uint32_t)
-	const size_t hopCountsOffset = align16(fastRouteOffset + graphNodeCount*sizeof(uint32_t));						// size = graphNodeCount*sizeof(uint32_t)
-	const size_t edgeRemovedArrayOffset = align16(hopCountsOffset + graphNodeCount*sizeof(uint32_t));				// size = 0 or FixedBoolArray::requiredMemorySize(bondCount)
-	return align16(edgeRemovedArrayOffset + (bondCount == 0 ? 0 : FixedBoolArray::requiredMemorySize(bondCount)));
-}
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTACTORSERIALIZATIONBLOCK_H
diff --git a/NvBlast/sdk/lowlevel/source/NvBlastAsset.cpp b/NvBlast/sdk/lowlevel/source/NvBlastAsset.cpp
deleted file mode 100644
index 29fc6b0..0000000
--- a/NvBlast/sdk/lowlevel/source/NvBlastAsset.cpp
+++ /dev/null
@@ -1,931 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastAssert.h"
-#include "NvBlastAsset.h"
-#include "NvBlastActor.h"
-#include "NvBlastMath.h"
-#include "NvBlastPreprocessorInternal.h"
-#include "NvBlastIndexFns.h"
-#include "NvBlastActorSerializationBlock.h"
-#include "NvBlastMemory.h"
-
-#include <algorithm>
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-
-//////// Local helper functions ////////
-
-
-/**
-Helper function to validate the input parameters for NvBlastCreateAsset.  See NvBlastCreateAsset for parameter definitions.
-*/
-static bool solverAssetBuildValidateInput(void* mem, const NvBlastAssetDesc* desc, void* scratch, NvBlastLog logFn)
-{
-	if (mem == nullptr)
-	{
-		NVBLAST_LOG_ERROR(logFn, "AssetBuildValidateInput: NULL mem pointer input.");
-		return false;
-	}
-
-	if (desc == nullptr)
-	{
-		NVBLAST_LOG_ERROR(logFn, "AssetBuildValidateInput: NULL desc pointer input.");
-		return false;
-	}
-
-	if (desc->chunkCount == 0)
-	{
-		NVBLAST_LOG_ERROR(logFn, "AssetBuildValidateInput: Zero chunk count not allowed.");
-		return false;
-	}
-
-	if (desc->chunkDescs == nullptr)
-	{
-		NVBLAST_LOG_ERROR(logFn, "AssetBuildValidateInput: NULL chunkDescs pointer input.");
-		return false;
-	}
-
-	if (desc->bondCount != 0 && desc->bondDescs == nullptr)
-	{
-		NVBLAST_LOG_ERROR(logFn, "AssetBuildValidateInput: bondCount non-zero but NULL bondDescs pointer input.");
-		return false;
-	}
-
-	if (scratch == nullptr)
-	{
-		NVBLAST_LOG_ERROR(logFn, "AssetBuildValidateInput: NULL scratch pointer input.");
-		return false;
-	}
-
-	return true;
-}
-
-
-struct AssetDataOffsets
-{
-	size_t m_chunks;
-	size_t m_bonds;
-	size_t m_subtreeLeafChunkCounts;
-	size_t m_supportChunkIndices;
-	size_t m_chunkToGraphNodeMap;
-	size_t m_graphAdjacencyPartition;
-	size_t m_graphAdjacentNodeIndices;
-	size_t m_graphAdjacentBondIndices;
-};
-
-
-static size_t createAssetDataOffsets(AssetDataOffsets& offsets, uint32_t chunkCount, uint32_t graphNodeCount, uint32_t bondCount)
-{
-	NvBlastCreateOffsetStart(sizeof(Asset));
-	NvBlastCreateOffsetAlign16(offsets.m_chunks, chunkCount * sizeof(NvBlastChunk));
-	NvBlastCreateOffsetAlign16(offsets.m_bonds, bondCount * sizeof(NvBlastBond));
-	NvBlastCreateOffsetAlign16(offsets.m_subtreeLeafChunkCounts, chunkCount * sizeof(uint32_t));
-	NvBlastCreateOffsetAlign16(offsets.m_supportChunkIndices, graphNodeCount * sizeof(uint32_t));
-	NvBlastCreateOffsetAlign16(offsets.m_chunkToGraphNodeMap, chunkCount * sizeof(uint32_t));
-	NvBlastCreateOffsetAlign16(offsets.m_graphAdjacencyPartition, (graphNodeCount + 1) * sizeof(uint32_t));
-	NvBlastCreateOffsetAlign16(offsets.m_graphAdjacentNodeIndices, (2 * bondCount) * sizeof(uint32_t));
-	NvBlastCreateOffsetAlign16(offsets.m_graphAdjacentBondIndices, (2 * bondCount) * sizeof(uint32_t));
-	return NvBlastCreateOffsetEndAlign16();
-}
-
-
-Asset* initializeAsset(void* mem, NvBlastID id, uint32_t chunkCount, uint32_t graphNodeCount, uint32_t leafChunkCount, uint32_t firstSubsupportChunkIndex, uint32_t bondCount, NvBlastLog logFn)
-{
-	// Data offsets
-	AssetDataOffsets offsets;
-	const size_t dataSize = createAssetDataOffsets(offsets, chunkCount, graphNodeCount, bondCount);
-
-	// Restricting our data size to < 4GB so that we may use uint32_t offsets
-	if (dataSize > (size_t)UINT32_MAX)
-	{
-		NVBLAST_LOG_ERROR(logFn, "Nv::Blast::allocateAsset: Asset data size will exceed 4GB.  Instance not created.\n");
-		return nullptr;
-	}
-
-	// Zero memory and cast to Asset
-	Asset* asset = reinterpret_cast<Asset*>(memset(mem, 0, dataSize));
-
-	// Fill in fields
-	const size_t graphOffset = NV_OFFSET_OF(Asset, m_graph);
-	asset->m_header.dataType = NvBlastDataBlock::AssetDataBlock;
-	asset->m_header.formatVersion = NvBlastAssetDataFormat::Current;
-	asset->m_header.size = (uint32_t)dataSize;
-	asset->m_header.reserved = 0;
-	asset->m_ID = id;
-	asset->m_chunkCount = chunkCount;
-	asset->m_graph.m_nodeCount = graphNodeCount;
-	asset->m_graph.m_chunkIndicesOffset = (uint32_t)(offsets.m_supportChunkIndices - graphOffset);
-	asset->m_graph.m_adjacencyPartitionOffset = (uint32_t)(offsets.m_graphAdjacencyPartition - graphOffset);
-	asset->m_graph.m_adjacentNodeIndicesOffset = (uint32_t)(offsets.m_graphAdjacentNodeIndices - graphOffset);
-	asset->m_graph.m_adjacentBondIndicesOffset = (uint32_t)(offsets.m_graphAdjacentBondIndices - graphOffset);
-	asset->m_leafChunkCount = leafChunkCount;
-	asset->m_firstSubsupportChunkIndex = firstSubsupportChunkIndex;
-	asset->m_bondCount = bondCount;
-	asset->m_chunksOffset = (uint32_t)offsets.m_chunks;
-	asset->m_bondsOffset = (uint32_t)offsets.m_bonds;
-	asset->m_subtreeLeafChunkCountsOffset = (uint32_t)offsets.m_subtreeLeafChunkCounts;
-	asset->m_chunkToGraphNodeMapOffset = (uint32_t)offsets.m_chunkToGraphNodeMap;
-
-	// Ensure Bonds remain aligned
-	NV_COMPILE_TIME_ASSERT((sizeof(NvBlastBond) & 0xf) == 0);
-
-	// Ensure Bonds are aligned - note, this requires that the block be aligned
-	NVBLAST_ASSERT((uintptr_t(asset->getBonds()) & 0xf) == 0);
-
-	return asset;
-}
-
-
-/**
-Tests for a loop in a digraph starting at a given graph vertex.
-
-Using the implied digraph given by the chunkDescs' parentChunkIndex fields, the graph is walked from the chunk descriptor chunkDescs[chunkIndex],
-to determine if that walk leads to a loop.
-
-Input:
-chunkDescs	- the chunk descriptors
-chunkIndex	- the index of the starting chunk descriptor
-
-Return:
-true if a loop is found, false otherwise.
-*/
-NV_INLINE bool testForLoop(const NvBlastChunkDesc* chunkDescs, uint32_t chunkIndex)
-{
-	NVBLAST_ASSERT(!isInvalidIndex(chunkIndex));
-
-	uint32_t chunkIndex1 = chunkDescs[chunkIndex].parentChunkIndex;
-	if (isInvalidIndex(chunkIndex1))
-	{
-		return false;
-	}
-
-	uint32_t chunkIndex2 = chunkDescs[chunkIndex1].parentChunkIndex;
-	if (isInvalidIndex(chunkIndex2))
-	{
-		return false;
-	}
-
-	do
-	{
-		// advance index 1
-		chunkIndex1 = chunkDescs[chunkIndex1].parentChunkIndex;	// No need to check for termination here.  index 2 would find it first.
-
-		// advance index 2 twice and check for incidence with index 1 as well as termination
-		if ((chunkIndex2 = chunkDescs[chunkIndex2].parentChunkIndex) == chunkIndex1)
-		{
-			return true;
-		}
-		if (isInvalidIndex(chunkIndex2))
-		{
-			return false;
-		}
-		if ((chunkIndex2 = chunkDescs[chunkIndex2].parentChunkIndex) == chunkIndex1)
-		{
-			return true;
-		}
-	} while (!isInvalidIndex(chunkIndex2));
-
-	return false;
-}
-
-
-/**
-Tests a set of chunk descriptors to see if the implied hierarchy describes valid trees.
-
-A single tree implies that only one of the chunkDescs has an invalid (invalidIndex<uint32_t>()) parentChunkIndex, and all other
-chunks are descendents of that chunk. Passed set of chunk is checked to contain one or more single trees.
-
-Input:
-chunkCount	- the number of chunk descriptors
-chunkDescs	- an array of chunk descriptors of length chunkCount
-logFn		- message function (see NvBlastLog definition).
-
-Return:
-true if the descriptors imply a valid trees, false otherwise.
-*/
-static bool testForValidTrees(uint32_t chunkCount, const NvBlastChunkDesc* chunkDescs, NvBlastLog logFn)
-{
-	for (uint32_t i = 0; i < chunkCount; ++i)
-	{
-		// Ensure there are no loops
-		if (testForLoop(chunkDescs, i))
-		{
-			NVBLAST_LOG_WARNING(logFn, "testForValidTrees: loop found.  Asset will not be created.");
-			return false;
-		}
-	}
-
-	return true;
-}
-
-
-/**
-Struct to hold chunk indices and bond index for sorting
-
-Utility struct used by NvBlastCreateAsset in order to arrange bond data in a lookup table, and also to easily identify redundant input.
-*/
-struct BondSortData	
-{
-	BondSortData(uint32_t c0, uint32_t c1, uint32_t b) : m_c0(c0), m_c1(c1), m_b(b) {}
-
-	uint32_t	m_c0;
-	uint32_t	m_c1;
-	uint32_t	m_b;
-};
-
-
-/**
-Functional class for sorting a list of BondSortData
-*/
-class BondsOrdered
-{
-public:
-	bool	operator () (const BondSortData& bond0, const BondSortData& bond1) const
-	{
-		return (bond0.m_c0 != bond1.m_c0) ? (bond0.m_c0 < bond1.m_c0) : (bond0.m_c1 < bond1.m_c1);
-	}
-};
-
-
-//////// Asset static functions ////////
-
-size_t Asset::getMemorySize(const NvBlastAssetDesc* desc)
-{
-	NVBLAST_ASSERT(desc != nullptr);
-
-	// Count graph nodes
-	uint32_t graphNodeCount = 0;
-	for (uint32_t i = 0; i < desc->chunkCount; ++i)
-	{
-		graphNodeCount += (uint32_t)((desc->chunkDescs[i].flags & NvBlastChunkDesc::SupportFlag) != 0);
-	}
-
-	AssetDataOffsets offsets;
-	return createAssetDataOffsets(offsets, desc->chunkCount, graphNodeCount, desc->bondCount);
-}
-
-
-size_t Asset::createRequiredScratch(const NvBlastAssetDesc* desc)
-{
-#if NVBLAST_CHECK_PARAMS
-	if (desc == nullptr)
-	{
-		NVBLAST_ALWAYS_ASSERT();
-		return 0;
-	}
-#endif
-
-	// Aligned and padded
-	return 16 +
-		align16(desc->chunkCount*sizeof(char)) +
-		align16(desc->chunkCount*sizeof(uint32_t)) +
-		align16(2 * desc->bondCount*sizeof(Nv::Blast::BondSortData)) +
-		align16(desc->bondCount*sizeof(uint32_t));
-}
-
-
-Asset* Asset::create(void* mem, const NvBlastAssetDesc* desc, void* scratch, NvBlastLog logFn)
-{
-#if NVBLAST_CHECK_PARAMS
-	if (!solverAssetBuildValidateInput(mem, desc, scratch, logFn))
-	{
-		return nullptr;
-	}
-#else 
-	NV_UNUSED(solverAssetBuildValidateInput);
-#endif
-
-	NVBLAST_CHECK((reinterpret_cast<uintptr_t>(mem) & 0xF) == 0, logFn, "NvBlastCreateAsset: mem pointer not 16-byte aligned.", return nullptr);
-
-	// Make sure we have valid trees before proceeding
-	if (!testForValidTrees(desc->chunkCount, desc->chunkDescs, logFn))
-	{
-		return nullptr;
-	}
-
-	scratch = (void*)align16((size_t)scratch);	// Bump to 16-byte alignment (see padding in NvBlastGetRequiredScratchForCreateAsset)
-
-	// reserve chunkAnnotation on scratch
-	char* chunkAnnotation = reinterpret_cast<char*>(scratch); scratch = Nv::Blast::pointerOffset(scratch, align16(desc->chunkCount));
-
-	// test for coverage, chunkAnnotation will be filled there.
-	uint32_t leafChunkCount;
-	uint32_t supportChunkCount;
-	if (!ensureExactSupportCoverage(supportChunkCount, leafChunkCount, chunkAnnotation, desc->chunkCount, const_cast<NvBlastChunkDesc*>(desc->chunkDescs), true, logFn))
-	{
-		return nullptr;
-	}
-
-	// test for valid chunk order
-	if (!testForValidChunkOrder(desc->chunkCount, desc->chunkDescs, chunkAnnotation, scratch))
-	{
-		NVBLAST_LOG_ERROR(logFn, "NvBlastCreateAsset: chunks order is invalid.  Asset will not be created.  Use Asset helper functions such as NvBlastBuildAssetDescChunkReorderMap to fix descriptor order.");
-		return nullptr;
-	}
-
-	// Find first subsupport chunk
-	uint32_t firstSubsupportChunkIndex = desc->chunkCount;	// Set value to chunk count if no subsupport chunks are found
-	for (uint32_t i = 0; i < desc->chunkCount; ++i)
-	{
-		if ((chunkAnnotation[i] & ChunkAnnotation::UpperSupport) == 0)
-		{
-			firstSubsupportChunkIndex = i;
-			break;
-		}
-	}
-
-	// Create map from global indices to graph node indices and initialize to invalid values 
-	uint32_t* graphNodeIndexMap = (uint32_t*)scratch; scratch = Nv::Blast::pointerOffset(scratch, align16(desc->chunkCount * sizeof(uint32_t)));
-	memset(graphNodeIndexMap, 0xFF, desc->chunkCount*sizeof(uint32_t));
-
-	// Fill graphNodeIndexMap
-	uint32_t graphNodeCount = 0;
-	for (uint32_t i = 0; i < desc->chunkCount; ++i)
-	{
-		if ((chunkAnnotation[i] & ChunkAnnotation::Support) != 0)
-		{
-			graphNodeIndexMap[i] = graphNodeCount++;
-		}
-	}
-	NVBLAST_ASSERT(graphNodeCount == supportChunkCount);
-
-	// Scratch array for bond sorting, of size 2*desc->bondCount
-	Nv::Blast::BondSortData* bondSortArray = (Nv::Blast::BondSortData*)scratch; scratch = Nv::Blast::pointerOffset(scratch, align16(2 * desc->bondCount*sizeof(Nv::Blast::BondSortData)));
-
-	// Bond remapping array of size desc->bondCount
-	uint32_t* bondMap = (uint32_t*)scratch;
-	memset(bondMap, 0xFF, desc->bondCount*sizeof(uint32_t));
-
-	// Eliminate bad or redundant bonds, finding actual bond count
-	uint32_t bondCount = 0;
-	if (desc->bondCount > 0)
-	{
-		// Check for duplicates from input data as well as non-support chunk indices.  All such bonds must be removed.
-		bool invalidFound = false;
-		bool duplicateFound = false;
-		bool nonSupportFound = false;
-
-		// Construct temp array of chunk index pairs and bond indices.  This array is symmetrized to hold the reversed chunk indices as well.
-		uint32_t bondSortArraySize = 0;
-		Nv::Blast::BondSortData* t = bondSortArray;
-		for (uint32_t i = 0; i < desc->bondCount; ++i)
-		{
-			const NvBlastBondDesc& bondDesc = desc->bondDescs[i];
-			const uint32_t chunkIndex0 = bondDesc.chunkIndices[0];
-			const uint32_t chunkIndex1 = bondDesc.chunkIndices[1];
-
-			if (chunkIndex0 >= desc->chunkCount || chunkIndex1 >= desc->chunkCount || chunkIndex0 == chunkIndex1)
-			{
-				invalidFound = true;
-				continue;
-			}
-
-			const uint32_t graphIndex0 = graphNodeIndexMap[chunkIndex0];
-			const uint32_t graphIndex1 = graphNodeIndexMap[chunkIndex1];
-			if (Nv::Blast::isInvalidIndex(graphIndex0) || Nv::Blast::isInvalidIndex(graphIndex1))
-			{
-				nonSupportFound = true;
-				continue;
-			}
-
-			t[bondSortArraySize++] = Nv::Blast::BondSortData(graphIndex0, graphIndex1, i);
-			t[bondSortArraySize++] = Nv::Blast::BondSortData(graphIndex1, graphIndex0, i);
-		}
-
-		// Sort the temp array
-		std::sort(bondSortArray, bondSortArray + bondSortArraySize, Nv::Blast::BondsOrdered());
-
-		uint32_t symmetrizedBondCount = 0;
-		for (uint32_t i = 0; i < bondSortArraySize; ++i)
-		{
-			const bool duplicate = i > 0 && bondSortArray[i].m_c0 == bondSortArray[i - 1].m_c0 && bondSortArray[i].m_c1 == bondSortArray[i - 1].m_c1;	// Since the array is sorted, uniqueness may be tested by only considering the previous element
-			duplicateFound = duplicateFound || duplicate;
-			if (!duplicate)
-			{	// Keep this bond
-				if (symmetrizedBondCount != i)
-				{
-					bondSortArray[symmetrizedBondCount] = bondSortArray[i];	// Compact array if we've dropped bonds
-				}
-				++symmetrizedBondCount;
-			}
-		}
-		NVBLAST_ASSERT((symmetrizedBondCount & 1) == 0);	// Because we symmetrized, there should be an even number
-
-		bondCount = symmetrizedBondCount / 2;
-
-		// Report warnings
-		if (invalidFound)
-		{
-			NVBLAST_LOG_WARNING(logFn, "NvBlastCreateAsset: Invalid bonds found (non-existent or same chunks referenced) and removed from asset.");
-		}
-		if (duplicateFound)
-		{
-			NVBLAST_LOG_WARNING(logFn, "NvBlastCreateAsset: Duplicate bonds found and removed from asset.");
-		}
-		if (nonSupportFound)
-		{
-			NVBLAST_LOG_WARNING(logFn, "NvBlastCreateAsset: Bonds referencing non-support chunks found and removed from asset.");
-		}
-	}
-
-	// Allocate memory for asset
-	NvBlastID id;
-	memset(&id, 0, sizeof(NvBlastID));	// To do - create an actual id
-	Nv::Blast::Asset* asset = initializeAsset(mem, id, desc->chunkCount, supportChunkCount, leafChunkCount, firstSubsupportChunkIndex, bondCount, logFn);
-
-	// Asset data pointers
-	Nv::Blast::SupportGraph& graph = asset->m_graph;
-	NvBlastChunk* chunks = asset->getChunks();
-	NvBlastBond* bonds = asset->getBonds();
-	uint32_t* subtreeLeafChunkCounts = asset->getSubtreeLeafChunkCounts();
-
-	// Create chunks
-	uint32_t* graphChunkIndices = graph.getChunkIndices();
-	for (uint32_t i = 0; i < desc->chunkCount; ++i)
-	{
-		const NvBlastChunkDesc& chunkDesc = desc->chunkDescs[i];
-		const uint32_t newChunkIndex = i;
-		NvBlastChunk& assetChunk = chunks[newChunkIndex];
-		memcpy(assetChunk.centroid, chunkDesc.centroid, 3 * sizeof(float));
-		assetChunk.volume = chunkDesc.volume;
-		assetChunk.parentChunkIndex = Nv::Blast::isInvalidIndex(chunkDesc.parentChunkIndex) ? chunkDesc.parentChunkIndex : chunkDesc.parentChunkIndex;
-		assetChunk.firstChildIndex = Nv::Blast::invalidIndex<uint32_t>();	// Will be filled in below
-		assetChunk.childIndexStop = assetChunk.firstChildIndex;
-		assetChunk.userData = chunkDesc.userData;
-		if (!Nv::Blast::isInvalidIndex(graphNodeIndexMap[newChunkIndex]))
-		{
-			graphChunkIndices[graphNodeIndexMap[newChunkIndex]] = newChunkIndex;
-		}
-	}
-
-	// Copy chunkToGraphNodeMap
-	memcpy(asset->getChunkToGraphNodeMap(), graphNodeIndexMap, desc->chunkCount * sizeof(uint32_t));
-
-	// Count chunk children
-	for (uint32_t i = 0; i < desc->chunkCount; ++i)
-	{
-		const uint32_t parentChunkIndex = chunks[i].parentChunkIndex;
-		if (!Nv::Blast::isInvalidIndex(parentChunkIndex))
-		{
-			if (chunks[parentChunkIndex].childIndexStop == chunks[parentChunkIndex].firstChildIndex)
-			{
-				chunks[parentChunkIndex].childIndexStop = chunks[parentChunkIndex].firstChildIndex = i;
-			}
-			++chunks[parentChunkIndex].childIndexStop;
-		}
-	}
-
-	// Create bonds
-	uint32_t* graphAdjacencyPartition = graph.getAdjacencyPartition();
-	uint32_t* graphAdjacentNodeIndices = graph.getAdjacentNodeIndices();
-	uint32_t* graphAdjacentBondIndices = graph.getAdjacentBondIndices();
-	if (bondCount > 0)
-	{
-		// Create the lookup table from the sorted array
-		Nv::Blast::createIndexStartLookup<uint32_t>(graphAdjacencyPartition, 0, graphNodeCount - 1, &bondSortArray->m_c0, 2 * bondCount, sizeof(Nv::Blast::BondSortData));
-
-		// Write the adjacent chunk and bond index data
-		uint32_t bondIndex = 0;
-		for (uint32_t i = 0; i < 2 * bondCount; ++i)
-		{
-			const Nv::Blast::BondSortData& bondSortData = bondSortArray[i];
-			graphAdjacentNodeIndices[i] = bondSortData.m_c1;
-			const uint32_t oldBondIndex = bondSortData.m_b;
-			const NvBlastBondDesc& bondDesc = desc->bondDescs[oldBondIndex];
-			if (Nv::Blast::isInvalidIndex(bondMap[oldBondIndex]))
-			{
-				bonds[bondIndex] = bondDesc.bond;
-				// Our convention is that the bond normal points away from the lower-indexed chunk, towards the higher-indexed chunk.
-				// If our new (graph node) indexing would reverse this direction from the bond descriptor's indexing, we must flip the nomral.
-				const bool nodeIndicesOrdered = bondSortData.m_c0 < bondSortData.m_c1;
-				const bool descNodeIndicesOrdered = bondDesc.chunkIndices[0] < bondDesc.chunkIndices[1];
-				if (descNodeIndicesOrdered && !nodeIndicesOrdered)
-				{
-					float* normal = bonds[bondIndex].normal;
-					normal[0] = -normal[0];
-					normal[1] = -normal[1];
-					normal[2] = -normal[2];
-				}
-				bondMap[oldBondIndex] = bondIndex++;
-			}
-			graphAdjacentBondIndices[i] = bondMap[oldBondIndex];
-		}
-	}
-	else
-	{
-		// No bonds - zero out all partition elements (including last one, to give zero size for adjacent data arrays)
-		memset(graphAdjacencyPartition, 0, (graphNodeCount + 1)*sizeof(uint32_t));
-	}
-
-	// Count subtree leaf chunks
-	memset(subtreeLeafChunkCounts, 0, desc->chunkCount*sizeof(uint32_t));
-	uint32_t* breadthFirstChunkIndices = graphNodeIndexMap;	// Reusing graphNodeIndexMap ... graphNodeIndexMap may no longer be used
-	for (uint32_t startChunkIndex = 0; startChunkIndex < desc->chunkCount; ++startChunkIndex)
-	{
-		if (!Nv::Blast::isInvalidIndex(chunks[startChunkIndex].parentChunkIndex))
-		{
-			break;	// Only iterate through root chunks at this level
-		}
-		const uint32_t enumeratedChunkCount = enumerateChunkHierarchyBreadthFirst(breadthFirstChunkIndices, desc->chunkCount, chunks, startChunkIndex, false);
-		for (uint32_t chunkNum = enumeratedChunkCount; chunkNum--;)
-		{
-			const uint32_t chunkIndex = breadthFirstChunkIndices[chunkNum];
-			const NvBlastChunk& chunk = chunks[chunkIndex];
-			if (chunk.childIndexStop <= chunk.firstChildIndex)
-			{
-				subtreeLeafChunkCounts[chunkIndex] = 1;
-			}
-			NVBLAST_ASSERT(!isInvalidIndex(chunk.parentChunkIndex));	// Parent index is valid because root chunk is not included in this list (because of 'false' passed into enumerateChunkHierarchyBreadthFirst, above)
-			subtreeLeafChunkCounts[chunk.parentChunkIndex] += subtreeLeafChunkCounts[chunkIndex];
-		}
-	}
-
-	return asset;
-}
-
-
-bool Asset::ensureExactSupportCoverage(uint32_t& supportChunkCount, uint32_t& leafChunkCount, char* chunkAnnotation, uint32_t chunkCount, NvBlastChunkDesc* chunkDescs, bool testOnly, NvBlastLog logFn)
-{
-	// Clear leafChunkCount
-	leafChunkCount = 0;
-
-	memset(chunkAnnotation, 0, chunkCount);
-
-	// Walk up the hierarchy from all chunks and mark all parents
-	for (uint32_t i = 0; i < chunkCount; ++i)
-	{
-		if (chunkAnnotation[i] & Asset::ChunkAnnotation::Parent)
-		{
-			continue;
-		}
-		uint32_t chunkIndex = i;
-		while (!isInvalidIndex(chunkIndex = chunkDescs[chunkIndex].parentChunkIndex))
-		{
-			chunkAnnotation[chunkIndex] = Asset::ChunkAnnotation::Parent;	// Note as non-leaf
-		}
-	}
-
-	// Walk up the hierarchy from all leaves (counting them with leafChunkCount) and keep track of the support chunks found on each chain
-	// Exactly one support chunk should be found on each walk.  Remove all but the highest support markings if more than one are found.
-	bool redundantCoverage = false;
-	bool insufficientCoverage = false;
-	for (uint32_t i = 0; i < chunkCount; ++i)
-	{
-		if (chunkAnnotation[i] & Asset::ChunkAnnotation::Parent)
-		{
-			continue;
-		}
-		++leafChunkCount;
-		uint32_t supportChunkIndex;
-		supportChunkIndex = invalidIndex<uint32_t>();
-		uint32_t chunkIndex = i;
-		bool doneWithChain = false;
-		do
-		{
-			if (chunkDescs[chunkIndex].flags & NvBlastChunkDesc::SupportFlag)
-			{
-				if (chunkAnnotation[chunkIndex] & Asset::ChunkAnnotation::Support)
-				{
-					// We've already been up this chain and marked this as support, so we have unique coverage already
-					doneWithChain = true;
-				}
-				chunkAnnotation[chunkIndex] |= Asset::ChunkAnnotation::Support;	// Note as support
-				if (!isInvalidIndex(supportChunkIndex))
-				{
-					if (testOnly)
-					{
-						return false;
-					}
-					redundantCoverage = true;
-					chunkAnnotation[supportChunkIndex] &= ~Asset::ChunkAnnotation::Support;	// Remove support marking
-					do	// Run up the hierarchy from supportChunkIndex to chunkIndex and remove the supersupport markings
-					{
-						supportChunkIndex = chunkDescs[supportChunkIndex].parentChunkIndex;
-						chunkAnnotation[supportChunkIndex] &= ~Asset::ChunkAnnotation::SuperSupport;	// Remove supersupport marking
-					} while (supportChunkIndex != chunkIndex);
-				}
-				supportChunkIndex = chunkIndex;
-			}
-			else
-			if (!isInvalidIndex(supportChunkIndex))
-			{
-				chunkAnnotation[chunkIndex] |= Asset::ChunkAnnotation::SuperSupport;	// Not a support chunk and we've already found a support chunk, so this is super-support
-			}
-		} while (!doneWithChain && !isInvalidIndex(chunkIndex = chunkDescs[chunkIndex].parentChunkIndex));
-		if (isInvalidIndex(supportChunkIndex))
-		{
-			if (testOnly)
-			{
-				return false;
-			}
-			insufficientCoverage = true;
-		}
-	}
-
-	if (redundantCoverage)
-	{
-		NVBLAST_LOG_INFO(logFn, "NvBlastCreateAsset: some leaf-to-root chains had more than one support chunk.  Some support chunks removed.");
-	}
-
-	if (insufficientCoverage)
-	{
-		// If coverage was insufficient, then walk up the hierarchy again and mark all chunks that have a support descendant.
-		// This will allow us to place support chunks at the highest possible level to obtain coverage.
-		for (uint32_t i = 0; i < chunkCount; ++i)
-		{
-			if (chunkAnnotation[i] & Asset::ChunkAnnotation::Parent)
-			{
-				continue;
-			}
-			bool supportFound = false;
-			uint32_t chunkIndex = i;
-			do
-			{
-				if (chunkAnnotation[chunkIndex] & Asset::ChunkAnnotation::Support)
-				{
-					supportFound = true;
-				}
-				else
-				if (supportFound)
-				{
-					chunkAnnotation[chunkIndex] |= Asset::ChunkAnnotation::SuperSupport;	// Note that a descendant has support
-				}
-			} while (!isInvalidIndex(chunkIndex = chunkDescs[chunkIndex].parentChunkIndex));
-		}
-
-		// Now walk up the hierarchy from each leaf one more time, and make sure there is coverage
-		for (uint32_t i = 0; i < chunkCount; ++i)
-		{
-			if (chunkAnnotation[i] & Asset::ChunkAnnotation::Parent)
-			{
-				continue;
-			}
-			uint32_t previousChunkIndex;
-			previousChunkIndex = invalidIndex<uint32_t>();
-			uint32_t chunkIndex = i;
-			for (;;)
-			{
-				if (chunkAnnotation[chunkIndex] & Asset::ChunkAnnotation::Support)
-				{
-					break;	// There is support along this chain
-				}
-				if (chunkAnnotation[chunkIndex] & Asset::ChunkAnnotation::SuperSupport)
-				{
-					NVBLAST_ASSERT(!isInvalidIndex(previousChunkIndex));	// This should be impossible
-					chunkAnnotation[previousChunkIndex] |= Asset::ChunkAnnotation::Support;	// There is no support along this chain, and this is the highest place where we can put support
-					break;
-				}
-				previousChunkIndex = chunkIndex;
-				chunkIndex = chunkDescs[chunkIndex].parentChunkIndex;
-				if (isInvalidIndex(chunkIndex))
-				{
-					chunkAnnotation[previousChunkIndex] |= Asset::ChunkAnnotation::Support;	// There was no support found anywhere in the hierarchy, so we add it at the root
-					break;
-				}
-			}
-		}
-
-		NVBLAST_LOG_INFO(logFn, "NvBlastCreateAsset: some leaf-to-root chains had no support chunks.  Support chunks added.");
-	}
-
-	// Apply changes and count the number of support chunks
-	supportChunkCount = 0;
-	for (uint32_t i = 0; i < chunkCount; ++i)
-	{
-		const bool wasSupport = (chunkDescs[i].flags & NvBlastChunkDesc::SupportFlag) != 0;
-		const bool nowSupport = (chunkAnnotation[i] & Asset::ChunkAnnotation::Support) != 0;
-		if (wasSupport != nowSupport)
-		{
-			chunkDescs[i].flags ^= NvBlastChunkDesc::SupportFlag;
-		}
-		if ((chunkDescs[i].flags & NvBlastChunkDesc::SupportFlag) != 0)
-		{
-			++supportChunkCount;
-		}
-	}
-
-	return !redundantCoverage && !insufficientCoverage;
-}
-
-
-bool Asset::testForValidChunkOrder(uint32_t chunkCount, const NvBlastChunkDesc* chunkDescs, const char* chunkAnnotation, void* scratch)
-{
-	char* chunkMarks = static_cast<char*>(memset(scratch, 0, chunkCount));
-
-	uint32_t currentParentChunkIndex = invalidIndex<uint32_t>();
-	for (uint32_t i = 0; i < chunkCount; ++i)
-	{
-		const uint32_t parentChunkIndex = chunkDescs[i].parentChunkIndex;
-		if (parentChunkIndex != currentParentChunkIndex)
-		{
-			if (!Nv::Blast::isInvalidIndex(currentParentChunkIndex))
-			{
-				chunkMarks[currentParentChunkIndex] = 1;
-			}
-			currentParentChunkIndex = parentChunkIndex;
-			if (Nv::Blast::isInvalidIndex(currentParentChunkIndex))
-			{
-				return false;
-			}
-			else if (chunkMarks[currentParentChunkIndex] != 0)
-			{
-				return false;
-			}
-		}
-
-		if (i < chunkCount - 1)
-		{
-			const bool upperSupport0 = (chunkAnnotation[i] & ChunkAnnotation::UpperSupport) != 0;
-			const bool upperSupport1 = (chunkAnnotation[i + 1] & ChunkAnnotation::UpperSupport) != 0;
-
-			if (!upperSupport0 && upperSupport1)
-			{
-				return false;
-			}
-		}
-	}
-
-	return true;
-}
-
-} // namespace Blast
-} // namespace Nv
-
-
-// API implementation
-
-extern "C"
-{
-
-size_t NvBlastGetRequiredScratchForCreateAsset(const NvBlastAssetDesc* desc, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(desc != nullptr, logFn, "NvBlastGetRequiredScratchForCreateAsset: NULL desc pointer input.", return 0);
-
-	return Nv::Blast::Asset::createRequiredScratch(desc);
-}
-
-
-size_t NvBlastGetAssetMemorySize(const NvBlastAssetDesc* desc, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(desc != nullptr, logFn, "NvBlastGetAssetMemorySize: NULL desc input.", return 0);
-
-	return Nv::Blast::Asset::getMemorySize(desc);
-}
-
-
-NvBlastAsset* NvBlastCreateAsset(void* mem, const NvBlastAssetDesc* desc, void* scratch, NvBlastLog logFn)
-{
-	return Nv::Blast::Asset::create(mem, desc, scratch, logFn);
-}
-
-
-size_t NvBlastAssetGetFamilyMemorySize(const NvBlastAsset* asset, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(asset != nullptr, logFn, "NvBlastAssetGetFamilyMemorySize: NULL asset pointer input.", return 0);
-
-	return Nv::Blast::getFamilyMemorySize(reinterpret_cast<const Nv::Blast::Asset*>(asset));
-}
-
-
-NvBlastID NvBlastAssetGetID(const NvBlastAsset* asset, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(asset != nullptr, logFn, "NvBlastAssetGetID: NULL asset pointer input.", NvBlastID zero; memset(&zero, 0, sizeof(NvBlastID)); return zero);
-
-	return ((Nv::Blast::Asset*)asset)->m_ID;
-}
-
-
-bool NvBlastAssetSetID(NvBlastAsset* asset, const NvBlastID* id, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(asset != nullptr, logFn, "NvBlastAssetSetID: NULL asset pointer input.", return false);
-	NVBLAST_CHECK(id != nullptr, logFn, "NvBlastAssetSetID: NULL id pointer input.", return false);
-
-	((Nv::Blast::Asset*)asset)->m_ID = *id;
-
-	return true;
-}
-
-
-uint32_t NvBlastAssetGetFormatVersion(const NvBlastAsset* asset, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(asset != nullptr, logFn, "NvBlastAssetGetFormatVersion: NULL asset input.", return UINT32_MAX);
-
-	return ((Nv::Blast::Asset*)asset)->m_header.formatVersion;
-}
-
-
-uint32_t NvBlastAssetGetSize(const NvBlastAsset* asset, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(asset != nullptr, logFn, "NvBlastAssetGetSize: NULL asset input.", return 0);
-
-	return ((Nv::Blast::Asset*)asset)->m_header.size;
-}
-
-
-uint32_t NvBlastAssetGetChunkCount(const NvBlastAsset* asset, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(asset != nullptr, logFn, "NvBlastAssetGetChunkCount: NULL asset input.", return 0);
-
-	return ((Nv::Blast::Asset*)asset)->m_chunkCount;
-}
-
-
-uint32_t NvBlastAssetGetLeafChunkCount(const NvBlastAsset* asset, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(asset != nullptr, logFn, "NvBlastAssetGetLeafChunkCount: NULL asset input.", return 0);
-
-	return ((Nv::Blast::Asset*)asset)->m_leafChunkCount;
-}
-
-
-uint32_t NvBlastAssetGetFirstSubsupportChunkIndex(const NvBlastAsset* asset, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(asset != nullptr, logFn, "NvBlastAssetGetFirstSubsupportChunkIndex: NULL asset input.", return 0);
-
-	return ((Nv::Blast::Asset*)asset)->m_firstSubsupportChunkIndex;
-}
-
-
-uint32_t NvBlastAssetGetBondCount(const NvBlastAsset* asset, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(asset != nullptr, logFn, "NvBlastAssetGetBondCount: NULL asset input.", return 0);
-
-	return ((Nv::Blast::Asset*)asset)->m_bondCount;
-}
-
-
-const NvBlastSupportGraph NvBlastAssetGetSupportGraph(const NvBlastAsset* asset, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(asset != nullptr, logFn, "NvBlastAssetGetSupportGraph: NULL asset input.",
-		NvBlastSupportGraph blank; blank.nodeCount = 0; blank.chunkIndices = blank.adjacencyPartition = blank.adjacentNodeIndices = blank.adjacentBondIndices = nullptr; return blank);
-
-	const Nv::Blast::SupportGraph& supportGraph = static_cast<const Nv::Blast::Asset*>(asset)->m_graph;
-
-	NvBlastSupportGraph graph;
-	graph.nodeCount = supportGraph.m_nodeCount;
-	graph.chunkIndices = supportGraph.getChunkIndices();
-	graph.adjacencyPartition = supportGraph.getAdjacencyPartition();
-	graph.adjacentNodeIndices = supportGraph.getAdjacentNodeIndices();
-	graph.adjacentBondIndices = supportGraph.getAdjacentBondIndices();
-
-	return graph;
-}
-
-
-const uint32_t* NvBlastAssetGetChunkToGraphNodeMap(const NvBlastAsset* asset, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(asset != nullptr, logFn, "NvBlastAssetGetChunkToGraphNodeMap: NULL asset input.", return nullptr);
-
-	return static_cast<const Nv::Blast::Asset*>(asset)->getChunkToGraphNodeMap();
-}
-
-
-const NvBlastChunk* NvBlastAssetGetChunks(const NvBlastAsset* asset, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(asset != nullptr, logFn, "NvBlastAssetGetChunks: NULL asset input.", return 0);
-
-	return ((Nv::Blast::Asset*)asset)->getChunks();
-}
-
-
-const NvBlastBond* NvBlastAssetGetBonds(const NvBlastAsset* asset, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(asset != nullptr, logFn, "NvBlastAssetGetBonds: NULL asset input.", return 0);
-
-	return ((Nv::Blast::Asset*)asset)->getBonds();
-}
-
-
-uint32_t NvBlastAssetGetActorSerializationSizeUpperBound(const NvBlastAsset* asset, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(asset != nullptr, logFn, "NvBlastAssetGetActorSerializationSizeUpperBound: NULL asset input.", return 0);
-
-	const Nv::Blast::Asset& solverAsset = *(const Nv::Blast::Asset*)asset;
-	const uint32_t graphNodeCount = solverAsset.m_graph.m_nodeCount;
-
-	// Calculate serialization size for an actor with all graph nodes (and therefore all bonds), and somehow with all graph nodes visible (after all, this is an upper bound).
-	const uint64_t upperBound = Nv::Blast::getActorSerializationSize(graphNodeCount, solverAsset.getLowerSupportChunkCount(), graphNodeCount, solverAsset.getBondCount());
-
-	if (upperBound > UINT32_MAX)
-	{
-		NVBLAST_LOG_WARNING(logFn, "NvBlastAssetGetActorSerializationSizeUpperBound: Serialization block size exceeds 4GB.  Returning 0.\n");
-		return 0;
-	}
-
-	return static_cast<uint32_t>(upperBound);
-}
-
-} // extern "C"
diff --git a/NvBlast/sdk/lowlevel/source/NvBlastAsset.h b/NvBlast/sdk/lowlevel/source/NvBlastAsset.h
deleted file mode 100644
index 30e8161..0000000
--- a/NvBlast/sdk/lowlevel/source/NvBlastAsset.h
+++ /dev/null
@@ -1,294 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTASSET_H
-#define NVBLASTASSET_H
-
-
-#include "NvBlastSupportGraph.h"
-#include "NvBlast.h"
-#include "NvBlastAssert.h"
-#include "NvBlastIndexFns.h"
-#include "NvBlastChunkHierarchy.h"
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-class Asset : public NvBlastAsset
-{
-public:
-
-	/**
-	Struct-enum which is used to mark chunk descriptors when building an asset.
-	*/
-	struct ChunkAnnotation
-	{
-		enum Enum
-		{
-			Parent = (1 << 0),
-			Support = (1 << 1),
-			SuperSupport = (1 << 2),
-
-			// Combinations
-			UpperSupport = Support | SuperSupport
-		};
-	};
-
-
-	/**
-	Create an asset from a descriptor.
-
-	\param[in] mem		Pointer to block of memory of at least the size given by getMemorySize(desc).  Must be 16-byte aligned.
-	\param[in] desc		Asset descriptor (see NvBlastAssetDesc).
-	\param[in] scratch	User-supplied scratch memory of size createRequiredScratch(desc) bytes.
-	\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-	\return the pointer to the new asset, or nullptr if unsuccessful.
-	*/
-	static Asset*	create(void* mem, const NvBlastAssetDesc* desc, void* scratch, NvBlastLog logFn);
-
-	/**
-	Returns the number of bytes of memory that an asset created using the given descriptor will require.  A pointer
-	to a block of memory of at least this size must be passed in as the mem argument of create.
-
-	\param[in] desc	The asset descriptor that will be passed into NvBlastCreateAsset.
-	*/
-	static size_t	getMemorySize(const NvBlastAssetDesc* desc);
-
-	/**
-	Returns the size of the scratch space (in bytes) required to be passed into the create function, based upon
-	the input descriptor that will be passed to the create function.
-
-	\param[in] desc	The descriptor that will be passed to the create function.
-
-	\return the number of bytes required.
-	*/
-	static size_t	createRequiredScratch(const NvBlastAssetDesc* desc);
-
-
-	/**
-	Returns the number of upper-support chunks in this asset..
-
-	\return the number of upper-support chunks.
-	*/
-	uint32_t		getUpperSupportChunkCount() const;
-
-	/**
-	Returns the number of lower-support chunks in this asset.  This is the required actor buffer size for a Actor family.
-
-	\return the number of lower-support chunks.
-	*/
-	uint32_t		getLowerSupportChunkCount() const;
-
-	/**
-	Returns the number of bonds in this asset's support graph.
-
-	\return the number of bonds in this asset's support graph.
-	*/
-	uint32_t		getBondCount() const;
-
-	/**
-	Returns the number of separate chunk hierarchies in the asset.  This will be the initial number of visible chunks in an actor instanced from this asset.
-
-	\return the number of separate chunk hierarchies in the asset.
-	*/
-	uint32_t		getHierarchyCount() const;
-
-	/**
-	Maps all lower-support chunk indices to a contiguous range [0, getLowerSupportChunkCount()).
-
-	\param[in] chunkIndex	Asset chunk index.
-
-	\return an index in the range [0, getLowerSupportChunkCount()) if it is a lower-support chunk, invalidIndex<uint32_t>() otherwise.
-	*/
-	uint32_t		getContiguousLowerSupportIndex(uint32_t chunkIndex) const;
-
-
-	// Static functions
-
-	/**
-	Function to ensure support coverage of chunks.
-
-	Support chunks (marked in the NvBlastChunkDesc struct) must provide full coverage over the asset.
-	This means that from any leaf chunk to the root node, exactly one chunk must be support.  If this condition
-	is not met, the actual support chunks will be adjusted accordingly.
-
-	Chunk order depends on support coverage, so this function should be called before chunk reordering.
-
-	\param[out]	supportChunkCount	The number of support chunks.  NOTE - this value is not meaninful if testOnly = true and the return value is false.
-	\param[out] leafChunkCount		The number of leaf chunks.  NOTE - this value is not meaninful if testOnly = true and the return value is false.
-	\param[out]	chunkAnnotation		User-supplied char array of size chunkCount.  NOTE - these values are not meaninful if testOnly = true and the return value is false.
-	\param[in]  chunkCount			The number of chunk descriptors.
-	\param[in]  chunkDescs			Array of chunk descriptors of size chunkCount. It will be updated accordingly.
-	\param[in]	testOnly			If true, this function early-outs if support coverage is not exact.  If false, exact coverage is ensured by possibly modifying chunkDescs' flags.
-	\param[in]  logFn				User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-	\return	true iff coverage was already exact.
-	*/
-	static bool		ensureExactSupportCoverage(uint32_t& supportChunkCount, uint32_t& leafChunkCount, char* chunkAnnotation, uint32_t chunkCount, NvBlastChunkDesc* chunkDescs, bool testOnly, NvBlastLog logFn);
-
-	/**
-	Tests a set of chunk descriptors to see if chunks are in valid chunk order.
-
-	Chunk order conditions checked:
-	1. 'all chunks with same parent index should go in a row'.
-	2. 'root chunks should go first'.
-	3. 'upper-support chunks should come before subsupport chunks'.
-
-	\param[in]	chunkCount		The number of chunk descriptors.
-	\param[in]	chunkDescs		An array of chunk descriptors of length chunkCount.
-	\param[in]	chunkAnnotation	Annotation generated from ensureExactSupportCoverage (see ensureExactSupportCoverage).
-	\param[in]	scratch			User-supplied scratch memory of chunkCount bytes.
-
-	\return true if the descriptors meet the ordering conditions, false otherwise.
-	*/
-	static bool		testForValidChunkOrder(uint32_t chunkCount, const NvBlastChunkDesc* chunkDescs, const char* chunkAnnotation, void* scratch);
-
-
-	//////// Data ////////
-
-	/**
-	Asset data block header.
-	*/
-	NvBlastDataBlock	m_header;
-
-	/**
-	ID for this asset.
-	*/
-	NvBlastID			m_ID;
-
-	/**
-	The total number of chunks in the asset, support and non-support.
-	*/
-	uint32_t			m_chunkCount;
-
-	/**
-	The support graph.
-	*/
-	SupportGraph		m_graph;
-
-	/**
-	The number of leaf chunks in the asset.
-	*/
-	uint32_t			m_leafChunkCount;
-
-	/**
-	Chunks are sorted such that subsupport chunks come last.  This is the first subsupport chunk index.  Equals m_chunkCount if there are no subsupport chunks.
-	*/
-	uint32_t			m_firstSubsupportChunkIndex;
-
-	/**
-	The number of bonds in the asset.
-	*/
-	uint32_t			m_bondCount;
-
-	/**
-	Chunks, of type NvBlastChunk.
-
-	getChunks returns an array of size m_chunkCount.
-	*/
-	NvBlastBlockArrayData(NvBlastChunk, m_chunksOffset, getChunks, m_chunkCount);
-
-	/**
-	Array of bond data for the interfaces between two chunks.  Since the bond is shared by two chunks, the same
-	bond data is used for chunk[i] -> chunk[j] as for chunk[j] -> chunk[i].
-	The size of the array is m_graph.adjacencyPartition[m_graph.m_nodeCount]/2.
-	See NvBlastBond.
-
-	getBonds returns an array of size m_bondCount.
-	*/
-	NvBlastBlockArrayData(NvBlastBond, m_bondsOffset, getBonds, m_bondCount);
-
-	/**
-	Caching the number of leaf chunks descended from each chunk (including the chunk itself).
-	This data parallels the Chunks array, and is an array of the same size.
-
-	getSubtreeLeafChunkCount returns a uint32_t array of size m_chunkCount.
-	*/
-	NvBlastBlockArrayData(uint32_t, m_subtreeLeafChunkCountsOffset, getSubtreeLeafChunkCounts, m_chunkCount);
-
-	/**
-	Mapping from chunk index to graph node index (inverse of m_graph.getChunkIndices().
-
-	getChunkToGraphNodeMap returns a uint32_t array of size m_chunkCount.
-	*/
-	NvBlastBlockArrayData(uint32_t, m_chunkToGraphNodeMapOffset, getChunkToGraphNodeMap, m_chunkCount);
-
-
-	//////// Iterators ////////
-
-	/**
-	Chunk hierarchy depth-first iterator.  Traverses subtree with root given by startChunkIndex.
-	If upperSupportOnly == true, then the iterator will not traverse subsuppport chunks.
-	*/
-	class DepthFirstIt : public ChunkDepthFirstIt
-	{
-	public:
-		/** Constructed from an asset. */
-		DepthFirstIt(const Asset& asset, uint32_t startChunkIndex, bool upperSupportOnly = false) :
-			ChunkDepthFirstIt(asset.getChunks(), startChunkIndex, upperSupportOnly ? asset.getUpperSupportChunkCount() : asset.m_chunkCount) {}
-	};
-};
-
-
-//////// Asset inline member functions ////////
-
-NV_INLINE uint32_t Asset::getUpperSupportChunkCount() const
-{
-	return m_firstSubsupportChunkIndex;
-}
-
-
-NV_INLINE uint32_t Asset::getLowerSupportChunkCount() const
-{
-	return m_graph.m_nodeCount + (m_chunkCount - m_firstSubsupportChunkIndex);
-}
-
-
-NV_INLINE uint32_t Asset::getBondCount() const
-{
-	NVBLAST_ASSERT((m_graph.getAdjacencyPartition()[m_graph.m_nodeCount] & 1) == 0);	// The bidirectional graph data should have an even number of edges
-	return m_graph.getAdjacencyPartition()[m_graph.m_nodeCount] / 2;	// Directional bonds, divide by two
-}
-
-
-NV_INLINE uint32_t Asset::getHierarchyCount() const
-{
-	const NvBlastChunk* chunks = getChunks();
-	for (uint32_t i = 0; i < m_chunkCount; ++i)
-	{
-		if (!isInvalidIndex(chunks[i].parentChunkIndex))
-		{
-			return i;
-		}
-	}
-	return m_chunkCount;
-}
-
-
-NV_INLINE uint32_t Asset::getContiguousLowerSupportIndex(uint32_t chunkIndex) const
-{
-	NVBLAST_ASSERT(chunkIndex < m_chunkCount);
-
-	return chunkIndex < m_firstSubsupportChunkIndex ? getChunkToGraphNodeMap()[chunkIndex] : (chunkIndex - m_firstSubsupportChunkIndex + m_graph.m_nodeCount);
-}
-
-
-//JDM: Expose this so serialization layer can use it.
-NVBLAST_API Asset* initializeAsset(void* mem, NvBlastID id, uint32_t chunkCount, uint32_t graphNodeCount, uint32_t leafChunkCount, uint32_t firstSubsupportChunkIndex, uint32_t bondCount, NvBlastLog logFn);
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTASSET_H
diff --git a/NvBlast/sdk/lowlevel/source/NvBlastAssetHelper.cpp b/NvBlast/sdk/lowlevel/source/NvBlastAssetHelper.cpp
deleted file mode 100644
index 0d6c5d2..0000000
--- a/NvBlast/sdk/lowlevel/source/NvBlastAssetHelper.cpp
+++ /dev/null
@@ -1,183 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastAsset.h"
-#include "NvBlastIndexFns.h"
-#include "NvBlastAssert.h"
-#include "NvBlastMemory.h"
-
-#include <algorithm>
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-/**
-Class to hold chunk descriptor and annotation context for sorting a list of indices
-*/
-class ChunksOrdered
-{
-public:
-	ChunksOrdered(const NvBlastChunkDesc* descs, const char* annotation) : m_descs(descs), m_annotation(annotation) {}
-
-	bool	operator () (uint32_t i0, uint32_t i1) const
-	{
-		const bool upperSupport0 = (m_annotation[i0] & Asset::ChunkAnnotation::UpperSupport) != 0;
-		const bool upperSupport1 = (m_annotation[i1] & Asset::ChunkAnnotation::UpperSupport) != 0;
-
-		if (upperSupport0 != upperSupport1)
-		{
-			return upperSupport0;	// If one is uppersupport and one is subsupport, uppersupport should come first
-		}
-
-		// Parent chunk index (+1 so that UINT32_MAX becomes the lowest value)
-		const uint32_t p0 = m_descs[i0].parentChunkIndex + 1;
-		const uint32_t p1 = m_descs[i1].parentChunkIndex + 1;
-
-		return p0 < p1;	// With the same support relationship, order by parent index
-	}
-
-private:
-	const NvBlastChunkDesc*	m_descs;
-	const char*				m_annotation;
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-using namespace Nv::Blast;
-
-extern "C"
-{
-
-bool NvBlastBuildAssetDescChunkReorderMap(uint32_t* chunkReorderMap, const NvBlastChunkDesc* chunkDescs, uint32_t chunkCount, void* scratch, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(chunkCount == 0 || chunkDescs != nullptr, logFn, "NvBlastBuildAssetDescChunkReorderMap: NULL chunkDescs input with non-zero chunkCount", return false);
-	NVBLAST_CHECK(chunkReorderMap == nullptr || chunkCount != 0, logFn, "NvBlastBuildAssetDescChunkReorderMap: NULL chunkReorderMap input with non-zero chunkCount", return false);
-	NVBLAST_CHECK(chunkCount == 0 || scratch != nullptr, logFn, "NvBlastBuildAssetDescChunkReorderMap: NULL scratch input with non-zero chunkCount", return false);
-
-	uint32_t* chunkMap = static_cast<uint32_t*>(scratch);	scratch = pointerOffset(scratch, chunkCount * sizeof(uint32_t));
-	char* chunkAnnotation = static_cast<char*>(scratch);	scratch = pointerOffset(scratch, chunkCount * sizeof(char));
-
-	uint32_t supportChunkCount;
-	uint32_t leafChunkCount;
-	if (!Asset::ensureExactSupportCoverage(supportChunkCount, leafChunkCount, chunkAnnotation, chunkCount, const_cast<NvBlastChunkDesc*>(chunkDescs), true, logFn))
-	{
-		NVBLAST_LOG_ERROR(logFn, "NvBlastBuildAssetDescChunkReorderMap: chunk descriptors did not have exact coverage, map could not be built.  Use NvBlastEnsureAssetExactSupportCoverage to fix descriptors.");
-		return false;
-	}
-
-	// check order for fast out (identity map)
-	if (Asset::testForValidChunkOrder(chunkCount, chunkDescs, chunkAnnotation, scratch))
-	{
-		for (uint32_t i = 0; i < chunkCount; ++i)
-		{
-			chunkReorderMap[i] = i;
-		}
-
-		return true;
-	}
-	
-	for (uint32_t i = 0; i < chunkCount; ++i)
-	{
-		chunkMap[i] = i;
-	}
-	std::sort(chunkMap, chunkMap + chunkCount, ChunksOrdered(chunkDescs, chunkAnnotation));
-
-	invertMap(chunkReorderMap, chunkMap, chunkCount);
-
-	return false;
-}
-
-
-void NvBlastApplyAssetDescChunkReorderMap
-(
-	NvBlastChunkDesc* reorderedChunkDescs,
-	const NvBlastChunkDesc* chunkDescs,
-	uint32_t chunkCount,
-	NvBlastBondDesc* bondDescs,
-	uint32_t bondCount,
-	const uint32_t* chunkReorderMap,
-	NvBlastLog logFn
-)
-{
-	NVBLAST_CHECK(chunkCount == 0 || chunkDescs != nullptr, logFn, "NvBlastApplyAssetDescChunkReorderMap: NULL chunkDescs input with non-zero chunkCount", return);
-	NVBLAST_CHECK(reorderedChunkDescs == nullptr || chunkCount != 0, logFn, "NvBlastApplyAssetDescChunkReorderMap: NULL reorderedChunkDescs input with non-zero chunkCount", return);
-	NVBLAST_CHECK(chunkReorderMap == nullptr || chunkCount != 0, logFn, "NvBlastApplyAssetDescChunkReorderMap: NULL chunkReorderMap input with non-zero chunkCount", return);
-	NVBLAST_CHECK(bondCount == 0 || bondDescs != nullptr, logFn, "NvBlastApplyAssetDescChunkReorderMap: NULL bondDescs input with non-zero bondCount", return);
-	NVBLAST_CHECK(bondDescs == nullptr || chunkReorderMap != nullptr, logFn, "NvBlastApplyAssetDescChunkReorderMap: NULL bondDescs input with NULL chunkReorderMap", return);
-
-	// Copy chunk descs 
-	if (reorderedChunkDescs)
-	{
-		for (uint32_t i = 0; i < chunkCount; ++i)
-		{
-			reorderedChunkDescs[chunkReorderMap[i]] = chunkDescs[i];
-			uint32_t& parentIndex = reorderedChunkDescs[chunkReorderMap[i]].parentChunkIndex;
-			if (parentIndex < chunkCount)
-			{
-				parentIndex = chunkReorderMap[parentIndex];	// If the parent index is valid, remap it too to reflect the new order
-			}
-		}
-	}
-
-	if (bondDescs)
-	{
-		for (uint32_t i = 0; i < bondCount; ++i)
-		{
-			for (int j = 0; j < 2; ++j)
-			{
-				uint32_t& index = bondDescs[i].chunkIndices[j];
-				if (index < chunkCount)
-				{
-					index = chunkReorderMap[index];
-				}
-			}
-		}
-	}
-}
-
-
-void NvBlastApplyAssetDescChunkReorderMapInplace(NvBlastChunkDesc* chunkDescs, uint32_t chunkCount, NvBlastBondDesc* bondDescs, uint32_t bondCount, const uint32_t* chunkReorderMap, void* scratch, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(chunkCount == 0 || chunkDescs != nullptr, logFn, "NvBlastApplyAssetDescChunkReorderMapInplace: NULL chunkDescs input with non-zero chunkCount", return);
-	NVBLAST_CHECK(chunkCount == 0 || scratch != nullptr, logFn, "NvBlastApplyAssetDescChunkReorderMapInplace: NULL scratch input with non-zero chunkCount", return);
-
-	NvBlastChunkDesc* chunksTemp = static_cast<NvBlastChunkDesc*>(scratch);
-	memcpy(chunksTemp, chunkDescs, sizeof(NvBlastChunkDesc) * chunkCount);
-	NvBlastApplyAssetDescChunkReorderMap(chunkDescs, chunksTemp, chunkCount, bondDescs, bondCount, chunkReorderMap, logFn);
-}
-
-
-bool NvBlastReorderAssetDescChunks(NvBlastChunkDesc* chunkDescs, uint32_t chunkCount, NvBlastBondDesc* bondDescs, uint32_t bondCount, uint32_t* chunkReorderMap, void* scratch, NvBlastLog logFn)
-{
-	if (!NvBlastBuildAssetDescChunkReorderMap(chunkReorderMap, chunkDescs, chunkCount, scratch, logFn))
-	{
-		NvBlastApplyAssetDescChunkReorderMapInplace(chunkDescs, chunkCount, bondDescs, bondCount, chunkReorderMap, scratch, logFn);
-		return false;
-	}
-	return true;
-}
-
-
-bool NvBlastEnsureAssetExactSupportCoverage(NvBlastChunkDesc* chunkDescs, uint32_t chunkCount, void* scratch, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(chunkCount == 0 || chunkDescs != nullptr, logFn, "NvBlastEnsureAssetExactSupportCoverage: NULL chunkDescs input with non-zero chunkCount", return false);
-	NVBLAST_CHECK(chunkCount == 0 || scratch != nullptr, logFn, "NvBlastEnsureAssetExactSupportCoverage: NULL scratch input with non-zero chunkCount", return false);
-
-	uint32_t supportChunkCount;
-	uint32_t leafChunkCount;
-	return Asset::ensureExactSupportCoverage(supportChunkCount, leafChunkCount, static_cast<char*>(scratch), chunkCount, chunkDescs, false, logFn);
-}
-
-} // extern "C"
diff --git a/NvBlast/sdk/lowlevel/source/NvBlastChunkHierarchy.h b/NvBlast/sdk/lowlevel/source/NvBlastChunkHierarchy.h
deleted file mode 100644
index e7e05c6..0000000
--- a/NvBlast/sdk/lowlevel/source/NvBlastChunkHierarchy.h
+++ /dev/null
@@ -1,232 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTCHUNKHIERARCHY_H
-#define NVBLASTCHUNKHIERARCHY_H
-
-
-#include "NvBlastIndexFns.h"
-#include "NvBlastDLink.h"
-#include "NvBlast.h"
-#include "NvBlastAssert.h"
-#include "NvBlastIteratorBase.h"
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-/**
-Chunk hierarchy depth-first iterator.  Traverses subtree with root given by startChunkIndex.
-Will not traverse chunks with index at or beyond chunkIndexLimit.
-*/
-class ChunkDepthFirstIt : public IteratorBase<uint32_t>
-{
-public:
-	/** Constructed from a chunk array. */
-	ChunkDepthFirstIt(const NvBlastChunk* chunks, uint32_t startChunkIndex, uint32_t chunkIndexLimit) :
-		IteratorBase<uint32_t>(startChunkIndex), m_chunks(chunks), m_stop(startChunkIndex), m_limit(chunkIndexLimit)
-	{
-		if (m_curr >= m_limit)
-		{
-			m_curr = invalidIndex<uint32_t>();
-		}
-	}
-
-	/** Pre-increment.  Only use if valid() == true. */
-	uint32_t	operator ++ ()
-	{
-		NVBLAST_ASSERT(!isInvalidIndex(m_curr));
-		const NvBlastChunk* chunk = m_chunks + m_curr;
-		if (chunk->childIndexStop > chunk->firstChildIndex && chunk->firstChildIndex < m_limit)
-		{
-			m_curr = chunk->firstChildIndex;
-		}
-		else
-		{
-			for (;;)
-			{
-				if (m_curr == m_stop)
-				{
-					m_curr = invalidIndex<uint32_t>();
-					break;
-				}
-				NVBLAST_ASSERT(!isInvalidIndex(chunk->parentChunkIndex));	// This should not be possible with this search
-				const NvBlastChunk* parentChunk = m_chunks + chunk->parentChunkIndex;
-				if (++m_curr < parentChunk->childIndexStop)
-				{
-					break;	// Sibling chunk is valid, that's the next chunk
-				}
-				m_curr = chunk->parentChunkIndex;
-				chunk = parentChunk;
-			}
-		}
-		return m_curr;
-	}
-
-private:
-	const NvBlastChunk*	m_chunks;
-	uint32_t			m_stop;
-	uint32_t			m_limit;
-};
-
-
-/**
-Enumerates chunk indices in a subtree with root given by chunkIndex, in breadth-first order.
-Will not traverse chunks with index at or beyond chunkIndexLimit.
-Returns the number of indices written to the chunkIndex array
-*/
-NV_INLINE uint32_t enumerateChunkHierarchyBreadthFirst
-(
-uint32_t* chunkIndices,
-uint32_t chunkIndicesSize,
-const NvBlastChunk* chunks,
-uint32_t chunkIndex,
-bool includeRoot = true,
-uint32_t chunkIndexLimit = invalidIndex<uint32_t>()
-)
-{
-	if (chunkIndicesSize == 0)
-	{
-		return 0;
-	}
-	uint32_t chunkIndexCount = 0;
-	bool rootHandled = false;
-	if (includeRoot)
-	{
-		chunkIndices[chunkIndexCount++] = chunkIndex;
-		rootHandled = true;
-	}
-	for (uint32_t curr = 0; !rootHandled || curr < chunkIndexCount;)
-	{
-		const NvBlastChunk& chunk = chunks[rootHandled ? chunkIndices[curr] : chunkIndex];
-		if (chunk.firstChildIndex < chunkIndexLimit)
-		{
-			const uint32_t childIndexStop = chunk.childIndexStop < chunkIndexLimit ? chunk.childIndexStop : chunkIndexLimit;
-			const uint32_t childIndexBufferStop = chunk.firstChildIndex + (chunkIndicesSize - chunkIndexCount);
-			const uint32_t stop = childIndexStop < childIndexBufferStop ? childIndexStop : childIndexBufferStop;
-			for (uint32_t childIndex = chunk.firstChildIndex; childIndex < stop; ++childIndex)
-			{
-				chunkIndices[chunkIndexCount++] = childIndex;
-			}
-		}
-		if (rootHandled)
-		{
-			++curr;
-		}
-		rootHandled = true;
-	}
-	return chunkIndexCount;
-}
-
-
-/**
-VisibilityRep must have m_firstVisibleChunkIndex and m_visibleChunkCount fields
-*/
-template<class VisibilityRep>
-void updateVisibleChunksFromSupportChunk
-(
-VisibilityRep* actors,
-IndexDLink<uint32_t>* visibleChunkIndexLinks,
-uint32_t* chunkActorIndices,
-uint32_t actorIndex,
-uint32_t supportChunkIndex,
-const NvBlastChunk* chunks,
-uint32_t upperSupportChunkCount
-)
-{
-	uint32_t chunkIndex = supportChunkIndex;
-	uint32_t chunkActorIndex = chunkActorIndices[supportChunkIndex];
-	uint32_t newChunkActorIndex = actorIndex;
-	VisibilityRep& thisActor = actors[actorIndex];
-
-	do
-	{
-		if (chunkActorIndex == newChunkActorIndex)
-		{
-			break;	// Nothing to do
-		}
-
-		const uint32_t parentChunkIndex = chunks[chunkIndex].parentChunkIndex;
-		const uint32_t parentChunkActorIndex = parentChunkIndex != invalidIndex<uint32_t>() ? chunkActorIndices[parentChunkIndex] : invalidIndex<uint32_t>();
-		const bool chunkVisible = chunkActorIndex != parentChunkActorIndex;
-
-		// If the chunk is visible, it needs to be removed from its old actor's visibility list
-		if (chunkVisible && !isInvalidIndex(chunkActorIndex))
-		{
-			VisibilityRep& chunkActor = actors[chunkActorIndex];
-			IndexDList<uint32_t>().removeFromList(chunkActor.m_firstVisibleChunkIndex, visibleChunkIndexLinks, chunkIndex);
-			--chunkActor.m_visibleChunkCount;
-		}
-
-		// Now update the chunk's actor index
-		const uint32_t oldChunkActorIndex = chunkActorIndices[chunkIndex];
-		chunkActorIndices[chunkIndex] = newChunkActorIndex;
-		if (newChunkActorIndex != invalidIndex<uint32_t>() && parentChunkActorIndex != newChunkActorIndex)
-		{
-			// The chunk is now visible.  Add it to this actor's visibility list
-			IndexDList<uint32_t>().insertListHead(thisActor.m_firstVisibleChunkIndex, visibleChunkIndexLinks, chunkIndex);
-			++thisActor.m_visibleChunkCount;
-			// Remove its children from this actor's visibility list
-			if (actorIndex != oldChunkActorIndex)
-			{
-				const NvBlastChunk& chunk = chunks[chunkIndex];
-				if (chunk.firstChildIndex < upperSupportChunkCount)	// Only need to deal with upper-support children
-				{
-					for (uint32_t childChunkIndex = chunk.firstChildIndex; childChunkIndex < chunk.childIndexStop; ++childChunkIndex)
-					{
-						if (chunkActorIndices[childChunkIndex] == actorIndex)
-						{
-							IndexDList<uint32_t>().removeFromList(thisActor.m_firstVisibleChunkIndex, visibleChunkIndexLinks, childChunkIndex);
-							--thisActor.m_visibleChunkCount;
-						}
-					}
-				}
-			}
-		}
-
-		if (parentChunkIndex != invalidIndex<uint32_t>())
-		{
-			// If all of its siblings have the same index, then the parent will too.  Otherwise, the parent will have an invalid index and its children will be visible
-			const NvBlastChunk& parentChunk = chunks[parentChunkIndex];
-			bool uniform = true;
-			for (uint32_t childChunkIndex = parentChunk.firstChildIndex; uniform && childChunkIndex < parentChunk.childIndexStop; ++childChunkIndex)
-			{
-				uniform = (newChunkActorIndex == chunkActorIndices[childChunkIndex]);
-			}
-			if (!uniform)
-			{
-				newChunkActorIndex = invalidIndex<uint32_t>();
-				for (uint32_t childChunkIndex = parentChunk.firstChildIndex; childChunkIndex < parentChunk.childIndexStop; ++childChunkIndex)
-				{
-					const uint32_t childChunkActorIndex = chunkActorIndices[childChunkIndex];
-					if (childChunkActorIndex != invalidIndex<uint32_t>() && childChunkActorIndex == parentChunkActorIndex)
-					{
-						// The child was invisible.  Add it to its actor's visibility list
-						VisibilityRep& childChunkActor = actors[childChunkActorIndex];
-						IndexDList<uint32_t>().insertListHead(childChunkActor.m_firstVisibleChunkIndex, visibleChunkIndexLinks, childChunkIndex);
-						++childChunkActor.m_visibleChunkCount;
-					}
-				}
-			}
-		}
-
-		// Climb the hierarchy
-		chunkIndex = parentChunkIndex;
-		chunkActorIndex = parentChunkActorIndex;
-	} while (chunkIndex != invalidIndex<uint32_t>());
-}
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTCHUNKHIERARCHY_H
diff --git a/NvBlast/sdk/lowlevel/source/NvBlastFamily.cpp b/NvBlast/sdk/lowlevel/source/NvBlastFamily.cpp
deleted file mode 100644
index 1f517b1..0000000
--- a/NvBlast/sdk/lowlevel/source/NvBlastFamily.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-
-#include "NvBlastFamily.h"
-#include "NvBlastFamilyGraph.h"
-#include "NvBlastIndexFns.h"
-
-#include <new>
-
-namespace Nv
-{
-namespace Blast
-{
-
-//////// Global functions ////////
-
-struct FamilyDataOffsets
-{
-	size_t m_actors;
-	size_t m_visibleChunkIndexLinks;
-	size_t m_chunkActorIndices;
-	size_t m_graphNodeIndexLinks;
-	size_t m_lowerSupportChunkHealths;
-	size_t m_graphBondHealths;
-	size_t m_familyGraph;
-};
-
-
-static size_t createFamilyDataOffsets(FamilyDataOffsets& offsets, const Asset* asset)
-{
-	const Nv::Blast::SupportGraph& graph = asset->m_graph;
-
-	NvBlastCreateOffsetStart(sizeof(FamilyHeader));
-	NvBlastCreateOffsetAlign16(offsets.m_actors, asset->getLowerSupportChunkCount() * sizeof(Actor));
-	NvBlastCreateOffsetAlign16(offsets.m_visibleChunkIndexLinks, asset->m_chunkCount * sizeof(IndexDLink<uint32_t>));
-	NvBlastCreateOffsetAlign16(offsets.m_chunkActorIndices, asset->getUpperSupportChunkCount() * sizeof(uint32_t));
-	NvBlastCreateOffsetAlign16(offsets.m_graphNodeIndexLinks, graph.m_nodeCount * sizeof(uint32_t));
-	NvBlastCreateOffsetAlign16(offsets.m_lowerSupportChunkHealths, asset->getLowerSupportChunkCount() * sizeof(float));
-	NvBlastCreateOffsetAlign16(offsets.m_graphBondHealths, asset->getBondCount() * sizeof(float));
-	NvBlastCreateOffsetAlign16(offsets.m_familyGraph, static_cast<size_t>(FamilyGraph::requiredMemorySize(graph.m_nodeCount, asset->getBondCount())));
-	return NvBlastCreateOffsetEndAlign16();
-}
-
-
-size_t getFamilyMemorySize(const Asset* asset)
-{
-#if NVBLAST_CHECK_PARAMS
-	if (asset == nullptr)
-	{
-		NVBLAST_ALWAYS_ASSERT();
-		return 0;
-	}
-#endif
-
-	FamilyDataOffsets offsets;
-	return createFamilyDataOffsets(offsets, asset);
-}
-
-
-NvBlastFamily* createFamily(void* mem, const NvBlastAsset* asset, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(mem != nullptr, logFn, "createFamily: NULL mem pointer input.", return nullptr);
-	NVBLAST_CHECK(asset != nullptr, logFn, "createFamily: NULL asset pointer input.", return nullptr);
-
-	NVBLAST_CHECK((reinterpret_cast<uintptr_t>(mem) & 0xF) == 0, logFn, "createFamily: mem pointer not 16-byte aligned.", return nullptr);
-
-	const Asset& solverAsset = *static_cast<const Asset*>(asset);
-
-	if (solverAsset.m_chunkCount == 0)
-	{
-		NVBLAST_LOG_ERROR(logFn, "createFamily: Asset has no chunks.  Family not created.\n");
-		return nullptr;
-	}
-
-	const Nv::Blast::SupportGraph& graph = solverAsset.m_graph;
-
-	const uint32_t bondCount = solverAsset.getBondCount();
-
-	// We need to keep this many actor representations around for our island indexing scheme.
-	const uint32_t lowerSupportChunkCount = solverAsset.getLowerSupportChunkCount();
-
-	// We need this many chunk actor indices.
-	const uint32_t upperSupportChunkCount = solverAsset.getUpperSupportChunkCount();
-
-	// Family offsets
-	FamilyDataOffsets offsets;
-	const size_t dataSize = createFamilyDataOffsets(offsets, &solverAsset);
-
-	// Restricting our data size to < 4GB so that we may use uint32_t offsets
-	if (dataSize > (size_t)UINT32_MAX)
-	{
-		NVBLAST_LOG_ERROR(logFn, "Nv::Blast::Actor::instanceAllocate: Instance data block size will exceed 4GB.  Instance not created.\n");
-		return nullptr;
-	}
-
-	// Allocate family
-	NvBlastFamily* family = (NvBlastFamily*)mem;
-
-	// Fill in family header
-	FamilyHeader* header = (FamilyHeader*)family;
-	header->dataType = NvBlastDataBlock::FamilyDataBlock;
-	header->formatVersion = NvBlastFamilyDataFormat::Current;
-	header->size = (uint32_t)dataSize;
-	header->m_assetID = solverAsset.m_ID;
-	header->m_actorCount = 0;
-	header->m_actorsOffset = (uint32_t)offsets.m_actors;
-	header->m_visibleChunkIndexLinksOffset = (uint32_t)offsets.m_visibleChunkIndexLinks;
-	header->m_chunkActorIndicesOffset = (uint32_t)offsets.m_chunkActorIndices;
-	header->m_graphNodeIndexLinksOffset = (uint32_t)offsets.m_graphNodeIndexLinks;
-	header->m_lowerSupportChunkHealthsOffset = (uint32_t)offsets.m_lowerSupportChunkHealths;
-	header->m_graphBondHealthsOffset = (uint32_t)offsets.m_graphBondHealths;
-	header->m_familyGraphOffset = (uint32_t)offsets.m_familyGraph;
-
-	// Runtime data
-	header->m_asset = &solverAsset;	// NOTE: this should be resolved from m_assetID
-
-	// Initialize family header data:
-
-	// Actors - initialize to defaults, with zero offset value (indicating inactive state)
-	Actor* actors = header->getActors();	// This will get the subsupport actors too
-	for (uint32_t i = 0; i < lowerSupportChunkCount; ++i)
-	{
-		new (actors + i) Actor();
-	}
-
-	// Visible chunk index links - initialize to solitary links (0xFFFFFFFF fields)
-	memset(header->getVisibleChunkIndexLinks(), 0xFF, solverAsset.m_chunkCount*sizeof(IndexDLink<uint32_t>));
-
-	// Chunk actor IDs - initialize to invalid (0xFFFFFFFF)
-	memset(header->getChunkActorIndices(), 0xFF, upperSupportChunkCount*sizeof(uint32_t));
-
-	// Graph node index links - initialize to solitary links
-	memset(header->getGraphNodeIndexLinks(), 0xFF, graph.m_nodeCount*sizeof(uint32_t));
-
-	// Healths are initialized to 0
-	memset(header->getLowerSupportChunkHealths(), 0, lowerSupportChunkCount*sizeof(float));
-	memset(header->getBondHealths(), 0, bondCount*sizeof(float));
-
-	// FamilyGraph ctor
-	new (header->getFamilyGraph()) FamilyGraph(&graph);
-
-	return family;
-}
-
-} // namespace Blast
-} // namespace Nv
-
-
-// API implementation
-
-extern "C"
-{
-
-NvBlastFamily* NvBlastAssetCreateFamily(void* mem, const NvBlastAsset* asset, NvBlastLog logFn)
-{
-	return Nv::Blast::createFamily(mem, asset, logFn);
-}
-
-
-uint32_t NvBlastFamilyGetFormatVersion(const NvBlastFamily* family, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(family != nullptr, logFn, "NvBlastFamilyGetFormatVersion: NULL family pointer input.", return UINT32_MAX);
-	return reinterpret_cast<const Nv::Blast::FamilyHeader*>(family)->formatVersion;
-}
-
-
-void NvBlastFamilySetAsset(NvBlastFamily* family, const NvBlastAsset* asset, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(family != nullptr, logFn, "NvBlastFamilySetAsset: NULL family pointer input.", return);
-	NVBLAST_CHECK(asset != nullptr, logFn, "NvBlastFamilySetAsset: NULL asset pointer input.", return);
-
-	Nv::Blast::FamilyHeader* header = reinterpret_cast<Nv::Blast::FamilyHeader*>(family);
-	const Nv::Blast::Asset* solverAsset = reinterpret_cast<const Nv::Blast::Asset*>(asset);
-
-	if (memcmp(&header->m_assetID, &solverAsset->m_ID, sizeof(NvBlastID)))
-	{
-		NVBLAST_LOG_ERROR(logFn, "NvBlastFamilySetAsset: wrong asset.  Passed asset ID doesn't match family asset ID.");
-		return;
-	}
-
-	header->m_asset = solverAsset;
-}
-
-
-uint32_t NvBlastFamilyGetSize(const NvBlastFamily* family, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(family != nullptr, logFn, "NvBlastFamilyGetSize: NULL family pointer input.", return 0);
-	return reinterpret_cast<const Nv::Blast::FamilyHeader*>(family)->size;
-}
-
-
-NvBlastID NvBlastFamilyGetAssetID(const NvBlastFamily* family, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(family != nullptr, logFn, "NvBlastFamilyGetAssetID: NULL family pointer input.", return NvBlastID());
-	return reinterpret_cast<const Nv::Blast::FamilyHeader*>(family)->m_assetID;
-}
-
-
-uint32_t NvBlastFamilyGetActorCount(const NvBlastFamily* family, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(family != nullptr, logFn, "NvBlastFamilyGetActorCount: NULL family pointer input.", return 0);
-
-	const Nv::Blast::FamilyHeader* header = reinterpret_cast<const Nv::Blast::FamilyHeader*>(family);
-
-	if (header->formatVersion != NvBlastFamilyDataFormat::Current)
-	{
-		NVBLAST_LOG_ERROR(logFn, "NvBlastFamilyGetActorCount: wrong family format.  Family must be converted to current version.");
-		return 0;
-	}
-
-	return header->m_actorCount;
-}
-
-
-uint32_t NvBlastFamilyGetActors(NvBlastActor** actors, uint32_t actorsSize, const NvBlastFamily* family, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(actors != nullptr, logFn, "NvBlastFamilyGetActors: NULL actors pointer input.", return 0);
-	NVBLAST_CHECK(family != nullptr, logFn, "NvBlastFamilyGetActors: NULL family pointer input.", return 0);
-
-	const Nv::Blast::FamilyHeader* header = reinterpret_cast<const Nv::Blast::FamilyHeader*>(family);
-
-	if (header->formatVersion != NvBlastFamilyDataFormat::Current)
-	{
-		NVBLAST_LOG_ERROR(logFn, "NvBlastFamilyGetActors: wrong family format.  Family must be converted to current version.");
-		return 0;
-	}
-
-	// Iterate through active actors and write to supplied array
-	const uint32_t familyActorCount = header->getActorBufferSize();
-	Nv::Blast::Actor* familyActor = header->getActors();
-	uint32_t actorCount = 0;
-	for (uint32_t i = 0; actorCount < actorsSize && i < familyActorCount; ++i, ++familyActor)
-	{
-		if (familyActor->isActive())
-		{
-			actors[actorCount++] = familyActor;
-		}
-	}
-
-	return actorCount;
-}
-
-
-NvBlastActor* NvBlastFamilyGetChunkActor(const NvBlastFamily* family, uint32_t chunkIndex, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(family != nullptr, logFn, "NvBlastFamilyGetChunkActor: NULL family pointer input.", return nullptr);
-
-	const Nv::Blast::FamilyHeader* header = reinterpret_cast<const Nv::Blast::FamilyHeader*>(family);
-
-	NVBLAST_CHECK(header->m_asset != nullptr, logFn, "NvBlastFamilyGetChunkActor: NvBlastFamily has null asset set.", return nullptr);
-
-	const Nv::Blast::Asset& solverAsset = *static_cast<const Nv::Blast::Asset*>(header->m_asset);
-	NVBLAST_CHECK(chunkIndex < solverAsset.m_chunkCount, logFn, "NvBlastFamilyGetChunkActor: bad value of chunkIndex for the given family's asset.", return nullptr);
-
-	// get actorIndex from chunkIndex
-	uint32_t actorIndex;
-	if (chunkIndex < solverAsset.getUpperSupportChunkCount())
-	{
-		actorIndex = header->getChunkActorIndices()[chunkIndex];
-	}
-	else
-	{
-		actorIndex = chunkIndex - (solverAsset.getUpperSupportChunkCount() - solverAsset.m_graph.m_nodeCount);
-	}
-
-	// get actor from actorIndex
-	if (!Nv::Blast::isInvalidIndex(actorIndex))
-	{
-		NVBLAST_ASSERT(actorIndex < header->getActorBufferSize());
-		Nv::Blast::Actor* actor = &header->getActors()[actorIndex];
-		if (actor->isActive())
-		{
-			return actor;
-		}
-	}
-	return nullptr;
-}
-
-
-uint32_t NvBlastFamilyGetMaxActorCount(const NvBlastFamily* family, NvBlastLog logFn)
-{
-	NVBLAST_CHECK(family != nullptr, logFn, "NvBlastFamilyGetMaxActorCount: NULL family pointer input.", return 0);
-	const Nv::Blast::FamilyHeader* header = reinterpret_cast<const Nv::Blast::FamilyHeader*>(family);
-	return header->getActorBufferSize();
-}
-
-} // extern "C"
diff --git a/NvBlast/sdk/lowlevel/source/NvBlastFamily.h b/NvBlast/sdk/lowlevel/source/NvBlastFamily.h
deleted file mode 100644
index d1cb069..0000000
--- a/NvBlast/sdk/lowlevel/source/NvBlastFamily.h
+++ /dev/null
@@ -1,238 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTFAMILY_H
-#define NVBLASTFAMILY_H
-
-
-#include "NvBlastPreprocessorInternal.h"
-#include "NvBlastAsset.h"
-#include "NvBlastPreprocessor.h"
-#include "NvBlastDLink.h"
-#include "NvBlastAtomic.h"
-#include "NvBlastMemory.h"
-
-#include <cstring>
-
-
-struct NvBlastAsset;
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-// Forward declarations
-class FamilyGraph;
-class Actor;
-class Asset;
-
-
-/**
-Data header at the beginning of every NvBlastActor family
-
-The block address may be cast to a valid FamilyHeader pointer.
-*/
-struct FamilyHeader : public NvBlastDataBlock
-{
-	/**
-	The ID for the asset.  This will be resolved into a pointer in the runtime data.
-	*/
-	NvBlastID	m_assetID;
-
-	/**
-	Actors, of type Actor.
-
-	Actors with support chunks will use this array in the range [0, m_asset->m_graphNodeCount),
-	while subsupport actors will be placed in the range [m_asset->m_graphNodeCount, getActorBufferSize()).
-	*/
-	NvBlastBlockArrayData(Actor, m_actorsOffset, getActors, m_asset->m_graph.m_nodeCount);
-
-	/**
-	Visible chunk index links, of type IndexDLink<uint32_t>.
-
-	getVisibleChunkIndexLinks returns an array of size m_asset->m_chunkCount of IndexDLink<uint32_t> (see IndexDLink).
-	*/
-	NvBlastBlockArrayData(IndexDLink<uint32_t>, m_visibleChunkIndexLinksOffset, getVisibleChunkIndexLinks, m_asset->m_chunkCount);
-
-	/**
-	Chunk actor IDs, of type uint32_t.  These correspond to the ID of the actor which owns each chunk.  A value of invalidIndex<uint32_t>() indicates no owner.
-
-	getChunkActorIndices returns an array of size m_asset->m_firstSubsupportChunkIndex.
-	*/
-	NvBlastBlockArrayData(uint32_t, m_chunkActorIndicesOffset, getChunkActorIndices, m_asset->m_firstSubsupportChunkIndex);
-
-	/**
-	Graph node index links, of type uint32_t.  The successor to index[i] is m_graphNodeIndexLinksOffset[i].  A value of invalidIndex<uint32_t>() indicates no successor.
-
-	getGraphNodeIndexLinks returns an array of size m_asset->m_graphNodeCount.
-	*/
-	NvBlastBlockArrayData(uint32_t, m_graphNodeIndexLinksOffset, getGraphNodeIndexLinks, m_asset->m_graph.m_nodeCount);
-
-	/**
-	Health for each support chunk and subsupport chunk, of type float.
-
-	To access support chunks, use the corresponding graph node index in the array returned by getLowerSupportChunkHealths.
-
-	To access subsupport chunk healths, use getSubsupportChunkHealths (see documentation for details).
-	*/
-	NvBlastBlockArrayData(float, m_lowerSupportChunkHealthsOffset, getLowerSupportChunkHealths, m_asset->getLowerSupportChunkCount());
-
-	/**
-	Utility function to get the start of the subsupport chunk health array.
-
-	To access a subsupport chunk health indexed by i, use getSubsupportChunkHealths()[i - m_asset->m_firstSubsupportChunkIndex]
-
-	\return the array of health values associated with all descendants of support chunks.
-	*/
-	float*	getSubsupportChunkHealths() const
-	{
-		NVBLAST_ASSERT(m_asset != nullptr);
-		return (float*)((uintptr_t)this + m_lowerSupportChunkHealthsOffset) + m_asset->m_graph.m_nodeCount;
-	}
-
-	/**
-	Bond health for the interfaces between two chunks, of type float.  Since the bond is shared by two chunks, the same bond health is used for chunk[i] -> chunk[j] as for chunk[j] -> chunk[i].
-
-	getBondHealths returns the array of healths associated with all bonds in the support graph.
-	*/
-	NvBlastBlockArrayData(float, m_graphBondHealthsOffset, getBondHealths, m_asset->getBondCount());
-
-	/**
-	The instance graph for islands searching, of type FamilyGraph.
-
-	Return the dynamic data generated for the support graph.  (See FamilyGraph.)
-	This is used to store current connectivity information based upon bond and chunk healths, as well as cached intermediate data for faster incremental updates.
-	*/
-	NvBlastBlockData(FamilyGraph, m_familyGraphOffset, getFamilyGraph);
-
-
-	//////// Runtime data ////////
-
-	/**
-	The number of actors using this block.
-	*/
-	volatile uint32_t	m_actorCount;
-
-	/**
-	The asset corresponding to all actors in this family.
-	This is runtime data and will be resolved from m_assetID.
-	*/
-	union
-	{
-		const Asset*	m_asset;
-		uint64_t		m_runtimePlaceholder;	// Make sure we reserve enough room for an 8-byte pointer
-	};
-
-
-	//////// Functions ////////
-
-	/**
-	Gets an actor from the actor array and validates it if it is not already valid.  This increments the actor reference count.
-
-	\param[in] index	The index of the actor to borrow.  Must be in the range [0, getActorBufferSize()).
-
-	\return	A pointer to the indexed Actor.
-	*/
-	Actor*		borrowActor(uint32_t index);
-
-	/**
-	Invalidates the actor if it is not already invalid.  This decrements the actor reference count, but does not free this block when the count goes to zero.
-
-	\param[in] actor	The actor to invalidate.
-	*/
-	void		returnActor(Actor& actor);
-
-	/**
-	Returns the total number of actors in the Actor buffer, active and inactive.
-
-	\return the number of Actors in the actor buffer.  See borrowActor.
-	*/
-	uint32_t	getActorBufferSize() const;
-
-	/**
-	Returns a value to indicate whether or not the Actor with the given index is valid for use (active).
-
-	\return	true iff the indexed actor is active.
-	*/
-	bool		isActorActive(uint32_t index) const;
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-#include "NvBlastActor.h"
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-//////// FamilyHeader inline methods ////////
-
-NV_INLINE Actor* FamilyHeader::borrowActor(uint32_t index)
-{
-	NVBLAST_ASSERT(index < getActorBufferSize());
-	Actor& actor = getActors()[index];
-	if (actor.m_familyOffset == 0)
-	{
-		const uintptr_t offset = (uintptr_t)&actor - (uintptr_t)this;
-		NVBLAST_ASSERT(offset <= UINT32_MAX);
-		actor.m_familyOffset = (uint32_t)offset;
-		atomicIncrement(reinterpret_cast<volatile int32_t*>(&m_actorCount));
-	}
-	return &actor;
-}
-
-
-NV_INLINE void FamilyHeader::returnActor(Actor& actor)
-{
-	if (actor.m_familyOffset != 0)
-	{
-		actor.m_familyOffset = 0;
-		// The actor count should be positive since this actor was valid.  Check to be safe.
-		NVBLAST_ASSERT(m_actorCount > 0);
-		atomicDecrement(reinterpret_cast<volatile int32_t*>(&m_actorCount));
-	}
-}
-
-
-NV_INLINE uint32_t FamilyHeader::getActorBufferSize() const
-{
-	NVBLAST_ASSERT(m_asset);
-	return m_asset->getLowerSupportChunkCount();
-}
-
-
-NV_INLINE bool FamilyHeader::isActorActive(uint32_t index) const
-{
-	NVBLAST_ASSERT(index < getActorBufferSize());
-	return getActors()[index].m_familyOffset != 0;
-}
-
-
-//////// Global functions ////////
-
-/**
-Returns the number of bytes of memory that a family created using the given asset will require.  A pointer
-to a block of memory of at least this size must be passed in as the mem argument of createFamily.
-
-\param[in] asset	The asset that will be passed into NvBlastAssetCreateFamily.
-*/
-size_t getFamilyMemorySize(const Asset* asset);
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTFAMILY_H
diff --git a/NvBlast/sdk/lowlevel/source/NvBlastFamilyGraph.cpp b/NvBlast/sdk/lowlevel/source/NvBlastFamilyGraph.cpp
deleted file mode 100644
index 08ed83d..0000000
--- a/NvBlast/sdk/lowlevel/source/NvBlastFamilyGraph.cpp
+++ /dev/null
@@ -1,629 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastFamilyGraph.h"
-
-#include "NvBlastAssert.h"
-
-#include <vector>
-#include <stack>
-
-#define SANITY_CHECKS 0
-
-namespace Nv
-{
-namespace Blast
-{
-
-
-size_t FamilyGraph::fillMemory(FamilyGraph* familyGraph, uint32_t nodeCount, uint32_t bondCount)
-{
-	// calculate all offsets, and dataSize as a result
-	NvBlastCreateOffsetStart(sizeof(FamilyGraph));
-	const size_t NvBlastCreateOffsetAlign16(dirtyNodeLinksOffset, sizeof(NodeIndex) * nodeCount);
-	const size_t NvBlastCreateOffsetAlign16(firstDirtyNodeIndicesOffset, sizeof(uint32_t) * nodeCount);
-	const size_t NvBlastCreateOffsetAlign16(islandIdsOffset, sizeof(IslandId) * nodeCount);
-	const size_t NvBlastCreateOffsetAlign16(fastRouteOffset, sizeof(NodeIndex) * nodeCount);
-	const size_t NvBlastCreateOffsetAlign16(hopCountsOffset, sizeof(uint32_t) * nodeCount);
-	const size_t NvBlastCreateOffsetAlign16(isEdgeRemovedOffset, FixedBoolArray::requiredMemorySize(bondCount));
-	const size_t NvBlastCreateOffsetAlign16(isNodeInDirtyListOffset, FixedBoolArray::requiredMemorySize(nodeCount));
-	const size_t dataSize = NvBlastCreateOffsetEndAlign16();
-
-	// fill only if familyGraph was passed (otherwise we just used this function to get dataSize)
-	if (familyGraph)
-	{
-		familyGraph->m_dirtyNodeLinksOffset			= static_cast<uint32_t>(dirtyNodeLinksOffset);
-		familyGraph->m_firstDirtyNodeIndicesOffset	= static_cast<uint32_t>(firstDirtyNodeIndicesOffset);
-		familyGraph->m_islandIdsOffset				= static_cast<uint32_t>(islandIdsOffset);
-		familyGraph->m_fastRouteOffset				= static_cast<uint32_t>(fastRouteOffset);
-		familyGraph->m_hopCountsOffset				= static_cast<uint32_t>(hopCountsOffset);
-		familyGraph->m_isEdgeRemovedOffset			= static_cast<uint32_t>(isEdgeRemovedOffset);
-		familyGraph->m_isNodeInDirtyListOffset		= static_cast<uint32_t>(isNodeInDirtyListOffset);
-
-		new (familyGraph->getIsEdgeRemoved())FixedBoolArray(bondCount);
-		new (familyGraph->getIsNodeInDirtyList())FixedBoolArray(nodeCount);
-	}
-
-	return dataSize;
-}
-
-
-FamilyGraph::FamilyGraph(const SupportGraph* graph)
-{
-	// fill memory with all internal data
-	// we need chunks count for size calculation
-	const uint32_t nodeCount = graph->m_nodeCount;
-	const uint32_t bondCount = graph->getAdjacencyPartition()[nodeCount] / 2;
-
-	fillMemory(this, nodeCount, bondCount);
-
-	// fill arrays with invalid indices / max value (0xFFFFFFFF)
-	memset(getIslandIds(), 0xFF, nodeCount*sizeof(uint32_t));
-	memset(getFastRoute(), 0xFF, nodeCount*sizeof(uint32_t));
-	memset(getHopCounts(), 0xFF, nodeCount*sizeof(uint32_t));		// Initializing to large value
-	memset(getDirtyNodeLinks(), 0xFF, nodeCount*sizeof(uint32_t));	// No dirty list initially
-	memset(getFirstDirtyNodeIndices(), 0xFF, nodeCount*sizeof(uint32_t));
-
-	getIsNodeInDirtyList()->clear();
-	getIsEdgeRemoved()->fill();
-}
-
-
-/**
-Graph initialization, reset all internal data to initial state. Marks all nodes dirty for this actor.
-First island search probably would be the longest one, as it has to traverse whole graph and set all the optimization stuff like fastRoute and hopCounts for all nodes.
-*/
-void FamilyGraph::initialize(ActorIndex actorIndex, const SupportGraph* graph)
-{
-	// used internal data pointers
-	NodeIndex* dirtyNodeLinks = getDirtyNodeLinks();
-	uint32_t* firstDirtyNodeIndices = getFirstDirtyNodeIndices();
-
-	// link dirty nodes
-	for (NodeIndex node = 1; node < graph->m_nodeCount; node++)
-	{
-		dirtyNodeLinks[node-1] = node;
-	}
-	firstDirtyNodeIndices[actorIndex] = 0;
-
-	getIsNodeInDirtyList()->fill();
-	getIsEdgeRemoved()->clear();
-}
-
-
-void FamilyGraph::addToDirtyNodeList(ActorIndex actorIndex, NodeIndex node)
-{
-	// used internal data pointers
-	FixedBoolArray* isNodeInDirtyList = getIsNodeInDirtyList();
-	NodeIndex* dirtyNodeLinks = getDirtyNodeLinks();
-	uint32_t* firstDirtyNodeIndices = getFirstDirtyNodeIndices();
-
-	// check for bitmap first for avoid O(n) list search
-	if (isNodeInDirtyList->test(node))
-		return;
-
-	// add node to dirty node list head
-	dirtyNodeLinks[node] = firstDirtyNodeIndices[actorIndex];
-	firstDirtyNodeIndices[actorIndex] = node;
-	isNodeInDirtyList->set(node);
-}
-
-
-/**
-Removes fast routes and marks involved nodes as dirty
-*/
-bool FamilyGraph::notifyEdgeRemoved(ActorIndex actorIndex, NodeIndex node0, NodeIndex node1, const SupportGraph* graph)
-{
-	NVBLAST_ASSERT(node0 < graph->m_nodeCount);
-	NVBLAST_ASSERT(node1 < graph->m_nodeCount);
-
-	// used internal data pointers
-	NodeIndex* fastRoute = getFastRoute();
-	const uint32_t* adjacencyPartition = graph->getAdjacencyPartition();
-	const uint32_t* adjacentBondIndices = graph->getAdjacentBondIndices();
-
-	// search for bond
-	for (uint32_t adjacencyIndex = adjacencyPartition[node0]; adjacencyIndex < adjacencyPartition[node0 + 1]; adjacencyIndex++)
-	{
-		if (getAdjacentNode(adjacencyIndex, graph) == node1)
-		{
-			// found bond
-			const uint32_t bondIndex = adjacentBondIndices[adjacencyIndex];
-
-			// remove bond
-			getIsEdgeRemoved()->set(bondIndex);
-
-			// broke fast route if it goes through this edge:
-			if (fastRoute[node0] == node1)
-				fastRoute[node0] = invalidIndex<uint32_t>();
-			if (fastRoute[node1] == node0)
-				fastRoute[node1] = invalidIndex<uint32_t>();
-
-			// mark nodes dirty (add to list if doesn't exist)
-			addToDirtyNodeList(actorIndex, node0);
-			addToDirtyNodeList(actorIndex, node1);
-
-			// we don't expect to be more than one bond between 2 nodes
-			return true;
-		}
-	}
-
-	return false;
-}
-
-bool FamilyGraph::notifyEdgeRemoved(ActorIndex actorIndex, NodeIndex node0, NodeIndex node1, uint32_t bondIndex, const SupportGraph* graph)
-{
-	NV_UNUSED(graph);
-	NVBLAST_ASSERT(node0 < graph->m_nodeCount);
-	NVBLAST_ASSERT(node1 < graph->m_nodeCount);
-
-	getIsEdgeRemoved()->set(bondIndex);
-
-
-	NodeIndex* fastRoute = getFastRoute();
-
-	// broke fast route if it goes through this edge:
-	if (fastRoute[node0] == node1)
-		fastRoute[node0] = invalidIndex<uint32_t>();
-	if (fastRoute[node1] == node0)
-		fastRoute[node1] = invalidIndex<uint32_t>();
-
-	// mark nodes dirty (add to list if doesn't exist)
-	addToDirtyNodeList(actorIndex, node0);
-	addToDirtyNodeList(actorIndex, node1);
-
-	return true;
-}
-
-bool FamilyGraph::notifyNodeRemoved(ActorIndex actorIndex, NodeIndex nodeIndex, const SupportGraph* graph)
-{
-	NVBLAST_ASSERT(nodeIndex < graph->m_nodeCount);
-
-	// used internal data pointers
-	NodeIndex* fastRoute = getFastRoute();
-	const uint32_t* adjacencyPartition = graph->getAdjacencyPartition();
-	const uint32_t* adjacentBondIndices = graph->getAdjacentBondIndices();
-
-	// remove all edges leaving this node
-	for (uint32_t adjacencyIndex = adjacencyPartition[nodeIndex]; adjacencyIndex < adjacencyPartition[nodeIndex + 1]; adjacencyIndex++)
-	{
-		const uint32_t adjacentNodeIndex = getAdjacentNode(adjacencyIndex, graph);
-		if (!isInvalidIndex(adjacentNodeIndex))
-		{
-			const uint32_t bondIndex = adjacentBondIndices[adjacencyIndex];
-			getIsEdgeRemoved()->set(bondIndex);
-
-			if (fastRoute[adjacentNodeIndex] == nodeIndex)
-				fastRoute[adjacentNodeIndex] = invalidIndex<uint32_t>();
-			if (fastRoute[nodeIndex] == adjacentNodeIndex)
-				fastRoute[nodeIndex] = invalidIndex<uint32_t>();
-
-			addToDirtyNodeList(actorIndex, adjacentNodeIndex);
-		}
-	}
-	addToDirtyNodeList(actorIndex, nodeIndex);
-
-	// ignore this node in partition (only needed for "chunk deleted from graph")
-	// getIslandIds()[nodeIndex] = invalidIndex<uint32_t>();
-
-	return true;
-}
-
-void FamilyGraph::unwindRoute(uint32_t traversalIndex, NodeIndex lastNode, uint32_t hopCount, IslandId id, FixedArray<TraversalState>* visitedNodes)
-{
-	// used internal data pointers
-	IslandId* islandIds = getIslandIds();
-	NodeIndex* fastRoute = getFastRoute();
-	uint32_t* hopCounts = getHopCounts();
-
-	uint32_t currIndex = traversalIndex;
-	uint32_t hc = hopCount + 1; //Add on 1 for the hop to the witness/root node.
-	do
-	{
-		TraversalState& state = visitedNodes->at(currIndex);
-		hopCounts[state.mNodeIndex] = hc++;
-		islandIds[state.mNodeIndex] = id;
-		fastRoute[state.mNodeIndex] = lastNode;
-		currIndex = state.mPrevIndex;
-		lastNode = state.mNodeIndex;
-	}
-	while(currIndex != invalidIndex<uint32_t>());
-}
-
-
-bool FamilyGraph::tryFastPath(NodeIndex startNode, NodeIndex targetNode, IslandId islandId, FixedArray<TraversalState>* visitedNodes, FixedBitmap* isNodeWitness, const SupportGraph* graph)
-{
-	NV_UNUSED(graph);
-
-	// used internal data pointers
-	IslandId* islandIds = getIslandIds();
-	NodeIndex* fastRoute = getFastRoute();
-
-	// prepare for iterating path
-	NodeIndex currentNode = startNode;
-	uint32_t visitedNotesInitialSize = visitedNodes->size();
-	uint32_t depth = 0;
-
-	bool found = false;
-	do
-	{
-		// witness ?
-		if (isNodeWitness->test(currentNode))
-		{
-			// Already visited and not tagged with invalid island == a witness!
-			found = islandIds[currentNode] != invalidIndex<uint32_t>();
-			break;
-		}
-
-		// reached targetNode ?
-		if (currentNode == targetNode)
-		{
-			found = true;
-			break;
-		}
-
-		TraversalState state(currentNode, visitedNodes->size(), visitedNodes->size() - 1, depth++);
-		visitedNodes->pushBack(state);
-
-		NVBLAST_ASSERT(isInvalidIndex(fastRoute[currentNode]) || hasEdge(currentNode, fastRoute[currentNode], graph));
-
-		islandIds[currentNode] = invalidIndex<uint32_t>();
-		isNodeWitness->set(currentNode);
-
-		currentNode = fastRoute[currentNode];
-	} while (currentNode != invalidIndex<uint32_t>());
-
-	for (uint32_t a = visitedNotesInitialSize; a < visitedNodes->size(); ++a)
-	{
-		TraversalState& state = visitedNodes->at(a);
-		islandIds[state.mNodeIndex] = islandId;
-	}
-
-	// if fast path failed we have to remove all isWitness marks on visited nodes and nodes from visited list
-	if (!found)
-	{
-		for (uint32_t a = visitedNotesInitialSize; a < visitedNodes->size(); ++a)
-		{
-			TraversalState& state = visitedNodes->at(a);
-			isNodeWitness->reset(state.mNodeIndex);
-		}
-
-		visitedNodes->forceSize_Unsafe(visitedNotesInitialSize);
-	}
-
-	return found;
-}
-
-
-bool FamilyGraph::findRoute(NodeIndex startNode, NodeIndex targetNode, IslandId islandId, FixedArray<TraversalState>* visitedNodes, FixedBitmap* isNodeWitness, NodePriorityQueue* priorityQueue, const SupportGraph* graph)
-{
-	// used internal data pointers
-	IslandId* islandIds = getIslandIds();
-	NodeIndex* fastRoute = getFastRoute();
-	uint32_t* hopCounts = getHopCounts();
-	const uint32_t* adjacencyPartition = graph->getAdjacencyPartition();
-
-	// Firstly, traverse the fast path and tag up witnesses. TryFastPath can fail. In that case, no witnesses are left but this node is permitted to report
-	// that it is still part of the island. Whichever node lost its fast path will be tagged as dirty and will be responsible for recovering the fast path
-	// and tagging up the visited nodes
-	if (fastRoute[startNode] != invalidIndex<uint32_t>())
-	{
-		if (tryFastPath(startNode, targetNode, islandId, visitedNodes, isNodeWitness, graph))
-			return true;
-	}
-
-	// If we got here, there was no fast path. Therefore, we need to fall back on searching for the root node. This is optimized by using "hop counts".
-	// These are per-node counts that indicate the expected number of hops from this node to the root node. These are lazily evaluated and updated
-	// as new edges are formed or when traversals occur to re-establish islands. As a result, they may be inaccurate but they still serve the purpose
-	// of guiding our search to minimize the chances of us doing an exhaustive search to find the root node.
-	islandIds[startNode] = invalidIndex<uint32_t>();
-	TraversalState startTraversal(startNode, visitedNodes->size(), invalidIndex<uint32_t>(), 0);
-	isNodeWitness->set(startNode);
-	QueueElement element(&visitedNodes->pushBack(startTraversal), hopCounts[startNode]);
-	priorityQueue->push(element);
-
-	do
-	{
-		QueueElement currentQE = priorityQueue->pop();
-
-		TraversalState& currentState = *currentQE.mState;
-		NodeIndex& currentNode = currentState.mNodeIndex;
-
-		// iterate all edges of currentNode
-		for (uint32_t adjacencyIndex = adjacencyPartition[currentNode]; adjacencyIndex < adjacencyPartition[currentNode + 1]; adjacencyIndex++)
-		{
-			NodeIndex nextIndex = getAdjacentNode(adjacencyIndex, graph);
-
-			if (nextIndex != invalidIndex<uint32_t>())
-			{
-				if (nextIndex == targetNode)
-				{
-					// targetNode found!
-					unwindRoute(currentState.mCurrentIndex, nextIndex, 0, islandId, visitedNodes);
-					return true;
-				}
-
-				if (isNodeWitness->test(nextIndex))
-				{
-					// We already visited this node. This means that it's either in the priority queue already or we 
-					// visited in on a previous pass. If it was visited on a previous pass, then it already knows what island it's in. 
-					// We now need to test the island id to find out if this node knows the root.
-					// If it has a valid root id, that id *is* our new root. We can guesstimate our hop count based on the node's properties
-
-					IslandId visitedIslandId = islandIds[nextIndex];
-					if (visitedIslandId != invalidIndex<uint32_t>())
-					{
-						// If we get here, we must have found a node that knows a route to our root node. It must not be a different island
-						// because that would caused me to have been visited already because totally separate islands trigger a full traversal on 
-						// the orphaned side.
-						NVBLAST_ASSERT(visitedIslandId == islandId);
-						unwindRoute(currentState.mCurrentIndex, nextIndex, hopCounts[nextIndex], islandId, visitedNodes);
-						return true;
-					}
-				}
-				else
-				{
-					// This node has not been visited yet, so we need to push it into the stack and continue traversing
-					TraversalState state(nextIndex, visitedNodes->size(), currentState.mCurrentIndex, currentState.mDepth + 1);
-					QueueElement qe(&visitedNodes->pushBack(state), hopCounts[nextIndex]);
-					priorityQueue->push(qe);
-					isNodeWitness->set(nextIndex);
-					NVBLAST_ASSERT(islandIds[nextIndex] == islandId);
-					islandIds[nextIndex] = invalidIndex<uint32_t>(); //Flag as invalid island until we know whether we can find root or an island id.
-				}
-			}
-		}
-	} while (priorityQueue->size());
-
-	return false;
-}
-
-
-size_t FamilyGraph::findIslandsRequiredScratch(uint32_t graphNodeCount)
-{
-	const size_t visitedNodesSize = align16(FixedArray<TraversalState>::requiredMemorySize(graphNodeCount));
-	const size_t isNodeWitnessSize = align16(FixedBitmap::requiredMemorySize(graphNodeCount));
-	const size_t priorityQueueSize = align16(NodePriorityQueue::requiredMemorySize(graphNodeCount));
-
-	// Aligned and padded
-	return 16 + visitedNodesSize
-			  + isNodeWitnessSize
-			  +	priorityQueueSize;
-}
-
-
-uint32_t FamilyGraph::findIslands(ActorIndex actorIndex, void* scratch, const SupportGraph* graph)
-{
-	// check if we have at least 1 dirty node for this actor before proceeding
-	uint32_t* firstDirtyNodeIndices = getFirstDirtyNodeIndices();
-	if (isInvalidIndex(firstDirtyNodeIndices[actorIndex]))
-		return 0;
-
-	// used internal data pointers
-	IslandId* islandIds = getIslandIds();
-	NodeIndex* fastRoute = getFastRoute();
-	uint32_t* hopCounts = getHopCounts();
-	NodeIndex* dirtyNodeLinks = getDirtyNodeLinks();
-	FixedBoolArray* isNodeInDirtyList = getIsNodeInDirtyList();
-
-	// prepare intermediate data on scratch
-	scratch = (void*)align16((size_t)scratch); // Bump to 16-byte alignment (see padding in findIslandsRequiredScratch)
-	const uint32_t nodeCount = graph->m_nodeCount;
-	
-	FixedArray<TraversalState>* visitedNodes = new (scratch)FixedArray<TraversalState>();
-	scratch = pointerOffset(scratch, align16(FixedArray<TraversalState>::requiredMemorySize(nodeCount)));
-
-	FixedBitmap* isNodeWitness = new (scratch)FixedBitmap(nodeCount);
-	scratch = pointerOffset(scratch, align16(FixedBitmap::requiredMemorySize(nodeCount)));
-
-	NodePriorityQueue* priorityQueue = new (scratch)NodePriorityQueue();
-	scratch = pointerOffset(scratch, align16(NodePriorityQueue::requiredMemorySize(nodeCount)));
-
-	// reset nodes visited bitmap
-	isNodeWitness->clear();
-
-	uint32_t newIslandsCount = 0;
-
-	while (!isInvalidIndex(firstDirtyNodeIndices[actorIndex]))
-	{
-		// Pop head off of dirty node's list
-		const NodeIndex dirtyNode = firstDirtyNodeIndices[actorIndex];
-		firstDirtyNodeIndices[actorIndex] = dirtyNodeLinks[dirtyNode];
-		dirtyNodeLinks[dirtyNode] = invalidIndex<uint32_t>();
-		NVBLAST_ASSERT(isNodeInDirtyList->test(dirtyNode));
-		isNodeInDirtyList->reset(dirtyNode);
-
-		// clear PriorityQueue
-		priorityQueue->clear();
-
-		// if we already visited this node before in this loop it's not dirty anymore
-		if (isNodeWitness->test(dirtyNode))
-			continue;
-
-		NodeIndex& islandRootNode = islandIds[dirtyNode];
-		IslandId islandId = islandRootNode; // the same in this implementation
-		
-		// if this node is island root node we don't need to do anything
-		if (islandRootNode == dirtyNode)
-			continue;
-
-		// clear visited notes list (to fill during traverse)
-		visitedNodes->clear();
-
-		// try finding island root node from this dirtyNode
-		if (findRoute(dirtyNode, islandRootNode, islandId, visitedNodes, isNodeWitness, priorityQueue, graph))
-		{
-			// We found the root node so let's let every visited node know that we found its root
-			// and we can also update our hop counts because we recorded how many hops it took to reach this
-			// node
-
-			// We already filled in the path to the root/witness with accurate hop counts. Now we just need to fill in the estimates
-			// for the remaining nodes and re-define their islandIds. We approximate their path to the root by just routing them through
-			// the route we already found.
-
-			// This loop works because visitedNodes are recorded in the order they were visited and we already filled in the critical path
-			// so the remainder of the paths will just fork from that path.
-			for (uint32_t b = 0; b < visitedNodes->size(); ++b)
-			{
-				TraversalState& state = visitedNodes->at(b);
-				if (isInvalidIndex(islandIds[state.mNodeIndex]))
-				{
-					hopCounts[state.mNodeIndex] = hopCounts[visitedNodes->at(state.mPrevIndex).mNodeIndex] + 1;
-					fastRoute[state.mNodeIndex] = visitedNodes->at(state.mPrevIndex).mNodeIndex;
-					islandIds[state.mNodeIndex] = islandId;
-				}
-			}
-		}
-		else
-		{
-			// NEW ISLAND BORN!
-
-			// If I traversed and could not find the root node, then I have established a new island. In this island, I am the root node
-			// and I will point all my nodes towards me. Furthermore, I have established how many steps it took to reach all nodes in my island
-
-			// OK. We need to separate the islands. We have a list of nodes that are part of the new island (visitedNodes) and we know that the 
-			// first node in that list is the root node.
-
-#if SANITY_CHECKS
-			NVBLAST_ASSERT(!canFindRoot(dirtyNode, islandRootNode, NULL));
-#endif
-
-			IslandId newIsland = dirtyNode;
-			newIslandsCount++;
-
-			hopCounts[dirtyNode] = 0;
-			fastRoute[dirtyNode] = invalidIndex<uint32_t>();
-			islandIds[dirtyNode] = newIsland;
-
-			for (uint32_t a = 1; a < visitedNodes->size(); ++a)
-			{
-				NodeIndex visitedNode = visitedNodes->at(a).mNodeIndex;
-				hopCounts[visitedNode] = visitedNodes->at(a).mDepth; //How many hops to root
-				fastRoute[visitedNode] = visitedNodes->at(visitedNodes->at(a).mPrevIndex).mNodeIndex;
-				islandIds[visitedNode] = newIsland;
-			}
-		}
-	}
-
-	// all dirty nodes processed
-	return newIslandsCount;
-}
-
-
-/**
-!!! Debug/Test function.
-Function to check that root between nodes exists.
-*/
-bool FamilyGraph::canFindRoot(NodeIndex startNode, NodeIndex targetNode, FixedArray<NodeIndex>* visitedNodes, const SupportGraph* graph)
-{
-	if (visitedNodes)
-		visitedNodes->pushBack(startNode);
-
-	if (startNode == targetNode)
-		return true;
-
-	std::vector<bool> visitedState;
-	visitedState.resize(graph->m_nodeCount);
-	for (uint32_t i = 0; i < graph->m_nodeCount; i++)
-		visitedState[i] = false;
-
-	std::stack<NodeIndex> stack;
-
-	stack.push(startNode);
-	visitedState[startNode] = true;
-
-	const uint32_t* adjacencyPartition = graph->getAdjacencyPartition();
-	do
-	{
-		NodeIndex currentNode = stack.top();
-		stack.pop();
-
-		for (uint32_t adjacencyIndex = adjacencyPartition[currentNode]; adjacencyIndex < adjacencyPartition[currentNode + 1]; adjacencyIndex++)
-		{
-			NodeIndex nextNode = getAdjacentNode(adjacencyIndex, graph);
-
-			if (isInvalidIndex(nextNode))
-				continue;
-
-			if (!visitedState[nextNode])
-			{
-				if (nextNode == targetNode)
-				{
-					return true;
-				}
-
-				visitedState[nextNode] = true;
-				stack.push(nextNode);
-
-				if (visitedNodes)
-					visitedNodes->pushBack(nextNode);
-			}
-		}
-
-	} while (!stack.empty());
-
-	return false;
-}
-
-
-/**
-!!! Debug/Test function.
-Function to check if edge exists.
-*/
-bool FamilyGraph::hasEdge(NodeIndex node0, NodeIndex node1, const SupportGraph* graph) const
-{
-	const uint32_t* adjacencyPartition = graph->getAdjacencyPartition();
-	uint32_t edges = 0;
-	for (uint32_t adjacencyIndex = adjacencyPartition[node0]; adjacencyIndex < adjacencyPartition[node0 + 1]; adjacencyIndex++)
-	{
-		if (getAdjacentNode(adjacencyIndex, graph) == node1)
-		{
-			edges++;
-			break;
-		}
-	}
-	for (uint32_t adjacencyIndex = adjacencyPartition[node1]; adjacencyIndex < adjacencyPartition[node1 + 1]; adjacencyIndex++)
-	{
-		if (getAdjacentNode(adjacencyIndex, graph) == node0)
-		{
-			edges++;
-			break;
-		}
-	}
-	return edges > 0;
-}
-
-
-/**
-!!! Debug/Test function.
-Function to calculate and return edges count
-*/
-uint32_t FamilyGraph::getEdgesCount(const SupportGraph* graph) const
-{
-	const uint32_t* adjacencyPartition = graph->getAdjacencyPartition();
-	uint32_t edges = 0;
-	for (NodeIndex n = 0; n < graph->m_nodeCount; n++)
-	{
-		for (uint32_t adjacencyIndex = adjacencyPartition[n]; adjacencyIndex < adjacencyPartition[n + 1]; adjacencyIndex++)
-		{
-			if (getAdjacentNode(adjacencyIndex, graph) != invalidIndex<uint32_t>())
-				edges++;
-		}
-	}
-	NVBLAST_ASSERT(edges % 2 == 0);
-	return edges / 2;
-}
-
-
-
-
-} // namespace Nv
-} // namespace Blast
-
diff --git a/NvBlast/sdk/lowlevel/source/NvBlastFamilyGraph.h b/NvBlast/sdk/lowlevel/source/NvBlastFamilyGraph.h
deleted file mode 100644
index 9fa331a..0000000
--- a/NvBlast/sdk/lowlevel/source/NvBlastFamilyGraph.h
+++ /dev/null
@@ -1,280 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTFAMILYGRAPH_H
-#define NVBLASTFAMILYGRAPH_H
-
-
-#include "NvBlastSupportGraph.h"
-#include "NvBlastFixedArray.h"
-#include "NvBlastFixedBitmap.h"
-#include "NvBlastFixedBoolArray.h"
-#include "NvBlastMath.h"
-#include "NvBlastFixedPriorityQueue.h"
-#include "NvBlastPreprocessorInternal.h"
-#include "NvBlastMemory.h"
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-
-typedef uint32_t NodeIndex;
-typedef NodeIndex IslandId;
-typedef uint32_t ActorIndex;
-
-/**
-Internal implementation of family graph stored on the family.
-
-It processes full NvBlastSupportGraph graph, stores additional information used for faster islands finding, 
-keeps and provides access to current islandId for every node.
-*/
-class FamilyGraph
-{
-public:
-
-	//////// ctor ////////
-
-	/**
-	Constructor. family graph is meant to be placed (with placement new) on family memory.
-
-	\param[in] graph	The graph to instance (see SupportGraph)
-	*/
-	FamilyGraph(const SupportGraph* graph);
-
-
-	/**
-	Returns memory needed for this class (see fillMemory).
-
-	\param[in] nodeCount	The number of nodes in the graph.
-	\param[in] bondCount	The number of bonds in the graph.
-
-	\return the number of bytes required.
-	*/
-	static size_t	requiredMemorySize(uint32_t nodeCount, uint32_t bondCount)
-	{
-		return fillMemory(nullptr, nodeCount, bondCount);
-	}
-
-
-	//////// API ////////
-
-	/**
-	Function to initialize graph (all nodes added to dirty list for this actor)
-
-	\param[in] actorIndex	The index of the actor to initialize graph with. Must be in the range [0, m_nodeCount).
-	\param[in] graph		The static graph data for this family.
-	*/
-	void			initialize(ActorIndex actorIndex, const SupportGraph* graph);
-
-	/**
-	Function to notify graph about removed edges. These nodes will be added to dirty list for this actor. Returns true if bond as removed.
-
-	\param[in] actorIndex	The index of the actor from which the edge is removed. Must be in the range [0, m_nodeCount).
-	\param[in] node0		The index of the first node of removed edge. Must be in the range [0, m_nodeCount).
-	\param[in] node1		The index of the second node of removed edge. Must be in the range [0, m_nodeCount).
-	\param[in] graph		The static graph data for this family.
-	*/
-	bool			notifyEdgeRemoved(ActorIndex actorIndex, NodeIndex node0, NodeIndex node1, const SupportGraph* graph);
-	bool			notifyEdgeRemoved(ActorIndex actorIndex, NodeIndex node0, NodeIndex node1, uint32_t bondIndex, const SupportGraph* graph);
-
-	bool			notifyNodeRemoved(ActorIndex actorIndex, NodeIndex nodeIndex, const SupportGraph* graph);
-
-	/**
-	Function to find new islands by examining dirty nodes associated with this actor (they can be associated with actor if 
-	notifyEdgeRemoved() were previously called for it.
-
-	\param[in] actorIndex	The index of the actor on which graph part (edges + nodes) findIslands will be performed. Must be in the range [0, m_nodeCount).
-	\param[in] scratch		User-supplied scratch memory of size findIslandsRequiredScratch(graphNodeCount) bytes.
-	\param[in] graph		The static graph data for this family.
-
-	\return the number of new islands found.
-	*/
-	uint32_t		findIslands(ActorIndex actorIndex, void* scratch, const SupportGraph* graph);
-
-	/**
-	The scratch space required to call the findIslands function, in bytes.
-
-	\param[in] graphNodeCount The number of nodes in the graph.
-
-	\return the number of bytes required.
-	*/
-	static size_t	findIslandsRequiredScratch(uint32_t graphNodeCount);
-
-
-	//////// data getters ////////
-
-	/**
-	Utility function to get the start of the island ids array. This is an array of size nodeCount.
-	Every islandId == NodeIndex of root node in this island, it is set for every Node.
-
-	\return the array of island ids.
-	*/
-	NvBlastBlockData(IslandId, m_islandIdsOffset, getIslandIds);
-
-	/**
-	Utility function to get the start of the dirty node links array. This is an array of size nodeCount.
-	*/
-	NvBlastBlockData(NodeIndex, m_dirtyNodeLinksOffset, getDirtyNodeLinks);
-
-	/**
-	Utility function to get the start of the first dirty node indices array. This is an array of size nodeCount.
-	*/
-	NvBlastBlockData(uint32_t, m_firstDirtyNodeIndicesOffset, getFirstDirtyNodeIndices);
-
-	/**
-	Utility function to get the start of the fast route array. This is an array of size nodeCount.
-	*/
-	NvBlastBlockData(NodeIndex, m_fastRouteOffset, getFastRoute);
-
-	/**
-	Utility function to get the start of the hop counts array. This is an array of size nodeCount.
-	*/
-	NvBlastBlockData(uint32_t, m_hopCountsOffset, getHopCounts);
-
-	/**
-	Utility function to get the pointer of the is edge removed bitmap. This is an bitmap of size bondCount.
-	*/
-	NvBlastBlockData(FixedBoolArray, m_isEdgeRemovedOffset, getIsEdgeRemoved);
-
-	/**
-	Utility function to get the pointer of the is node in dirty list bitmap. This is an bitmap of size nodeCount.
-	*/
-	NvBlastBlockData(FixedBoolArray, m_isNodeInDirtyListOffset, getIsNodeInDirtyList);
-
-
-	//////// Debug/Test ////////
-
-	uint32_t	getEdgesCount(const SupportGraph* graph) const;
-	bool		hasEdge(NodeIndex node0, NodeIndex node1, const SupportGraph* graph) const;
-	bool		canFindRoot(NodeIndex startNode, NodeIndex targetNode, FixedArray<NodeIndex>* visitedNodes, const SupportGraph* graph);
-
-
-private:
-
-	FamilyGraph& operator = (const FamilyGraph&);
-
-	//////// internal types ////////
-
-	/**
-	Used to represent current graph traverse state.
-	*/
-	struct TraversalState
-	{
-		NodeIndex mNodeIndex;
-		uint32_t mCurrentIndex;
-		uint32_t mPrevIndex;
-		uint32_t mDepth;
-
-		TraversalState()
-		{
-		}
-
-		TraversalState(NodeIndex nodeIndex, uint32_t currentIndex, uint32_t prevIndex, uint32_t depth) :
-			mNodeIndex(nodeIndex), mCurrentIndex(currentIndex), mPrevIndex(prevIndex), mDepth(depth)
-		{
-		}
-	};
-
-	/**
-	Queue element for graph traversal with priority queue.
-	*/
-	struct QueueElement
-	{
-		TraversalState* mState;
-		uint32_t mHopCount;
-
-		QueueElement()
-		{
-		}
-
-		QueueElement(TraversalState* state, uint32_t hopCount) : mState(state), mHopCount(hopCount)
-		{
-		}
-	};
-
-	/**
-	Queue comparator for graph traversal with priority queue.
-	*/
-	struct NodeComparator
-	{
-		NodeComparator()
-		{
-		}
-
-		bool operator() (const QueueElement& node0, const QueueElement& node1) const
-		{
-			return node0.mHopCount < node1.mHopCount;
-		}
-	private:
-		NodeComparator& operator = (const NodeComparator&);
-	};
-
-	/**
-	PriorityQueue for graph traversal. Queue element with smallest hopCounts will be always on top.
-	*/
-	typedef FixedPriorityQueue<QueueElement, NodeComparator> NodePriorityQueue;
-
-
-	//////// internal operations ////////
-
-	/**
-	Function calculate needed memory and feel it if familyGraph is passed. FamilyGraph is designed to use 
-	memory right after itself. So it should be initialized with placement new operation	on memory of memoryNeeded() size.
-
-	\param[in] familyGraph		The pointer to actual FamilyGraph instance which will be filled. Can be nullptr, function will only return required bytes and do nothing.
-	\param[in] nodeCount		The number of nodes in the graph.
-	\param[in] bondCount		The number of bonds in the graph.
-
-	\return the number of bytes required or filled
-	*/
-	static size_t	fillMemory(FamilyGraph* familyGraph, uint32_t nodeCount, uint32_t bondCount);
-
-	/**
-	Function to find route from on node to another. It uses fastPath first as optimization and then if it fails it performs brute-force traverse (with hop count heuristic)
-	*/
-	bool			findRoute(NodeIndex startNode, NodeIndex targetNode, IslandId islandId, FixedArray<TraversalState>* visitedNodes, FixedBitmap* isNodeWitness, NodePriorityQueue* priorityQueue, const SupportGraph* graph);
-
-	/**
-	Function to try finding targetNode (from startNode) with getFastRoute().
-	*/
-	bool			tryFastPath(NodeIndex startNode, NodeIndex targetNode, IslandId islandId, FixedArray<TraversalState>* visitedNodes, FixedBitmap* isNodeWitness, const SupportGraph* graph);
-
-	/**
-	Function to unwind route upon successful finding of root node or witness.
-	We have found either a witness *or* the root node with this traversal. In the event of finding the root node, hopCount will be 0. In the event of finding
-	a witness, hopCount will be the hopCount that witness reported as being the distance to the root.
-	*/
-	void			unwindRoute(uint32_t traversalIndex, NodeIndex lastNode, uint32_t hopCount, IslandId id, FixedArray<TraversalState>* visitedNodes);
-
-	/**
-	Function to add node to dirty node list associated with actor.
-	*/
-	void			addToDirtyNodeList(ActorIndex actorIndex, NodeIndex node);
-
-	/**
-	Function used to get adjacentNode using index from adjacencyPartition with check for bondHealths (if it's not removed already)
-	*/
-	NodeIndex		getAdjacentNode(uint32_t adjacencyIndex, const SupportGraph* graph) const
-	{
-		const uint32_t bondIndex = graph->getAdjacentBondIndices()[adjacencyIndex];
-		return getIsEdgeRemoved()->test(bondIndex) ? invalidIndex<uint32_t>() : graph->getAdjacentNodeIndices()[adjacencyIndex];
-	}
-
-};
-
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTFAMILYGRAPH_H
diff --git a/NvBlast/sdk/lowlevel/source/NvBlastSupportGraph.h b/NvBlast/sdk/lowlevel/source/NvBlastSupportGraph.h
deleted file mode 100644
index 9ee3fc9..0000000
--- a/NvBlast/sdk/lowlevel/source/NvBlastSupportGraph.h
+++ /dev/null
@@ -1,134 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTSUPPORTGRAPH_H
-#define NVBLASTSUPPORTGRAPH_H
-
-
-#include "NvBlastIndexFns.h"
-#include "NvBlastPreprocessorInternal.h"
-#include "NvBlastMemory.h"
-
-namespace Nv
-{
-namespace Blast
-{
-
-/**
-Describes the connectivity between support chunks via bonds.
-
-Vertices in the support graph are termed "nodes," and represent particular chunks (NvBlastChunk) in an NvBlastAsset.
-The indexing for nodes is not the same as that for chunks.  Only some chunks are represented by nodes in the graph,
-and these chunks are called "support chunks."
-
-Adjacent node indices and adjacent bond indices are stored for each node, and therefore each bond is represented twice in this graph,
-going from node[i] -> node[j] and from node[j] -> node[i].  Therefore the size of the getAdjacentNodeIndices() and getAdjacentBondIndices()
-arrays are twice the number of bonds stored in the corresponding NvBlastAsset.
-
-The graph is used as follows.  Given a SupportGraph "graph" and node index i, (0 <= i < graph.nodeCount), one may find all
-adjacent bonds and nodes using:
-
-	const uint32_t* adjacencyPartition = graph.getAdjacencyPartition();
-	const uint32_t* adjacentNodeIndices = graph.getAdjacentNodeIndices();
-	const uint32_t* adjacentBondIndices = graph.getAdjacentBondIndices();
-
-	// adj is the lookup value in adjacentNodeIndices and graph.getAdjacentBondIndices()
-	for (uint32_t adj = adjacencyPartition[i]; adj < adjacencyPartition[i+1]; ++adj)
-	{
-		// An adjacent node:
-		uint32_t adjacentNodeIndex = adjacentNodeIndices[adj];
-
-		// The corresponding bond (that connects node index i with node indexed adjacentNodeIndex:
-		uint32_t adjacentBondIndex = adjacentBondIndices[adj];
-	}
-
-For a graph node with index i, the corresponding asset chunk index is found using graph.getChunkIndices()[i].  The reverse mapping
-(obtaining a graph node index from an asset chunk index) can be done using the
-
-	NvBlastAssetGetChunkToGraphNodeMap(asset, logFn);
-
-function.  See the documentation for its use.  The returned "node index" for a non-support chunk is the invalid value 0xFFFFFFFF.
-*/
-struct SupportGraph
-{
-	/**
-	Total number of nodes in the support graph.
-	*/
-	uint32_t	m_nodeCount;
-
-	/**
-	Indices of chunks represented by the nodes.
-
-	getChunkIndices returns an array of size m_nodeCount.
-	*/
-	NvBlastBlockArrayData(uint32_t, m_chunkIndicesOffset, getChunkIndices, m_nodeCount);
-
-	/**
-	Adjacency lookup table, of type uint32_t.
-
-	Partitions both the getAdjacentNodeIndices() and the getAdjacentBondIndices() arrays into subsets corresponding to each node.
-	The size of this array is nodeCount+1.
-	For 0 <= i < nodeCount, getAdjacencyPartition()[i] is the index of the first element in getAdjacentNodeIndices() (or getAdjacentBondIndices()) for nodes adjacent to the node with index i.
-	getAdjacencyPartition()[nodeCount] is the size of the getAdjacentNodeIndices() and getAdjacentBondIndices() arrays.
-	This allows one to easily count the number of nodes adjacent to a node with index i, using getAdjacencyPartition()[i+1] - getAdjacencyPartition()[i].
-
-	getAdjacencyPartition returns an array of size m_nodeCount + 1.
-	*/
-	NvBlastBlockArrayData(uint32_t, m_adjacencyPartitionOffset, getAdjacencyPartition, m_nodeCount + 1);
-
-	/**
-	Array of uint32_t composed of subarrays holding the indices of nodes adjacent to a given node.  The subarrays may be accessed through the getAdjacencyPartition() array.
-
-	getAdjacentNodeIndices returns an array of size getAdjacencyPartition()[m_nodeCount].
-	*/
-	NvBlastBlockArrayData(uint32_t, m_adjacentNodeIndicesOffset, getAdjacentNodeIndices, getAdjacencyPartition()[m_nodeCount]);
-
-	/**
-	Array of uint32_t composed of subarrays holding the indices of bonds (NvBlastBond) for a given node.  The subarrays may be accessed through the getAdjacencyPartition() array.
-
-	getAdjacentBondIndices returns an array of size getAdjacencyPartition()[m_nodeCount].
-	*/
-	NvBlastBlockArrayData(uint32_t, m_adjacentBondIndicesOffset, getAdjacentBondIndices, getAdjacencyPartition()[m_nodeCount]);
-
-	/**
-	Finds the bond between two given graph nodes (if it exists) and returns the bond index.
-	If no bond exists, returns invalidIndex<uint32_t>().
-
-	\return the index of the bond between the given nodes.
-	*/
-	uint32_t	findBond(uint32_t nodeIndex0, uint32_t nodeIndex1) const;
-};
-
-
-//////// SupportGraph inline member functions ////////
-
-NV_INLINE uint32_t SupportGraph::findBond(uint32_t nodeIndex0, uint32_t nodeIndex1) const
-{
-	const uint32_t* adjacencyPartition = getAdjacencyPartition();
-	const uint32_t* adjacentNodeIndices = getAdjacentNodeIndices();
-	const uint32_t* adjacentBondIndices = getAdjacentBondIndices();
-
-	// Iterate through all neighbors of nodeIndex0 chunk
-	for (uint32_t i = adjacencyPartition[nodeIndex0]; i < adjacencyPartition[nodeIndex0 + 1]; i++)
-	{
-		if (adjacentNodeIndices[i] == nodeIndex1)
-		{
-			return adjacentBondIndices[i];
-		}
-	}
-
-	return invalidIndex<uint32_t>();
-}
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTSUPPORTGRAPH_H
diff --git a/NvBlast/sdk/profiler/NvBlastProfiler.cpp b/NvBlast/sdk/profiler/NvBlastProfiler.cpp
deleted file mode 100644
index 3e82396..0000000
--- a/NvBlast/sdk/profiler/NvBlastProfiler.cpp
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastProfilerInternal.h"
-#include "PxProfiler.h"
-
-#if NV_PROFILE || NV_CHECKED || NV_DEBUG
-
-#if NV_NVTX  
-#include "nvToolsExt.h"
-NV_INLINE void platformZoneStart(const char* name) { nvtxRangePush(name); }
-NV_INLINE void platformZoneEnd(const char*)		 { nvtxRangePop(); }
-
-#elif NV_XBOXONE
-#include "xboxone/NvBlastProfilerXB1.h"
-
-#elif NV_PS4
-#include "ps4/NvBlastProfilerPS4.h"
-
-#else
-NV_INLINE void platformZoneStart(const char*)	{ }
-NV_INLINE void platformZoneEnd(const char*)	{ }
-
-#endif
-
-static const uint64_t blastContextId = 0xb1a57;
-static physx::PxProfilerCallback* sCallback = nullptr;
-static bool sPlatform = false;
-static NvBlastProfilerDetail::Level sDetail = NvBlastProfilerDetail::LOW;
-
-void NvBlastProfilerSetCallback(physx::PxProfilerCallback* pcb)
-{
-	sCallback = pcb;
-}
-
-void NvBlastProfilerEnablePlatform(bool enable)
-{
-	sPlatform = enable;
-}
-
-void NvBlastProfilerBegin(const char* name, NvBlastProfilerDetail::Level level)
-{
-	if (level <= sDetail)
-	{
-		if (sCallback != nullptr)
-		{
-			sCallback->zoneStart(name, false, blastContextId);
-		}
-
-		if (sPlatform)
-		{
-			platformZoneStart(name);
-		}
-	}
-}
-
-void NvBlastProfilerEnd(const char* name, NvBlastProfilerDetail::Level level)
-{
-	if (level <= sDetail)
-	{
-		if (sCallback != nullptr)
-		{
-			sCallback->zoneEnd(nullptr, name, false, blastContextId);
-		}
-
-		if (sPlatform)
-		{
-			platformZoneEnd(name);
-		}
-	}
-}
-
-void NvBlastProfilerSetDetail(NvBlastProfilerDetail::Level level)
-{
-	sDetail = level;
-}
-
-#else
-
-void NvBlastProfilerSetCallback(physx::PxProfilerCallback*) {}
-void NvBlastProfilerEnablePlatform(bool) {}
-void NvBlastProfilerSetDetail(NvBlastProfilerDetail::Level) {}
-
-#endif //NV_PROFILE
diff --git a/NvBlast/sdk/profiler/NvBlastProfilerInternal.h b/NvBlast/sdk/profiler/NvBlastProfilerInternal.h
deleted file mode 100644
index 9be3c87..0000000
--- a/NvBlast/sdk/profiler/NvBlastProfilerInternal.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTPROFILERINTERNAL_H
-#define NVBLASTPROFILERINTERNAL_H
-
-#include "NvBlastPreprocessor.h"
-#include "NvBlastProfiler.h"
-
-#if NV_PROFILE || NV_CHECKED || NV_DEBUG
-
-void NvBlastProfilerBegin(const char* name, NvBlastProfilerDetail::Level);
-void NvBlastProfilerEnd(const char* name, NvBlastProfilerDetail::Level);
-
-class ProfileScope
-{
-public:
-	ProfileScope(const char* name, NvBlastProfilerDetail::Level level) :m_name(name), m_level(level)
-	{
-		NvBlastProfilerBegin(m_name, m_level);
-	}
-
-	~ProfileScope() 
-	{
-		NvBlastProfilerEnd(m_name, m_level);
-	}
-
-private:
-	const char* m_name;
-	NvBlastProfilerDetail::Level m_level;
-};
-
-#define PERF_BLAST_PREFIX			"Blast: "
-#define PERF_ZONE_BEGIN(name)		NvBlastProfilerBegin(PERF_BLAST_PREFIX name, NvBlastProfilerDetail::HIGH)
-#define PERF_ZONE_END(name)			NvBlastProfilerEnd(PERF_BLAST_PREFIX name, NvBlastProfilerDetail::HIGH)
-#define PERF_SCOPE(name, detail)	ProfileScope PX_CONCAT(_scope,__LINE__) (PERF_BLAST_PREFIX name, detail)
-#define PERF_SCOPE_L(name)			PERF_SCOPE(name, NvBlastProfilerDetail::LOW)
-#define PERF_SCOPE_M(name)			PERF_SCOPE(name, NvBlastProfilerDetail::MEDIUM)
-#define PERF_SCOPE_H(name)			PERF_SCOPE(name, NvBlastProfilerDetail::HIGH)
-
-#else
-
-#define PERF_ZONE_BEGIN(name)	
-#define PERF_ZONE_END(name)
-#define PERF_SCOPE_L(name)
-#define PERF_SCOPE_M(name)
-#define PERF_SCOPE_H(name)
-
-#endif
-
-#endif
diff --git a/NvBlast/sdk/toolkit/include/NvBlastTk.h b/NvBlast/sdk/toolkit/include/NvBlastTk.h
deleted file mode 100644
index 6471165..0000000
--- a/NvBlast/sdk/toolkit/include/NvBlastTk.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTTK_H
-#define NVBLASTTK_H
-
-
-/**
-This is the main include header for the BlastTk SDK, for users who
-want to use a single #include file.
-
-Alternatively, one can instead directly #include a subset of the below files.
-*/
-
-
-#include "NvBlastTkFramework.h"
-#include "NvBlastTkAsset.h"
-#include "NvBlastTkActor.h"
-#include "NvBlastTkJoint.h"
-#include "NvBlastTkFamily.h"
-#include "NvBlastTkGroup.h"
-
-
-#endif // ifndef NVBLASTTK_H
diff --git a/NvBlast/sdk/toolkit/include/NvBlastTkActor.h b/NvBlast/sdk/toolkit/include/NvBlastTkActor.h
deleted file mode 100644
index a810ee1..0000000
--- a/NvBlast/sdk/toolkit/include/NvBlastTkActor.h
+++ /dev/null
@@ -1,239 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTTKACTOR_H
-#define NVBLASTTKACTOR_H
-
-#include "NvBlastTkObject.h"
-#include "NvBlastTypes.h"
-
-// Forward declarations
-struct NvBlastActor;
-struct NvBlastFamily;
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-// Forward declarations
-class TkAsset;
-class TkFamily;
-class TkGroup;
-class TkJoint;
-
-
-/**
-The BlastTk entity which encapsulates an NvBlastActor.  Every TkActor represents a group
-of chunks which may correspond to a single physical rigid body.  TkActors are created
-using TkFramework::createActor.
-*/
-class TkActor : public TkObject
-{
-public:
-	/**
-	Access to underlying low-level actor.
-
-	\return a pointer to the (const) low-level NvBlastActor object.
-	*/
-	virtual const NvBlastActor*	getActorLL() const = 0;
-
-	/**
-	Every actor is part of an actor family, even if that family contains a single actor.
-	This function returns a reference to the actor's TkFamily.
-
-	\return a pointer to the actor's TkFamily.
-	*/
-	virtual TkFamily&			getFamily() const = 0;
-
-	/**
-	Every actor has a unique index within a family.  This function returns that index.
-	*/
-	virtual uint32_t			getIndex() const = 0;
-
-	/**
-	Actors may be part of (no more than) one group.  See TkGroup for the functions to add and remove actors.
-	This function returns a pointer to the actor's group, or NULL if it is not in a group.
-	*/
-	virtual TkGroup*			getGroup() const = 0;
-
-	/**
-	Remove this actor from its group, if it is in one.
-
-	\return the actor's former group if successful, NULL otherwise.
-	*/
-	virtual TkGroup*			removeFromGroup() = 0;
-
-	/**
-	Every actor has an associated asset.
-
-	\return a pointer to the (const) TkAsset object.
-	*/
-	virtual const TkAsset*		getAsset() const = 0;
-
-	/**
-	Get the number of visible chunks for this actor.  May be used in conjunction with getVisibleChunkIndices.
-
-	NOTE: Wrapper function over low-level function call, see NvBlastActorGetVisibleChunkCount for details.
-
-	\return	the number of visible chunk indices for the actor.
-	*/
-	virtual uint32_t			getVisibleChunkCount() const = 0;
-
-	/**
-	Retrieve a list of visible chunk indices for the actor into the given array.
-
-	NOTE: Wrapper function over low-level function call, see NvBlastActorGetVisibleChunkIndices for details.
-
-	\param[in] visibleChunkIndices		User-supplied array to be filled in with indices of visible chunks for this actor.
-	\param[in] visibleChunkIndicesSize	The size of the visibleChunkIndices array.  To receive all visible chunk indices, the size must be at least that given by getVisibleChunkCount().
-
-	\return	the number of indices written to visibleChunkIndices.  This will not exceed visibleChunkIndicesSize.
-	*/
-	virtual uint32_t			getVisibleChunkIndices(uint32_t* visibleChunkIndices, uint32_t visibleChunkIndicesSize) const = 0;
-
-	/**
-	Get the number of graph nodes for this actor.  May be used in conjunction with getGraphNodeIndices.
-
-	NOTE: Wrapper function over low-level function call, see NvBlastActorGetGraphNodeCount for details.
-
-	\return	the number of graph node indices for the actor.
-	*/
-	virtual uint32_t			getGraphNodeCount() const = 0;
-
-	/**
-	Retrieve a list of graph node indices for the actor into the given array.
-
-	NOTE: Wrapper function over low-level function call, see NvBlastActorGetGraphNodeIndices for details.
-
-	\param[in] graphNodeIndices		User-supplied array to be filled in with indices of graph nodes for this actor.
-	\param[in] graphNodeIndicesSize	The size of the graphNodeIndices array.  To receive all graph node indices, the size must be at least that given by getGraphNodeCount().
-
-	\return	the number of indices written to graphNodeIndices.  This will not exceed graphNodeIndicesSize.
-	*/
-	virtual uint32_t			getGraphNodeIndices(uint32_t* graphNodeIndices, uint32_t graphNodeIndicesSize) const = 0;
-
-	/**
-	Access the bond health data for an actor. 
-
-	NOTE: Wrapper function over low-level function call, see NvBlastActorGetBondHealths for details.
-
-	\return	the array of bond healths for the actor's family, or NULL if the actor is invalid.
-	*/
-	virtual const float*		getBondHealths() const = 0;
-
-	/**
-	Returns the upper-bound number of actors which can be created by splitting this actor.
-
-	NOTE: Wrapper function over low-level function call, see NvBlastActorGetMaxActorCountForSplit for details.
-
-	\return	the upper-bound number of actors which can be created by splitting this actor.
-	*/
-	virtual uint32_t			getSplitMaxActorCount() const = 0;
-
-	/**
-	Report whether this actor is in 'pending' state.  Being in 'pending' state leads to actor being processed by group.
-
-	\return true iff actor is in 'pending' state.
-	*/
-	virtual bool				isPending() const = 0;
-
-	/**
-	Apply damage to this actor.
-
-	Actual damage processing is deferred till the group process() call. Sets actor in 'pending' state.
-
-	It's the user's responsibility to keep programParams pointer alive until the group sync() call.
-
-	\param[in] program				A NvBlastDamageProgram containing damage shaders.
-	\param[in] programParams		Parameters for the NvBlastDamageProgram.
-	*/
-	virtual void				damage(const NvBlastDamageProgram& program, const NvBlastProgramParams* programParams) = 0;
-
-	/**
-	Apply damage to this actor.
-
-	Actual damage processing is deferred till the group process() call. Sets actor in 'pending' state.
-
-	Damage Desc will be stacked into NvBlastProgramParams. NvBlastProgramParams will be passed into shader.
-
-	Material set on actor's family will be passed into NvBlastProgramParams.
-
-	\param[in] program				A NvBlastDamageProgram containing damage shaders.
-	\param[in] damageDesc			Parameters to be put in NvBlastProgramParams, have to be POD type (will be copied).
-	\param[in] descSize				Size of damageDesc in bytes. Required to copy and store Damage Desc.
-	*/
-	virtual void				damage(const NvBlastDamageProgram& program, const void* damageDesc, uint32_t descSize) = 0;
-
-	/**
-	Apply damage to this actor.
-
-	Actual damage processing is deferred till the group process() call. Sets actor in 'pending' state.
-
-	Damage Desc will be stacked into NvBlastDamageProgram. NvBlastDamageProgram will be passed into shader.
-
-	This function overload explicitly sets a material to be passed into NvBlastProgramParams, it must be valid until the group sync() call.
-
-	\param[in] program				A NvBlastDamageProgram containing damage shaders.
-	\param[in] damageDesc			Parameters to be put in NvBlastDamageProgram, have to be POD type (will be copied).
-	\param[in] descSize				Size of damageDesc in bytes. Required to copy and store Damage Desc.
-	\param[in] material				Material to be passed into NvBlastProgramParams. Must be valid until the group sync() call.
-	*/
-	virtual void				damage(const NvBlastDamageProgram& program, const void* damageDesc, uint32_t descSize, const void* material) = 0;
-
-	/**
-	Creates fracture commands for the actor using an NvBlastMaterialFunction.
-
-	Cannot be called during group processing, in that case a warning will be raised and function will do nothing.
-
-	NOTE: Wrapper function over low-level function call, see NvBlastActorGenerateFracture for details.
-
-	\param[in,out]	commands		Target buffers to hold generated commands.
-									To avoid data loss, provide an entry for every support chunk and every bond in the original actor.
-	\param[in]		program			A NvBlastDamageProgram containing damage shaders.
-	\param[in]		programParams	Parameters for the NvBlastDamageProgram.
-	*/
-	virtual void				generateFracture(NvBlastFractureBuffers* commands, const NvBlastDamageProgram& program, const NvBlastProgramParams* programParams) const = 0;
-
-	/**
-	Function applies the direct fracture and breaks graph bonds/edges as necessary. Sets actor in 'pending' state if any bonds or chunks were damaged. Dispatches FractureCommand events.
-
-	NOTE: Calls NvBlastActorApplyFracture internally. see NvBlastActorApplyFracture for details.
-
-	\param[in,out]	eventBuffers	Target buffers to hold applied fracture events. May be NULL, in which case events are not reported.
-									To avoid data loss, provide an entry for every lower-support chunk and every bond in the original actor.
-	\param[in]		commands		The fracture commands to process.
-	*/
-	virtual void				applyFracture(NvBlastFractureBuffers* eventBuffers, const NvBlastFractureBuffers* commands) = 0;
-
-	/**
-	The number of joints currently attached to this actor.
-
-	\return the number of TkJoints that are currently attached to this actor.
-	*/
-	virtual uint32_t			getJointCount() const = 0;
-
-	/**
-	Retrieve an array of pointers (into the user-supplied buffer) to joints.
-
-	\param[out]	joints		A user-supplied array of TkJoint pointers.
-	\param[in]	jointsSize	The number of elements available to write into the joints array.
-
-	\return the number of TkJoint pointers written to the joints array.
-	*/
-	virtual uint32_t			getJoints(TkJoint** joints, uint32_t jointsSize) const = 0;
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTTKACTOR_H
diff --git a/NvBlast/sdk/toolkit/include/NvBlastTkAsset.h b/NvBlast/sdk/toolkit/include/NvBlastTkAsset.h
deleted file mode 100644
index 987da7d..0000000
--- a/NvBlast/sdk/toolkit/include/NvBlastTkAsset.h
+++ /dev/null
@@ -1,136 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTTKASSET_H
-#define NVBLASTTKASSET_H
-
-#include "NvBlastTkSerializable.h"
-#include "NvBlastTypes.h"
-#include "PxVec3.h"
-
-// Forward declarations
-struct NvBlastAsset;
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-/**
-A descriptor stored by a TkAsset for an internal joint.  Internal joints are created when a TkAsset is instanced into a TkActor.
-*/
-struct TkAssetJointDesc
-{
-	uint32_t		nodeIndices[2];		//!< The graph node indices corresponding to the support chunks joined by a joint
-	physx::PxVec3	attachPositions[2];	//!< The joint's attachment positions in asset-local space
-};
-
-
-/**
-The static data associated with a destructible actor.  TkAsset encapsulates an NvBlastAsset.  In addition to the NvBlastAsset,
-the TkAsset stores joint descriptors (see TkAssetJointDesc).
-*/
-class TkAsset : public TkSerializable
-{
-public:
-	/**
-	Access to underlying low-level asset.
-
-	\return a pointer to the (const) low-level NvBlastAsset object.
-	*/
-	virtual const NvBlastAsset*			getAssetLL() const = 0;
-
-	/**
-	Get the number of chunks in this asset.
-
-	NOTE: Wrapper function over low-level function call, see NvBlastAssetGetChunkCount for details.
-
-	\return	the number of chunks in the asset.
-	*/
-	virtual uint32_t					getChunkCount() const = 0;
-
-	/**
-	Get the number of leaf chunks in the given asset.
-
-	NOTE: Wrapper function over low-level function call, see NvBlastAssetGetLeafChunkCount for details.
-
-	\return	the number of leaf chunks in the asset.
-	*/
-	virtual uint32_t					getLeafChunkCount() const = 0;
-
-	/**
-	Get the number of bonds in the given asset.
-
-	NOTE: Wrapper function over low-level function call, see NvBlastAssetGetBondCount for details.
-
-	\return	the number of bonds in the asset.
-	*/
-	virtual uint32_t					getBondCount() const = 0;
-
-	/**
-	Access an array of chunks of the given asset.
-		
-	NOTE: Wrapper function over low-level function call, see NvBlastAssetGetChunks for details.
-
-	\return	a pointer to an array of chunks of the asset.
-	*/
-	virtual const NvBlastChunk*			getChunks() const = 0;
-
-	/**
-	Access an array of bonds of the given asset.
-
-	NOTE: Wrapper function over low-level function call, see NvBlastAssetGetBonds for details.
-
-	\return	a pointer to an array of bonds of the asset.
-	*/
-	virtual const NvBlastBond*			getBonds() const = 0;
-
-	/**
-	Access an support graph for the given asset.
-
-	NOTE: Wrapper function over low-level function call, see NvBlastAssetGetSupportGraph for details.
-
-	\return	a struct of support graph for the given asset.
-	*/
-	virtual const NvBlastSupportGraph	getGraph() const = 0;
-
-	/**
-	Retrieve the size (in bytes) of the LL asset.
-
-	NOTE: Wrapper function over low-level function call, see NvBlastAssetGetSize for details.
-
-	\return	the size of the data block (in bytes).
-	*/
-	virtual uint32_t					getDataSize() const = 0;
-
-	/**
-	The number of internal TkJoint objects that will be created when this asset is instanced into a TkActor
-	(see TkFramework::createActor).  These joints will not trigger TkJointUpdateEvent events
-	until this actor is split into actors such that a joint connects two actors.  At this time the actor's family
-	will dispatch a TkJointUpdateEvent::External event during a call to TkGroup::sync() (see TkGroup).
-
-	\return the number of descriptors for internal joints.
-	*/
-	virtual uint32_t					getJointDescCount() const = 0;
-
-	/**
-	The descriptors for the internal joints created when this asset is instanced.  (See getJointDescCount.)
-
-	\return a pointer to the array of descriptors for internal joints.
-	*/
-	virtual const TkAssetJointDesc*		getJointDescs() const = 0;
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTTKASSET_H
diff --git a/NvBlast/sdk/toolkit/include/NvBlastTkEvent.h b/NvBlast/sdk/toolkit/include/NvBlastTkEvent.h
deleted file mode 100644
index 1e640f1..0000000
--- a/NvBlast/sdk/toolkit/include/NvBlastTkEvent.h
+++ /dev/null
@@ -1,166 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTTKEVENT_H
-#define NVBLASTTKEVENT_H
-
-#include <vector>
-
-#include "NvBlastTypes.h"
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-// Forward declarations
-class TkObject;
-class TkActor;
-class TkFamily;
-class TkJoint;
-
-
-/**
-By the time events are dispatched, a specific TkActor may have been split and became invalid.
-This structure caches the state before invalidation happened.
-*/
-struct TkActorData
-{
-	TkFamily*	family;		//!< TkFamily of the originating TkActor
-	void*		userData;	//!< TkActor.userData of the originating TkActor
-	uint32_t	index;		//!< TkActor::getIndex() of the originating TkActor
-};
-
-
-/**
-Event data dispatched to TkEventListener objects.  The user may implement the abstract TkEventListener interface
-and pass the listener object to a BlastTk object which dispatches events.  (See for example TkFamily.)
-*/
-struct TkEvent
-{
-	// Enums
-	enum Type
-	{
-		Split,				//!< Sent when a TkActor is split.  See TkSplitEvent.
-		FractureCommand,	//!< Sent when a TkActor generated fracture commands using TkActor::generateFracture.
-		FractureEvent,		//!< Sent when a TkActor is fractured using TkActor::applyFracture.
-		JointUpdate,		//!< Sent when TkJoints change their attachment state.  See TkJointUpdateEvent.
-
-		TypeCount
-	};
-
-	// Data
-	const void*	payload;	//!< Type-dependent payload data
-	Type		type;		//!< See the Type enum, above
-
-	/**
-	Casts the payload data into its type-dependent format.
-
-	\return the payload for an event of type T
-	*/
-	template<typename T>
-	const T* getPayload() const { return reinterpret_cast<const T*>(payload); }
-};
-
-
-/**
-Payload for TkEvent::Split events
-
-When this event is sent, the parent TkActor that was split is no longer valid.  Therefore it is not referenced
-directly in the event data.  Instead, its TkFamily, index within the TkFamily, and userData are stored.  In addition,
-this event gives the child TkActors generated by the split.
-*/
-struct TkSplitEvent
-{
-	enum { EVENT_TYPE = TkEvent::Split };
-
-	TkActorData	parentData;		//!< The data of parent TkActor that was split
-	uint32_t	numChildren;	//!< The number of children into which the parent TkActor was split
-	TkActor**	children;		//!< An array of pointers to the children into which the TkActor was split
-};
-
-
-/**
-Payload for the TkEvent::FractureCommand events
-
-Fracture Commands used to apply fracture to a TkActor.
-*/
-struct TkFractureCommands
-{
-	enum { EVENT_TYPE = TkEvent::FractureCommand };
-
-	TkActorData				tkActorData;	//!< The data of TkActor that received the fracture command
-	NvBlastFractureBuffers	buffers;		//!< The fracture commands used to modify the TkActor
-};
-
-
-/**
-Payload for the TkEvent::FractureEvent events
-
-Fracture Events resulting from applying fracture to a TkActor.
-*/
-struct TkFractureEvents
-{
-	enum { EVENT_TYPE = TkEvent::FractureEvent };
-
-	TkActorData				tkActorData;	//!< The data of TkActor that received the fracture command
-	NvBlastFractureBuffers	buffers;		//!< The fracture result of the modified TkActor
-	uint32_t				bondsDamaged;	//!< number of damaged bonds (health remains)
-	uint32_t				bondsBroken;	//!< number of broken bonds (health exhausted)
-	uint32_t				chunksDamaged;	//!< number of damaged chunks (health remains) including child chunks
-	uint32_t				chunksBroken;	//!< number of broken chunks (health exhausted) including child chunks
-};
-
-
-/**
-Payload for the TkEvent::JointUpdate events
-
-Event type sent when a TkJoint's TkActor references change.  This may indicate a joint becoming external,
-simply changing actors when split events occur on one or both of the actors, or when one or both of the actors
-are destroyed.
-*/
-struct TkJointUpdateEvent
-{
-	enum { EVENT_TYPE = TkEvent::JointUpdate };
-
-	enum Subtype
-	{
-		External,		//!< A joint that used to be internal to a single TkActor now joins two different TkActors
-		Changed,		//!< One or both of the joint's attached TkActors has changed.  The previous TkActors were distinct, however, differentiating this from the JointExternal case
-		Unreferenced	//!< The joint's actors have been set to NULL.  The joint will not be used again, and the user may release the TkJoint at this time
-	};
-
-	TkJoint*	joint;		//!< The joint being updated
-	Subtype		subtype;	//!< The type of update event this is (see Subtype)
-};
-
-
-/**
-Interface for a listener of TkEvent data.  The user must implement this interface and pass it
-to the object which will dispatch the events.
-*/
-class TkEventListener
-{
-public:
-	/**
-	Interface to be implemented by the user.  Events will be sent by BlastTk through a call to this function.
-
-	\param[in]	events		The array of events being dispatched.
-	\param[in]	eventCount	The number of events in the array.
-	*/
-	virtual void	receive(const TkEvent* events, uint32_t eventCount) = 0;
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTTKEVENT_H
diff --git a/NvBlast/sdk/toolkit/include/NvBlastTkFamily.h b/NvBlast/sdk/toolkit/include/NvBlastTkFamily.h
deleted file mode 100644
index be6edd6..0000000
--- a/NvBlast/sdk/toolkit/include/NvBlastTkFamily.h
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTTKFAMILY_H
-#define NVBLASTTKFAMILY_H
-
-#include "NvBlastTkSerializable.h"
-
-
-// Forward declarations
-struct NvBlastFamily;
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-// Forward declarations
-class TkActor;
-class TkAsset;
-class TkEventListener;
-
-
-/**
-The TkFamily is associated with the TkActor that is instanced from a TkAsset, as well as all descendent TkActors generated
-by spliting TkActors within the family.  It encapsulates an NvBlastFamily, and also holds a material which will be used
-by default on all TkActors during damage functions.
-*/
-class TkFamily : public TkSerializable
-{
-public:
-	/**
-	Access to underlying low-level family.
-
-	\return a pointer to the (const) low-level NvBlastFamily object.
-	*/
-	virtual const NvBlastFamily*	getFamilyLL() const = 0;
-
-	/**
-	Every family has an associated asset (the TkAsset which was instanced to create the first member of the family).
-
-	\return a pointer to the (const) TkAsset object.
-	*/
-	virtual const TkAsset*			getAsset() const = 0;
-
-	/**
-	The number of actors currently in this family.
-
-	\return the number of TkActors that currently exist in this family.
-	*/
-	virtual uint32_t				getActorCount() const = 0;
-
-	/**
-	Retrieve an array of pointers (into the user-supplied buffer) to actors.
-
-	\param[out]	buffer		A user-supplied array of TkActor pointers.
-	\param[in]	bufferSize	The number of elements available to write into buffer.
-	\param[in]	indexStart	The starting index of the actor.
-
-	\return the number of TkActor pointers written to the buffer.
-	*/
-	virtual uint32_t				getActors(TkActor** buffer, uint32_t bufferSize, uint32_t indexStart = 0) const = 0;
-
-	/**
-	Add a user implementation of TkEventListener to this family's list of listeners.  These listeners will receive
-	all split and fracture events generated by TkActor objects in this family.  They will also receive joint update events
-	when TkJoint objects are updated that are (or were) associated with a TkActor in this family.
-
-	\param[in]	l			The event listener to add.
-	*/
-	virtual void					addListener(TkEventListener& l) = 0;
-
-	/**
-	Remove a TkEventReciever from this family's list of listeners.
-
-	\param[in]	l			The event listener to remove.
-	*/
-	virtual void					removeListener(TkEventListener& l) = 0;
-
-	/**
-	This function applies fracture buffers on relevant actors (actor which contains corresponding bond/chunk) in family.
-
-	\param[in]	commands	The fracture commands to process.
-	*/
-	virtual void					applyFracture(const NvBlastFractureBuffers* commands) = 0;
-
-	/**
-	A function to reinitialize this family with new family. The Family must be created from the same low-level asset, but can be 
-	in any other state.  As a result split events (TkEvent::Split) will be dispatched reflecting the resulting changes (created and removed actors)
-	Afterwards the family will contain a copy of the new family and all actors' low-level actor pointers will be updated.
-
-	\param[in] newFamily		The NvBlastFamily to use to reinitialize this family.
-	\param[in] group			The group for new actors to be placed in.
-	*/
-	virtual void					reinitialize(const NvBlastFamily* newFamily, TkGroup* group = nullptr) = 0;
-
-	/**
-	The default material to be passed into NvBlastDamageProgram when a TkActor in this family is damaged.
-
-	\return a pointer to the default material.
-	*/
-	virtual const void*				getMaterial() const = 0;
-
-	/**
-	Set the default material to be passed into NvBlastDamageProgram when a TkActor in this family is damaged.  Must be valid till group sync() call.
-
-	\param[in] material			The material to be the new default.
-	*/
-	virtual void					setMaterial(const void* material) = 0;
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTTKFAMILY_H
diff --git a/NvBlast/sdk/toolkit/include/NvBlastTkFramework.h b/NvBlast/sdk/toolkit/include/NvBlastTkFramework.h
deleted file mode 100644
index 353eebd..0000000
--- a/NvBlast/sdk/toolkit/include/NvBlastTkFramework.h
+++ /dev/null
@@ -1,365 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTTKFRAMEWORK_H
-#define NVBLASTTKFRAMEWORK_H
-
-
-#include "NvBlastTkType.h"
-#include "NvBlastTkEvent.h"
-
-#include "NvBlastPreprocessor.h"
-#include "NvBlastTypes.h"
-
-#include "PxVec3.h"
-
-
-// Forward declarations
-namespace physx
-{
-class PxErrorCallback;
-class PxAllocatorCallback;
-class PxTransform;
-namespace general_PxIOStream2
-{
-class PxFileBuf;
-}
-}
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-// Forward declarations
-class TkObject;
-class TkEventDispatcher;
-class TkAsset;
-struct TkGroupDesc;
-class TkGroup;
-class TkActor;
-class TkJoint;
-class TkSerializable;
-class TkIdentifiable;
-struct TkAssetJointDesc;
-
-
-
-/**
-Descriptor for framework creation.
-
-The TkFramework uses PxShared callbacks for messages and allocation.
-*/
-struct TkFrameworkDesc
-{
-	physx::PxErrorCallback*		errorCallback;		//!< User-defined message callback (see PxErrorCallback)
-	physx::PxAllocatorCallback*	allocatorCallback;	//!< User-defined allocation callback (see PxAllocatorCallback)
-};
-
-
-/**
-Descriptor for asset creation
-
-Used to create a TkAsset.  This may be used by an authoring tool to describe the asset to be created.
-
-The TkAssetDesc is a simple extension of the low-level NvBlastAsset descriptor, NvBlastAssetDesc.
-*/
-struct TkAssetDesc : public NvBlastAssetDesc
-{
-	/**
-	Flags which may be associated with each bond described in the base NvBlastAssetDesc.
-	*/
-	enum BondFlags
-	{
-		NoFlags = 0,
-
-		/**
-		If this flag is set then a TkJoint will be created joining the support chunks jointed by the bond.
-
-		These joints will remain "quiet" until the actor is split in such a way that the joint joins two
-		different actors.  In that case, a TkJointUpdateEvent will be dispatched with subtype External.
-		(See TkJointUpdateEvent.)
-		*/
-		BondJointed = (1 << 0)
-	};
-
-	/**
-	An array of size bondCount, see BondFlags.
-	If NULL, all flags are assumed to be NoFlags.
-	*/
-	const uint8_t*	bondFlags;
-
-	/** Constructor sets sane default values.  The zero chunkCount will cause TkFramework::createAsset(...) to fail, though gracefully. */
-	TkAssetDesc() : bondFlags(nullptr)
-	{
-		chunkCount = bondCount = 0;
-		chunkDescs = nullptr;
-		bondDescs = nullptr;
-	}
-};
-
-
-/**
-Descriptor for actor creation.
-
-The TkActorDesc is a simple extension of the low-level NvBlastActor descriptor, NvBlastActorDesc.
-*/
-struct TkActorDesc : public NvBlastActorDesc
-{
-	const TkAsset* asset;	//!< The TkAsset to instance
-
-	/** Constructor sets sane default values */
-	TkActorDesc(const TkAsset* inAsset = nullptr) : asset(inAsset)
-	{
-		uniformInitialBondHealth = uniformInitialLowerSupportChunkHealth = 1.0f;
-		initialBondHealths = initialSupportChunkHealths = nullptr;
-	}
-};
-
-
-/**
-Descriptor for joint creation.
-*/
-struct TkJointDesc
-{
-	TkFamily*		families[2];		//!< The TkFamily objects containint the chunks joined by the joint
-	uint32_t		chunkIndices[2];	//!< The chunk indices within the corresponding TkFamily objects joined by the joint.  The indexed chunks will be support chunks.
-	physx::PxVec3	attachPositions[2];	//!< The position of the joint relative to each TkActor which ownes the chunks jointed by this joint
-};
-
-
-/**
-Struct-enum to index object types handled by the framework
-*/
-struct TkTypeIndex
-{
-	enum Enum
-	{
-		Asset = 0,	//!< TkAsset object type
-		Family,		//!< TkFamily object type
-		Group,		//!< TkGroup object type
-
-		TypeCount
-	};
-};
-
-
-/**
-BlastTk Framework.
-
-The framework exists as a singleton and is used to create objects, deserialize object streams, and hold references
-to identified objects (TkAsset, TkFamily, and TkGroup) which may be recalled by their GUIDs.
-*/
-class TkFramework
-{
-public:
-	/**
-	Release this framework and all contained objects.
-	Global singleton is set to NULL.
-	*/
-	virtual void						release() = 0;
-
-	/**
-	Access to the error callback set by the user.
-	*/
-	virtual physx::PxErrorCallback&		getErrorCallback() const = 0;
-
-	/**
-	Access to the allocator callback set by the user.
-	*/
-	virtual physx::PxAllocatorCallback&	getAllocatorCallback() const = 0;
-
-	/**
-	Access to a log function which can be used in Blast low-level calls.
-	This function uses the user-supplied PxErrorCallback (see TkFrameworkDesc).
-	*/
-	virtual NvBlastLog					getLogFn() const = 0;
-
-	/**
-	Deserialize an object from the given stream.  Only objects derived from TkSerializable may be serialized and
-	deserialized.  Use the parent class method TkIdentifiable::getType() to know the type to which to cast the object.
-
-	Notes for different classes:
-
-	TkAsset: deserializing a serialized TkAsset will recreate the asset in memory with the same NvBlastID (see
-	TkIdentifiable::getID()) as the original asset.
-
-	TkFamily: deserializing a serialized TkFamily will generate all TkActor and TkJoint objects that were originally
-	contained in the family.  The TkAsset which generated the family must exist at the time the family is deserialized.
-
-	\param[in]	stream	User-defined stream object.
-
-	\return pointer the deserialized object if successful, or NULL if unsuccessful.
-	*/
-	virtual TkSerializable*				deserialize(physx::general_PxIOStream2::PxFileBuf& stream) = 0;
-
-	/**
-	To find the type information for a given TkIdentifiable-derived class, use this funtion with the TkTypeIndex::Enum
-	corresponding to the desired class name.
-
-	\param[in]	typeIndex	Enumerated object type (see TkTypeIndex).
-
-	\return type object associated with the object's class.
-	*/
-	virtual const TkType*				getType(TkTypeIndex::Enum typeIndex) const = 0;
-
-	/**
-	Look up an object derived from TkIdentifiable by its ID.
-
-	\param[in]	id	The ID of the object to look up (see NvBlastID).
-
-	\return pointer the object if it exists, NULL otherwise.
-	*/
-	virtual TkIdentifiable*				findObjectByID(const NvBlastID& id) const = 0;
-
-	/**
-	The number of TkIdentifiable-derived objects in the framework of the given type.
-
-	\param[in]	type	The type object for the given type.
-
-	\return the number of objects that currently exist of the given type.
-	*/
-	virtual uint32_t					getObjectCount(const TkType& type) const = 0;
-
-	/**
-	Retrieve an array of pointers (into the user-supplied buffer) to TkIdentifiable-derived objects of the given type.
-
-	\param[out]	buffer		A user-supplied array of TkIdentifiable pointers.
-	\param[in]	bufferSize	The number of elements available to write into buffer.
-	\param[in]	type		The type object for the given type.
-	\param[in]	indexStart	The starting index of the object.
-
-	\return the number of TkIdentifiable pointers written to the buffer.
-	*/
-	virtual uint32_t					getObjects(TkIdentifiable** buffer, uint32_t bufferSize, const TkType& type, uint32_t indexStart = 0) const = 0;
-
-	//////// Asset creation ////////
-	/**
-	Helper function to build and apply chunk reorder map, so that chunk descriptors are properly ordered for the createAsset function.
-
-	This is a convenience wrapper for the low-level NvBlastReorderAssetDescChunks function.
-
-	This function may modify both the chunkDescs and bondDescs array, since rearranging chunk descriptors requires re-indexing within the bond descriptors.
-
-	\param[in]  chunkDescs		Array of chunk descriptors of size chunkCount. It will be updated accordingly.
-	\param[in]  chunkCount		The number of chunk descriptors.
-	\param[in]  bondDescs		Array of bond descriptors of size chunkCount. It will be updated accordingly.
-	\param[in]  bondCount		The number of bond descriptors.
-	\param[in]	chunkReorderMap	If not NULL, must be a pointer to a uint32_t array of size desc.chunkCount.  Maps old chunk indices to the reordered chunk indices.
-
-	\return	true iff the chunks did not require reordering (chunkReorderMap is the identity map).
-	*/
-	virtual bool						reorderAssetDescChunks(NvBlastChunkDesc* chunkDescs, uint32_t chunkCount, NvBlastBondDesc* bondDescs, uint32_t bondCount, uint32_t* chunkReorderMap = nullptr) const = 0;
-
-	/**
-	Helper function to ensure (check and update) support coverage of chunks, required for asset creation via the createAsset function.
-
-	This is a convenience wrapper for the low-level NvBlastEnsureAssetExactSupportCoverage function.
-
-	The chunk descriptors may have their support flags be modified to ensure exact coverage.
-
-	\param[in]	chunkDescs	An array of chunk descriptors.
-	\param[in]	chunkCount	The size of the chunkDescs array.
-
-	\return	true iff coverage was already exact.
-	*/
-	virtual bool						ensureAssetExactSupportCoverage(NvBlastChunkDesc* chunkDescs, uint32_t chunkCount) const = 0;
-
-	/**
-	Create an asset from the given descriptor.
-
-	\param[in]	desc	The asset descriptor (see TkAssetDesc).
-
-	\return the created asset, if the descriptor was valid and memory was available for the operation.  Otherwise, returns NULL.
-	*/
-	virtual TkAsset*					createAsset(const TkAssetDesc& desc) = 0;
-
-	/**
-	Create an asset from a low-level NvBlastAsset.
-
-	\param[in]	assetLL			The low-level NvBlastAsset to encapsulate.
-	\param[in]	jointDescs		Optional joint descriptors to add to the new asset.
-	\param[in]	jointDescCount	The number of joint descriptors in the jointDescs array.  If non-zero, jointDescs cannot be NULL.
-	\param[in]  ownsAsset		Does this TkAsset own the NvBlastAsset and thus is responsible for freeing it.
-
-	\return the created asset, if memory was available for the operation.  Otherwise, returns NULL.
-	*/
-	virtual TkAsset*					createAsset(const NvBlastAsset* assetLL, Nv::Blast::TkAssetJointDesc* jointDescs = nullptr, uint32_t jointDescCount = 0, bool ownsAsset = false) = 0;
-
-	//////// Group creation ////////
-	/**
-	Create a group from the given descriptor.  A group is a processing unit, to which the user may add TkActors.  New actors generated
-	from splitting a TkActor are automatically put into the same group.  However, any actor may be removed from its group and optionally
-	placed into another group, or left groupless.
-
-	\param[in]	desc	The group descriptor (see TkGroupDesc).
-
-	\return the created group, if the descriptor was valid and memory was available for the operation.  Otherwise, returns NULL.
-	*/
-	virtual TkGroup*					createGroup(const TkGroupDesc& desc) = 0;
-
-	//////// Actor creation ////////
-	/**
-	Create an actor from the given descriptor.  The actor will be the first member of a new TkFamily.
-
-	\param[in]	desc	The actor descriptor (see TkActorDesc).
-
-	\return the created actor, if the descriptor was valid and memory was available for the operation.  Otherwise, returns NULL.
-	*/
-	virtual TkActor*					createActor(const TkActorDesc& desc) = 0;
-
-	//////// Joint creation ////////
-	/**
-	Create a joint from the given descriptor.  The following restrictions apply:
-	
-	* Only one joint may be created between any two support chunks.
-
-	* A joint cannot be created between chunks within the same actor using this method.  See TkAssetDesc for a description of
-	bond joint flags, which will create internal joints within an actor.
-
-	\param[in]	desc	The joint descriptor (see TkJointDesc).
-
-	\return the created joint, if the descriptor was valid and memory was available for the operation.  Otherwise, returns NULL.
-	*/
-	virtual TkJoint*					createJoint(const TkJointDesc& desc)  = 0;
-
-protected:
-	/**
-	Destructor is virtual and not public - use the release() method instead of explicitly deleting the TkFramework
-	*/
-	virtual								~TkFramework() {}
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-//////// Global API to Create and Access Framework ////////
-
-/**
-Create a new TkFramework.  This creates a global singleton, and will fail if a TkFramework object already exists.
-
-\param[in]	desc	The descriptor used to create the new framework (see TkFrameworkDesc).
-
-\return the new TkFramework if successful, NULL otherwise.
-*/
-NVBLAST_API Nv::Blast::TkFramework* NvBlastTkFrameworkCreate(const Nv::Blast::TkFrameworkDesc& desc);
-
-
-/**
-Retrieve a pointer to the global TkFramework singleton (if it exists).
-
-\return the pointer to the global TkFramework (NULL if none exists).
-*/
-NVBLAST_API Nv::Blast::TkFramework* NvBlastTkFrameworkGet();
-
-
-#endif // ifndef NVBLASTTKFRAMEWORK_H
diff --git a/NvBlast/sdk/toolkit/include/NvBlastTkGroup.h b/NvBlast/sdk/toolkit/include/NvBlastTkGroup.h
deleted file mode 100644
index 585cccb..0000000
--- a/NvBlast/sdk/toolkit/include/NvBlastTkGroup.h
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTTKGROUP_H
-#define NVBLASTTKGROUP_H
-
-#include "NvBlastTkIdentifiable.h"
-
-
-// Forward declarations
-namespace physx
-{
-class PxTaskManager;
-}
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-// Forward declarations
-class TkActor;
-
-
-/**
-Descriptor for a TkGroup.  It uses the PxShared PxTaskManager interface to dispatch PxLightCpuTask.
-@see TkWorker
-*/
-struct TkGroupDesc
-{
-	physx::PxTaskManager* pxTaskManager;	//!< User-defined task manager
-};
-
-
-/**
-Used to collect internal counters using TkGroup::getStats (for profile builds only)
-@see TkGroup::getStats()
-*/
-struct TkGroupStats
-{
-	NvBlastTimers	timers;					//!< Accumulated time spent in blast low-level functions, see NvBlastTimers
-	uint32_t		processedActorsCount;	//!< Accumulated number of processed actors in all TkWorker
-	int64_t			workerTime;				//!< Accumulated time spent executing TkWorker::run. Unit is ticks, see NvBlastTimers.
-};
-
-
-/**
-A group is a processing unit, to which the user may add TkActors.  New actors generated from splitting a TkActor
-are automatically put into the same group.  However, any actor may be removed from its group and placed into
-another group (or no group) by the user's choice.
-
-When the group's process function is called, all actors' damage buffers will be processed and turned into fracture events
-and the actor is split if applicable.
-This work is done in separate (possibly multiple) threads.  The sync function waits for the processing threads to finish
-and dispatches events for processing that actually occurred.
-*/
-class TkGroup : public TkIdentifiable
-{
-public:
-	/**
-	Add the actor to this group, if the actor does not currently belong to a group.
-
-	\param[in]	actor	The actor to add.
-
-	\return true if successful, false otherwise.
-	*/
-	virtual bool		addActor(TkActor& actor) = 0;
-
-	/**
-	The number of actors currently in this group.
-
-	\return the number of TkActors that currently exist in this group.
-	*/
-	virtual uint32_t	getActorCount() const = 0;
-
-	/**
-	Retrieve an array of pointers (into the user-supplied buffer) to actors.
-
-	\param[out]	buffer		A user-supplied array of TkActor pointers.
-	\param[in]	bufferSize	The number of elements available to write into buffer.
-	\param[in]	indexStart	The starting index of the actor.
-
-	\return the number of TkActor pointers written to the buffer.
-	*/
-	virtual uint32_t	getActors(TkActor** buffer, uint32_t bufferSize, uint32_t indexStart = 0) const = 0;
-
-	/**
-	TkActors that have been damaged with applyFracture() such that they may be split into separate
-	actors are split by this function. TkActors that have damage queued through the actor's damage() function
-	will be fractured and split by this function.
-	Fracture and splitting work will be run on different threads provided through TkGroupDesc::pxTaskManager.  
-	All work is done asynchronously, and the results are gathered by the sync() function.
-
-	Note: The number of threads provided by pxTaskManager must not change over the group's lifetime.
-
-	\return true if processing may be launched (this group is not currently processing), false otherwise.
-	*/
-	virtual bool		process() = 0;
-
-	/**
-	If all threads spawned by process() have finished, and sync() has not yet been called since, then this
-	function gathers the results of the split operations on the actors in this group.  Events will be dispatched
-	to notify listeners of new and deleted actors.
-
-	\param[in]	block	If true, this function waits until all threads have completed execution, then performs the gather and dispatch work.
-						If false, this function will perform the gather and dispatch work only if threads have completed execution, otherwise it returns immediately.
-
-	\return true if gather and dispatch work have been performed, false otherwise.
-	*/
-	virtual bool		sync(bool block = true) = 0;
-
-	/**
-	For profile builds only, request stats of the last successful processing. Inactive in other builds.
-	The times and counters reported account for all the TkWorker (accumulated) taking part in the processing.
-
-	\param[in]	stats	The struct to be filled in.
-	*/
-	virtual void		getStats(TkGroupStats& stats) const = 0;
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTTKGROUP_H
diff --git a/NvBlast/sdk/toolkit/include/NvBlastTkIdentifiable.h b/NvBlast/sdk/toolkit/include/NvBlastTkIdentifiable.h
deleted file mode 100644
index 6efe954..0000000
--- a/NvBlast/sdk/toolkit/include/NvBlastTkIdentifiable.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTTKIDENTIFIABLE_H
-#define NVBLASTTKIDENTIFIABLE_H
-
-
-#include "NvBlastTkObject.h"
-
-#include "NvBlastTypes.h"
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-// Forward declarations
-class TkType;
-
-
-/**
-TkIdentifiable objects have getID and setID methods for individual objects.  They also have a type (class) identification.
-*/
-class TkIdentifiable : public TkObject
-{
-public:
-	// Identifiable API
-
-	/**
-	Return the ID associated with this object.
-
-	\return the ID for this object.
-	*/
-	virtual const NvBlastID&	getID() const = 0;
-
-	/**
-	Set the ID for this object.
-	*/
-	virtual void				setID(const NvBlastID& id) = 0;
-
-	/**
-	Access to the static (class) type data for this object.
-
-	\return the static type data for this object type.
-	*/
-	virtual const TkType&		getType() const = 0;
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTTKIDENTIFIABLE_H
diff --git a/NvBlast/sdk/toolkit/include/NvBlastTkJoint.h b/NvBlast/sdk/toolkit/include/NvBlastTkJoint.h
deleted file mode 100644
index 1fc41c0..0000000
--- a/NvBlast/sdk/toolkit/include/NvBlastTkJoint.h
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTTKJOINT_H
-#define NVBLASTTKJOINT_H
-
-#include "NvBlastTkObject.h"
-
-#include "PxVec3.h"
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-/**
-The data contained in a TkJoint.
-*/
-struct TkJointData
-{
-	TkActor*		actors[2];			//!< The TkActor objects joined by the joint
-	uint32_t		chunkIndices[2];	//!< The chunk indices within the corresponding TkActor objects joined by the joint.  The indexed chunks will be support chunks.
-	physx::PxVec3	attachPositions[2];	//!< The position of the joint relative to each TkActor
-};
-
-
-/**
-The TkJoint is may join two different TkActors, or be created internally within a single TkActor.
-
-When a TkActor is created from a TkAsset with jointed bonds (the asset is created using a TkAssetDesc with joint flags on bonds, see TkActorDesc) then
-internal TkJoint objects are created and associated with every TkActor created from that TkAsset.  The user only gets notification of the internal TkJoint
-objects when the TkActor is split into separate TkActor objects that hold the support chunks joined by an internal TkJoint.
-
-The user will be notified when the TkActor objects that are attached to TkJoint objects change, or are released.  In that case, a TkEvent with
-a TkJointUpdateEvent payload is dispatched to TkEventListener objects registered with the TkFamily objects to which the actors belong.
-*/
-class TkJoint : public TkObject
-{
-public:
-	/**
-	Retrieve data in this joint.
-
-	\return a TkJointData containing this joint's data.
-	*/
-	virtual const TkJointData	getData() const = 0;
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTTKJOINT_H
diff --git a/NvBlast/sdk/toolkit/include/NvBlastTkObject.h b/NvBlast/sdk/toolkit/include/NvBlastTkObject.h
deleted file mode 100644
index 085e859..0000000
--- a/NvBlast/sdk/toolkit/include/NvBlastTkObject.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTTKOBJECT_H
-#define NVBLASTTKOBJECT_H
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-/**
-Base class for all objects in Tk.  All TkObjects are releasable.
-*/
-class TkObject
-{
-public:
-	/**
-	Constructor clears userData.
-	*/
-	TkObject() : userData(nullptr) {}
-
-	// Object API
-
-	/**
-	Release this object and free associated memory.
-	*/
-	virtual void	release() = 0;
-
-protected:
-	/**
-	Destructor is virtual and not public - use the release() method instead of explicitly deleting a TkObject
-	*/
-	virtual			~TkObject() {}
-
-public:
-	// Data
-
-	/**
-	Pointer field available to the user.
-	*/
-	void*	userData;
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTTKOBJECT_H
diff --git a/NvBlast/sdk/toolkit/include/NvBlastTkSerializable.h b/NvBlast/sdk/toolkit/include/NvBlastTkSerializable.h
deleted file mode 100644
index 93b9b47..0000000
--- a/NvBlast/sdk/toolkit/include/NvBlastTkSerializable.h
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTTKSERIALIZABLE_H
-#define NVBLASTTKSERIALIZABLE_H
-
-
-#include "NvBlastTkIdentifiable.h"
-
-
-// Forward declarations
-namespace physx
-{
-namespace general_PxIOStream2
-{
-class PxFileBuf;
-}
-}
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-/**
-TkSerializable objects support the serialize interface, and are returned by TkFramework::deserialize.
-*/
-class TkSerializable : public TkIdentifiable
-{
-public:
-	/**
-	Write the object data to the user-defined PxFileBuf stream.
-
-	\param[in]	stream	User-defined stream object.
-
-	\return true if serialization was successful, false otherwise.
-	*/
-	virtual bool	serialize(physx::general_PxIOStream2::PxFileBuf& stream) const = 0;
-
-	// Data
-
-	/**
-	Integer field available to the user.  This data is serialized.
-	*/
-	uint64_t	userIntData;
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTTKSERIALIZABLE_H
diff --git a/NvBlast/sdk/toolkit/include/NvBlastTkType.h b/NvBlast/sdk/toolkit/include/NvBlastTkType.h
deleted file mode 100644
index 6f3afbf..0000000
--- a/NvBlast/sdk/toolkit/include/NvBlastTkType.h
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTTKTYPE_H
-#define NVBLASTTKTYPE_H
-
-#include "NvBlastTypes.h"
-
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-/**
-Interface for static (class) type data.  This data is used for identification in streams,
-class-specific object queries in TkFramework, etc.  Only classes derived from TkIdentifiable
-use TkType data.
-*/
-class TkType
-{
-public:
-	/**
-	The class name.
-
-	\return the class name.
-	*/
-	virtual const char*	getName() const = 0;
-
-	/**
-	The data format version for this class.  When deserializing, this version must match the
-	current version.  If not, the user may convert the data format using the format conversion
-	extension.
-
-	\return the version number.
-	*/
-	virtual uint32_t	getVersion() const = 0;
-
-	/**
-	Test for equality.  This type is used in static (per-class) data, so types are equal exactly
-	when their addresses are equal.
-
-	\param[in]	type	The TkType to compare with this TkType.
-
-	\return true if this type equals the input type, false otherwise.
-	*/
-	bool				operator == (const TkType& type) const
-	{
-		return &type == this;
-	}
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTTKTYPE_H
diff --git a/NvBlast/sdk/toolkit/source/NvBlastTkActorImpl.cpp b/NvBlast/sdk/toolkit/source/NvBlastTkActorImpl.cpp
deleted file mode 100644
index 028e0f1..0000000
--- a/NvBlast/sdk/toolkit/source/NvBlastTkActorImpl.cpp
+++ /dev/null
@@ -1,434 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastPreprocessor.h"
-
-#include "NvBlastTkFrameworkImpl.h"
-#include "NvBlastTkActorImpl.h"
-#include "NvBlastTkGroupImpl.h"
-#include "NvBlastTkAssetImpl.h"
-#include "NvBlastTkFamilyImpl.h"
-#include "NvBlastTkJointImpl.h"
-
-#include "NvBlast.h"
-#include "NvBlastAssert.h"
-#include "NvBlastMemory.h"
-
-#include "Px.h"
-#include "PxFileBuf.h"
-#include "PxAllocatorCallback.h"
-#include "PxTransform.h"
-
-using namespace physx::general_PxIOStream2;
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-TkActorImpl* TkActorImpl::create(const TkActorDesc& desc)
-{
-	const TkAssetImpl* asset = static_cast<const TkAssetImpl*>(desc.asset);
-
-	TkFamilyImpl* family = TkFamilyImpl::create(asset);
-
-	NvBlastFamily* familyLL = family->getFamilyLLInternal();
-	TkArray<char>::type scratch((uint32_t)NvBlastFamilyGetRequiredScratchForCreateFirstActor(familyLL, TkFrameworkImpl::get()->log));
-	NvBlastActor* actorLL = NvBlastFamilyCreateFirstActor(familyLL, &desc, scratch.begin(), TkFrameworkImpl::get()->log);
-	if (actorLL == nullptr)
-	{
-		NVBLASTTK_LOG_ERROR("TkActorImpl::create: low-level actor could not be created.");
-		return nullptr;
-	}
-
-	TkActorImpl* actor = family->addActor(actorLL);
-
-	// Add internal joints
-	if (actor != nullptr)
-	{
-		const uint32_t internalJointCount = asset->getJointDescCountInternal();
-		const TkAssetJointDesc* jointDescs = asset->getJointDescsInternal();
-		const NvBlastSupportGraph graph = asset->getGraph();
-		TkJointImpl* joints = family->getInternalJoints();
-		for (uint32_t jointNum = 0; jointNum < internalJointCount; ++jointNum)
-		{
-			const TkAssetJointDesc& assetJointDesc = jointDescs[jointNum];
-			NVBLAST_ASSERT(assetJointDesc.nodeIndices[0] < graph.nodeCount && assetJointDesc.nodeIndices[1] < graph.nodeCount);
-			TkJointDesc jointDesc;
-			jointDesc.families[0] = jointDesc.families[1] = family;
-			jointDesc.chunkIndices[0] = graph.chunkIndices[assetJointDesc.nodeIndices[0]];
-			jointDesc.chunkIndices[1] = graph.chunkIndices[assetJointDesc.nodeIndices[1]];
-			jointDesc.attachPositions[0] = assetJointDesc.attachPositions[0];
-			jointDesc.attachPositions[1] = assetJointDesc.attachPositions[1];
-			TkJointImpl* joint = new (joints + jointNum) TkJointImpl(jointDesc, family);
-			actor->addJoint(joint->m_links[0]);
-		}
-	}
-
-	return actor;
-}
-
-
-//////// Member functions ////////
-
-TkActorImpl::TkActorImpl()
-	: m_actorLL(nullptr)
-	, m_family(nullptr)
-	, m_group(nullptr)
-	, m_groupJobIndex(invalidIndex<uint32_t>())
-	, m_flags(0)
-	, m_jointCount(0)
-{
-#if NV_PROFILE
-	NvBlastTimersReset(&m_timers);
-#endif
-}
-
-
-TkActorImpl::~TkActorImpl()
-{
-}
-
-
-void TkActorImpl::release()
-{
-	// Disassoaciate all joints
-
-	// Copy joint array for safety against implementation of joint->setActor
-	TkJointImpl** joints = reinterpret_cast<TkJointImpl**>(NvBlastAlloca(sizeof(TkJointImpl*)*getJointCountInternal()));
-	TkJointImpl** stop = joints + getJointCountInternal();
-	TkJointImpl** jointHandle = joints;
-	for (JointIt j(*this); (bool)j; ++j)
-	{
-		*jointHandle++ = *j;
-	}
-	jointHandle = joints;
-	while (jointHandle < stop)
-	{
-		NVBLAST_ASSERT(*jointHandle != nullptr);
-		NVBLAST_ASSERT((*jointHandle)->getDataInternal().actors[0] == this || (*jointHandle)->getDataInternal().actors[1] == this);
-		(*jointHandle++)->setActors(nullptr, nullptr);
-	}
-	NVBLAST_ASSERT(getJointCountInternal() == 0);
-
-	if (m_group != nullptr)
-	{
-		m_group->removeActor(*this);
-	}
-
-	if (m_actorLL != nullptr)
-	{
-		NvBlastActorDeactivate(m_actorLL, TkFrameworkImpl::get()->log);
-	}
-
-	if (m_family != nullptr)
-	{
-		m_family->removeActor(this);
-
-		// Make sure we dispatch any remaining events when this family is emptied, since it will no longer be done by any group
-		if (m_family->getActorCountInternal() == 0)
-		{
-			m_family->getQueue().dispatch();
-		}
-	}
-}
-
-
-const NvBlastActor* TkActorImpl::getActorLL() const
-{
-	return m_actorLL;
-}
-
-
-TkFamily& TkActorImpl::getFamily() const
-{
-	return getFamilyImpl();
-}
-
-
-uint32_t TkActorImpl::getIndex() const
-{
-	return getIndexInternal();
-}
-
-
-TkGroup* TkActorImpl::getGroup() const
-{
-	return getGroupImpl();
-}
-
-
-TkGroup* TkActorImpl::removeFromGroup()
-{
-	if (m_group == nullptr)
-	{
-		NVBLASTTK_LOG_WARNING("TkActorImpl::removeFromGroup: actor not in a group.");
-		return nullptr;
-	}
-
-	if (m_group->isProcessing())
-	{
-		NVBLASTTK_LOG_ERROR("TkActorImpl::removeFromGroup: cannot alter Group while processing.");
-		return nullptr;
-	}
-
-	TkGroup* group = m_group;
-	
-	return m_group->removeActor(*this) ? group : nullptr;
-}
-
-
-NvBlastFamily* TkActorImpl::getFamilyLL() const
-{ 
-	return m_family->getFamilyLLInternal(); 
-}
-
-
-const TkAsset* TkActorImpl::getAsset() const
-{ 
-	return m_family->getAssetImpl(); 
-}
-
-
-uint32_t TkActorImpl::getVisibleChunkCount() const
-{
-	return NvBlastActorGetVisibleChunkCount(m_actorLL, TkFrameworkImpl::get()->log);
-}
-
-
-uint32_t TkActorImpl::getVisibleChunkIndices(uint32_t* visibleChunkIndices, uint32_t visibleChunkIndicesSize) const
-{
-	return NvBlastActorGetVisibleChunkIndices(visibleChunkIndices, visibleChunkIndicesSize, m_actorLL, TkFrameworkImpl::get()->log);
-}
-
-
-uint32_t TkActorImpl::getGraphNodeCount() const
-{
-	return NvBlastActorGetGraphNodeCount(m_actorLL, TkFrameworkImpl::get()->log);
-}
-
-
-uint32_t TkActorImpl::getGraphNodeIndices(uint32_t* graphNodeIndices, uint32_t graphNodeIndicesSize) const
-{
-	return NvBlastActorGetGraphNodeIndices(graphNodeIndices, graphNodeIndicesSize, m_actorLL, TkFrameworkImpl::get()->log);
-}
-
-
-const float* TkActorImpl::getBondHealths() const
-{
-	return NvBlastActorGetBondHealths(m_actorLL, TkFrameworkImpl::get()->log);
-}
-
-
-uint32_t TkActorImpl::getSplitMaxActorCount() const
-{
-	return NvBlastActorGetMaxActorCountForSplit(m_actorLL, TkFrameworkImpl::get()->log);
-}
-
-
-bool TkActorImpl::isDamaged() const
-{
-	NVBLAST_ASSERT(!m_flags.isSet(TkActorFlag::DAMAGED) || (m_flags.isSet(TkActorFlag::DAMAGED) && m_flags.isSet(TkActorFlag::PENDING)));
-	return m_flags.isSet(TkActorFlag::DAMAGED);
-}
-
-
-void TkActorImpl::markAsDamaged()
-{
-	m_flags |= TkActorFlag::DAMAGED;
-	makePending();
-}
-
-
-void TkActorImpl::makePending()
-{
-	if (m_group != nullptr && !isPending())
-	{
-		m_group->enqueue(this);
-	}
-
-	m_flags |= TkActorFlag::PENDING;
-}
-
-
-TkActorImpl::operator Nv::Blast::TkActorData() const
-{
-	TkActorData data = { m_family, userData, getIndex() };
-	return data;
-}
-
-
-void TkActorImpl::damage(const NvBlastDamageProgram& program, const NvBlastProgramParams* programParams)
-{
-	PERF_SCOPE_L("TkActor::damage");
-
-	if (m_group == nullptr)
-	{
-		NVBLASTTK_LOG_WARNING("TkActor::damage: actor is not in a group, cannot fracture.");
-		return;
-	}
-
-	if (m_group->isProcessing())
-	{
-		NVBLASTTK_LOG_WARNING("TkActor::damage: group is being processed, cannot fracture this actor.");
-		return;
-	}
-
-	if (NvBlastActorCanFracture(m_actorLL, TkFrameworkImpl::get()->log))
-	{
-		m_damageBuffer.pushBack(DamageData(program, programParams));
-		makePending();
-	}
-}
-
-
-void TkActorImpl::damage(const NvBlastDamageProgram& program, const void* damageDesc, uint32_t descSize)
-{
-	damage(program, damageDesc, descSize, m_family->getMaterial());
-}
-
-
-void TkActorImpl::damage(const NvBlastDamageProgram& program, const void* damageDesc, uint32_t descSize, const void* material)
-{
-	PERF_SCOPE_L("TkActor::damage");
-
-	if (m_group == nullptr)
-	{
-		NVBLASTTK_LOG_WARNING("TkActor::damage: actor is not in a group, cannot fracture.");
-		return;
-	}
-
-	if (m_group->isProcessing())
-	{
-		NVBLASTTK_LOG_WARNING("TkActor::damage: group is being processed, cannot fracture this actor.");
-		return;
-	}
-
-	if (NvBlastActorCanFracture(m_actorLL, TkFrameworkImpl::get()->log))
-	{
-		bool appended = false;
-		for (auto& damageData : m_damageBuffer)
-		{
-			if (damageData.tryAppend(program, material, damageDesc, descSize))
-			{
-				appended = true;
-				break;
-			}
-		}
-
-		if (!appended)
-		{
-			m_damageBuffer.pushBack(DamageData(program, material, damageDesc, descSize));
-		}
-
-		makePending();
-	}
-}
-
-
-void TkActorImpl::generateFracture(NvBlastFractureBuffers* commands, const NvBlastDamageProgram& program, const NvBlastProgramParams* programParams) const
-{
-	PERF_SCOPE_L("TkActor::generateFracture");
-
-	if (m_group && m_group->isProcessing())
-	{
-		NVBLASTTK_LOG_WARNING("TkActor::generateFracture: group is being processed, cannot fracture this actor.");
-		return;
-	}
-
-	// const context, must make m_timers mutable otherwise
-	NvBlastActorGenerateFracture(commands, m_actorLL, program, programParams, TkFrameworkImpl::get()->log, const_cast<NvBlastTimers*>(&m_timers));
-}
-
-
-void TkActorImpl::applyFracture(NvBlastFractureBuffers* eventBuffers, const NvBlastFractureBuffers* commands)
-{
-	PERF_SCOPE_L("TkActor::applyFracture");
-
-	if (m_group && m_group->isProcessing())
-	{
-		NVBLASTTK_LOG_WARNING("TkActor::applyFracture: group is being processed, cannot fracture this actor.");
-		return;
-	}
-
-	NvBlastActorApplyFracture(eventBuffers, m_actorLL, commands, TkFrameworkImpl::get()->log, &m_timers);
-
-	if (commands->chunkFractureCount > 0 || commands->bondFractureCount > 0)
-	{
-		markAsDamaged();
-
-		TkFractureCommands* fevt = getFamilyImpl().getQueue().allocData<TkFractureCommands>();
-		fevt->tkActorData = *this;
-		fevt->buffers = *commands;
-		getFamilyImpl().getQueue().addEvent(fevt);
-		getFamilyImpl().getQueue().dispatch();
-	}
-}
-
-
-uint32_t TkActorImpl::getJointCount() const
-{
-	return getJointCountInternal();
-}
-
-
-uint32_t TkActorImpl::getJoints(TkJoint** joints, uint32_t jointsSize) const
-{
-	uint32_t jointsWritten = 0;
-
-	for (JointIt j(*this); (bool)j && jointsWritten < jointsSize; ++j)
-	{
-		joints[jointsWritten++] = *j;
-	}
-
-	return jointsWritten;
-}
-
-
-//////// TkActorImpl::DamageData methods ////////
-
-static bool operator==(const NvBlastDamageProgram& lhs, const NvBlastDamageProgram& rhs)
-{
-	return lhs.graphShaderFunction == rhs.graphShaderFunction && lhs.subgraphShaderFunction == rhs.subgraphShaderFunction;
-}
-
-
-TkActorImpl::DamageData::DamageData(const NvBlastDamageProgram& program, const NvBlastProgramParams* params)
-	: m_program(program), m_programParams(params), m_damageDescCount(0)
-{
-}
-
-
-TkActorImpl::DamageData::DamageData(const NvBlastDamageProgram& program, const void* material, const void* desc, uint32_t descSize)
-	: m_program(program), m_material(material), m_damageDescs((char*)desc, (char*)desc + descSize), m_damageDescCount(1)
-{
-}
-
-
-bool TkActorImpl::DamageData::tryAppend(const NvBlastDamageProgram& program, const void* material, const void* desc, uint32_t descSize)
-{
-	if (getType() == Buffered && m_program == program && m_material == material)
-	{
-		const uint32_t currentDescSize = m_damageDescs.size() / m_damageDescCount;
-		if (descSize == currentDescSize)
-		{
-			const uint32_t s = m_damageDescs.size();
-			m_damageDescs.resizeUninitialized(s + static_cast<uint32_t>(descSize));
-			memcpy(m_damageDescs.begin() + s, desc, descSize);
-			m_damageDescCount++;
-			return true;
-		}
-	}
-	return false;
-}
-
-} // namespace Blast
-} // namespace Nv
diff --git a/NvBlast/sdk/toolkit/source/NvBlastTkActorImpl.h b/NvBlast/sdk/toolkit/source/NvBlastTkActorImpl.h
deleted file mode 100644
index 4d65660..0000000
--- a/NvBlast/sdk/toolkit/source/NvBlastTkActorImpl.h
+++ /dev/null
@@ -1,375 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTTKACTORIMPL_H
-#define NVBLASTTKACTORIMPL_H
-
-
-#include "NvBlastTkCommon.h"
-
-#include "NvBlastAssert.h"
-#include "NvBlastDLink.h"
-#include "NvBlastIteratorBase.h"
-
-#include "NvBlastTkJointImpl.h"
-
-#include "NvBlast.h"
-
-#include "NvBlastTkActor.h"
-
-#include "PxFlags.h"
-
-namespace Nv
-{
-namespace Blast
-{
-
-// Forward declarations:
-class TkGroupImpl;
-class TkFamilyImpl;
-class TkAssetImpl;
-class TkJointImpl;
-
-
-/**
-Struct-enum for actor status flags, used in TkGroup processing.
-*/
-struct TkActorFlag
-{
-	enum Enum
-	{
-		DAMAGED = (1 << 0),	//!< The actor had fractures applied successfully and will take the split step.
-		PENDING = (1 << 1), //!< The actor will be processed when its group executes, used to update job queues when moving group.
-	};
-};
-
-
-/**
-Implementation of TkActor.
-*/
-class TkActorImpl : public TkActor
-{
-public:
-	TkActorImpl();
-	~TkActorImpl();
-
-	// Begin TkActor
-	virtual const NvBlastActor*	getActorLL() const override;
-
-	virtual TkFamily&			getFamily() const override;
-
-	virtual uint32_t			getIndex() const override;
-
-	virtual TkGroup*			getGroup() const override;
-
-	virtual TkGroup*			removeFromGroup() override;
-
-	virtual const TkAsset*		getAsset() const override;
-
-	virtual uint32_t 			getVisibleChunkCount() const override;
-
-	virtual uint32_t 			getVisibleChunkIndices(uint32_t* visibleChunkIndices, uint32_t visibleChunkIndicesSize) const override;
-
-	virtual uint32_t 			getGraphNodeCount() const override;
-
-	virtual uint32_t 			getGraphNodeIndices(uint32_t* graphNodeIndices, uint32_t graphNodeIndicesSize) const override;
-
-	virtual const float* 		getBondHealths() const override;
-
-	virtual uint32_t			getSplitMaxActorCount() const override;
-
-	virtual void				damage(const NvBlastDamageProgram& program, const NvBlastProgramParams* programParams) override;
-	virtual void				damage(const NvBlastDamageProgram& program, const void* damageDesc, uint32_t descSize) override;
-	virtual void				damage(const NvBlastDamageProgram& program, const void* damageDesc, uint32_t descSize, const void* material) override;
-
-	virtual bool				isPending() const override;
-
-	virtual void				generateFracture(NvBlastFractureBuffers* commands, const NvBlastDamageProgram& program, const NvBlastProgramParams* programParams) const override;
-
-	virtual void				applyFracture(NvBlastFractureBuffers* eventBuffers, const NvBlastFractureBuffers* commands) override;
-
-	virtual uint32_t			getJointCount() const override;
-
-	virtual uint32_t			getJoints(TkJoint** joints, uint32_t jointsSize) const override;
-	// End TkActor
-
-	// Begin TkObject
-	virtual void				release() override;
-	// End TkObject
-
-
-	// Public methods
-	
-	/**
-	Factory create method.
-
-	\param[in]	desc	Actor descriptor set by the user.
-
-	\return a pointer to a new TkActorImpl object if successful, NULL otherwise.
-	*/
-	static TkActorImpl*			create(const TkActorDesc& desc);
-
-	/**
-	TkActorImpl objects are created in an array within a TkFamilyImpl.  Actors may become
-	'inactive' without their memory being freed.  If inactive, the actor should be treated as if
-	it has been released.
-
-	\return the active status of this TkActorImpl.
-	*/
-	bool						isActive() const;
-
-	/**
-	Utility to return the low-level family to which the low-level actor belongs.
-
-	\return a pointer to the NvBlastFamily to which the low-level actor belongs.
-	*/
-	NvBlastFamily*				getFamilyLL() const;
-
-	/**
-	Utility to access the TkFamily to which this actor belongs.
-
-	\return a reference to the TkFamilyImpl to which this TkActorImpl belongs.
-	*/
-	TkFamilyImpl&				getFamilyImpl() const;
-
-	/**
-	\return the index of this actor with its TkFamilyImpl.
-	*/
-	uint32_t					getIndexInternal() const;
-
-	/**
-	Access to the group to which this actor belongs, if any.
-
-	\return a pointer to the TkGroupImpl to which this TkActorImpl belongs, if any.  If this actor is not in a group, this function returns NULL.
-	*/
-	TkGroupImpl*				getGroupImpl() const;
-
-	/**
-	Access to the low-level actor associated with this TkActorImpl.
-
-	\return a pointer to the NvBlastActor associated with this TkActorImpl.  If this actor is inactive (see isActive), this function returns NULL.
-	*/
-	NvBlastActor*				getActorLLInternal() const;
-
-	/**
-	\return the number of TkJointImpl objects that reference this actor.
-	*/
-	uint32_t					getJointCountInternal() const;
-
-	/**
-		Joint iterator.  Usage:
-
-		Given a TkActorImpl a,
-
-		for (TkActorImpl::JointIt i(a); (bool)i; ++i)
-		{
-			TkJointImpl* joint = (TkJointImpl*)i;
-			// ...
-		}
-	*/
-	class JointIt : public DList::It
-	{
-	public:
-		/** Constructed from an actor. */
-		JointIt(const TkActorImpl& actor, Direction dir = Forward);
-
-		/** Current joint. */
-		TkJointImpl* operator * () const;
-	};
-
-	/**
-	Implicit converter to TkActorData for events.
-	*/
-	operator Nv::Blast::TkActorData() const;
-
-private:
-	/**
-	Used to buffer damage for deferred fracture generation. Unifies 2 different ways to pass and store damage data.
-	*/
-	struct DamageData
-	{
-		DamageData(const NvBlastDamageProgram& program, const NvBlastProgramParams* params);
-		DamageData(const NvBlastDamageProgram& program, const void* material, const void* desc, uint32_t descSize);
-
-		bool tryAppend(const NvBlastDamageProgram& program, const void* material, const void* desc, uint32_t descSize);
-		void generateFracture(NvBlastFractureBuffers* commandBuffers, const NvBlastActor* actorLL, NvBlastTimers* timers) const;
-
-		enum Type
-		{
-			Plain,
-			Buffered
-		};
-
-		Type getType() const;
-
-		NvBlastDamageProgram  m_program;
-		union
-		{
-			const void*					m_material;			//!< for Buffered type
-			const NvBlastProgramParams*	m_programParams;	//!< for Plain type
-		};
-		TkArray<char>::type	m_damageDescs;
-		uint32_t			m_damageDescCount;
-	};
-
-
-	/**
-	Functions to raise or check 'damaged' state: this actor will take the split step.
-	'damaged' actors automatically become 'pending' also.
-	*/
-	void						markAsDamaged();
-	bool						isDamaged() const;
-
-	/**
-	Raise actor to 'pending' state: this actor will be processed when its group executes next.
-	Enqueues the actor in its group's job list if a group is set. Otherwise the group will enqueue the actor when it is added.
-	*/
-	void						makePending();
-
-	/**
-	Functions to add or remove an internal reference to a joint.  (Joints and actors mutually reference each other.)
-	*/
-	void						addJoint(TkJointLink& jointLink);
-	void						removeJoint(TkJointLink& jointLink);
-
-
-	// Data
-
-	NvBlastActor*							m_actorLL;			//!< The low-level actor associated with this actor
-	TkFamilyImpl*							m_family;			//!< The TkFamilyImpl to which this actor belongs
-	TkGroupImpl*							m_group;			//!< The TkGroupImpl (if any) to which this actor belongs
-	uint32_t								m_groupJobIndex;	//!< The index of this actor's job within its group's job list
-	physx::PxFlags<TkActorFlag::Enum, char>	m_flags;			//!< Status flags for this actor
-	TkArray<DamageData>::type				m_damageBuffer;		//!< Buffered damage input
-	uint32_t								m_jointCount;		//!< The number of joints referenced in m_jointList
-	DList									m_jointList;		//!< A doubly-linked list of joint references
-
-//#if NV_PROFILE
-	NvBlastTimers							m_timers;			//!< If profiling, each actor stores timing data
-//#endif
-
-	friend class TkWorker;					// m_damageBuffer and m_flags 
-	friend class TkGroupImpl;
-	friend class TkFamilyImpl;
-	friend class TkJointImpl;
-	friend class TkFrameworkImpl;
-};
-
-
-//////// TkActorImpl inline methods ////////
-
-NV_INLINE TkFamilyImpl& TkActorImpl::getFamilyImpl() const
-{
-	NVBLAST_ASSERT(m_family != nullptr);
-
-	return *m_family;
-}
-
-
-NV_INLINE uint32_t TkActorImpl::getIndexInternal() const
-{
-	NVBLAST_ASSERT(isActive());
-	return NvBlastActorGetIndex(m_actorLL, TkFrameworkImpl::get()->log);
-}
-
-
-NV_INLINE NvBlastActor* TkActorImpl::getActorLLInternal() const
-{
-	return m_actorLL;
-}
-
-
-NV_INLINE uint32_t TkActorImpl::getJointCountInternal() const
-{
-	return m_jointCount;
-}
-
-
-NV_INLINE TkGroupImpl* TkActorImpl::getGroupImpl() const
-{
-	return m_group;
-}
-
-
-NV_INLINE bool TkActorImpl::isActive() const
-{
-	return m_actorLL != nullptr;
-}
-
-
-NV_INLINE bool TkActorImpl::isPending() const
-{
-	return m_flags.isSet(TkActorFlag::PENDING);
-}
-
-
-NV_INLINE void TkActorImpl::addJoint(TkJointLink& jointLink)
-{
-	NVBLAST_ASSERT(m_jointList.isSolitary(jointLink));
-
-	m_jointList.insertHead(jointLink);
-	++m_jointCount;
-}
-
-
-NV_INLINE void TkActorImpl::removeJoint(TkJointLink& jointLink)
-{
-	NVBLAST_ASSERT(!m_jointList.isSolitary(jointLink));
-	NVBLAST_ASSERT(m_jointCount > 0);
-	if (m_jointCount > 0)
-	{
-		--m_jointCount;
-		m_jointList.remove(jointLink);
-	}
-}
-
-
-//////// TkActorImpl::DamageData inline methods ////////
-
-NV_INLINE TkActorImpl::DamageData::Type TkActorImpl::DamageData::getType() const
-{
-	return m_damageDescCount > 0 ? Buffered : Plain;
-}
-
-
-NV_INLINE void TkActorImpl::DamageData::generateFracture(NvBlastFractureBuffers* commandBuffers, const NvBlastActor* actorLL, NvBlastTimers* timers) const
-{
-	if (getType() == Plain)
-	{
-		NvBlastActorGenerateFracture(commandBuffers, actorLL, m_program, m_programParams, TkFrameworkImpl::get()->log, timers);
-	}
-	else
-	{
-		const NvBlastProgramParams programParams = {
-			m_damageDescs.begin(),
-			m_damageDescCount,
-			m_material,
-		};
-		NvBlastActorGenerateFracture(commandBuffers, actorLL, m_program, &programParams, TkFrameworkImpl::get()->log, timers);
-	}
-}
-
-
-//////// TkActorImpl::JointIt methods ////////
-
-NV_INLINE TkActorImpl::JointIt::JointIt(const TkActorImpl& actor, Direction dir) : DList::It(actor.m_jointList, dir) {}
-
-
-NV_INLINE TkJointImpl* TkActorImpl::JointIt::operator * () const
-{
-	const DLink* link = (const DLink*)(*this);
-	return reinterpret_cast<const TkJointLink*>(link)->m_joint;
-}
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTTKACTORIMPL_H
diff --git a/NvBlast/sdk/toolkit/source/NvBlastTkAllocator.cpp b/NvBlast/sdk/toolkit/source/NvBlastTkAllocator.cpp
deleted file mode 100644
index b1c2c65..0000000
--- a/NvBlast/sdk/toolkit/source/NvBlastTkAllocator.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastTkAllocator.h"
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-physx::PxAllocatorCallback*	TkAllocator::s_allocatorCallback = nullptr;
-
-} // namespace Blast
-} // namespace Nv
diff --git a/NvBlast/sdk/toolkit/source/NvBlastTkAllocator.h b/NvBlast/sdk/toolkit/source/NvBlastTkAllocator.h
deleted file mode 100644
index abc7b16..0000000
--- a/NvBlast/sdk/toolkit/source/NvBlastTkAllocator.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTTKALLOCATOR_H
-#define NVBLASTTKALLOCATOR_H
-
-#include "PxAllocatorCallback.h"
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-/**
-An allocator which can be used in PxShared containers.
-*/
-class TkAllocator
-{
-public:
-	TkAllocator(const char* = 0)
-	{
-	}
-
-	void* allocate(size_t size, const char* file, int line)
-	{
-		return s_allocatorCallback->allocate(size, nullptr, file, line);
-	}
-
-	void deallocate(void* ptr)
-	{
-		return s_allocatorCallback->deallocate(ptr);
-	}
-
-	static physx::PxAllocatorCallback* s_allocatorCallback;
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // #ifndef NVBLASTTKALLOCATOR_H
diff --git a/NvBlast/sdk/toolkit/source/NvBlastTkArray.h b/NvBlast/sdk/toolkit/source/NvBlastTkArray.h
deleted file mode 100644
index c07dc11..0000000
--- a/NvBlast/sdk/toolkit/source/NvBlastTkArray.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTTKARRAY_H
-#define NVBLASTTKARRAY_H
-
-
-#include "NvBlastTkAllocator.h"
-#include "PsInlineArray.h"
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-template <class T>
-struct TkArray
-{
-	typedef physx::shdfnd::Array<T, TkAllocator> type;
-};
-
-
-template <class T, uint32_t N>
-struct TkInlineArray
-{
-	typedef physx::shdfnd::InlineArray<T, N, TkAllocator> type;
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // #ifndef NVBLASTTKARRAY_H
diff --git a/NvBlast/sdk/toolkit/source/NvBlastTkAssetImpl.cpp b/NvBlast/sdk/toolkit/source/NvBlastTkAssetImpl.cpp
deleted file mode 100644
index 577d46b..0000000
--- a/NvBlast/sdk/toolkit/source/NvBlastTkAssetImpl.cpp
+++ /dev/null
@@ -1,337 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-
-#include "NvBlastTkFrameworkImpl.h"
-#include "NvBlastTkAssetImpl.h"
-#include "NvBlastTkFamilyImpl.h"
-
-#include "NvBlast.h"
-#include "NvBlastMemory.h"
-
-#include "Px.h"
-#include "PxFileBuf.h"
-#include "PxAllocatorCallback.h"
-
-
-using namespace physx::general_PxIOStream2;
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-//////// Static data ////////
-
-NVBLASTTK_DEFINE_TYPE_SERIALIZABLE(Asset);
-
-
-//////// Member functions ////////
-
-TkAssetImpl::TkAssetImpl()
-	: m_assetLL(nullptr), m_ownsAsset(false)
-{
-}
-
-
-TkAssetImpl::TkAssetImpl(const NvBlastID& id)
-	: TkAssetType(id), m_assetLL(nullptr), m_ownsAsset(false)
-{
-}
-
-
-TkAssetImpl::~TkAssetImpl()
-{
-	if (m_assetLL != nullptr && m_ownsAsset)
-	{
-		TkFrameworkImpl::get()->free(m_assetLL);
-	}
-}
-
-
-const NvBlastAsset* TkAssetImpl::getAssetLL() const
-{
-	return getAssetLLInternal();
-}
-
-
-uint32_t TkAssetImpl::getChunkCount() const
-{
-	return NvBlastAssetGetChunkCount(m_assetLL, TkFrameworkImpl::get()->log);
-}
-
-
-uint32_t TkAssetImpl::getLeafChunkCount() const
-{
-	return NvBlastAssetGetLeafChunkCount(m_assetLL, TkFrameworkImpl::get()->log);
-}
-
-
-uint32_t TkAssetImpl::getBondCount() const
-{
-	return NvBlastAssetGetBondCount(m_assetLL, TkFrameworkImpl::get()->log);
-}
-
-
-const NvBlastChunk* TkAssetImpl::getChunks() const
-{
-	return NvBlastAssetGetChunks(m_assetLL, TkFrameworkImpl::get()->log);
-}
-
-
-const NvBlastBond* TkAssetImpl::getBonds() const
-{
-	return NvBlastAssetGetBonds(m_assetLL, TkFrameworkImpl::get()->log);
-}
-
-
-const NvBlastSupportGraph TkAssetImpl::getGraph() const
-{
-	return NvBlastAssetGetSupportGraph(m_assetLL, TkFrameworkImpl::get()->log);
-}
-
-
-uint32_t TkAssetImpl::getDataSize() const
-{
-	return NvBlastAssetGetSize(m_assetLL, TkFrameworkImpl::get()->log);
-}
-
-
-uint32_t TkAssetImpl::getJointDescCount() const
-{
-	return getJointDescCountInternal();
-}
-
-
-const TkAssetJointDesc* TkAssetImpl::getJointDescs() const
-{
-	return getJointDescsInternal();
-}
-
-
-void TkAssetImpl::release()
-{
-	const TkType& tkType = TkFamilyImpl::s_type;
-	const uint32_t num = TkFrameworkImpl::get()->getObjectCount(tkType);
-
-	if (num)
-	{
-		TkArray<TkIdentifiable*>::type dependents(num);
-		TkFrameworkImpl::get()->getObjects(dependents.begin(), dependents.size(), tkType);
-
-		for (TkObject* o : dependents)
-		{
-			TkFamilyImpl* f = static_cast<TkFamilyImpl*>(o);
-			if (f->getAssetImpl() == this)
-			{
-				f->release();
-			}
-		}
-	}
-
-	NVBLASTTK_DELETE(this, TkAssetImpl);
-}
-
-
-bool TkAssetImpl::serialize(PxFileBuf& stream) const
-{
-	TkFrameworkImpl::get()->serializeHeader(*this, stream);
-
-	// Asset data
-	const uint32_t assetSize = NvBlastAssetGetSize(m_assetLL, TkFrameworkImpl::get()->log);
-	stream.storeDword(assetSize);
-	stream.write(m_assetLL, assetSize);
-
-	// Joint descs
-	stream.storeDword((uint32_t)m_jointDescs.size());
-	for (uint32_t i = 0; i < m_jointDescs.size(); ++i)
-	{
-		const TkAssetJointDesc& jointDesc = m_jointDescs[i];
-		stream.storeDword(jointDesc.nodeIndices[0]);
-		stream.storeDword(jointDesc.nodeIndices[1]);
-		stream.storeFloat(jointDesc.attachPositions[0].x);
-		stream.storeFloat(jointDesc.attachPositions[0].y);
-		stream.storeFloat(jointDesc.attachPositions[0].z);
-		stream.storeFloat(jointDesc.attachPositions[1].x);
-		stream.storeFloat(jointDesc.attachPositions[1].y);
-		stream.storeFloat(jointDesc.attachPositions[1].z);
-	}
-
-	return true;
-}
-
-
-//////// Static functions ////////
-
-TkSerializable* TkAssetImpl::deserialize(PxFileBuf& stream, const NvBlastID& id)
-{
-	// Allocate
-	TkAssetImpl* asset = NVBLASTTK_NEW(TkAssetImpl)(id);
-	if (asset == nullptr)
-	{
-		NVBLASTTK_LOG_ERROR("TkAssetImpl::deserialize: asset allocation failed.");
-		return nullptr;
-	}
-
-	// Asset data
- 	const uint32_t assetSize = stream.readDword();
-	asset->m_assetLL = static_cast<NvBlastAsset*>(TkFrameworkImpl::get()->alloc(assetSize));
-	asset->m_ownsAsset = true;
-	stream.read(asset->m_assetLL, assetSize);
-
-	// Joint descs
-	const uint32_t jointDescCount = stream.readDword();
-	asset->m_jointDescs.resize(jointDescCount);
-	for (uint32_t i = 0; i < asset->m_jointDescs.size(); ++i)
-	{
-		TkAssetJointDesc& jointDesc = asset->m_jointDescs[i];
-		jointDesc.nodeIndices[0] = stream.readDword();
-		jointDesc.nodeIndices[1] = stream.readDword();
-		jointDesc.attachPositions[0].x = stream.readFloat();
-		jointDesc.attachPositions[0].y = stream.readFloat();
-		jointDesc.attachPositions[0].z = stream.readFloat();
-		jointDesc.attachPositions[1].x = stream.readFloat();
-		jointDesc.attachPositions[1].y = stream.readFloat();
-		jointDesc.attachPositions[1].z = stream.readFloat();
-	}
-
-
-	if (asset->m_assetLL == nullptr)
-	{
-		asset->release();
-		asset = nullptr;
-	}
-
-	return asset;
-}
-
-
-TkAssetImpl* TkAssetImpl::create(const TkAssetDesc& desc)
-{
-	TkAssetImpl* asset = NVBLASTTK_NEW(TkAssetImpl);
-
-	TkArray<char>::type scratch((uint32_t)NvBlastGetRequiredScratchForCreateAsset(&desc, TkFrameworkImpl::get()->log));
-	void* mem = TkFrameworkImpl::get()->alloc(NvBlastGetAssetMemorySize(&desc, TkFrameworkImpl::get()->log));
-	asset->m_assetLL = NvBlastCreateAsset(mem, &desc, scratch.begin(), TkFrameworkImpl::get()->log);
-	if (asset->m_assetLL == nullptr)
-	{
-		NVBLASTTK_LOG_ERROR("TkAssetImpl::create: low-level asset could not be created.");
-		asset->release();
-		return nullptr;
-	}
-
-	if (desc.bondFlags != nullptr)
-	{
-		for (uint32_t bondN = 0; bondN < desc.bondCount; ++bondN)
-		{
-			if (0 != (desc.bondFlags[bondN] & TkAssetDesc::BondJointed))
-			{
-				const NvBlastBondDesc& bondDesc = desc.bondDescs[bondN];
-				const uint32_t c0 = bondDesc.chunkIndices[0];
-				const uint32_t c1 = bondDesc.chunkIndices[1];
-				if (c0 >= desc.chunkCount || c1 >= desc.chunkCount)
-				{
-					NVBLASTTK_LOG_WARNING("TkAssetImpl::create: joint flag set for badly described bond.  No joint descriptor created.");
-					continue;
-				}
-
-				if (!asset->addJointDesc(c0, c1))
-				{
-					NVBLASTTK_LOG_WARNING("TkAssetImpl::create: no bond corresponds to the user-described bond indices.  No joint descriptor created.");
-				}
-			}
-		}
-	}
-
-	asset->m_ownsAsset = true;
-//	asset->setID(NvBlastAssetGetID(asset->m_assetLL, TkFrameworkImpl::get()->log));	// Keeping LL and Tk IDs distinct
-
-	return asset;
-}
-
-
-TkAssetImpl* TkAssetImpl::create(const NvBlastAsset* assetLL, Nv::Blast::TkAssetJointDesc* jointDescs, uint32_t jointDescCount, bool ownsAsset)
-{
-	TkAssetImpl* asset = NVBLASTTK_NEW(TkAssetImpl);
-
-	//NOTE: Why are we passing in a const NvBlastAsset* and then discarding the const?
-	asset->m_assetLL = const_cast<NvBlastAsset*>(assetLL);
-	if (asset->m_assetLL == nullptr)
-	{
-		NVBLASTTK_LOG_ERROR("TkAssetImpl::create: low-level asset could not be created.");
-		asset->release();
-		return nullptr;
-	}
-
-	asset->m_ownsAsset = ownsAsset;
-	asset->setID(NvBlastAssetGetID(asset->m_assetLL, TkFrameworkImpl::get()->log));
-
-	asset->m_jointDescs.resize(jointDescCount);
-	for (uint32_t i = 0; i < asset->m_jointDescs.size(); ++i)
-	{
-		asset->m_jointDescs[i] = jointDescs[i];
-	}
-
-	return asset;
-}
-
-bool TkAssetImpl::addJointDesc(uint32_t chunkIndex0, uint32_t chunkIndex1)
-{
-	if (m_assetLL == nullptr)
-	{
-		return false;
-	}
-
-	const uint32_t upperSupportChunkCount = NvBlastAssetGetFirstSubsupportChunkIndex(m_assetLL, TkFrameworkImpl::get()->log);
-	if (chunkIndex0 >= upperSupportChunkCount || chunkIndex1 >= upperSupportChunkCount)
-	{
-		return false;
-	}
-
-	const uint32_t* chunkToGraphNodeMap = NvBlastAssetGetChunkToGraphNodeMap(m_assetLL, TkFrameworkImpl::get()->log);
-	const uint32_t node0 = chunkToGraphNodeMap[chunkIndex0];
-	const uint32_t node1 = chunkToGraphNodeMap[chunkIndex1];
-	const NvBlastSupportGraph graph = NvBlastAssetGetSupportGraph(m_assetLL, TkFrameworkImpl::get()->log);
-	if (node0 >= graph.nodeCount && node1 >= graph.nodeCount)
-	{
-		return false;
-	}
-
-	// Find bond index
-	// Iterate through all neighbors of node0 chunk
-	uint32_t bondIndex = 0xFFFFFFFF;
-	for (uint32_t i = graph.adjacencyPartition[node0]; i < graph.adjacencyPartition[node0 + 1]; i++)
-	{
-		if (graph.adjacentNodeIndices[i] == node1)
-		{
-			bondIndex = graph.adjacentBondIndices[i];
-			break;
-		}
-	}
-
-	if (bondIndex >= NvBlastAssetGetBondCount(m_assetLL, TkFrameworkImpl::get()->log))
-	{
-		return false;
-	}
-
-	const NvBlastBond& bond = NvBlastAssetGetBonds(m_assetLL, TkFrameworkImpl::get()->log)[bondIndex];
-
-	TkAssetJointDesc jointDesc;
-	jointDesc.attachPositions[0] = jointDesc.attachPositions[1] = physx::PxVec3(bond.centroid[0], bond.centroid[1], bond.centroid[2]);
-	jointDesc.nodeIndices[0] = node0;
-	jointDesc.nodeIndices[1] = node1;
-	m_jointDescs.pushBack(jointDesc);
-
-	return true;
-}
-
-} // namespace Blast
-} // namespace Nv
diff --git a/NvBlast/sdk/toolkit/source/NvBlastTkAssetImpl.h b/NvBlast/sdk/toolkit/source/NvBlastTkAssetImpl.h
deleted file mode 100644
index ae68af8..0000000
--- a/NvBlast/sdk/toolkit/source/NvBlastTkAssetImpl.h
+++ /dev/null
@@ -1,162 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTTKASSETIMPL_H
-#define NVBLASTTKASSETIMPL_H
-
-
-#include "NvBlastTkCommon.h"
-#include "NvBlastTkJoint.h"
-#include "NvBlastTkAsset.h"
-#include "NvBlastTkTypeImpl.h"
-#include "NvBlastTkArray.h"
-
-
-// Forward declarations
-struct NvBlastAsset;
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-/**
-Implementation of TkAsset
-*/
-NVBLASTTK_IMPL_DECLARE(Asset)
-{
-public:
-	/**
-	Enum which keeps track of the serialized data format.
-	*/
-	enum Version
-	{
-		/** Initial version */
-		Initial,
-
-		//	New formats must come before Count.  They should be given descriptive names with more information in comments.
-
-		/** The number of serialized formats. */
-		Count,
-
-		/** The current version.  This should always be Count-1 */
-		Current = Count - 1
-	};
-
-	TkAssetImpl();
-	TkAssetImpl(const NvBlastID& id);
-	~TkAssetImpl();
-
-	NVBLASTTK_IMPL_DEFINE_SERIALIZABLE('A', 'S', 'S', 'T');
-
-	// Public methods
-
-	/**
-	Factory create method.  This method creates a low-level asset and stores a reference to it.
-
-	\param[in]	desc	Asset descriptor set by the user.
-
-	\return a pointer to a new TkAssetImpl object if successful, NULL otherwise.
-	*/
-	static TkAssetImpl*					create(const TkAssetDesc& desc);
-	
-	/**
-	Static method to create an asset from an existing low-level asset.
-
-	\param[in]	assetLL			A valid low-level asset passed in by the user.
-	\param[in]	jointDescs		Optional joint descriptors to add to the new asset.
-	\param[in]	jointDescCount	The number of joint descriptors in the jointDescs array.  If non-zero, jointDescs cannot be NULL.
-	\param[in]	ownsAsset		Whether or not to let this TkAssetImpl object release the low-level NvBlastAsset memory upon its own release.
-
-	\return a pointer to a new TkAssetImpl object if successful, NULL otherwise.
-	*/
-	static TkAssetImpl*					create(const NvBlastAsset* assetLL, Nv::Blast::TkAssetJointDesc* jointDescs = nullptr, uint32_t jointDescCount = 0, bool ownsAsset = false);
-
-	/**
-	\return a pointer to the underlying low-level NvBlastAsset associated with this asset.
-	*/
-	const NvBlastAsset*					getAssetLLInternal() const;
-
-	/**
-	\return the number of internal joint descriptors stored with this asset.
-	*/
-	uint32_t							getJointDescCountInternal() const;
-
-	/**
-	\return the array of internal joint descriptors stored with this asset, with size given by getJointDescCountInternal().
-	*/
-	const TkAssetJointDesc*				getJointDescsInternal() const;
-
-	// Begin TkAsset
-	virtual const NvBlastAsset*			getAssetLL() const override;
-
-	virtual uint32_t					getChunkCount() const override;
-
-	virtual uint32_t					getLeafChunkCount() const override;
-
-	virtual uint32_t					getBondCount() const override;
-
-	virtual const NvBlastChunk*			getChunks() const override;
-
-	virtual const NvBlastBond*			getBonds() const override;
-
-	virtual const NvBlastSupportGraph	getGraph() const override;
-
-	virtual uint32_t					getDataSize() const override;
-
-	virtual uint32_t					getJointDescCount() const override;
-
-	virtual const TkAssetJointDesc*		getJointDescs() const override;
-	// End TkAsset
-
-private:
-	/**
-	Utility to add a joint descriptor between the indexed chunks.  The two chunks
-	must be support chunks, and there must exist a bond between them.  The joint's
-	attachment positions will be the bond centroid.
-
-	\param[in]	chunkIndex0	The first chunk index.
-	\param[in]	chunkIndex1	The second chunk index.
-
-	\return true iff successful.
-	*/
-	bool								addJointDesc(uint32_t chunkIndex0, uint32_t chunkIndex1);
-
-	NvBlastAsset*					m_assetLL;		//!< The underlying low-level asset.
-	TkArray<TkAssetJointDesc>::type	m_jointDescs;	//!< The array of internal joint descriptors.
-	bool							m_ownsAsset;	//!< Whether or not this asset should release its low-level asset upon its own release.
-};
-
-
-//////// TkAssetImpl inline methods ////////
-
-NV_INLINE const NvBlastAsset* TkAssetImpl::getAssetLLInternal() const
-{
-	return m_assetLL;
-}
-
-
-NV_INLINE uint32_t TkAssetImpl::getJointDescCountInternal() const
-{
-	return m_jointDescs.size();
-}
-
-
-NV_INLINE const TkAssetJointDesc* TkAssetImpl::getJointDescsInternal() const
-{
-	return m_jointDescs.begin();
-}
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTTKASSETIMPL_H
diff --git a/NvBlast/sdk/toolkit/source/NvBlastTkCommon.h b/NvBlast/sdk/toolkit/source/NvBlastTkCommon.h
deleted file mode 100644
index edc1a91..0000000
--- a/NvBlast/sdk/toolkit/source/NvBlastTkCommon.h
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTTKCOMMON_H
-#define NVBLASTTKCOMMON_H
-
-
-#include "NvPreprocessor.h"
-#include "NvBlastTkGUID.h"
-
-
-// Macro to load a uint32_t (or larger) with four characters
-#define NVBLASTTK_FOURCC(_a, _b, _c, _d)	( (uint32_t)(_a) | (uint32_t)(_b)<<8 | (uint32_t)(_c)<<16 | (uint32_t)(_d)<<24 )
-
-
-// Macro to define standard object classes.  An intermediate class is defined which holds common implementations.
-#define NVBLASTTK_IMPL_DECLARE(_name)												\
-class Tk##_name##Type : public Tk##_name											\
-{																					\
-public:																				\
-	/* Blank constructor generates a new NvBlastID and informs framework  */		\
-	Tk##_name##Type()																\
-	{																				\
-		memset(&m_ID, 0, sizeof(NvBlastID));										\
-		setID(TkGenerateGUID(this));												\
-		TkFrameworkImpl::get()->onCreate(*this);									\
-	}																				\
-																					\
-	/* This constructor takes an existing NvBlastID and informs framework  */		\
-	Tk##_name##Type(const NvBlastID& id)											\
-	{																				\
-		memset(&m_ID, 0, sizeof(NvBlastID));										\
-		setID(id);																	\
-		TkFrameworkImpl::get()->onCreate(*this);									\
-	}																				\
-																					\
-	/* Destructor informs framework  */												\
-	~Tk##_name##Type()	{ TkFrameworkImpl::get()->onDestroy(*this); }				\
-																					\
-	/* Begin TkIdentifiable */														\
-	virtual void				setID(const NvBlastID& id) override					\
-	{																				\
-		/* Inform framework of ID change */											\
-		TkFrameworkImpl::get()->onIDChange(*this, m_ID, id);						\
-		m_ID = id;																	\
-	}																				\
-	virtual const NvBlastID&	getID() const override { return getIDInternal(); }	\
-	virtual const TkType&		getType() const override { return s_type; }			\
-	/* End TkIdentifiable */														\
-																					\
-	/* Begin public API */															\
-																					\
-	/* Inline method for internal access to NvBlastID */							\
-	const  NvBlastID&			getIDInternal() const { return m_ID; }				\
-																					\
-	/* End public API */															\
-																					\
-	/* Static type information */													\
-	static TkTypeImpl	s_type;														\
-																					\
-private:																			\
-	NvBlastID			m_ID;	/* NvBlastID for a TkIdentifiable object */			\
-};																					\
-																					\
-/* Derive object implementation from common implementation class above */			\
-class Tk##_name##Impl final : public Tk##_name##Type
-
-
-// Macro to declare standard object interfaces, enums, etc.
-#define NVBLASTTK_IMPL_DEFINE_IDENTIFIABLE(_id0, _id1, _id2, _id3)		\
-	/* Begin TkObject */												\
-	virtual void		release() override;								\
-	/* End TkObject */													\
-																		\
-	/* Enums */															\
-																		\
-	/* Generate a ClassID enum used to identify this TkIdentifiable. */	\
-	enum { ClassID = NVBLASTTK_FOURCC(_id0, _id1, _id2, _id3) }
-
-
-// Macro to declare standard object interfaces, enums, etc (serializable version)
-#define NVBLASTTK_IMPL_DEFINE_SERIALIZABLE(_id0, _id1, _id2, _id3)										\
-	NVBLASTTK_IMPL_DEFINE_IDENTIFIABLE(_id0, _id1, _id2, _id3);											\
-																										\
-	/* Begin TkSerializable */																			\
-	virtual bool			serialize(physx::general_PxIOStream2::PxFileBuf& stream) const override;	\
-	/* End TkSerializable */																			\
-																										\
-	/* Static deserialization function, called by TkFrameworkImpl::deserialize after header data */		\
-	static TkSerializable*	deserialize(physx::general_PxIOStream2::PxFileBuf& stream, const NvBlastID& id)
-
-
-// Macro to define class type data
-#define NVBLASTTK_DEFINE_TYPE_IDENTIFIABLE(_name) \
-	TkTypeImpl Tk##_name##Type::s_type("Tk" #_name, Tk##_name##Impl::ClassID, 0, nullptr)
-
-
-// Macro to define class type data (serializable version)
-#define NVBLASTTK_DEFINE_TYPE_SERIALIZABLE(_name) \
-	TkTypeImpl Tk##_name##Type::s_type("Tk" #_name, Tk##_name##Impl::ClassID, Tk##_name##Impl::Version::Current, Tk##_name##Impl::deserialize)
-
-
-#endif // ifndef NVBLASTTKCOMMON_H
diff --git a/NvBlast/sdk/toolkit/source/NvBlastTkEventQueue.h b/NvBlast/sdk/toolkit/source/NvBlastTkEventQueue.h
deleted file mode 100644
index 00a1a61..0000000
--- a/NvBlast/sdk/toolkit/source/NvBlastTkEventQueue.h
+++ /dev/null
@@ -1,231 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTTKEVENTQUEUE_H
-#define NVBLASTTKEVENTQUEUE_H
-
-#include <algorithm>
-#include <vector>
-
-#include <mutex>
-#include <atomic>
-
-#include "PxAllocatorCallback.h"
-#include "NvBlastTkFrameworkImpl.h"
-#include "NvBlastAssert.h"
-
-
-namespace Nv {
-namespace Blast {
-
-/**
-A dispatcher queue providing preallocation and thread-safe insertions therein.
-
-Typical usage:
-- preallocate space for events and payload:											
- - reserveEvents, reserveData
-- enable asserts to detect undersized storage (allocations are not thread safe):	
- - protect(true)
-- get pointers to payload data and events to fill in, thread safe for preallocated memory:												
- - allocData, addEvent
-- back on main thread, ensure consistency:											
- - protect(false)
-
-- continue adding events and payload on main thread if necessary like above (allocations are safe here)
-eventually dispatch, or reset if dispatched by proxy
-*/
-class TkEventQueue
-{
-public:
-	TkEventQueue() : m_currentEvent(0), m_poolCapacity(0), m_pool(nullptr), m_allowAllocs(true) {}
-
-	/**
-	Peek events queue for dispatch.
-	Do not use in protected state.
-	*/
-	operator const TkArray<TkEvent>::type&() 
-	{
-		NVBLAST_ASSERT(m_allowAllocs);
-		NVBLAST_ASSERT(m_currentEvent == m_events.size());
-		return m_events; 
-	}
-
-	/** 
-	Debug help to catch (unwanted) allocations during task work.
-	Note that this will not actually avoid allocations, but assert in debug builds.
-
-	Set true before using in distributed environment.
-	Set false to return to single-thread mode.
-	*/
-	void protect(bool enable)
-	{
-		// During parallel use, m_events.size() and m_currentEvent are allowed to diverge.
-		// This is fine because resizeUninitialized does not alter the stored data.
-		NVBLAST_ASSERT(m_currentEvent <= m_events.capacity());
-		m_events.resizeUninitialized(m_currentEvent);
-		m_allowAllocs = !enable;
-	}
-
-	/**
-	Restores initial state.
-	Data memory is currently not being reused. To be improved.
-	*/
-	void reset()
-	{
-		m_events.clear();
-		m_currentEvent = 0;
-		for (void* mem : m_memory)
-		{
-			NVBLASTTK_FREE(mem);
-		}
-		m_memory.clear();
-		m_currentData = 0;
-		m_allowAllocs = true;
-		m_poolCapacity = 0;
-		m_pool = nullptr;
-	}
-
-	/**
-	Queue an event with a payload.
-	*/
-	template<class T>
-	void addEvent(T* payload)
-	{
-		uint32_t index = m_currentEvent.fetch_add(1);
-
-		// Should not allocate in protected state.
-		NVBLAST_ASSERT(m_allowAllocs || m_currentEvent <= m_events.capacity());
-
-		m_events.resizeUninitialized(m_currentEvent);
-
-		// During parallel use, m_events.size() and m_currentEvent are allowed to diverge.
-		// Consistency is restored in protect().
-		NVBLAST_ASSERT(!m_allowAllocs || m_currentEvent == m_events.size());
-
-		TkEvent& evt = m_events[index];
-		evt.type = TkEvent::Type(T::EVENT_TYPE);
-		evt.payload = payload;
-	}
-
-	/**
-	Request storage for payload.
-	*/
-	template<typename T>
-	T* allocData()
-	{
-		uint32_t index = m_currentData.fetch_add(sizeof(T));
-		if (m_currentData <= m_poolCapacity)
-		{
-			return reinterpret_cast<T*>(&m_pool[index]);
-		}
-		else
-		{
-			// Could do larger block allocation here.
-			reserveData(sizeof(T));
-			// Account for the requested size.
-			m_currentData = sizeof(T);
-			return reinterpret_cast<T*>(&m_pool[0]);
-		}
-	}
-
-	/**
-	Preallocate a memory block of size Bytes for payload data.
-	Note that this will inevitably allocate a new memory block.
-	Subsequent calls to allocData will use this memory piecewise.
-	*/
-	void reserveData(size_t size)
-	{
-		NVBLAST_ASSERT(m_allowAllocs);
-		m_pool = reinterpret_cast<uint8_t*>(allocDataBySize(size));
-		m_poolCapacity = size;
-		m_currentData = 0;
-	}
-
-	/**
-	Preallocate space for events.
-	*/
-	void reserveEvents(uint32_t n)
-	{
-		NVBLAST_ASSERT(m_allowAllocs);
-		m_events.reserve(m_events.size() + n);
-	}
-
-	/**
-	Add a listener to dispatch to.
-	*/
-	void addListener(TkEventListener& l)
-	{
-		m_listeners.pushBack(&l);
-	}
-
-	/**
-	Remove a listener from dispatch list.
-	*/
-	void removeListener(TkEventListener& l)
-	{
-		m_listeners.findAndReplaceWithLast(&l);
-	}
-
-	/**
-	Dispatch the stored events to the registered listeners.
-	After dispatch, all data is invalidated.
-	*/
-	void dispatch()
-	{
-		dispatch(*this);
-		reset();
-	}
-
-	/**
-	Proxy function to dispatch events to this queue's listeners.
-	*/
-	void dispatch(const TkArray<TkEvent>::type& events) const
-	{
-		if (events.size())
-		{
-			for (TkEventListener* l : m_listeners)
-			{
-				PERF_SCOPE_M("TkEventQueue::dispatch");
-				l->receive(events.begin(), events.size());
-			}
-		}
-	}
-
-private:
-	/**
-	Allocates and stores a block of size Bytes of payload data.
-	*/
-	void* allocDataBySize(size_t size)
-	{
-		void* memory = nullptr;
-		if (size > 0)
-		{
-			memory = NVBLASTTK_ALLOC(size, "TkEventQueue Data");
-			m_memory.pushBack(memory);
-		}
-		return memory;
-	}
-
-
-	TkArray<TkEvent>::type					m_events;		//!< holds events
-	TkArray<void*>::type					m_memory;		//!< holds allocated data memory blocks
-	std::atomic<uint32_t>					m_currentEvent;	//!< reference index for event insertion
-	std::atomic<uint32_t>					m_currentData;	//!< reference index for data insertion
-	size_t									m_poolCapacity;	//!< size of the currently active memory block (m_pool)
-	uint8_t*								m_pool;			//!< the current memory block allocData() uses
-	bool									m_allowAllocs;	//!< assert guard
-	TkInlineArray<TkEventListener*,4>::type	m_listeners;	//!< objects to dispatch to
-};
-
-}	// namespace Blast
-}	// namespace Nv
-
-
-#endif	// ifndef NVBLASTTKEVENTQUEUE_H
diff --git a/NvBlast/sdk/toolkit/source/NvBlastTkFamilyImpl.cpp b/NvBlast/sdk/toolkit/source/NvBlastTkFamilyImpl.cpp
deleted file mode 100644
index 33baafe..0000000
--- a/NvBlast/sdk/toolkit/source/NvBlastTkFamilyImpl.cpp
+++ /dev/null
@@ -1,815 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastTkFrameworkImpl.h"
-#include "NvBlastTkFamilyImpl.h"
-#include "NvBlastTkGroupImpl.h"
-#include "NvBlastTkAssetImpl.h"
-#include "NvBlastTkActorImpl.h"
-#include "NvBlastTkJointImpl.h"
-
-#include "Px.h"
-#include "PxFileBuf.h"
-#include "PxAllocatorCallback.h"
-
-#include "NvBlastIndexFns.h"
-#include "NvBlastMemory.h"
-
-using namespace physx::general_PxIOStream2;
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-//////// Static data ////////
-
-NVBLASTTK_DEFINE_TYPE_SERIALIZABLE(Family);
-
-
-//////// Member functions ////////
-
-TkFamilyImpl::TkFamilyImpl() : m_familyLL(nullptr), m_internalJointCount(0), m_asset(nullptr), m_material(nullptr)
-{
-}
-
-
-TkFamilyImpl::TkFamilyImpl(const NvBlastID& id) : TkFamilyType(id), m_familyLL(nullptr), m_internalJointCount(0), m_asset(nullptr), m_material(nullptr)
-{
-}
-
-
-TkFamilyImpl::~TkFamilyImpl()
-{
-	if (m_familyLL != nullptr)
-	{
-		uint32_t familyActorCount = NvBlastFamilyGetActorCount(m_familyLL, TkFrameworkImpl::get()->log);
-		if (familyActorCount != 0)
-		{
-			NVBLASTTK_LOG_WARNING("TkFamilyImpl::~TkFamilyImpl(): family actor count is not 0.");
-		}
-		TkFrameworkImpl::get()->free(m_familyLL);
-	}
-}
-
-
-void TkFamilyImpl::release()
-{
-	for (TkActorImpl& actor : m_actors)
-	{
-		if (actor.isActive())
-		{
-			actor.release();
-		}
-	}
-
-	m_actors.clear();
-
-	NVBLASTTK_DELETE(this, TkFamilyImpl);
-}
-
-
-const NvBlastFamily* TkFamilyImpl::getFamilyLL() const
-{
-	return m_familyLL;
-}
-
-
-TkActorImpl* TkFamilyImpl::addActor(NvBlastActor* actorLL)
-{
-	TkActorImpl* actor = getActorByActorLL(actorLL);
-	NVBLAST_ASSERT(actor);
-	actor->m_actorLL = actorLL;
-	actor->m_family = this;
-	return actor;
-}
-
-
-void TkFamilyImpl::removeActor(TkActorImpl* actor)
-{
-	NVBLAST_ASSERT(actor != nullptr && actor->m_family == this);
-	//actor->m_family = nullptr;
-	actor->m_actorLL = nullptr;
-}
-
-
-uint32_t TkFamilyImpl::getActorCount() const
-{
-	return getActorCountInternal();
-}
-
-
-uint32_t TkFamilyImpl::getActors(TkActor** buffer, uint32_t bufferSize, uint32_t indexStart /*= 0*/) const
-{
-	uint32_t actorCount = getActorCount();
-	if (actorCount <= indexStart)
-	{
-		NVBLASTTK_LOG_WARNING("TkFamilyImpl::getActors: indexStart beyond end of actor list.");
-		return 0;
-	}
-
-	actorCount -= indexStart;
-	if (actorCount > bufferSize)
-	{
-		actorCount = static_cast<uint32_t>(bufferSize);
-	}
-
-	uint32_t index = 0;
-	for (const TkActorImpl& actor : m_actors)
-	{
-		if (actor.isActive())
-		{
-			if (index >= indexStart)
-			{
-				if ((index - indexStart) >= actorCount)
-				{
-					break;
-				}
-				else
-				{
-					*buffer++ = const_cast<TkActorImpl*>(&actor);
-				}
-			}
-			index++;
-		}
-	}
-
-	return actorCount;
-}
-
-
-NV_INLINE bool areLLActorsEqual(const NvBlastActor* actor0, const NvBlastActor* actor1, TkArray<uint32_t>::type& scratch)
-{
-	if (NvBlastActorGetGraphNodeCount(actor0, TkFrameworkImpl::get()->log) != NvBlastActorGetGraphNodeCount(actor1, TkFrameworkImpl::get()->log))
-	{
-		return false;
-	}
-
-	const uint32_t chunkCount = NvBlastActorGetVisibleChunkCount(actor0, TkFrameworkImpl::get()->log);
-	if (chunkCount != NvBlastActorGetVisibleChunkCount(actor1, TkFrameworkImpl::get()->log))
-	{
-		return false;
-	}
-
-	scratch.resize(chunkCount * 2);
-	NvBlastActorGetVisibleChunkIndices(scratch.begin(), chunkCount, actor0, TkFrameworkImpl::get()->log);
-	NvBlastActorGetVisibleChunkIndices(scratch.begin() + chunkCount, chunkCount, actor1, TkFrameworkImpl::get()->log);
-	return memcmp(scratch.begin(), scratch.begin() + chunkCount, chunkCount * sizeof(uint32_t)) == 0;
-}
-
-
-void TkFamilyImpl::reinitialize(const NvBlastFamily* newFamily, TkGroup* group)
-{
-	NVBLAST_ASSERT(newFamily);
-#if NV_ENABLE_ASSERTS
-	NvBlastID id0 = NvBlastFamilyGetAssetID(m_familyLL, TkFrameworkImpl::get()->log);
-	NvBlastID id1 = NvBlastFamilyGetAssetID(newFamily, TkFrameworkImpl::get()->log);
-	NVBLAST_ASSERT(TkGUIDsEqual(&id0, &id1));
-#endif
-	NVBLAST_ASSERT(NvBlastFamilyGetSize(m_familyLL, TkFrameworkImpl::get()->log) == NvBlastFamilyGetSize(newFamily, TkFrameworkImpl::get()->log));
-
-	// alloc and init new family
-	const uint32_t blockSize = NvBlastFamilyGetSize(newFamily, TkFrameworkImpl::get()->log);
-	NvBlastFamily* newFamilyCopy = (NvBlastFamily*)TkFrameworkImpl::get()->alloc(blockSize);
-	memcpy(newFamilyCopy, newFamily, blockSize);
-	NvBlastFamilySetAsset(newFamilyCopy, m_asset->getAssetLL(), TkFrameworkImpl::get()->log);
-
-	// get actors from new family
-	TkArray<NvBlastActor*>::type newLLActors(NvBlastFamilyGetActorCount(newFamilyCopy, TkFrameworkImpl::get()->log));
-	uint32_t actorCount = NvBlastFamilyGetActors(newLLActors.begin(), newLLActors.size(), newFamilyCopy, TkFrameworkImpl::get()->log);
-
-	// reset actor families to nullptr (we use it as a flag later)
-	for (TkActorImpl& actor : m_actors)
-	{
-		if (actor.isActive())
-		{
-			actor.m_family = nullptr;
-		}
-	}
-
-	// prepare split event with new actors
-	auto newActorsSplitEvent = getQueue().allocData<TkSplitEvent>();
-	TkArray<TkActor*>::type children(actorCount);
-	children.resizeUninitialized(0);
-	newActorsSplitEvent->children = children.begin();
-
-	// scratch
-	TkArray<uint32_t>::type scratch(m_asset->getChunkCount());
-
-	for (uint32_t i = 0; i < actorCount; ++i)
-	{
-		NvBlastActor* newLLActor = newLLActors[i];
-		uint32_t actorIndex = NvBlastActorGetIndex(newLLActor, TkFrameworkImpl::get()->log);
-		TkActorImpl& tkActor = *getActorByIndex(actorIndex);
-
-		tkActor.m_family = this;
-
-		if (!tkActor.isActive() || !areLLActorsEqual(newLLActor, tkActor.m_actorLL, scratch))
-		{
-			if (tkActor.isActive())
-			{
-				auto removeSplitEvent = getQueue().allocData<TkSplitEvent>();
-				removeSplitEvent->parentData.family = this;
-				removeSplitEvent->numChildren = 0;
-				removeSplitEvent->parentData.userData = tkActor.userData;
-				removeSplitEvent->parentData.index = tkActor.getIndex();
-				getQueue().addEvent(removeSplitEvent);
-			}
-
-			tkActor.m_actorLL = newLLActor;
-
-			// switch groups
-			TkGroupImpl* prevGroup = tkActor.m_group;
-			if (prevGroup != group)
-			{
-				if (prevGroup)
-				{
-					prevGroup->removeActor(tkActor);
-				}
-				if (group)
-				{
-					group->addActor(tkActor);
-				}
-			}
-
-			children.pushBack(&tkActor);
-		}
-		else
-		{
-			tkActor.m_actorLL = newLLActor;
-		}
-	}
-
-	// if m_family is still nullptr for an active actor -> remove it. It doesn't exist in new family.
-	for (TkActorImpl& tkActor : m_actors)
-	{
-		if (tkActor.isActive() && tkActor.m_family == nullptr)
-		{
-			tkActor.m_family = this;
-			if (tkActor.m_group)
-			{
-				tkActor.m_group->removeActor(tkActor);
-			}
-
-			auto removeSplitEvent = getQueue().allocData<TkSplitEvent>();
-			removeSplitEvent->parentData.family = this;
-			removeSplitEvent->numChildren = 0;
-			removeSplitEvent->parentData.userData = tkActor.userData;
-			removeSplitEvent->parentData.index = tkActor.getIndex();
-			getQueue().addEvent(removeSplitEvent);
-
-			tkActor.m_actorLL = nullptr;
-		}
-	}
-
-	// add split event with all new actors
-	newActorsSplitEvent->parentData.family = this;
-	newActorsSplitEvent->parentData.userData = 0;
-	newActorsSplitEvent->parentData.index = invalidIndex<uint32_t>();
-	newActorsSplitEvent->numChildren = children.size();
-	if (newActorsSplitEvent->numChildren > 0)
-	{
-		getQueue().addEvent(newActorsSplitEvent);
-	}
-
-	// replace family
-	TkFrameworkImpl::get()->free(m_familyLL);
-	m_familyLL = newFamilyCopy;
-
-	// update joints
-	for (TkActorImpl& tkActor : m_actors)
-	{
-		if (!tkActor.m_jointList.isEmpty())
-		{
-			updateJoints(&tkActor);
-		}
-	}
-
-	getQueue().dispatch();
-}
-
-
-TkActorImpl* TkFamilyImpl::getActorByChunk(uint32_t chunk)
-{
-	if (chunk >= NvBlastAssetGetChunkCount(m_asset->getAssetLLInternal(), TkFrameworkImpl::get()->log))
-	{
-		NVBLASTTK_LOG_WARNING("TkFamilyImpl::getActorByChunk: invalid chunk index.  Returning NULL.");
-		return nullptr;
-	}
-
-	NvBlastActor* actorLL = NvBlastFamilyGetChunkActor(m_familyLL, chunk, TkFrameworkImpl::get()->log);
-	return actorLL ? getActorByActorLL(actorLL) : nullptr;
-}
-
-
-void TkFamilyImpl::applyFractureInternal(const NvBlastFractureBuffers* commands)
-{
-	NvBlastSupportGraph graph = getAsset()->getGraph();
-
-	// apply bond fracture commands on relevant actors
-	{
-		TkActorImpl* currActor = nullptr;
-		NvBlastBondFractureData* bondFractures = commands->bondFractures;
-		uint32_t bondFracturesCount = 0;
-
-		auto applyFracture = [&]()
-		{
-			if (bondFracturesCount > 0)
-			{
-				if (currActor != nullptr && currActor->isActive())
-				{
-					NvBlastFractureBuffers newCommands;
-					newCommands.bondFractures = bondFractures;
-					newCommands.bondFractureCount = bondFracturesCount;
-					newCommands.chunkFractures = nullptr;
-					newCommands.chunkFractureCount = 0;
-					currActor->applyFracture(nullptr, &newCommands);
-				}
-
-				bondFractures += bondFracturesCount;
-				bondFracturesCount = 0;
-			}
-		};
-
-		for (uint32_t i = 0; i < commands->bondFractureCount; ++i, ++bondFracturesCount)
-		{
-			const NvBlastBondFractureData& command = commands->bondFractures[i];
-			uint32_t chunk0 = graph.chunkIndices[command.nodeIndex0];
-			uint32_t chunk1 = graph.chunkIndices[command.nodeIndex1];
-			TkActorImpl* actor0 = getActorByChunk(chunk0);
-			TkActorImpl* actor1 = getActorByChunk(chunk1);
-			if (actor0 != actor1)
-			{
-				// skipping this event, bond already broken
-				actor0 = nullptr;
-			}
-			if (actor0 != currActor)
-			{
-				applyFracture();
-				currActor = actor0;
-			}
-		}
-
-		if (bondFracturesCount > 0)
-		{
-			applyFracture();
-		}
-	}
-
-	// apply chunk fracture commands on relevant actors
-	{
-		TkActorImpl* currActor = nullptr;
-		NvBlastChunkFractureData* chunkFractures = commands->chunkFractures;
-		uint32_t chunkFracturesCount = 0;
-
-		auto applyFracture = [&]()
-		{
-			if (chunkFracturesCount > 0)
-			{
-				if (currActor != nullptr && currActor->isActive())
-				{
-					NvBlastFractureBuffers newCommands;
-					newCommands.bondFractures = nullptr;
-					newCommands.bondFractureCount = 0;
-					newCommands.chunkFractures = chunkFractures;
-					newCommands.chunkFractureCount = chunkFracturesCount;
-					currActor->applyFracture(nullptr, &newCommands);
-				}
-
-				chunkFractures += chunkFracturesCount;
-				chunkFracturesCount = 0;
-			}
-		};
-
-		for (uint32_t i = 0; i < commands->chunkFractureCount; ++i, ++chunkFracturesCount)
-		{
-			const NvBlastChunkFractureData& command = commands->chunkFractures[i];
-			TkActorImpl* actor = getActorByChunk(command.chunkIndex);
-			if (actor != currActor)
-			{
-				applyFracture();
-				currActor = actor;
-			}
-		}
-		if (chunkFracturesCount > 0)
-		{
-			applyFracture();
-		}
-	}
-}
-
-
-void TkFamilyImpl::updateJoints(TkActorImpl* actor, TkEventQueue* alternateQueue)
-{
-	// Copy joint array for safety against implementation of joint->setActor
-	TkJointImpl** joints = reinterpret_cast<TkJointImpl**>(NvBlastAlloca(sizeof(TkJointImpl*)*actor->getJointCountInternal()));
-	TkJointImpl** stop = joints + actor->getJointCountInternal();
-	TkJointImpl** jointHandle = joints;
-	for (TkActorImpl::JointIt j(*actor); (bool)j; ++j)
-	{
-		*jointHandle++ = *j;
-	}
-	jointHandle = joints;
-	while (jointHandle < stop)
-	{
-		TkJointImpl* joint = *jointHandle++;
-		
-		const TkJointData& data = joint->getDataInternal();
-
-		TkActorImpl* actor0 = data.actors[0] != nullptr ?
-			static_cast<TkActorImpl&>(*data.actors[0]).getFamilyImpl().getActorByChunk(data.chunkIndices[0]) : nullptr;
-
-		TkActorImpl* actor1 = data.actors[1] != nullptr ?
-			static_cast<TkActorImpl&>(*data.actors[1]).getFamilyImpl().getActorByChunk(data.chunkIndices[1]) : nullptr;
-
-		joint->setActors(actor0, actor1, alternateQueue);
-	}
-}
-
-
-const TkAsset* TkFamilyImpl::getAsset() const
-{
-	return m_asset;
-}
-
-
-bool TkFamilyImpl::serialize(PxFileBuf& stream) const
-{
-	TkFrameworkImpl::get()->serializeHeader(*this, stream);
-
-	if (m_material != nullptr)
-	{
-		NVBLASTTK_LOG_WARNING("TkFamilyImpl::serialize(): Material pointer is not nullptr, it will be lost during serialization.");
-	}
-
-	NVBLASTTK_CHECK_ERROR(m_asset != nullptr, "TkFamilyImpl::serialize(): TkFamily asset is nullptr, can't be serialized.", return false);
-	NVBLASTTK_CHECK_ERROR(m_familyLL != nullptr, "TkFamilyImpl::serialize(): TkFamily family is nullptr, can't be serialized.", return false);
-
-	// Asset ID
-	const NvBlastID& assetID = m_asset->getID();
-	NVBLASTTK_CHECK_ERROR(!TkGUIDIsZero(&assetID), "TkFamilyImpl::serialize(): Associated asset doesn't have an ID set.", return false);
-	stream.write(&assetID, sizeof(NvBlastID));
-
-	// Family
-	const uint32_t familySize = NvBlastFamilyGetSize(m_familyLL, TkFrameworkImpl::get()->log);
-	stream.storeDword(familySize);
-	stream.write(m_familyLL, familySize);
-
-	//// Joints ////
-
-	// Internal joint data
-	stream.storeDword(m_internalJointCount);
-
-	// External joint family ID list
-	stream.storeDword(m_jointSets.size());
-	for (uint32_t i = 0; i < m_jointSets.size(); ++i)
-	{
-		const JointSet* jointSet = m_jointSets[i];
-		stream.write(&jointSet->m_familyID, sizeof(NvBlastID));
-	}
-
-	// Actor joint lists
-	TkJointImpl* internalJoints = getInternalJoints();
-	for (uint32_t actorNum = 0; actorNum < m_actors.size(); ++actorNum)
-	{
-		const TkActorImpl& actor = m_actors[actorNum];
-		if (!actor.isActive())
-		{
-			continue;	// We may need a better way of iterating through active actors
-		}
-
-		stream.storeDword(actor.getJointCount());
-
-		for (TkActorImpl::JointIt j(actor); (bool)j; ++j)
-		{
-			TkJointImpl* joint = *j;
-
-			const TkJointData& jointData = joint->getDataInternal();
-			NVBLAST_ASSERT(jointData.actors[0] == &actor || jointData.actors[1] == &actor);
-
-			const uint32_t attachmentFlags = (uint32_t)(jointData.actors[0] == &actor) | (uint32_t)(jointData.actors[1] == &actor) << 1;
-			stream.storeDword(attachmentFlags);
-
-			const TkActorImpl* otherActor = static_cast<const TkActorImpl*>(jointData.actors[(attachmentFlags >> 1) ^ 1]);
-
-			if (joint->m_owner == this)
-			{
-				// Internal joint - write internal joint index
-				const uint32_t jointIndex = static_cast<uint32_t>(joint - internalJoints);
-				stream.storeDword(jointIndex);
-				if (otherActor != nullptr && otherActor->getIndexInternal() < actorNum)	// No need to write the joint data, it has already been written
-				{
-					continue;
-				}
-			}
-			else
-			{
-				// External joint - write external family index and joint information
-				stream.storeDword(invalidIndex<uint32_t>());	// Denotes external joint
-
-				const FamilyIDMap::Entry* e = m_familyIDMap.find(getFamilyID(otherActor));
-				NVBLASTTK_CHECK_ERROR(e != nullptr, "TkFamilyImpl::deserialize(): Bad data - attached family's ID not recorded.", return false);
-
-				stream.storeDword(e->second);	// Write family ID index
-			}
-
-			// Write joint data
-			for (int side = 0; side < 2; ++side)
-			{
-				stream.storeDword(jointData.chunkIndices[side]);
-				const physx::PxVec3& attachPosition = jointData.attachPositions[side];
-				stream.storeFloat(attachPosition.x); stream.storeFloat(attachPosition.y); stream.storeFloat(attachPosition.z);
-			}
-		}
-	}
-
-	return true;
-}
-
-
-//////// Static functions ////////
-
-TkSerializable* TkFamilyImpl::deserialize(PxFileBuf& stream, const NvBlastID& id)
-{
-	// Asset resolve
-	NvBlastID assetID;
-	stream.read(&assetID, sizeof(NvBlastID));
-	TkIdentifiable* object = TkFrameworkImpl::get()->findObjectByIDInternal(assetID);
-	NVBLASTTK_CHECK_ERROR(object && object->getType() == TkAssetImpl::s_type, "TkFamilyImpl::deserialize: can't find asset with corresponding ID.", return nullptr);
-	TkAssetImpl* asset = static_cast<TkAssetImpl*>(object);
-
-	// Allocate
-	TkFamilyImpl* family = NVBLASTTK_NEW(TkFamilyImpl)(id);
-	NVBLASTTK_CHECK_ERROR(family != nullptr, "TkFamilyImpl::deserialize: family allocation failed.", return nullptr);
-
-	// associate with found asset
-	family->m_asset = asset;
-
-	// Family
-	const uint32_t familySize = stream.readDword();
-	family->m_familyLL = static_cast<NvBlastFamily*>(TkFrameworkImpl::get()->alloc(familySize));
-	stream.read(family->m_familyLL, familySize);
-
-	if (family->m_familyLL == nullptr)
-	{
-		NVBLASTTK_LOG_ERROR("TkFamilyImpl::deserialize: low-level family could not be created.");
-		family->release();
-		return nullptr;
-	}
-
-#if NV_ENABLE_ASSERTS && 0
-	NvBlastID id = NvBlastFamilyGetAssetID(family->m_familyLL, TkFrameworkImpl::get()->log);
-	NVBLAST_ASSERT(TkGUIDsEqual(&id, &assetID));
-#endif
-
-	// preallocate actors
-	uint32_t maxActorCount = NvBlastFamilyGetMaxActorCount(family->m_familyLL, TkFrameworkImpl::get()->log);
-	family->m_actors.resize(maxActorCount);
-
-	// get actors from family
-	TkArray<NvBlastActor*>::type newLLActors(NvBlastFamilyGetActorCount(family->m_familyLL, TkFrameworkImpl::get()->log));
-	uint32_t actorCount = NvBlastFamilyGetActors(newLLActors.begin(), newLLActors.size(), family->m_familyLL, TkFrameworkImpl::get()->log);
-
-	// fill actors
-	for (uint32_t i = 0; i < actorCount; ++i)
-	{
-		NvBlastActor* newLLActor = newLLActors[i];
-		uint32_t actorIndex = NvBlastActorGetIndex(newLLActor, TkFrameworkImpl::get()->log);
-		TkActorImpl& tkActor = *family->getActorByIndex(actorIndex);
-
-		tkActor.m_family = family;
-		tkActor.m_actorLL = newLLActor;
-	}
-
-	//// Create joints ////
-
-	// internal
-	family->m_internalJointCount = stream.readDword();
-	family->m_internalJointBuffer.resize(family->m_internalJointCount * sizeof(TkJointImpl), '\0');
-	TkJointImpl* internalJoints = family->getInternalJoints();
-
-	// external joint family ID list
-	const uint32_t jointSetCount = stream.readDword();
-	family->m_jointSets.resize(jointSetCount);
-	for (uint32_t i = 0; i < jointSetCount; ++i)
-	{
-		family->m_jointSets[i] = NVBLASTTK_NEW(JointSet);
-		stream.read(&family->m_jointSets[i]->m_familyID, sizeof(NvBlastID));
-		family->m_familyIDMap[family->m_jointSets[i]->m_familyID] = i;
-	}
-
-	// fill actor joint lists
-	for (uint32_t actorNum = 0; actorNum < family->m_actors.size(); ++actorNum)
-	{
-		TkActorImpl& actor = family->m_actors[actorNum];
-		if (!actor.isActive())
-		{
-			continue;	// We may need a better way of iterating through active actors
-		}
-
-		// Read joint information
-		uint32_t jointCount = stream.readDword();
-		while (jointCount--)
-		{
-			const uint32_t attachmentFlags = stream.readDword();
-			const uint32_t jointIndex = stream.readDword();
-			if (!isInvalidIndex(jointIndex))
-			{
-				// Internal joint
-				TkJointImpl& joint = internalJoints[jointIndex];
-				TkJointData& jointData = joint.getDataWritable();
-
-				// Initialize joint if it has not been encountered yet
-				NVBLAST_ASSERT((joint.m_links[0].m_joint == nullptr) == (joint.m_links[1].m_joint == nullptr));
-				if (joint.m_links[0].m_joint == nullptr)
-				{
-					new (&joint) TkJointImpl;
-					joint.m_owner = family;
-					for (int side = 0; side < 2; ++side)
-					{
-						jointData.chunkIndices[side] = stream.readDword();
-						physx::PxVec3& attachPosition = jointData.attachPositions[side];
-						attachPosition.x = stream.readFloat();	attachPosition.y = stream.readFloat();	attachPosition.z = stream.readFloat();
-					}
-				}
-
-				if (attachmentFlags & 1)
-				{
-					jointData.actors[0] = &actor;
-					actor.addJoint(joint.m_links[0]);
-				}
-
-				if (attachmentFlags & 2)
-				{
-					jointData.actors[1] = &actor;
-					if (jointData.actors[0] != jointData.actors[1])
-					{
-						actor.addJoint(joint.m_links[1]);
-					}
-				}
-			}
-			else
-			{
-				// External joint
-				const uint32_t otherFamilyIndex = stream.readDword();
-				NVBLASTTK_CHECK_ERROR(otherFamilyIndex < family->m_jointSets.size(), "TkFamilyImpl::deserialize: family allocation failed.", return nullptr);
-				const NvBlastID& otherFamilyID = family->m_jointSets[otherFamilyIndex]->m_familyID;
-				TkFamilyImpl* otherFamily = static_cast<TkFamilyImpl*>(TkFrameworkImpl::get()->findObjectByIDInternal(otherFamilyID));
-
-				TkJointDesc jointDesc;
-				for (int side = 0; side < 2; ++side)
-				{
-					jointDesc.chunkIndices[side] = stream.readDword();
-					physx::PxVec3& attachPosition = jointDesc.attachPositions[side];
-					attachPosition.x = stream.readFloat();	attachPosition.y = stream.readFloat();	attachPosition.z = stream.readFloat();
-				}
-
-				NVBLASTTK_CHECK_ERROR(attachmentFlags != 3, "TkFamilyImpl::deserialize: both attached actors are the same in an external joint.", return nullptr);
-
-				const uint32_t attachmentIndex = attachmentFlags >> 1;
-
-				TkJointImpl** jointHandle = family->createExternalJointHandle(otherFamilyID, jointDesc.chunkIndices[attachmentIndex], jointDesc.chunkIndices[attachmentIndex ^ 1]);
-				NVBLASTTK_CHECK_ERROR(jointHandle != nullptr, "TkFamilyImpl::deserialize: joint handle could not be created.", return nullptr);
-
-				if (otherFamily == nullptr)
-				{
-					// Other family does not exist yet, we'll create the joint
-					jointDesc.families[attachmentIndex] = family;
-					jointDesc.families[attachmentIndex ^ 1] = nullptr;
-
-					TkJointImpl* joint = NVBLASTTK_NEW(TkJointImpl)(jointDesc, nullptr);
-					NVBLASTTK_CHECK_ERROR(joint != nullptr, "TkFamilyImpl::deserialize: joint createion failed.", return nullptr);
-
-					*jointHandle = joint;
-
-					actor.addJoint(joint->m_links[attachmentIndex]);
-				}
-				else
-				{
-					// Other family exists, and should have created the joint
-					TkJointImpl* joint = otherFamily->findExternalJoint(family, ExternalJointKey(jointDesc.chunkIndices[attachmentIndex ^ 1], jointDesc.chunkIndices[attachmentIndex]));
-					NVBLASTTK_CHECK_ERROR(joint != nullptr, "TkFamilyImpl::deserialize: other family should have created joint, but did not.", return nullptr);
-
-					*jointHandle = joint;
-
-					// Add the joint to its actor(s)
-					joint->getDataWritable().actors[attachmentIndex] = &actor;
-					actor.addJoint(joint->m_links[attachmentIndex]);
-				}
-			}
-		}
-	}
-
-	return family;
-}
-
-
-TkFamilyImpl* TkFamilyImpl::create(const TkAssetImpl* asset)
-{
-	TkFamilyImpl* family = NVBLASTTK_NEW(TkFamilyImpl);
-	family->m_asset = asset;
-	void* mem = TkFrameworkImpl::get()->alloc(NvBlastAssetGetFamilyMemorySize(asset->getAssetLL(), TkFrameworkImpl::get()->log));
-	family->m_familyLL = NvBlastAssetCreateFamily(mem, asset->getAssetLL(), TkFrameworkImpl::get()->log);
-	//family->addListener(*TkFrameworkImpl::get());
-
-	if (family->m_familyLL == nullptr)
-	{
-		NVBLASTTK_LOG_ERROR("TkFamilyImpl::create: low-level family could not be created.");
-		family->release();
-		return nullptr;
-	}
-
-	uint32_t maxActorCount = NvBlastFamilyGetMaxActorCount(family->m_familyLL, TkFrameworkImpl::get()->log);
-	family->m_actors.resize(maxActorCount);
-
-	family->m_internalJointBuffer.resize(asset->getJointDescCountInternal() * sizeof(TkJointImpl), 0);
-	family->m_internalJointCount = asset->getJointDescCountInternal();
-
-	return family;
-}
-
-
-TkJointImpl** TkFamilyImpl::createExternalJointHandle(const NvBlastID& otherFamilyID, uint32_t chunkIndex0, uint32_t chunkIndex1)
-{
-	JointSet* jointSet;
-	const FamilyIDMap::Entry* jointSetIndexEntry = m_familyIDMap.find(otherFamilyID);
-	uint32_t otherFamilyIndex;
-	if (jointSetIndexEntry != nullptr)
-	{
-		otherFamilyIndex = jointSetIndexEntry->second;
-		jointSet = m_jointSets[otherFamilyIndex];
-	}
-	else
-	{
-		jointSet = NVBLASTTK_NEW(JointSet);
-		NVBLASTTK_CHECK_ERROR(jointSet != nullptr, "TkFamilyImpl::addExternalJoint: failed to create joint set for other family ID.", return nullptr);
-		jointSet->m_familyID = otherFamilyID;
-		otherFamilyIndex = m_jointSets.size();
-		m_familyIDMap[otherFamilyID] = otherFamilyIndex;
-		m_jointSets.pushBack(jointSet);
-	}
-
-	const ExternalJointKey key(chunkIndex0, chunkIndex1);
-	const bool jointExists = jointSet->m_joints.find(key) != nullptr;
-	NVBLASTTK_CHECK_WARNING(!jointExists, "TkFamilyImpl::addExternalJoint: joint already added.", return nullptr);
-
-	return &jointSet->m_joints[key];
-}
-
-
-bool TkFamilyImpl::deleteExternalJointHandle(TkJointImpl*& joint, const NvBlastID& otherFamilyID, uint32_t chunkIndex0, uint32_t chunkIndex1)
-{
-	const FamilyIDMap::Entry* jointSetIndexEntry = m_familyIDMap.find(otherFamilyID);
-	if (jointSetIndexEntry != nullptr)
-	{
-		const uint32_t jointSetIndex = jointSetIndexEntry->second;
-		TkHashMap<ExternalJointKey, TkJointImpl*>::type::Entry e;
-		if (m_jointSets[jointSetIndex]->m_joints.erase(ExternalJointKey(chunkIndex0, chunkIndex1), e))
-		{
-			// Delete the joint set if it is empty
-			if (m_jointSets[jointSetIndex]->m_joints.size() == 0)
-			{
-				NVBLASTTK_DELETE(m_jointSets[jointSetIndex], JointSet);
-				m_jointSets.replaceWithLast(jointSetIndex);
-				m_familyIDMap.erase(otherFamilyID);
-				if (jointSetIndex < m_jointSets.size())
-				{
-					m_familyIDMap[m_jointSets[jointSetIndex]->m_familyID] = jointSetIndex;
-				}
-			}
-
-			// Return value that was stored
-			joint = e.second;
-			return true;
-		}
-	}
-
-	return false;
-}
-
-
-TkJointImpl* TkFamilyImpl::findExternalJoint(const TkFamilyImpl* otherFamily, ExternalJointKey key) const
-{
-	const FamilyIDMap::Entry* jointSetIndexEntry = m_familyIDMap.find(getFamilyID(otherFamily));
-	if (jointSetIndexEntry != nullptr)
-	{
-		const TkHashMap<ExternalJointKey, TkJointImpl*>::type::Entry* e = m_jointSets[jointSetIndexEntry->second]->m_joints.find(key);
-		if (e != nullptr)
-		{
-			return e->second;
-		}
-	}
-
-	return nullptr;
-}
-
-} // namespace Blast
-} // namespace Nv
diff --git a/NvBlast/sdk/toolkit/source/NvBlastTkFamilyImpl.h b/NvBlast/sdk/toolkit/source/NvBlastTkFamilyImpl.h
deleted file mode 100644
index 571ee75..0000000
--- a/NvBlast/sdk/toolkit/source/NvBlastTkFamilyImpl.h
+++ /dev/null
@@ -1,245 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTTKFAMILYIMPL_H
-#define NVBLASTTKFAMILYIMPL_H
-
-#include "NvBlastTkCommon.h"
-
-#include "NvBlastTkFamily.h"
-#include "NvBlastTkTypeImpl.h"
-#include "NvBlastTkActorImpl.h"
-
-#include "NvBlastTkEventQueue.h"
-#include "NvBlastTkHashSet.h"
-#include "NvBlastTkHashMap.h"
-
-#include "NvBlast.h"
-#include "NvBlastAssert.h"
-#include "NvBlastDLink.h"
-
-
-// Forward declarations
-struct NvBlastFamily;
-
-namespace Nv
-{
-namespace Blast
-{
-
-// Forward declarations
-class TkGroupImpl;
-class TkAssetImpl;
-
-
-NVBLASTTK_IMPL_DECLARE(Family)
-{
-public:
-	/**
-	Enum which keeps track of the serialized data format.
-	*/
-	enum Version
-	{
-		/** Initial version */
-		Initial,
-
-		//	New formats must come before Count.  They should be given descriptive names with more information in comments.
-
-		/** The number of serialized formats. */
-		Count,
-
-		/** The current version.  This should always be Count-1 */
-		Current = Count - 1
-	};
-
-	TkFamilyImpl();
-	TkFamilyImpl(const NvBlastID& id);
-	~TkFamilyImpl();
-
-	NVBLASTTK_IMPL_DEFINE_SERIALIZABLE('A', 'C', 'T', 'F');
-
-	// Begin TkFamily
-	virtual const NvBlastFamily*	getFamilyLL() const override;
-
-	virtual uint32_t				getActorCount() const override;
-
-	virtual uint32_t				getActors(TkActor** buffer, uint32_t bufferSize, uint32_t indexStart = 0) const override;
-
-	virtual void					addListener(TkEventListener& l) override { m_queue.addListener(l); }
-
-	virtual void					removeListener(TkEventListener& l) override { m_queue.removeListener(l); }
-
-	virtual void					applyFracture(const NvBlastFractureBuffers* commands) override { applyFractureInternal(commands); }
-
-	virtual const TkAsset*			getAsset() const override;
-
-	virtual void					reinitialize(const NvBlastFamily* newFamily, TkGroup* group) override;
-
-	virtual const void*				getMaterial() const override;
-
-	virtual void					setMaterial(const void* material) override;
-	// End TkFamily
-
-	// Public methods
-	static TkFamilyImpl*			create(const TkAssetImpl* asset);
-
-	const TkAssetImpl*				getAssetImpl() const;
-
-	NvBlastFamily*					getFamilyLLInternal() const;
-
-	uint32_t						getActorCountInternal() const;
-
-	TkActorImpl*					addActor(NvBlastActor* actorLL);
-
-	void							applyFractureInternal(const NvBlastFractureBuffers* commands);
-
-	void							removeActor(TkActorImpl* actorLL);
-
-	TkEventQueue&					getQueue() { return m_queue; }
-
-	TkActorImpl*					getActorByActorLL(const NvBlastActor* actorLL);
-
-	void							updateJoints(TkActorImpl* actor, TkEventQueue* alternateQueue = nullptr);
-
-	TkArray<TkActorImpl>::type&		getActorsInternal();
-
-	uint32_t						getInternalJointCount() const;
-
-	TkJointImpl*					getInternalJoints() const;
-
-	TkJointImpl**					createExternalJointHandle(const NvBlastID& otherFamilyID, uint32_t chunkIndex0, uint32_t chunkIndex1);
-
-	bool							deleteExternalJointHandle(TkJointImpl*& joint, const NvBlastID& otherFamilyID, uint32_t chunkIndex0, uint32_t chunkIndex1);
-
-	void							releaseJoint(TkJointImpl& joint);
-
-	TkActorImpl*					getActorByChunk(uint32_t chunkIndex);
-
-	typedef physx::shdfnd::Pair<uint32_t, uint32_t>	ExternalJointKey;	//!< The chunk indices within the TkFamily joined by the joint.  This chunks will be a supports chunks.
-
-	TkJointImpl*					findExternalJoint(const TkFamilyImpl* otherFamily, ExternalJointKey key) const;
-
-private:
-	TkActorImpl*					getActorByIndex(uint32_t index);
-
-	struct JointSet
-	{
-		NvBlastID										m_familyID;
-		TkHashMap<ExternalJointKey, TkJointImpl*>::type	m_joints;
-	};
-
-	typedef TkHashMap<NvBlastID, uint32_t>::type	FamilyIDMap;
-
-	NvBlastFamily*				m_familyLL;
-	TkArray<TkActorImpl>::type	m_actors;
-	uint32_t					m_internalJointCount;
-	TkArray<uint8_t>::type		m_internalJointBuffer;
-	TkArray<JointSet*>::type	m_jointSets;
-	FamilyIDMap					m_familyIDMap;
-	const TkAssetImpl*			m_asset;
-	const void*					m_material;
-
-	TkEventQueue				m_queue;
-};
-
-
-//////// TkFamilyImpl inline methods ////////
-
-NV_INLINE const TkAssetImpl* TkFamilyImpl::getAssetImpl() const
-{
-	return m_asset;
-}
-
-
-NV_INLINE NvBlastFamily* TkFamilyImpl::getFamilyLLInternal() const
-{ 
-	return m_familyLL; 
-}
-
-
-NV_INLINE uint32_t TkFamilyImpl::getActorCountInternal() const
-{
-	NVBLAST_ASSERT(m_familyLL != nullptr);
-
-	return NvBlastFamilyGetActorCount(m_familyLL, TkFrameworkImpl::get()->log);
-}
-
-
-NV_INLINE TkActorImpl* TkFamilyImpl::getActorByIndex(uint32_t index)
-{
-	NVBLAST_ASSERT(index < m_actors.size());
-	return &m_actors[index];
-}
-
-
-NV_INLINE TkActorImpl* TkFamilyImpl::getActorByActorLL(const NvBlastActor* actorLL)
-{
-	uint32_t index = NvBlastActorGetIndex(actorLL, TkFrameworkImpl::get()->log);
-	return getActorByIndex(index);
-}
-
-
-NV_INLINE const void* TkFamilyImpl::getMaterial() const
-{
-	return m_material;
-}
-
-
-NV_INLINE void TkFamilyImpl::setMaterial(const void* material)
-{
-	m_material = material;
-}
-
-
-NV_INLINE TkArray<TkActorImpl>::type& TkFamilyImpl::getActorsInternal()
-{
-	return m_actors;
-}
-
-
-NV_INLINE uint32_t TkFamilyImpl::getInternalJointCount() const
-{
-	return m_internalJointCount;
-}
-
-
-NV_INLINE TkJointImpl* TkFamilyImpl::getInternalJoints() const
-{
-	return const_cast<TkJointImpl*>(reinterpret_cast<const TkJointImpl*>(m_internalJointBuffer.begin()));
-}
-
-
-NV_INLINE void TkFamilyImpl::releaseJoint(TkJointImpl& joint)
-{
-	NVBLAST_ASSERT(joint.m_owner == this);
-	NVBLAST_ASSERT(&joint >= getInternalJoints() && &joint < getInternalJoints() + getInternalJointCount() * sizeof(TkJointImpl));
-
-	joint.~TkJointImpl();
-	joint.m_owner = nullptr;
-}
-
-
-//////// Inline global functions ////////
-
-NV_INLINE const NvBlastID& getFamilyID(const TkActor* actor)
-{
-	return actor != nullptr ? static_cast<const TkActorImpl*>(actor)->getFamilyImpl().getIDInternal() : *reinterpret_cast<const NvBlastID*>("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0");
-}
-
-NV_INLINE const NvBlastID& getFamilyID(const TkFamilyImpl* family)
-{
-	return family != nullptr ? family->getIDInternal() : *reinterpret_cast<const NvBlastID*>("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0");
-}
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTTKFAMILYIMPL_H
diff --git a/NvBlast/sdk/toolkit/source/NvBlastTkFrameworkImpl.cpp b/NvBlast/sdk/toolkit/source/NvBlastTkFrameworkImpl.cpp
deleted file mode 100644
index 6201101..0000000
--- a/NvBlast/sdk/toolkit/source/NvBlastTkFrameworkImpl.cpp
+++ /dev/null
@@ -1,613 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastAssert.h"
-
-#include "NvBlastTkFrameworkImpl.h"
-#include "NvBlastTkAssetImpl.h"
-#include "NvBlastTkFamilyImpl.h"
-#include "NvBlastTkGroupImpl.h"
-#include "NvBlastTkActorImpl.h"
-#include "NvBlastTkJointImpl.h"
-#include "NvBlastTkTypeImpl.h"
-
-#include "PxAllocatorCallback.h"
-#include "PxErrorCallback.h"
-#include "PxFileBuf.h"
-
-#include <algorithm>
-
-
-using namespace physx;
-using namespace physx::shdfnd;
-using namespace physx::general_PxIOStream2;
-
-
-NV_INLINE bool operator < (const NvBlastID& id1, const NvBlastID& id2)
-{
-	return memcmp(&id1, &id2, sizeof(NvBlastID)) < 0;
-}
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-//////// Local definitions ////////
-
-// Map type ID to static type data
-#define NVBLASTTK_REGISTER_TYPE(_name)										\
-	if (!Tk##_name##Impl::s_type.indexIsValid())							\
-	{																		\
-		Tk##_name##Impl::s_type.setIndex(TkTypeIndex::_name);				\
-	}																		\
-	m_types[TkTypeIndex::_name] = &Tk##_name##Impl::s_type;					\
-	m_typeIDToIndex[Tk##_name##Impl::s_type.getID()] = TkTypeIndex::_name
-
-
-#define NVBLASTTK_RELEASE_TYPE(_name)										\
-	{ 																		\
-		TkTypeImpl& type = Tk##_name##Impl::s_type;							\
-		auto& toRelease = m_objects[type.getIndex()];						\
-		for (TkObject* obj : toRelease) 									\
-		{ 																	\
-			obj->release();													\
-		}																	\
-	}
-
-
-//////// TkFrameworkImpl static variables ////////
-
-TkFrameworkImpl* TkFrameworkImpl::s_framework = nullptr;
-
-
-//////// TkFrameworkImpl static function ////////
-
-TkFrameworkImpl* TkFrameworkImpl::get()
-{
-	return s_framework;
-}
-
-
-bool TkFrameworkImpl::set(TkFrameworkImpl* framework)
-{
-	if (s_framework != nullptr)
-	{
-		if (framework != nullptr)
-		{
-			NVBLASTTK_LOG_ERROR("TkFrameworkImpl::set: framework already set.  Pass NULL to this function to destroy framework.");
-			return false;
-		}
-
-		PxAllocatorCallback& allocator = s_framework->getAllocatorCallbackInternal();
-		s_framework->~TkFrameworkImpl();
-		allocator.deallocate(s_framework);
-	}
-
-	s_framework = framework;
-
-	return true;
-}
-
-
-void TkFrameworkImpl::log(int type, const char* msg, const char* file, int line)
-{
-	if (s_framework == nullptr)
-	{
-		return;
-	}
-
-	PxErrorCode::Enum pxErrorCode = PxErrorCode::eNO_ERROR;
-	switch (type)
-	{
-	case NvBlastMessage::Error:		pxErrorCode = PxErrorCode::eINVALID_OPERATION;	break;
-	case NvBlastMessage::Warning:	pxErrorCode = PxErrorCode::eDEBUG_WARNING;		break;
-	case NvBlastMessage::Info:		pxErrorCode = PxErrorCode::eDEBUG_INFO;			break;
-	case NvBlastMessage::Debug:		pxErrorCode = PxErrorCode::eNO_ERROR;			break;
-	}
-
-	s_framework->getErrorCallback().reportError(pxErrorCode, msg, file, line);
-}
-
-
-void* TkFrameworkImpl::alloc(size_t size)
-{
-	if (s_framework == nullptr)
-	{
-		return nullptr;
-	}
-
-	NV_COMPILE_TIME_ASSERT(Alignment > 0 && Alignment <= 256);
-
-	unsigned char* mem = reinterpret_cast<unsigned char*>(s_framework->m_allocatorCallback->allocate(size + (size_t)Alignment, "NvBlast", __FILE__, __LINE__));
-
-	const unsigned char offset = (unsigned char)((uintptr_t)Alignment - (uintptr_t)mem % (size_t)Alignment - 1);
-	mem += offset;
-	*mem++ = offset;
-
-	return mem;
-}
-
-
-void TkFrameworkImpl::free(void* mem)
-{
-	if (s_framework == nullptr)
-	{
-		return;
-	}
-
-	unsigned char* ptr = reinterpret_cast<unsigned char*>(mem);
-	const unsigned char offset = *--ptr;
-
-	return s_framework->m_allocatorCallback->deallocate(ptr - offset);
-}
-
-
-//////// TkFrameworkImpl methods ////////
-
-TkFrameworkImpl::TkFrameworkImpl(const TkFrameworkDesc& desc)
-	: TkFramework()
-	, m_errorCallback(desc.errorCallback)
-	, m_allocatorCallback(desc.allocatorCallback)
-{
-	// Static create() function should ensure these pointers are not NULL
-	NVBLAST_ASSERT(m_errorCallback != nullptr);
-	NVBLAST_ASSERT(m_allocatorCallback != nullptr);
-
-	// Register types
-	m_types.resize(TkTypeIndex::TypeCount);
-	m_objects.resize(TkTypeIndex::TypeCount);
-	NVBLASTTK_REGISTER_TYPE(Asset);
-	NVBLASTTK_REGISTER_TYPE(Family);
-	NVBLASTTK_REGISTER_TYPE(Group);
-}
-
-
-TkFrameworkImpl::~TkFrameworkImpl()
-{
-}
-
-
-void TkFrameworkImpl::release()
-{
-	// Special release of joints, which are not TkIdentifiable:
-	TkArray<TkJointImpl*>::type joints;	// Since the EraseIterator is not exposed
-	joints.reserve(m_joints.size());
-	for (auto j = m_joints.getIterator(); !j.done(); ++j)
-	{
-		joints.pushBack(*j);
-	}
-	for (uint32_t i = 0; i < joints.size(); ++i)
-	{
-		joints[i]->release();
-	}
-	NVBLAST_ASSERT(m_joints.size() == 0);
-	joints.reset();	// Since we will be deleting the allocator
-
-	NVBLASTTK_RELEASE_TYPE(Group);
-	NVBLASTTK_RELEASE_TYPE(Asset);
-	set(nullptr);
-	Nv::Blast::TkAllocator::s_allocatorCallback = nullptr;
-}
-
-
-physx::PxErrorCallback& TkFrameworkImpl::getErrorCallback() const
-{
-	return getErrorCallbackInternal();
-}
-
-
-physx::PxAllocatorCallback& TkFrameworkImpl::getAllocatorCallback() const
-{
-	return getAllocatorCallbackInternal();
-}
-
-
-NvBlastLog TkFrameworkImpl::getLogFn() const
-{
-	return TkFrameworkImpl::log;
-}
-
-
-TkSerializable* TkFrameworkImpl::deserialize(PxFileBuf& stream)
-{
-	// Read framework ID
-	if (stream.readDword() != ClassID)
-	{
-		NVBLASTTK_LOG_ERROR("TkFrameworkImpl::deserialize: stream does not contain a BlastTk object.");
-		return nullptr;
-	}
-
-	// Read object class ID and get class type data
-	const auto it = m_typeIDToIndex.find(stream.readDword());
-	if (it == nullptr)
-	{
-		NVBLASTTK_LOG_ERROR("TkFrameworkImpl::deserialize: BlastTk object type unrecognized.");
-		return nullptr;
-	}
-
-	const uint32_t index = (*it).second;
-	NVBLAST_ASSERT(index < m_types.size());
-
-	const TkTypeImpl* type = m_types[index];
-
-	// Read object class version and ensure it's current
-	if (stream.readDword() != type->getVersionInternal())
-	{
-		NVBLASTTK_LOG_ERROR("TkFrameworkImpl::deserialize: BlastTk object version does not equal the current version for the loaded type.");
-		return nullptr;
-	}
-
-	// Object ID
-	NvBlastID id;
-	stream.read(&id, sizeof(NvBlastID));
-
-	// Serializable user data
-	const uint32_t lsq = stream.readDword();
-	const uint32_t msq = stream.readDword();
-
-	// All checks out, deserialize
-	TkSerializable* object = type->getDeserializeFn()(stream, id);
-
-	// Set serializable user data if deserialization was successful
-	if (object != nullptr)
-	{
-		object->userIntData = static_cast<uint64_t>(msq) << 32 | static_cast<uint64_t>(lsq);
-	}
-
-	return object;
-}
-
-
-const TkType* TkFrameworkImpl::getType(TkTypeIndex::Enum typeIndex) const
-{
-	if (typeIndex < 0 || typeIndex >= TkTypeIndex::TypeCount)
-	{
-		NVBLASTTK_LOG_WARNING("TkFrameworkImpl::getType: invalid typeIndex.");
-		return nullptr;
-	}
-
-	return m_types[typeIndex];
-}
-
-
-TkIdentifiable* TkFrameworkImpl::findObjectByID(const NvBlastID& id) const
-{
-	TkIdentifiable* object = findObjectByIDInternal(id);
-
-	if (object == nullptr)
-	{
-		NVBLASTTK_LOG_WARNING("TkFrameworkImpl::findObjectByID: object not found.");
-	}
-
-	return object;
-}
-
-
-uint32_t TkFrameworkImpl::getObjectCount(const TkType& type) const
-{
-	const uint32_t index = static_cast<const TkTypeImpl&>(type).getIndex();
-
-	if (index >= m_objects.size())
-	{
-		NVBLASTTK_LOG_ERROR("TkFrameworkImpl::getObjectCount: BlastTk object type unrecognized.");
-		return 0;
-
-	}
-
-	return m_objects[index].size();
-}
-
-
-uint32_t TkFrameworkImpl::getObjects(TkIdentifiable** buffer, uint32_t bufferSize, const TkType& type, uint32_t indexStart /* = 0 */) const
-{
-	const uint32_t index = static_cast<const TkTypeImpl&>(type).getIndex();
-
-	if (index >= m_objects.size())
-	{
-		NVBLASTTK_LOG_ERROR("TkFrameworkImpl::getObjectCount: BlastTk object type unrecognized.");
-		return 0;
-	}
-
-	const auto& objectArray = m_objects[index];
-
-	uint32_t objectCount = objectArray.size();
-	if (objectCount <= indexStart)
-	{
-		NVBLASTTK_LOG_WARNING("TkFrameworkImpl::getObjects: indexStart beyond end of object list.");
-		return 0;
-	}
-
-	objectCount -= indexStart;
-	if (objectCount > bufferSize)
-	{
-		objectCount = bufferSize;
-	}
-
-	memcpy(buffer, objectArray.begin() + indexStart, objectCount * sizeof(TkObject*));
-
-	return objectCount;
-}
-
-
-bool TkFrameworkImpl::reorderAssetDescChunks(NvBlastChunkDesc* chunkDescs, uint32_t chunkCount, NvBlastBondDesc* bondDescs, uint32_t bondCount, uint32_t* chunkReorderMap /*= nullptr*/) const
-{
-	uint32_t* map = chunkReorderMap != nullptr ? chunkReorderMap : static_cast<uint32_t*>(NVBLASTTK_ALLOC(chunkCount * sizeof(uint32_t), "reorderAssetDescChunks:chunkReorderMap"));
-	void* scratch = NVBLASTTK_ALLOC(chunkCount * sizeof(NvBlastChunkDesc), "reorderAssetDescChunks:scratch");
-	const bool result = NvBlastReorderAssetDescChunks(chunkDescs, chunkCount, bondDescs, bondCount, map, scratch, log);
-	NVBLASTTK_FREE(scratch);
-	if (chunkReorderMap == nullptr)
-	{
-		NVBLASTTK_FREE(map);
-	}
-	return result;
-}
-
-
-bool TkFrameworkImpl::ensureAssetExactSupportCoverage(NvBlastChunkDesc* chunkDescs, uint32_t chunkCount) const
-{
-	void* scratch = NVBLASTTK_ALLOC(chunkCount, "ensureAssetExactSupportCoverage:scratch");
-	const bool result = NvBlastEnsureAssetExactSupportCoverage(chunkDescs, chunkCount, scratch, log);
-	NVBLASTTK_FREE(scratch);
-	return result;
-}
-
-
-TkAsset* TkFrameworkImpl::createAsset(const TkAssetDesc& desc)
-{
-	TkAssetImpl* asset = TkAssetImpl::create(desc);
-	if (asset == nullptr)
-	{
-		NVBLASTTK_LOG_ERROR("TkFrameworkImpl::createAsset: failed to create asset.");
-	}
-
-	return asset;
-}
-
-
-TkAsset* TkFrameworkImpl::createAsset(const NvBlastAsset* assetLL, Nv::Blast::TkAssetJointDesc* jointDescs, uint32_t jointDescCount, bool ownsAsset)
-{
-	TkAssetImpl* asset = TkAssetImpl::create(assetLL, jointDescs, jointDescCount, ownsAsset);
-	if (asset == nullptr)
-	{
-		NVBLASTTK_LOG_ERROR("TkFrameworkImpl::createAsset: failed to create asset.");
-	}
-
-	return asset;
-}
-
-
-TkGroup* TkFrameworkImpl::createGroup(const TkGroupDesc& desc)
-{
-	TkGroupImpl* group = TkGroupImpl::create(desc);
-	if (group == nullptr)
-	{
-		NVBLASTTK_LOG_ERROR("TkFrameworkImpl::createGroup: failed to create group.");
-	}
-
-	return group;
-}
-
-
-TkActor* TkFrameworkImpl::createActor(const TkActorDesc& desc)
-{
-	TkActor* actor = TkActorImpl::create(desc);
-	if (actor == nullptr)
-	{
-		NVBLASTTK_LOG_ERROR("TkFrameworkImpl::createActor: failed to create actor.");
-	}
-
-	return actor;
-}
-
-
-TkJoint* TkFrameworkImpl::createJoint(const TkJointDesc& desc)
-{
-	TkJointImpl** handle0 = nullptr;
-	TkJointImpl** handle1 = nullptr;
-
-	TkFamilyImpl* family0 = static_cast<TkFamilyImpl*>(desc.families[0]);
-	TkFamilyImpl* family1 = static_cast<TkFamilyImpl*>(desc.families[1]);
-
-	NVBLASTTK_CHECK_ERROR(family0 != nullptr || family1 != nullptr, "TkFrameworkImpl::createJoint: at least one family in the TkJointDesc must be valid.", return nullptr);
-
-	NVBLASTTK_CHECK_ERROR(family0 == nullptr || desc.chunkIndices[0] < family0->getAssetImpl()->getChunkCount(), "TkFrameworkImpl::createJoint: desc.chunkIndices[0] is invalid.", return nullptr);
-	NVBLASTTK_CHECK_ERROR(family1 == nullptr || desc.chunkIndices[1] < family1->getAssetImpl()->getChunkCount(), "TkFrameworkImpl::createJoint: desc.chunkIndices[1] is invalid.", return nullptr);
-
-	const bool actorsAreTheSame = family0 == family1 && family0->getActorByChunk(desc.chunkIndices[0]) == family1->getActorByChunk(desc.chunkIndices[1]);
-	NVBLASTTK_CHECK_ERROR(!actorsAreTheSame, "TkFrameworkImpl::createJoint: the chunks listed in the TkJointDesc must be in different actors.", return nullptr);
-
-	if (family0 != nullptr)
-	{
-		const bool isSupportChunk = !isInvalidIndex(NvBlastAssetGetChunkToGraphNodeMap(family0->getAssetImpl()->getAssetLLInternal(), log)[desc.chunkIndices[0]]);
-		NVBLASTTK_CHECK_ERROR(isSupportChunk, "TkFrameworkImpl::createJoint: desc.chunkIndices[0] is not a support chunk in the asset for desc.families[0].  Joint not created.", return nullptr);
-		handle0 = family0->createExternalJointHandle(getFamilyID(family1), desc.chunkIndices[0], desc.chunkIndices[1]);
-		NVBLASTTK_CHECK_ERROR(handle0 != nullptr, "TkFrameworkImpl::createJoint: could not create joint handle in family[0].  Joint not created.", return nullptr);
-	}
-
-	if (family1 != nullptr)
-	{
-		const bool isSupportChunk = !isInvalidIndex(NvBlastAssetGetChunkToGraphNodeMap(family1->getAssetImpl()->getAssetLLInternal(), log)[desc.chunkIndices[1]]);
-		NVBLASTTK_CHECK_ERROR(isSupportChunk, "TkFrameworkImpl::createJoint: desc.chunkIndices[1] is not a support chunk in the asset for desc.families[1].  Joint not created.", return nullptr);
-		if (family1 != family0)
-		{
-			handle1 = family1->createExternalJointHandle(getFamilyID(family0), desc.chunkIndices[1], desc.chunkIndices[0]);
-			NVBLASTTK_CHECK_ERROR(handle1 != nullptr, "TkFrameworkImpl::createJoint: could not create joint handle in family[1].  Joint not created.", return nullptr);
-		}
-	}
-
-	TkJointImpl* joint = NVBLASTTK_NEW(TkJointImpl)(desc, nullptr);
-	NVBLASTTK_CHECK_ERROR(joint != nullptr, "TkFrameworkImpl::createJoint: failed to create joint.", return nullptr);
-
-	const TkJointData& jointData = joint->getDataInternal();
-
-	if (handle0 != nullptr)
-	{
-		*handle0 = joint;
-		static_cast<TkActorImpl*>(jointData.actors[0])->addJoint(joint->m_links[0]);
-	}
-
-	if (handle1 != nullptr)
-	{
-		*handle1 = joint;
-		if (jointData.actors[0] != jointData.actors[1])
-		{
-			static_cast<TkActorImpl*>(jointData.actors[1])->addJoint(joint->m_links[1]);
-		}
-	}
-
-	return joint;
-}
-
-
-bool TkFrameworkImpl::serializeHeader(const TkSerializable& object, PxFileBuf& stream)
-{
-	const TkTypeImpl& type = static_cast<const TkTypeImpl&>(object.getType());
-
-	// Tk framework identifier
-	stream.storeDword(ClassID);
-
-	// Object header
-	stream.storeDword(type.getID());
-	stream.storeDword(type.getVersionInternal());
-
-	// Object ID
-	stream.write(&object.getID(), sizeof(NvBlastID));
-
-	// Serializable user data
-	stream.storeDword(static_cast<uint32_t>(object.userIntData & 0xFFFFFFFF));
-	stream.storeDword(static_cast<uint32_t>(object.userIntData >> 32));
-
-	return true;
-}
-
-
-void TkFrameworkImpl::onCreate(TkIdentifiable& object)
-{
-	const TkTypeImpl& type = static_cast<const TkTypeImpl&>(object.getType());
-
-	const uint32_t index = type.getIndex();
-
-	if (index >= m_objects.size())
-	{
-		if (!isInvalidIndex(index))
-		{
-			NVBLASTTK_LOG_ERROR("TkFrameworkImpl::addObject: object type unrecognized.");
-		}
-		return;
-	}
-
-	auto& objectArray = m_objects[index];
-	NVBLAST_ASSERT(objectArray.find(&object) == objectArray.end());
-	objectArray.pushBack(&object);
-}
-
-
-void TkFrameworkImpl::onDestroy(TkIdentifiable& object)
-{
-	// remove from id map if present
-	const auto id = object.getID();
-	if (!TkGUIDIsZero(&id))
-	{
-		m_IDToObject.erase(id);
-	}
-
-	// remove from object list
-	const TkTypeImpl& type = static_cast<const TkTypeImpl&>(object.getType());
-
-	const uint32_t index = type.getIndex();
-
-	if (index >= m_objects.size())
-	{
-		if (!isInvalidIndex(index))
-		{
-			NVBLASTTK_LOG_ERROR("TkFrameworkImpl::removeObject: object type unrecognized.");
-		}
-		return;
-	}
-
-	auto& objectArray = m_objects[index];
-	objectArray.findAndReplaceWithLast(&object);
-}
-
-
-void TkFrameworkImpl::onCreate(TkJointImpl& joint)
-{
-	NVBLASTTK_CHECK_ERROR(m_joints.insert(&joint), "TkFrameworkImpl::onCreate: Joint already tracked.", return);
-}
-
-
-void TkFrameworkImpl::onDestroy(TkJointImpl& joint)
-{
-	NVBLASTTK_CHECK_ERROR(m_joints.erase(&joint), "TkFrameworkImpl::onDestroy: Joint not tracked.", return);
-}
-
-
-void TkFrameworkImpl::onIDChange(TkIdentifiable& object, const NvBlastID& IDPrev, const NvBlastID& IDCurr)
-{
-	if (!TkGUIDIsZero(&IDPrev))
-	{
-		if (!m_IDToObject.erase(IDPrev))
-		{
-			NVBLASTTK_LOG_ERROR("TkFrameworkImpl::reportIDChanged: object with previous ID doesn't exist.");
-		}
-	}
-
-	if (!TkGUIDIsZero(&IDCurr))
-	{
-		auto& value = m_IDToObject[IDCurr];
-		if (value != nullptr)
-		{
-			NVBLASTTK_LOG_ERROR("TkFrameworkImpl::reportIDChanged: object with new ID already exists.");
-			return;
-		}
-		value = &object;
-	}
-}
-
-} // namespace Blast
-} // namespace Nv
-
-
-//////// Global API implementation ////////
-
-Nv::Blast::TkFramework* NvBlastTkFrameworkCreate(const Nv::Blast::TkFrameworkDesc& desc)
-{
-	if (desc.errorCallback == nullptr)
-	{
-		return nullptr;
-	}
-
-	if (desc.allocatorCallback == nullptr)
-	{
-		desc.errorCallback->reportError(PxErrorCode::eINVALID_OPERATION, "TkFramework::create: NULL allocator given in descriptor.", __FILE__, __LINE__);
-		return nullptr;
-	}
-
-	if (Nv::Blast::TkFrameworkImpl::get() != nullptr)
-	{
-		desc.errorCallback->reportError(PxErrorCode::eINVALID_OPERATION, "TkFramework::create: framework already created.  Use TkFramework::get() to access.", __FILE__, __LINE__);
-		return nullptr;
-	}
-
-	Nv::Blast::TkAllocator::s_allocatorCallback = desc.allocatorCallback;
-
-	Nv::Blast::TkFrameworkImpl* framework = new (desc.allocatorCallback->allocate(sizeof(Nv::Blast::TkFrameworkImpl), "TkFrameworkImpl", __FILE__, __LINE__)) Nv::Blast::TkFrameworkImpl(desc);
-	Nv::Blast::TkFrameworkImpl::set(framework);
-
-	return Nv::Blast::TkFrameworkImpl::get();
-}
-
-
-Nv::Blast::TkFramework* NvBlastTkFrameworkGet()
-{
-	return Nv::Blast::TkFrameworkImpl::get();
-}
diff --git a/NvBlast/sdk/toolkit/source/NvBlastTkFrameworkImpl.h b/NvBlast/sdk/toolkit/source/NvBlastTkFrameworkImpl.h
deleted file mode 100644
index ceeff06..0000000
--- a/NvBlast/sdk/toolkit/source/NvBlastTkFrameworkImpl.h
+++ /dev/null
@@ -1,225 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTTKFRAMEWORKIMPL_H
-#define NVBLASTTKFRAMEWORKIMPL_H
-
-#include "NvBlastTkFramework.h"
-#include "NvBlastProfilerInternal.h"
-
-#include "NvBlastTkCommon.h"
-
-#include "NvBlastTkArray.h"
-#include "NvBlastTkHashMap.h"
-#include "NvBlastTkHashSet.h"
-
-
-//////// Log macros that use the TkFrameworkImpl::log function ////////
-
-#define NVBLASTTK_LOG_ERROR(_msg)	NVBLAST_LOG_ERROR(TkFrameworkImpl::log, _msg)
-#define NVBLASTTK_LOG_WARNING(_msg)	NVBLAST_LOG_WARNING(TkFrameworkImpl::log, _msg)
-#define NVBLASTTK_LOG_INFO(_msg)	NVBLAST_LOG_INFO(TkFrameworkImpl::log, _msg)
-#define NVBLASTTK_LOG_DEBUG(_msg)	NVBLAST_LOG_DEBUG(TkFrameworkImpl::log, _msg)
-
-#define NVBLASTTK_CHECK(_expr, _messageType, _msg, _onFail)																\
-	{																													\
-		if(!(_expr))																									\
-		{																												\
-			TkFrameworkImpl::log(_messageType, _msg, __FILE__, __LINE__);												\
-			{ _onFail; };																								\
-		}																												\
-	}																													
-
-#define NVBLASTTK_CHECK_ERROR(_expr, _msg, _onFail)		NVBLASTTK_CHECK(_expr, NvBlastMessage::Error, _msg, _onFail)
-#define NVBLASTTK_CHECK_WARNING(_expr, _msg, _onFail)	NVBLASTTK_CHECK(_expr, NvBlastMessage::Warning, _msg, _onFail)
-#define NVBLASTTK_CHECK_INFO(_expr, _msg, _onFail)		NVBLASTTK_CHECK(_expr, NvBlastMessage::Info, _msg, _onFail)
-#define NVBLASTTK_CHECK_DEBUG(_expr, _msg, _onFail)		NVBLASTTK_CHECK(_expr, NvBlastMessage::Debug, _msg, _onFail)
-
-
-//////// Allocator macros ////////
-
-#define NVBLASTTK_ALLOC(_size, _name)	TkFrameworkImpl::get()->getAllocatorCallbackInternal().allocate(_size, _name, __FILE__, __LINE__)
-#define NVBLASTTK_FREE(_mem)			TkFrameworkImpl::get()->getAllocatorCallbackInternal().deallocate(_mem)
-
-#define NVBLASTTK_NEW(T)	new (NVBLASTTK_ALLOC(sizeof(T), #T)) T
-#define NVBLASTTK_DELETE(obj, T)	\
-	(obj)->~T();					\
-	NVBLASTTK_FREE(obj)
-
-
-
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-// Forward declarations
-class TkTypeImpl;
-class TkJointImpl;
-
-/**
-Implementation of TkFramework
-*/
-class TkFrameworkImpl : public TkFramework
-{
-public:
-										TkFrameworkImpl(const TkFrameworkDesc& desc);
-										~TkFrameworkImpl();
-
-	// Begin TkFramework
-	virtual void						release() override;
-
-	virtual physx::PxErrorCallback&		getErrorCallback() const override;
-
-	virtual physx::PxAllocatorCallback&	getAllocatorCallback() const override;
-
-	virtual NvBlastLog					getLogFn() const override;
-
-	virtual TkSerializable*				deserialize(physx::general_PxIOStream2::PxFileBuf& stream) override;
-
-	virtual const TkType*				getType(TkTypeIndex::Enum typeIndex) const override;
-
-	virtual TkIdentifiable*				findObjectByID(const NvBlastID& id) const override;
-
-	virtual uint32_t					getObjectCount(const TkType& type) const override;
-
-	virtual uint32_t					getObjects(TkIdentifiable** buffer, uint32_t bufferSize, const TkType& type, uint32_t indexStart = 0) const override;
-
-	virtual bool						reorderAssetDescChunks(NvBlastChunkDesc* chunkDescs, uint32_t chunkCount, NvBlastBondDesc* bondDescs, uint32_t bondCount, uint32_t* chunkReorderMap = nullptr) const override;
-
-	virtual bool						ensureAssetExactSupportCoverage(NvBlastChunkDesc* chunkDescs, uint32_t chunkCount) const override;
-
-	virtual TkAsset*					createAsset(const TkAssetDesc& desc) override;
-
-	virtual TkAsset*					createAsset(const NvBlastAsset* assetLL, Nv::Blast::TkAssetJointDesc* jointDescs = nullptr, uint32_t jointDescCount = 0, bool ownsAsset = false) override;
-
-	virtual TkGroup*					createGroup(const TkGroupDesc& desc) override;
-
-	virtual TkActor*					createActor(const TkActorDesc& desc) override;
-
-	virtual TkJoint*					createJoint(const TkJointDesc& desc) override;
-	// End TkFramework
-
-	// Public methods
-	/**
-	Access to the error callback set by the user.
-	*/
-	physx::PxErrorCallback&				getErrorCallbackInternal() const;
-
-	/**
-	Access to the allocator callback set by the user.
-	*/
-	physx::PxAllocatorCallback&			getAllocatorCallbackInternal() const;
-
-	/**
-	To be called by any TkIdentifiable object when it is created, so the framework can track it.
-	*/
-	void								onCreate(TkIdentifiable& object);
-
-	/**
-	To be called by any TkIdentifiable object when it is deleted, so the framework can stop tracking it.
-	*/
-	void								onDestroy(TkIdentifiable& object);
-
-	/**
-	Special onCreate method for joints, since they are not TkIdentifiable.
-	*/
-	void								onCreate(TkJointImpl& joint);
-
-	/**
-	Special onDestroy method for joints, since they are not TkIdentifiable.
-	*/
-	void								onDestroy(TkJointImpl& joint);
-
-	/**
-	Must be called whenever a TkIdentifiable object's ID is changed, so that the framework can associate the new ID with it.
-	*/
-	void								onIDChange(TkIdentifiable& object, const NvBlastID& IDPrev, const NvBlastID& IDCurr);
-
-	/**
-	Internal (non-virtual) method to find a TkIdentifiable object based upon its NvBlastID.
-	*/
-	TkIdentifiable*						findObjectByIDInternal(const NvBlastID& id) const;
-
-	/**
-	Serialize a TkSerializable's standard header data, including its type ID, type version, object ID, and TkObject::userIntData.
-	*/
-	bool								serializeHeader(const TkSerializable& object, physx::general_PxIOStream2::PxFileBuf& stream);
-
-	// Access to singleton
-
-	/** Retrieve the global singleton. */
-	static TkFrameworkImpl*				get();
-
-	/** Set the global singleton, if it's not already set, or set it to NULL.  Returns true iff successful. */
-	static bool							set(TkFrameworkImpl* framework);
-
-	// Blast LL context functions
-	static	void						log(int type, const char* msg, const char* file, int line);	//!< A function with the NvBlastLog signature which can be used in NvBlast low-level function calls
-	static	void*						alloc(size_t size);											//!< A function with the std::malloc signature which returns 16-byte aligned memory
-	static	void						free(void* mem);											//!< A function with the std::free signature which can deallocate memory created by alloc
-
-private:
-	// Enums
-	enum { Alignment = 16 };									//!< Memory alignment used for allocations
-	enum { ClassID = NVBLASTTK_FOURCC('T', 'K', 'F', 'W') };	//!< TkFramework identifier token, used in serialization
-
-	// Static data
-	static TkFrameworkImpl*														s_framework;			//!< Global (singleton) object pointer
-
-	// Callbacks
-	physx::PxErrorCallback*														m_errorCallback;		//!< User-supplied error callback
-	physx::PxAllocatorCallback*													m_allocatorCallback;	//!< User-supplied allocator callback
-
-	// Types
-	TkInlineArray<const TkTypeImpl*, TkTypeIndex::TypeCount>::type				m_types;				//!< TkIdentifiable static type data
-	TkHashMap<uint32_t, uint32_t>::type											m_typeIDToIndex;		//!< Map to type data keyed by ClassID
-
-	// Objects and object names
-	TkHashMap<NvBlastID, TkIdentifiable*>::type									m_IDToObject;			//!< Map to all TkIdentifiable objects, keyed by NvBlastID
-	TkInlineArray<TkArray<TkIdentifiable*>::type, TkTypeIndex::TypeCount>::type	m_objects;				//!< Catalog of all TkIdentifiable objects, grouped by type.  (Revisit implementation.)
-
-	// Track external joints (to do: make this a pool)
-	TkHashSet<TkJointImpl*>::type												m_joints;				//!< All internal joints
-};
-
-
-//////// TkFrameworkImpl inline methods ////////
-
-NV_INLINE physx::PxErrorCallback& TkFrameworkImpl::getErrorCallbackInternal() const
-{
-	return *m_errorCallback;
-}
-
-
-NV_INLINE physx::PxAllocatorCallback& TkFrameworkImpl::getAllocatorCallbackInternal() const
-{
-	return *m_allocatorCallback;
-}
-
-
-NV_INLINE TkIdentifiable* TkFrameworkImpl::findObjectByIDInternal(const NvBlastID& id) const
-{
-	const auto entry = m_IDToObject.find(id);
-	if (entry == nullptr)
-	{
-		return nullptr;
-	}
-
-	return entry->second;
-}
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTTKFRAMEWORKIMPL_H
diff --git a/NvBlast/sdk/toolkit/source/NvBlastTkGUID.h b/NvBlast/sdk/toolkit/source/NvBlastTkGUID.h
deleted file mode 100644
index a770092..0000000
--- a/NvBlast/sdk/toolkit/source/NvBlastTkGUID.h
+++ /dev/null
@@ -1,135 +0,0 @@
-// This code contains NVIDIA Confidential Information and is disclosed to you
-// under a form of NVIDIA software license agreement provided separately to you.
-//
-// Notice
-// NVIDIA Corporation and its licensors retain all intellectual property and
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTTKGUID_H
-#define NVBLASTTKGUID_H
-
-#include "NvPreprocessor.h"
-
-#if NV_WINDOWS_FAMILY
-#include <rpc.h>
-#else
-//#include <uuid/uuid.h>
-#include "NvBlastTime.h"
-#endif
-
-#include "PsHash.h"
-
-namespace Nv
-{
-namespace Blast
-{
-
-#if NV_WINDOWS_FAMILY
-
-NV_INLINE NvBlastID TkGenerateGUID(void* ptr)
-{
-	NV_UNUSED(ptr);
-
-	NV_COMPILE_TIME_ASSERT(sizeof(UUID) == sizeof(NvBlastID));
-
-	NvBlastID guid;
-	UuidCreate(reinterpret_cast<UUID*>(&guid));
-
-	return guid;
-}
-
-#else
-
-NV_INLINE NvBlastID TkGenerateGUID(void* ptr)
-{
-//	NV_COMPILE_TIME_ASSERT(sizeof(uuid_t) == sizeof(NvBlastID));
-	Time time;
-
-	NvBlastID guid;
-	//	uuid_generate_random(reinterpret_cast<uuid_t&>(guid));
-
-	*reinterpret_cast<uint64_t*>(guid.data) = reinterpret_cast<uintptr_t>(ptr);
-	*reinterpret_cast<int64_t*>(guid.data + 8) = time.getLastTickCount();
-
-	return guid;
-}
-
-#endif
-
-
-/**
-Compares two NvBlastIDs.
-
-\param[in]	id1	A pointer to the first id to compare.
-\param[in]	id2	A pointer to the second id to compare.
-
-\return	true iff ids are equal.
-*/
-NV_INLINE bool TkGUIDsEqual(const NvBlastID* id1, const NvBlastID* id2)
-{
-	return !memcmp(id1, id2, sizeof(NvBlastID));
-}
-
-
-/**
-Clears an NvBlastID (sets all of its fields to zero).
-
-\param[out]	id	A pointer to the ID to clear.
-*/
-NV_INLINE void TkGUIDReset(NvBlastID* id)
-{
-	memset(id, 0, sizeof(NvBlastID));
-}
-
-
-/**
-Tests an NvBlastID to determine if it's zeroed.  After calling TkGUIDReset
-on an ID, passing it to this function will return a value of true.
-
-\param[in]	id	A pointer to the ID to test.
-*/
-NV_INLINE bool TkGUIDIsZero(const NvBlastID* id)
-{
-	return *reinterpret_cast<const uint64_t*>(&id->data[0]) == 0 && *reinterpret_cast<const uint64_t*>(&id->data[8]) == 0;
-}
-
-} // namespace Blast
-} // namespace Nv
-
-
-namespace physx
-{
-namespace shdfnd
-{
-
-// hash specialization for NvBlastID
-template <>
-struct Hash<NvBlastID>
-{
-	uint32_t operator()(const NvBlastID& k) const
-	{
-		// "DJB" string hash
-		uint32_t h = 5381;
-		for (uint32_t i = 0; i < sizeof(k.data) / sizeof(k.data[0]); ++i)
-			h = ((h << 5) + h) ^ uint32_t(k.data[i]);
-		return h;
-	}
-	bool equal(const NvBlastID& k0, const NvBlastID& k1) const
-	{
-		return Nv::Blast::TkGUIDsEqual(&k0, &k1);
-	}
-};
-
-} // namespace shdfnd
-} // namespace physx
-
-
-#endif // #ifndef NVBLASTTKGUID_H
diff --git a/NvBlast/sdk/toolkit/source/NvBlastTkGroupImpl.cpp b/NvBlast/sdk/toolkit/source/NvBlastTkGroupImpl.cpp
deleted file mode 100644
index d9a4b29..0000000
--- a/NvBlast/sdk/toolkit/source/NvBlastTkGroupImpl.cpp
+++ /dev/null
@@ -1,592 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvPreprocessor.h"
-
-#include "NvBlastAssert.h"
-#include "NvBlast.h"
-
-#include "NvBlastTkFrameworkImpl.h"
-#include "NvBlastTkGroupImpl.h"
-#include "NvBlastTkActorImpl.h"
-#include "NvBlastTkFamilyImpl.h"
-#include "NvBlastTkAssetImpl.h"
-#include "NvBlastTkTaskImpl.h"
-
-#include "Px.h"
-#include "PxFileBuf.h"
-#include "PxAllocatorCallback.h"
-#include "task/PxCpuDispatcher.h"
-
-#undef max
-#undef min
-#include <algorithm>
-
-using namespace physx;
-using namespace physx::general_PxIOStream2;
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-//////// Static data ////////
-
-NVBLASTTK_DEFINE_TYPE_IDENTIFIABLE(Group);
-
-
-//////// Local (static) functions ////////
-
-static uint32_t getNumThreads(PxTaskManager* tm)
-{
-	if (tm == nullptr) return 0;
-	if (tm->getCpuDispatcher() == nullptr) return 0;
-	return tm->getCpuDispatcher()->getWorkerCount();
-}
-
-
-//////// Member functions ////////
-
-TkGroupImpl::TkGroupImpl() : m_actorCount(0), m_isProcessing(false), m_sync(0)
-{
-#if NV_PROFILE
-	memset(&m_stats, 0, sizeof(TkGroupStats)); 
-#endif
-}
-
-
-TkGroupImpl::~TkGroupImpl()
-{
-	NVBLAST_ASSERT(getActorCount() == 0);
-	NVBLAST_ASSERT(m_sharedMemory.size() == 0);
-}
-
-
-void TkGroupImpl::release()
-{
-	if (isProcessing())
-	{
-		// abort all processing? 
-		NVBLASTTK_LOG_ERROR("TkGroup::release: cannot release Group while processing.");
-		NVBLAST_ALWAYS_ASSERT_MESSAGE("TkGroup::release: cannot release Group while processing.");
-		return;
-	}
-
-	for (auto it = m_sharedMemory.getIterator(); !it.done(); ++it)
-	{
-		TkFamilyImpl* family = it->first;
-		for (TkActorImpl& actor : family->getActorsInternal())
-		{
-			if (actor.m_group == this)
-			{
-				removeActorInternal(actor);
-			}
-		}
-		SharedMemory* mem = it->second;
-		mem->release();
-		NVBLASTTK_DELETE(mem, SharedMemory);
-	}
-	m_sharedMemory.clear();
-
-	m_bondTempDataBlock.release();
-	m_chunkTempDataBlock.release();
-	m_bondEventDataBlock.release();
-	m_chunkEventDataBlock.release();
-	m_splitScratchBlock.release();
-
-	NVBLASTTK_DELETE(this, TkGroupImpl);
-}
-
-
-void TkGroupImpl::addActorsInternal(TkActorImpl** actors, uint32_t numActors)
-{
-	for (uint32_t i = 0; i < numActors; i++)
-	{
-		addActorInternal(*actors[i]);
-	}
-}
-
-
-void TkGroupImpl::addActorInternal(TkActorImpl& tkActor)
-{
-	NVBLAST_ASSERT(tkActor.getGroup() == nullptr);
-	tkActor.m_group = this;
-	m_actorCount++;
-}
-
-
-bool TkGroupImpl::addActor(TkActor& actor)
-{
-	TkActorImpl& tkActor = static_cast<TkActorImpl&>(actor);
-	if (tkActor.getGroup() != nullptr)
-	{
-		NVBLASTTK_LOG_ERROR("TkGroup::addActor: actor already belongs to a Group.  Remove from current group first.");
-		return false;
-	}
-
-	if (isProcessing())
-	{
-		NVBLASTTK_LOG_ERROR("TkGroup::addActor: cannot alter Group while processing.");
-		return false;
-	}
-
-	// mark the actor that it now belongs to this group
-	addActorInternal(tkActor);
-
-	// actors that were fractured already or have damage requested
-	// must be enqueued to be processed
-	if (tkActor.isPending())
-	{
-		enqueue(&tkActor);
-	}
-
-	TkFamilyImpl& family = tkActor.getFamilyImpl();
-	SharedMemory* mem = m_sharedMemory[&family];
-	if (mem == nullptr)
-	{
-		// the actor belongs to a family not involved in this group yet
-		// shared memory must be allocated and temporary buffers adjusted accordingly
-
-		PERF_ZONE_BEGIN("family memory");
-		mem = NVBLASTTK_NEW(SharedMemory);
-		mem->allocate(family);
-		m_sharedMemory[&family] = mem;
-		PERF_ZONE_END("family memory");
-
-		PERF_ZONE_BEGIN("group memory");
-		
-		const uint32_t numThreads = getNumThreads(m_pxTaskManager);
-		// one worker always exists, even if it is the main thread (when numThreads is 0)
-		const uint32_t numWorkers = std::max(numThreads, (uint32_t)1);
-
-		// the number of threads could have changed, however this is unexpected and handled in process()
-
-
-		NvBlastLog theLog = TkFrameworkImpl::get()->log;
-
-		// this group's tasks will use one temporary buffer each, which is of max size of, for all families involved
-		const size_t requiredScratch = NvBlastActorGetRequiredScratchForSplit(tkActor.getActorLL(), theLog);
-		if (static_cast<size_t>(m_splitScratchBlock.numElementsPerBlock()) < requiredScratch)
-		{
-			m_splitScratchBlock.release();
-			m_splitScratchBlock.allocate(static_cast<uint32_t>(requiredScratch), numWorkers);
-		}
-		
-		// generate and apply fracture may create an entry for each bond
-		const uint32_t bondCount = NvBlastAssetGetBondCount(tkActor.getAsset()->getAssetLL(), theLog);
-		if (m_bondTempDataBlock.numElementsPerBlock() < bondCount)
-		{
-			m_bondTempDataBlock.release();
-			m_bondTempDataBlock.allocate(bondCount, numWorkers);
-			m_bondEventDataBlock.release();
-			m_bondEventDataBlock.allocate(bondCount, numWorkers);
-		}
-
-		// apply fracture may create an entry for each lower-support chunk
-		const uint32_t graphNodeCount = NvBlastAssetGetSupportGraph(tkActor.getAsset()->getAssetLL(), theLog).nodeCount;
-		const uint32_t subsupportChunkCount
-			= NvBlastAssetGetChunkCount(tkActor.getAsset()->getAssetLL(), theLog)
-			- NvBlastAssetGetFirstSubsupportChunkIndex(tkActor.getAsset()->getAssetLL(), theLog);
-		const uint32_t chunkCount = graphNodeCount + subsupportChunkCount;
-		if (m_chunkTempDataBlock.numElementsPerBlock() < chunkCount)
-		{
-			m_chunkTempDataBlock.release();
-			m_chunkTempDataBlock.allocate(chunkCount, numWorkers);
-			m_chunkEventDataBlock.release();
-			m_chunkEventDataBlock.allocate(chunkCount, numWorkers);
-		}
-		PERF_ZONE_END("group memory");
-	}
-	mem->addReference();
-
-	return true;
-}
-
-
-uint32_t TkGroupImpl::getActors(TkActor** buffer, uint32_t bufferSize, uint32_t indexStart /* = 0 */) const
-{
-	PERF_SCOPE_L("TkGroup::getActors");
-
-	uint32_t actorCount = m_actorCount;
-	if (actorCount <= indexStart)
-	{
-		NVBLASTTK_LOG_WARNING("TkGroup::getActors: indexStart beyond end of actor list.");
-		return 0;
-	}
-
-	actorCount -= indexStart;
-	if (actorCount > bufferSize)
-	{
-		actorCount = bufferSize;
-	}
-
-	uint32_t index = 0;
-	bool done = false;
-	for (auto it = const_cast<TkGroupImpl*>(this)->m_sharedMemory.getIterator(); !it.done();++it)
-	{
-		TkFamilyImpl* fam = it->first;
-		for (TkActorImpl& actor : fam->getActorsInternal())
-		{
-			if (actor.m_group == this)
-			{
-				NVBLAST_ASSERT(actor.isActive());
-				
-				if (index >= indexStart)
-				{
-					*buffer++ = &actor;
-				}
-			
-				index++;
-				done = (index - indexStart) >= actorCount;
-			}
-			if (done) break;
-		}
-		if (done) break;
-	}
-
-	return actorCount;
-}
-
-
-void TkGroupImpl::removeActorInternal(TkActorImpl& tkActor)
-{
-	NVBLAST_ASSERT(tkActor.m_group == this);
-	tkActor.m_group = nullptr;
-	m_actorCount--;
-}
-
-
-void TkGroupImpl::releaseSharedMemory(TkFamilyImpl* fam, SharedMemory* mem)
-{
-	NVBLAST_ASSERT(mem != nullptr && m_sharedMemory[fam] == mem);
-	mem->release();
-	m_sharedMemory.erase(fam);
-	NVBLASTTK_DELETE(mem, SharedMemory);
-}
-
-
-bool TkGroupImpl::removeActor(TkActor& actor)
-{
-	TkActorImpl& tkActor = static_cast<TkActorImpl&>(actor);
-
-	if (tkActor.getGroup() != this)
-	{
-		NVBLASTTK_LOG_ERROR("TkGroup::removeActor: actor does not belong to this Group.");
-		return false;
-	}
-
-	if (isProcessing())
-	{
-		NVBLASTTK_LOG_ERROR("TkGroup::removeActor: cannot alter Group while processing.");
-		return false;
-	}
-
-	removeActorInternal(tkActor);
-
-	// pending actors must be removed from the job queue as well
-	if(tkActor.isPending())
-	{
-		uint32_t index = tkActor.m_groupJobIndex;
-		tkActor.m_groupJobIndex = invalidIndex<uint32_t>();
-		m_jobs.replaceWithLast(index);
-		if (index < m_jobs.size())
-		{
-			NVBLAST_ASSERT(m_jobs[index].m_tkActor->m_groupJobIndex == m_jobs.size());
-			NVBLAST_ASSERT(m_jobs[index].m_tkActor->isPending());
-			m_jobs[index].m_tkActor->m_groupJobIndex = index;
-		}
-	}
-
-	// if the actor is the last of its family in this group
-	// the group-family memory can be released
-	TkFamilyImpl* family = &tkActor.getFamilyImpl();
-	SharedMemory* mem = getSharedMemory(family);
-	if (mem->removeReference())
-	{
-		releaseSharedMemory(family, mem);
-	}
-
-	return true;
-}
-
-
-TkGroupImpl* TkGroupImpl::create(const TkGroupDesc& desc)
-{
-	if (desc.pxTaskManager == nullptr)
-	{
-		NVBLASTTK_LOG_WARNING("TkGroup::create: attempting to create a Group with a NULL pxTaskManager.");
-	}
-
-	TkGroupImpl* group = NVBLASTTK_NEW(TkGroupImpl);
-
-	group->m_pxTaskManager = desc.pxTaskManager;
-	group->m_initialNumThreads = getNumThreads(group->m_pxTaskManager);
-
-	return group;
-}
-
-
-bool TkGroupImpl::process()
-{
-	PERF_SCOPE_L("TkGroup::process");
-
-	if (!setProcessing(true))
-	{
-		NVBLASTTK_LOG_WARNING("TkGroup::process: Group is still processing, call TkGroup::sync first.");
-		return false;
-	}
-
-	if (m_jobs.size() > 0)
-	{
-		PERF_ZONE_BEGIN("task setup");
-
-		PERF_ZONE_BEGIN("task memory");
-		const uint32_t numThreads = getNumThreads(m_pxTaskManager);
-		// one worker always exists, even if it is the main thread (when numThreads is 0)
-		const uint32_t numWorkers = std::max(numThreads, (uint32_t)1);
-
-		if (numThreads != m_initialNumThreads)
-		{
-			NVBLASTTK_LOG_WARNING("TkGroup::process: number of threads has changed, memory is being reallocated.");
-			m_initialNumThreads = numThreads;
-
-			const uint32_t bondCount = m_bondTempDataBlock.numElementsPerBlock();
-			if (bondCount > 0)
-			{
-				m_bondTempDataBlock.release();
-				m_bondTempDataBlock.allocate(bondCount, numWorkers);
-				m_bondEventDataBlock.release();
-				m_bondEventDataBlock.allocate(bondCount, numWorkers);
-			}
-			const uint32_t chunkCount = m_chunkTempDataBlock.numElementsPerBlock();
-			m_chunkTempDataBlock.release();
-			m_chunkTempDataBlock.allocate(chunkCount, numWorkers);
-			m_chunkEventDataBlock.release();
-			m_chunkEventDataBlock.allocate(chunkCount, numWorkers);
-			const uint32_t scratchSize = m_splitScratchBlock.numElementsPerBlock();
-			m_splitScratchBlock.release();
-			m_splitScratchBlock.allocate(scratchSize, numWorkers);
-		}
-		PERF_ZONE_END("task memory");
-
-
-		PERF_ZONE_BEGIN("setup job queue");
-		for (const auto& job : m_jobs)
-		{
-			const TkActorImpl* a = job.m_tkActor;
-			SharedMemory* mem = getSharedMemory(&a->getFamilyImpl());
-
-			const uint32_t damageCount = a->m_damageBuffer.size();
-
-			// applyFracture'd actor do not necessarily have damage queued
-			NVBLAST_ASSERT(damageCount > 0 || a->m_flags.isSet(TkActorFlag::DAMAGED));
-
-			// no reason to be here without these
-			NVBLAST_ASSERT(a->m_flags.isSet(TkActorFlag::PENDING));
-			NVBLAST_ASSERT(a->m_group == this);
-
-			// collect the amount of event payload memory to preallocate for TkWorkers
-			mem->m_eventsMemory += damageCount * (sizeof(TkFractureCommands) + sizeof(TkFractureEvents)) + sizeof(TkSplitEvent);
-
-			// collect the amount of event entries to preallocate for TkWorkers
-			// (two TkFracture* events per damage plus one TkSplitEvent)
-			mem->m_eventsCount += 2 * damageCount + 1;
-		}
-		PERF_ZONE_END("setup job queue");
-
-		PERF_ZONE_BEGIN("memory protect");
-		for (auto it = m_sharedMemory.getIterator(); !it.done(); ++it)
-		{
-			// preallocate the event memory for TkWorkers
-			SharedMemory* mem = it->second;
-			mem->m_events.reserveData(mem->m_eventsMemory);
-			mem->m_events.reserveEvents(mem->m_eventsCount);
-
-			// these counters are not used anymore
-			// reset them immediately for next time
-			mem->m_eventsCount = 0;
-			mem->m_eventsMemory = 0;
-
-			// switch to parallel mode
-			mem->m_events.protect(true);
-		}
-		PERF_ZONE_END("memory protect");
-
-		PERF_ZONE_END("task setup");
-
-		// ready queue for the workers
-		const uint32_t numJobs = m_jobs.size();
-		m_jobQueue.init(m_jobs.begin(), numJobs);
-
-		// do not start more workers than there are jobs
-		const uint32_t workersToRun = std::min(numWorkers, numJobs);
-		m_workers.resize(workersToRun);
-		m_sync.setCount(workersToRun);
-
-		uint32_t workerId = 0;
-		if (numThreads > 0)
-		{
-			for (auto& task : m_workers)
-			{
-				PERF_SCOPE_M("task release");
-				task.m_id = workerId++;
-				task.m_group = this;
-				task.setContinuation(*m_pxTaskManager, nullptr);
-				// mind m_sync.setCount above, immediately removing reference would not work with a continuation task
-				task.removeReference();
-			}
-		}
-		else
-		{
-			// let this thread do the work
-			NVBLAST_ASSERT(m_workers.size() == 1);
-			for (auto& task : m_workers)
-			{
-				task.m_id = workerId++;
-				task.m_group = this;
-				task.run();
-				task.release();
-			}
-		}
-	}
-
-
-	return true;
-}
-
-
-bool TkGroupImpl::sync(bool block /*= true*/)
-{
-	if (!m_sync.isDone() && block)
-	{
-		PERF_SCOPE_L("TkGroupImpl::sync wait");
-		m_sync.wait();
-	}
-
-	if (isProcessing() && m_sync.isDone())
-	{
-		PERF_SCOPE_L("TkGroupImpl::sync finalize");
-
-		if (m_jobs.size() > 0)
-		{
-#if NV_PROFILE
-			PERF_ZONE_BEGIN("accumulate timers");
-			NvBlastTimers accumulated;
-			NvBlastTimersReset(&accumulated);
-			uint32_t jobCount = 0;
-			int64_t workerTime = 0;
-			for (TkWorker& worker : m_workers)
-			{
-				accumulated += worker.m_stats.timers;
-				jobCount += worker.m_stats.processedActorsCount;
-				workerTime += worker.m_stats.workerTime;
-			}
-			m_stats.timers = accumulated;
-			m_stats.processedActorsCount = jobCount;
-			m_stats.workerTime = workerTime;
-			PERF_ZONE_END("accumulate timers");
-#endif
-
-			PERF_ZONE_BEGIN("job update");
-			for (auto& j : m_jobs)
-			{
-				if (j.m_newActorsCount)
-				{
-					TkFamilyImpl* fam = &j.m_tkActor->getFamilyImpl();
-					SharedMemory* mem = getSharedMemory(fam);
-
-					// as LL is implemented, where newActorsCount the parent is always deleted
-					removeActorInternal(*j.m_tkActor);
-					mem->removeReference();
-					addActorsInternal(j.m_newActors, j.m_newActorsCount);
-					mem->addReference(j.m_newActorsCount);
-					
-					// Update joints
-					mem->m_events.protect(false); // allow allocations again
-					fam->updateJoints(j.m_tkActor, &mem->m_events);
-				}
-
-				// virtually dequeue the actor
-				// the queue itself is cleared right after this loop
-				j.m_tkActor->m_flags.clear(TkActorFlag::PENDING);
-				j.m_tkActor->m_groupJobIndex = invalidIndex<uint32_t>();
-				j.m_tkActor->m_damageBuffer.clear();
-			}
-			m_jobs.clear();
-			PERF_ZONE_END("job update");
-
-			PERF_ZONE_BEGIN("event dispatch");
-			for (auto it = m_sharedMemory.getIterator(); !it.done(); ++it)
-			{
-				TkFamilyImpl* family = it->first;
-				SharedMemory* mem = it->second;
-
-				NVBLAST_ASSERT(family != nullptr);
-				NVBLAST_ASSERT(mem != nullptr && mem->isUsed());
-
-				// where no actor of a family has split, 
-				// its group/family event queue has not been 
-				// unprotected in the jobs loop above
-				mem->m_events.protect(false);
-
-				family->getQueue().dispatch(mem->m_events);
-
-				mem->m_events.reset();
-				mem->reset();
-			}
-			PERF_ZONE_END("event dispatch");
-
-			PERF_ZONE_BEGIN("event memory release");
-			for (auto& worker : m_workers)
-			{
-				worker.m_bondBuffer.clear();
-				worker.m_chunkBuffer.clear();
-			}
-			PERF_ZONE_END("event memory release");
-		}
-
-		bool success = setProcessing(false);
-		NVBLAST_ASSERT(success);
-		return success;
-	}
-
-	return false;
-}
-
-
-bool TkGroupImpl::setProcessing(bool value)
-{
-	bool expected = !value;
-	return m_isProcessing.compare_exchange_strong(expected, value);
-}
-
-
-void TkGroupImpl::enqueue(TkActorImpl* tkActor)
-{
-	NVBLAST_ASSERT(tkActor->getGroupImpl() != nullptr);
-	NVBLAST_ASSERT(tkActor->getGroupImpl() == this);
-	NVBLAST_ASSERT(isInvalidIndex(tkActor->m_groupJobIndex));
-	NVBLAST_ASSERT(isProcessing() == false);
-#if NV_DEBUG
-	for (TkWorkerJob& j : m_jobs)
-	{
-		NVBLAST_ASSERT(j.m_tkActor != tkActor);
-	}
-#endif
-
-	tkActor->m_groupJobIndex = m_jobs.size();
-	TkWorkerJob& j = m_jobs.insert();
-	j.m_tkActor = tkActor;
-}
-
-
-} // namespace Blast
-} // namespace Nv
diff --git a/NvBlast/sdk/toolkit/source/NvBlastTkGroupImpl.h b/NvBlast/sdk/toolkit/source/NvBlastTkGroupImpl.h
deleted file mode 100644
index db7e7c1..0000000
--- a/NvBlast/sdk/toolkit/source/NvBlastTkGroupImpl.h
+++ /dev/null
@@ -1,174 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTTKGROUPIMPL_H
-#define NVBLASTTKGROUPIMPL_H
-
-
-#include "NvBlastTkTaskImpl.h"
-#include "NvBlastTkGroup.h"
-#include "NvBlastTkTypeImpl.h"
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-class TkActorImpl;
-class TkFamilyImpl;
-
-NVBLASTTK_IMPL_DECLARE(Group)
-{
-	~TkGroupImpl();
-
-public:
-	TkGroupImpl();
-
-	NVBLASTTK_IMPL_DEFINE_IDENTIFIABLE('G', 'R', 'P', '\0');
-
-	static TkGroupImpl*	create(const TkGroupDesc& desc);
-
-	// Begin TkGroup
-	virtual bool		addActor(TkActor& actor) override;
-
-	virtual uint32_t	getActorCount() const override;
-
-	virtual uint32_t	getActors(TkActor** buffer, uint32_t bufferSize, uint32_t indexStart = 0) const override;
-
-	virtual bool		process() override;
-
-	virtual bool		sync(bool block = true) override;
-
-	virtual void		getStats(TkGroupStats& stats) const override;
-	// End TkGroup
-
-	// TkGroupImpl API
-
-	/**
-	Remove the actor from this group if the actor actually belongs to it and the group is not processing.
-
-	\param[in]	actor	The TkActor to remove.
-
-	\return				true if removing succeeded, false otherwise
-	*/
-	bool				removeActor(TkActor& actor);
-
-	/**
-	Add the actor to this group's job queue. 
-	It is the caller's responsibility to add an actor only once. This condition is checked in debug builds.
-	*/
-	void				enqueue(TkActorImpl* tkActor);
-
-	/**
-	Atomically check if this group is processing actors. @see setProcessing()
-
-	\return				true between process() and sync() calls, false otherwise
-	*/
-	bool				isProcessing() const;
-
-private:
-	/**
-	Atomically set the processing state. This function checks for the current state
-	before changing it. @see isProcessing()
-
-	\param[in]	value	the value of the new state
-
-	\return				true if the new state could be set, false otherwise
-	*/
-	bool				setProcessing(bool value);
-
-	/** 
-	Get the group-family shared memory for the specified family. To be used when the memory is expected to already exist.
-	*/
-	SharedMemory*		getSharedMemory(TkFamilyImpl* family);
-	void				releaseSharedMemory(TkFamilyImpl* fam, SharedMemory* mem);
-
-	// functions to add/remove actors _without_ group-family memory management
-	void				addActorInternal(TkActorImpl& tkActor);
-	void				addActorsInternal(TkActorImpl** actors, uint32_t numActors);
-	void				removeActorInternal(TkActorImpl& tkActor);
-
-
-	physx::PxTaskManager*							m_pxTaskManager;		//!< the task manager used to dispatch workers
-	uint32_t										m_initialNumThreads;	//!< tracks the number of worker threads
-
-	uint32_t										m_actorCount;			//!< number of actors in this group
-
-	TkHashMap<TkFamilyImpl*, SharedMemory*>::type	m_sharedMemory;			//!< memory sharable by actors in the same family in this group
-
-	// it is assumed no more than the asset's number of bond and chunks fracture commands are produced
-	SharedBlock<NvBlastChunkFractureData>			m_chunkTempDataBlock;	//!< chunk data for damage/fracture
-	SharedBlock<NvBlastBondFractureData>			m_bondTempDataBlock;	//!< bond data for damage/fracture
-	SharedBlock<NvBlastChunkFractureData>			m_chunkEventDataBlock;	//!< initial memory block for event data
-	SharedBlock<NvBlastBondFractureData>			m_bondEventDataBlock;	//!< initial memory block for event data
-	SharedBlock<char>								m_splitScratchBlock;	//!< split scratch memory 
-
-	std::atomic<bool>								m_isProcessing;			//!< true while workers are processing
-	TaskSync										m_sync;					//!< keeps track of finished workers
-
-	TkArray<TkWorker>::type							m_workers;				//!< this group's workers
-	TkAtomicJobQueue								m_jobQueue;				//!< shared job queue for workers
-
-	TkArray<TkWorkerJob>::type						m_jobs;					//!< this group's process jobs
-
-//#if NV_PROFILE
-	TkGroupStats									m_stats;				//!< accumulated group's worker stats
-//#endif
-
-	friend class TkWorker;
-};
-
-
-NV_INLINE bool TkGroupImpl::isProcessing() const
-{
-	return m_isProcessing.load();
-}
-
-
-NV_INLINE void TkGroupImpl::getStats(TkGroupStats& stats) const
-{
-#if NV_PROFILE
-	memcpy(&stats, &m_stats, sizeof(TkGroupStats));
-#else
-	NV_UNUSED(stats);
-#endif
-}
-
-
-NV_INLINE uint32_t TkGroupImpl::getActorCount() const
-{
-	return m_actorCount;
-}
-
-
-NV_INLINE SharedMemory* TkGroupImpl::getSharedMemory(TkFamilyImpl* family)
-{
-	SharedMemory* mem = m_sharedMemory[family];
-	NVBLAST_ASSERT(mem != nullptr);
-	return mem;
-}
-
-
-NV_FORCE_INLINE void operator +=(NvBlastTimers& lhs, const NvBlastTimers& rhs)
-{
-	lhs.material += rhs.material;
-	lhs.fracture += rhs.fracture;
-	lhs.island += rhs.fracture;
-	lhs.partition += rhs.partition;
-	lhs.visibility += rhs.visibility;
-}
-
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTTKGROUPIMPL_H
diff --git a/NvBlast/sdk/toolkit/source/NvBlastTkHashMap.h b/NvBlast/sdk/toolkit/source/NvBlastTkHashMap.h
deleted file mode 100644
index 14730c6..0000000
--- a/NvBlast/sdk/toolkit/source/NvBlastTkHashMap.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTTKHASHMAP_H
-#define NVBLASTTKHASHMAP_H
-
-
-#include "NvBlastTkAllocator.h"
-#include "PsHashMap.h"
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-template <class Key, class Value, class HashFn = physx::shdfnd::Hash<Key>>
-struct TkHashMap
-{
-	typedef physx::shdfnd::HashMap<Key, Value, HashFn, TkAllocator> type;
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // #ifndef NVBLASTTKHASHMAP_H
diff --git a/NvBlast/sdk/toolkit/source/NvBlastTkHashSet.h b/NvBlast/sdk/toolkit/source/NvBlastTkHashSet.h
deleted file mode 100644
index 4a3a3a0..0000000
--- a/NvBlast/sdk/toolkit/source/NvBlastTkHashSet.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTTKHASHSET_H
-#define NVBLASTTKHASHSET_H
-
-
-#include "NvBlastTkAllocator.h"
-#include "PsHashSet.h"
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-template <class Key, class HashFn = physx::shdfnd::Hash<Key>>
-struct TkHashSet
-{
-	typedef physx::shdfnd::HashSet<Key, HashFn, TkAllocator> type;
-};
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // #ifndef NVBLASTTKHASHSET_H
diff --git a/NvBlast/sdk/toolkit/source/NvBlastTkJointImpl.cpp b/NvBlast/sdk/toolkit/source/NvBlastTkJointImpl.cpp
deleted file mode 100644
index 46d6378..0000000
--- a/NvBlast/sdk/toolkit/source/NvBlastTkJointImpl.cpp
+++ /dev/null
@@ -1,183 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastTkFrameworkImpl.h"
-#include "NvBlastTkJointImpl.h"
-#include "NvBlastTkActorImpl.h"
-#include "NvBlastTkAssetImpl.h"
-#include "NvBlastTkFamilyImpl.h"
-
-#include "Px.h"
-#include "PxFileBuf.h"
-#include "PxAllocatorCallback.h"
-
-using namespace physx::general_PxIOStream2;
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-//////// Member functions ////////
-
-TkJointImpl::TkJointImpl(const TkJointDesc& desc, TkFamilyImpl* owner) : m_owner(owner)
-{
-	userData = nullptr;
-
-	// Do not fire off a creation event.  Creation events will only be fired when a family-internal joint is created.
-	NVBLAST_ASSERT(desc.families[0] != nullptr || desc.families[1] != nullptr);
-	NVBLAST_ASSERT(desc.families[0] == nullptr || desc.chunkIndices[0] < static_cast<TkFamilyImpl*>(desc.families[0])->getAssetImpl()->getChunkCount());
-	NVBLAST_ASSERT(desc.attachPositions[0].isFinite());
-	NVBLAST_ASSERT(desc.families[1] == nullptr || desc.chunkIndices[1] < static_cast<TkFamilyImpl*>(desc.families[1])->getAssetImpl()->getChunkCount());
-	NVBLAST_ASSERT(desc.attachPositions[1].isFinite());
-
-	for (int i = 0; i < 2; ++i)
-	{
-		m_data.actors[i] = desc.families[i] != nullptr ? static_cast<TkFamilyImpl*>(desc.families[i])->getActorByChunk(desc.chunkIndices[i]) : nullptr;
-		m_data.chunkIndices[i] = desc.chunkIndices[i];
-		m_data.attachPositions[i] = desc.attachPositions[i];
-		m_links[i].m_joint = this;
-	}
-
-	if (owner == nullptr)
-	{
-		TkFrameworkImpl::get()->onCreate(*this);
-	}
-}
-
-
-void TkJointImpl::release()
-{
-	removeReferencesInActors();
-
-	if (m_owner != nullptr)
-	{
-		// Internal joint
-		m_owner->releaseJoint(*this);
-	}
-	else
-	{
-		// External joint
-		removeReferencesInFamilies();
-		TkFrameworkImpl::get()->onDestroy(*this);
-		NVBLASTTK_DELETE(this, TkJointImpl);
-	}
-}
-
-
-void TkJointImpl::setActors(TkActorImpl* actor0, TkActorImpl* actor1, TkEventQueue* alternateQueue)
-{
-	NVBLAST_ASSERT(m_data.actors[0] != nullptr || m_data.actors[1] != nullptr);
-
-	const bool unreferenced = (actor0 == nullptr && m_data.actors[0] != nullptr) || (actor1 == nullptr && m_data.actors[1] != nullptr);
-
-	removeReferencesInActors();
-
-	if (!unreferenced)
-	{
-		if (actor0 != nullptr)
-		{
-			actor0->addJoint(m_links[0]);
-		}
-		
-		if (actor1 != nullptr && actor1 != actor0)	// If the actors are the same, we only need one joint reference
-		{
-			actor1->addJoint(m_links[1]);
-		}
-	}
-
-	// We do _not_ return if m_data.m_actors[0] == actor0 && m_data.m_actors[1] == actor1 since
-	// this leads to a bug.  This function will only be called when an actor is split.  It is
-	// possible that the two TkActors in a joint are the same as before, but in this case one
-	// of the actors will be the split actor.  Since will be represented by a different
-	// physical actor, this case still needs to be reported in an event. Returning when neither
-	// TkActor has changed will prevent that, and lead to unwanted joint disconnection.
-
-	const uint32_t familyToUse = m_data.actors[0] != actor0 ? 0 : 1;
-
-	TkEventQueue* q = alternateQueue == nullptr ?
-		&static_cast<TkActorImpl*>(m_data.actors[familyToUse])->getFamilyImpl().getQueue()
-		: alternateQueue;
-
-	const bool jointWasInternal = m_data.actors[0] == m_data.actors[1];
-
-	if (unreferenced)
-	{
-		removeReferencesInFamilies();
-		actor0 = actor1 = nullptr;	// Make both new actors NULL
-	}
-
-	if (!jointWasInternal || actor0 != actor1)
-	{
-		// The original actors were different, or they are now, signal a joint update
-		TkJointUpdateEvent* e = q->allocData<TkJointUpdateEvent>();
-		e->joint = this;
-		e->subtype = unreferenced ? TkJointUpdateEvent::Unreferenced : (jointWasInternal ? TkJointUpdateEvent::External : TkJointUpdateEvent::Changed);
-		m_data.actors[0] = actor0;
-		m_data.actors[1] = actor1;
-		q->addEvent(e);
-	}
-	else
-	if (jointWasInternal)
-	{
-		// The joint was originally created within the same actor and now it remains within the same actor.  
-		m_data.actors[0] = m_data.actors[1] = actor0;
-	}
-}
-
-
-const TkJointData TkJointImpl::getData() const
-{
-	return getDataInternal();
-}
-
-
-void TkJointImpl::removeReferencesInActors()
-{
-	TkActorImpl* actor0 = static_cast<TkActorImpl*>(m_data.actors[0]);
-	TkActorImpl* actor1 = static_cast<TkActorImpl*>(m_data.actors[1]);
-
-	if (actor0 != nullptr)
-	{
-		actor0->removeJoint(m_links[0]);
-	}
-
-	if (actor1 != nullptr && actor1 != actor0)	// If the actors are the same, we only had one joint reference
-	{
-		actor1->removeJoint(m_links[1]);
-	}
-}
-
-
-void TkJointImpl::removeReferencesInFamilies()
-{
-	if (m_owner != nullptr)
-	{
-		return;	// Only concerned with external joints
-	}
-
-	NVBLAST_ASSERT(m_data.actors[0] != m_data.actors[1] || m_data.actors[0] == nullptr);	// This is enforced by the initial assumption in TkFrameworkImpl::createJoint.
-
-	for (int i = 0; i < 2; ++i)
-	{
-		if (m_data.actors[i] != nullptr)
-		{
-			TkFamilyImpl& family = static_cast<TkActorImpl*>(m_data.actors[i])->getFamilyImpl();
-			TkJointImpl* joint = nullptr;
-			const bool found = family.deleteExternalJointHandle(joint, getFamilyID(m_data.actors[i ^ 1]), m_data.chunkIndices[i], m_data.chunkIndices[i ^ 1]);
-			NVBLAST_ASSERT((!found && m_data.actors[i ^ 1] == nullptr) || joint == this);	// Might not be found if the actors in a family are in the process of being deleted
-			NV_UNUSED(found);
-		}
-	}
-}
-
-} // namespace Blast
-} // namespace Nv
diff --git a/NvBlast/sdk/toolkit/source/NvBlastTkJointImpl.h b/NvBlast/sdk/toolkit/source/NvBlastTkJointImpl.h
deleted file mode 100644
index ec57309..0000000
--- a/NvBlast/sdk/toolkit/source/NvBlastTkJointImpl.h
+++ /dev/null
@@ -1,146 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTTKJOINTIMPL_H
-#define NVBLASTTKJOINTIMPL_H
-
-
-#include "NvBlastTkJoint.h"
-#include "NvBlastTkCommon.h"
-#include "NvBlastIndexFns.h"
-
-#include "NvBlastAssert.h"
-#include "NvBlastDLink.h"
-
-#include <atomic>
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-// Forward declarations
-class TkActorImpl;
-class TkJointImpl;
-class TkFamilyImpl;
-class TkEventQueue;
-
-
-/**
-Double-sided link (DLink) which holds a reference back to a joint which contains it.
-*/
-struct TkJointLink : public DLink
-{
-	TkJointImpl*	m_joint;	//!< The joint containing this link.
-};
-
-
-/**
-Implementation of TkJoint.
-*/
-class TkJointImpl : public TkJoint
-{
-public:
-	/** Blank constructor only creates valid TkJointLinks (point back to this object) */
-	TkJointImpl();
-
-	/**
-	This constructor sets all internal data.  If the joint is defined in an asset, the family
-	instanced from that asset will own this joint, and the 'owner' parameter is that family.
-	Otherwise, in the case where a joint is created from TkFramwork::createJoint, the joint
-	is not owned by a family and 'owner' will be NULL.
-	*/
-	TkJointImpl(const TkJointDesc& desc, TkFamilyImpl* owner);
-
-	// Begin TkObject
-	virtual void				release() override;
-	// End TkObject
-
-	// Begin TkJoint
-	virtual const	TkJointData	getData() const override;
-	// End TkJoint
-
-	// Public API
-
-	/**
-	Internal method to access a const reference to the joint data.
-
-	\return a const reference to the joint data.
-	*/
-	const TkJointData&			getDataInternal() const;	
-
-	/**
-	Internal method to access a non-const reference to the joint data.
-
-	\return a non-const reference to the joint data.
-	*/
-	TkJointData&				getDataWritable();
-
-	/**
-	Set the actors that this joint attaches to.  When the actors are different from the joint's current actors,
-	an event will be generated on one of the actors' families event queues to signal the change.  Alternatively,
-	if alternateQueue is not NULL then it will be used to hold the event.
-
-	If a non-NULL attached actor becomes NULL, then this joint will detach its references to both actors (if
-	they exist) and send an event of subtype Unreferenced.  This signals the user that the joint may be deleted.
-
-	\param[in]	actor0			The new TkActor to replace the first attached actor.
-	\param[in]	actor1			The new TkActor to replace the second attached actor.
-	\param[in]	alternateQueue	If not NULL, this queue will be used to hold events generated by this function.
-	*/
-	void						setActors(TkActorImpl* actor0, TkActorImpl* actor1, TkEventQueue* alternateQueue = nullptr);
-
-	/**
-	Ensures that any attached actors no longer refer to this joint.
-	*/
-	void						removeReferencesInActors();
-
-	/**
-	Ensures that any attached actors' families no longer refer to this joint.  External joints (created using
-	TkFramework::createJoint) are referenced by the attached actors' families.
-	*/
-	void						removeReferencesInFamilies();
-
-private:
-	TkJointData		m_data;		//!< The data given to the user: attached actors, chunk indices, and actor-local attachment positions.
-	TkJointLink		m_links[2];	//!< One link for each actor in m_data.m_actors.  If m_data.m_actors[0] == m_data.m_actors[1], then only m_links[0] is used.
-	TkFamilyImpl*	m_owner;	//!< The owning family if this is an internal joint created during TkFramework::createActor() from a TkAssetDesc with joint flags.
-
-	friend class TkFrameworkImpl;
-	friend class TkFamilyImpl;
-	friend class TkActorImpl;
-};
-
-
-//////// TkJointImpl inline methods ////////
-
-NV_INLINE TkJointImpl::TkJointImpl()
-{
-	m_links[0].m_joint = m_links[1].m_joint = this;
-}
-
-
-NV_INLINE const TkJointData& TkJointImpl::getDataInternal() const
-{
-	return m_data;
-}
-
-
-NV_INLINE TkJointData& TkJointImpl::getDataWritable()
-{
-	return m_data;
-}
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTTKJOINTIMPL_H
diff --git a/NvBlast/sdk/toolkit/source/NvBlastTkTaskImpl.cpp b/NvBlast/sdk/toolkit/source/NvBlastTkTaskImpl.cpp
deleted file mode 100644
index 3249928..0000000
--- a/NvBlast/sdk/toolkit/source/NvBlastTkTaskImpl.cpp
+++ /dev/null
@@ -1,263 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#include "NvBlastTime.h"
-
-#include "NvBlastTkTaskImpl.h"
-#include "NvBlastTkFamilyImpl.h"
-#include "NvBlastTkAssetImpl.h"
-#include "NvBlastTkGroupImpl.h"
-
-
-using namespace Nv::Blast;
-
-
-void SharedMemory::allocate(TkFamilyImpl& tkFamily)
-{
-	NVBLAST_ASSERT(m_refCount == 0);
-	const NvBlastAsset* assetLL = tkFamily.getAsset()->getAssetLL();
-	
-	// at most leafChunkCount actors can be created within a family
-	// tasks will grab their portion out of these memory blocks
-	uint32_t leafChunkCount = NvBlastAssetGetLeafChunkCount(assetLL, TkFrameworkImpl::get()->log);
-	m_newActorBuffers.allocate(2 * leafChunkCount); // GWD-167 workaround (2*)
-	m_newTkActorBuffers.allocate(leafChunkCount);
-}
-
-
-/**
-Creates a TkEvent::FractureCommand according to the input buffer for tkActor
-into events queue using the LocalBuffers to store the actual event data.
-*/
-NV_FORCE_INLINE void reportFractureCommands(
-	const NvBlastFractureBuffers& buffer,
-	LocalBuffer<NvBlastBondFractureData>& bondBuffer, LocalBuffer<NvBlastChunkFractureData>& chunkBuffer,
-	TkEventQueue& events, const TkActorImpl* tkActor)
-{
-
-	NvBlastBondFractureData* bdata = nullptr;
-	if (buffer.bondFractureCount > 0)
-	{
-		bdata = bondBuffer.allocate(buffer.bondFractureCount);
-		memcpy(bdata, buffer.bondFractures, sizeof(NvBlastBondFractureData)*buffer.bondFractureCount);
-	}
-
-	NvBlastChunkFractureData* cdata = nullptr;
-	if (buffer.chunkFractureCount > 0)
-	{
-		cdata = chunkBuffer.allocate(buffer.chunkFractureCount);
-		memcpy(cdata, buffer.chunkFractures, sizeof(NvBlastChunkFractureData)*buffer.chunkFractureCount);
-	}
-
-	TkFractureCommands* fevt = events.allocData<TkFractureCommands>();
-	fevt->tkActorData = *tkActor;
-	fevt->buffers = { buffer.bondFractureCount, buffer.chunkFractureCount, bdata, cdata };
-	events.addEvent(fevt);
-}
-
-
-/**
-Creates a TkEvent::FractureEvent according to the input buffer for tkActor
-into events queue using the LocalBuffers to store the actual event data.
-*/
-NV_FORCE_INLINE void reportFractureEvents(
-	const NvBlastFractureBuffers& buffer,
-	LocalBuffer<NvBlastBondFractureData>& bondBuffer, LocalBuffer<NvBlastChunkFractureData>& chunkBuffer,
-	TkEventQueue& events, const TkActorImpl* tkActor)
-{
-	uint32_t result[4] = { 0,0,0,0 };
-
-	NvBlastBondFractureData* bdata = nullptr;
-	if (buffer.bondFractureCount > 0)
-	{
-		bdata = bondBuffer.allocate(buffer.bondFractureCount);
-		for (uint32_t b = 0; b < buffer.bondFractureCount; ++b)
-		{
-			bdata[b] = buffer.bondFractures[b];
-			result[buffer.bondFractures[b].health > 0 ? 0 : 1]++;
-		}
-	}
-
-	NvBlastChunkFractureData* cdata = nullptr;
-	if (buffer.chunkFractureCount > 0)
-	{
-		cdata = chunkBuffer.allocate(buffer.chunkFractureCount);
-		for (uint32_t c = 0; c < buffer.chunkFractureCount; ++c)
-		{
-			cdata[c] = buffer.chunkFractures[c];
-			result[buffer.chunkFractures[c].health > 0 ? 2 : 3]++;
-		}
-	}
-
-	TkFractureEvents* fevt = events.allocData<TkFractureEvents>();
-	fevt->tkActorData = *tkActor;
-	fevt->buffers = { buffer.bondFractureCount, buffer.chunkFractureCount, bdata, cdata };
-	fevt->bondsDamaged = result[0];
-	fevt->bondsBroken = result[1];
-	fevt->chunksDamaged = result[2];
-	fevt->chunksBroken = result[3];
-	events.addEvent(fevt);
-}
-
-
-void TkWorker::run()
-{
-	PERF_SCOPE_L("TkWorker Task");
-
-	NvBlastTimers* timers = nullptr;
-
-#if NV_PROFILE
-	NvBlastTimers myTimers;
-	timers = &myTimers;
-	NvBlastTimersReset(timers);
-	uint32_t jobCount = 0;
-	Time workTime;
-#endif
-
-	// temporary memory used to generate and apply fractures
-	// it must fit for the largest family involved in the group that owns this worker 
-	NvBlastBondFractureData* bondFractureData = m_group->m_bondTempDataBlock.getBlock(m_id);
-	uint32_t bondFractureCount = m_group->m_bondTempDataBlock.numElementsPerBlock();
-	NvBlastChunkFractureData* chunkFractureData = m_group->m_chunkTempDataBlock.getBlock(m_id);
-	uint32_t chunkFractureCount = m_group->m_chunkTempDataBlock.numElementsPerBlock();
-	const NvBlastFractureBuffers tempBuffer = { bondFractureCount, chunkFractureCount, bondFractureData, chunkFractureData };
-
-	// temporary memory used to split the actor
-	// large enough for the largest family involved
-	void* splitScratch = m_group->m_splitScratchBlock.getBlock(m_id);
-
-	// to avoid unnecessary allocations, preallocated memory exists to fit all chunks and bonds taking damage once
-	// where multiple damage occurs, more memory will be allocated on demand (this may thwart other threads doing the same)
-	m_bondBuffer.initialize(m_group->m_bondEventDataBlock.getBlock(m_id), m_group->m_bondEventDataBlock.numElementsPerBlock());
-	m_chunkBuffer.initialize(m_group->m_chunkEventDataBlock.getBlock(m_id), m_group->m_chunkEventDataBlock.numElementsPerBlock());
-
-	TkAtomicJobQueue& q = m_group->m_jobQueue;
-	TkWorkerJob* j;
-
-	while ((j = q.next()) != nullptr)
-	{
-		PERF_SCOPE_M("TkActor");
-
-		TkActorImpl* tkActor = j->m_tkActor;
-		const uint32_t tkActorIndex = tkActor->getIndex();
-		NvBlastActor* actorLL = tkActor->getActorLLInternal();
-		TkFamilyImpl& family = tkActor->getFamilyImpl();
-		SharedMemory* mem = m_group->getSharedMemory(&family);
-		TkEventQueue& events = mem->m_events;
-
-		NVBLAST_ASSERT(tkActor->getGroupImpl() == m_group);
-
-#if NV_PROFILE
-		*timers += tkActor->m_timers;
-		NvBlastTimersReset(&tkActor->m_timers);
-		jobCount++;
-#endif
-
-		// generate and apply fracture for all damage requested on this actor
-		// and queue events accordingly
-		for (const auto& damage : tkActor->m_damageBuffer)
-		{
-			NvBlastFractureBuffers commandBuffer = tempBuffer;
-
-			PERF_ZONE_BEGIN("Material");
-			damage.generateFracture(&commandBuffer, actorLL, timers);
-			PERF_ZONE_END("Material");
-
-			if (commandBuffer.chunkFractureCount > 0 || commandBuffer.bondFractureCount > 0)
-			{
-				PERF_SCOPE_M("Fill Command Events");
-				reportFractureCommands(commandBuffer, m_bondBuffer, m_chunkBuffer, events, tkActor);
-			}
-
-			NvBlastFractureBuffers eventBuffer = tempBuffer;
-
-			PERF_ZONE_BEGIN("Fracture");
-			NvBlastActorApplyFracture(&eventBuffer, actorLL, &commandBuffer, TkFrameworkImpl::get()->log, timers);
-			PERF_ZONE_END("Fracture");
-
-			if (eventBuffer.chunkFractureCount > 0 || eventBuffer.bondFractureCount > 0)
-			{
-				PERF_SCOPE_M("Fill Fracture Events");
-				tkActor->m_flags |= (TkActorFlag::DAMAGED);
-				reportFractureEvents(eventBuffer, m_bondBuffer, m_chunkBuffer, events, tkActor);
-			}
-		}
-
-
-		// split the actor, which could have been damaged directly though the TkActor's fracture functions
-		// i.e. it did not have damage queued for the above loop
-
-		NvBlastActorSplitEvent splitEvent = { nullptr, nullptr };
-		if (tkActor->isDamaged())
-		{
-			PERF_ZONE_BEGIN("Split Memory");
-			uint32_t maxActorCount = NvBlastActorGetMaxActorCountForSplit(actorLL, TkFrameworkImpl::get()->log); 
-			splitEvent.newActors = mem->reserveNewActors(maxActorCount);
-			PERF_ZONE_END("Split Memory");
-			PERF_ZONE_BEGIN("Split");
-			j->m_newActorsCount = NvBlastActorSplit(&splitEvent, actorLL, maxActorCount, splitScratch, TkFrameworkImpl::get()->log, timers);
-			PERF_ZONE_END("Split");
-
-			tkActor->m_flags.clear(TkActorFlag::DAMAGED);
-		}
-		else
-		{
-			j->m_newActorsCount = 0;
-		}
-
-
-		// update the TkActor according to the LL split results and queue events accordingly
-		if (j->m_newActorsCount > 0)
-		{
-			NVBLAST_ASSERT(splitEvent.deletedActor == tkActor->getActorLL());
-
-			PERF_ZONE_BEGIN("memory new actors");
-
-			auto tkSplitEvent = events.allocData<TkSplitEvent>();
-
-			tkSplitEvent->children = mem->reserveNewTkActors(j->m_newActorsCount);
-			tkSplitEvent->numChildren = j->m_newActorsCount;
-
-			tkSplitEvent->parentData.family = &family;
-			tkSplitEvent->parentData.userData = tkActor->userData;
-			tkSplitEvent->parentData.index = tkActorIndex;
-			family.removeActor(tkActor);
-
-			PERF_ZONE_END("memory new actors");
-
-
-			PERF_ZONE_BEGIN("create new actors");
-			for (uint32_t i = 0; i < j->m_newActorsCount; ++i)
-			{
-				TkActorImpl* newActor = family.addActor(splitEvent.newActors[i]);
-				tkSplitEvent->children[i] = newActor;
-			}
-			j->m_newActors = reinterpret_cast<TkActorImpl**>(tkSplitEvent->children);
-			PERF_ZONE_END("create new actors");
-
-			PERF_ZONE_BEGIN("split event");
-			events.addEvent(tkSplitEvent);
-			PERF_ZONE_END("split event");
-		}
-	}
-
-#if NV_PROFILE
-	PERF_ZONE_BEGIN("write timers");
-	m_stats.timers = *timers;
-	m_stats.processedActorsCount = jobCount;
-	m_stats.workerTime = workTime.getElapsedTicks();
-	PERF_ZONE_END("write timers");
-#endif
-}
-
-void TkWorker::release()
-{
-	m_group->m_sync.notify();
-}
diff --git a/NvBlast/sdk/toolkit/source/NvBlastTkTaskImpl.h b/NvBlast/sdk/toolkit/source/NvBlastTkTaskImpl.h
deleted file mode 100644
index 75f92f8..0000000
--- a/NvBlast/sdk/toolkit/source/NvBlastTkTaskImpl.h
+++ /dev/null
@@ -1,444 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTTKTASKIMPL_H
-#define NVBLASTTKTASKIMPL_H
-
-#include "NvBlast.h"
-
-#include "NvBlastTkFrameworkImpl.h"
-#include "NvBlastTkEventQueue.h"
-#include "NvBlastTkArray.h"
-
-#include <atomic>
-#include <mutex>
-#include <condition_variable>
-
-#include "task/PxTask.h"
-#include "NvBlastAssert.h"
-
-#include "NvBlastTkGroup.h" // TkGroupStats
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-class TkGroupImpl;
-class TkActorImpl;
-class TkFamilyImpl;
-
-
-/**
-Transient structure describing a job and its results.
-*/
-struct TkWorkerJob
-{
-	TkActorImpl*	m_tkActor;			//!< the actor to process
-	TkActorImpl**	m_newActors;		//!< list of child actors created by splitting
-	uint32_t		m_newActorsCount;	//!< the number of child actors created
-};
-
-
-/**
-Counting synchronization object for waiting on TkWorkers to finish.
-*/
-class TaskSync
-{
-public:
-	/**
-	Initializes with an expected number of notifications.
-	*/
-	TaskSync(uint32_t count) : m_count(count) {}
-
-	/**
-	Blocks until the expected number of notifications happened.
-	*/
-	void wait()
-	{
-		std::unique_lock<std::mutex> lk(m_mutex);
-		m_cv.wait(lk, [&]{ return m_count == 0; });
-	}
-
-	/**
-	Decrement the wait() count by one.
-	*/
-	void notify()
-	{
-		PERF_SCOPE_H("TaskSync::notify");
-		std::unique_lock<std::mutex> lk(m_mutex);
-		m_count--;
-		if (m_count == 0)
-		{
-			lk.unlock();
-			m_cv.notify_one();
-		}
-	}
-
-	/**
-	Peek if notifications are pending.
-	*/
-	bool isDone()
-	{
-		std::unique_lock<std::mutex> lk(m_mutex);
-		return m_count == 0;
-	}
-
-	/**
-	Sets the expected number of notifications for wait() to unblock.
-	*/
-	void setCount(uint32_t count)
-	{
-		m_count = count;
-	}
-
-private:
-	std::mutex				m_mutex;
-	std::condition_variable	m_cv;
-	uint32_t				m_count;
-};
-
-
-/**
-A list of equally sized memory blocks sharable between tasks.
-*/
-template<typename T>
-class SharedBlock
-{
-public:
-
-	SharedBlock() : m_numElementsPerBlock(0), m_numBlocks(0), m_buffer(nullptr) {}
-
-	/**
-	Allocates one large memory block of elementsPerBlock*numBlocks elements.
-	*/
-	void allocate(uint32_t elementsPerBlock, uint32_t numBlocks)
-	{
-		NVBLAST_ASSERT(elementsPerBlock > 0 && numBlocks > 0);
-
-		m_buffer = reinterpret_cast<T*>(NVBLASTTK_ALLOC(elementsPerBlock*numBlocks*sizeof(T), "SharedBlock"));
-		m_numElementsPerBlock = elementsPerBlock;
-		m_numBlocks = numBlocks;
-	}
-
-	/**
-	Returns the pointer to the first element of a block of numElementsPerBlock() elements.
-	*/
-	T* getBlock(uint32_t id)
-	{
-		NVBLAST_ASSERT(id < m_numBlocks || 0 == m_numElementsPerBlock);
-		return &m_buffer[id*m_numElementsPerBlock];
-	}
-
-	/**
-	The number of elements available per block.
-	*/
-	uint32_t numElementsPerBlock() const 
-	{
-		return m_numElementsPerBlock; 
-	}
-
-	/**
-	Frees the whole memory block.
-	*/
-	void release()
-	{
-		m_numBlocks = 0;
-		m_numElementsPerBlock = 0;
-		NVBLASTTK_FREE(m_buffer);
-		m_buffer = nullptr;
-	}
-
-private:
-	uint32_t	m_numElementsPerBlock;	//!< elements available in one block
-	uint32_t	m_numBlocks;			//!< number of virtual blocks available
-	T*			m_buffer;				//!< contiguous memory for all blocks
-};
-
-
-/**
-A preallocated, shared array from which can be allocated from in tasks.
-Intended to be used when the maximum amount of data (e.g. for a family) 
-is known in advance. No further allocations take place on exhaustion.
-Exhaustion asserts in debug builds and overflows otherwise.
-*/
-template<typename T>
-class SharedBuffer
-{
-public:
-	SharedBuffer() : m_capacity(0), m_used(0), m_buffer(nullptr) {}
-
-	/**
-	Atomically gets a pointer to the first element of an array of n elements.
-	*/
-	T* reserve(size_t n)
-	{
-		NVBLAST_ASSERT(m_used + n <= m_capacity);
-		size_t start = m_used.fetch_add(n);
-		return &m_buffer[start];
-	}
-
-	/**
-	Preallocates memory for capacity elements.
-	*/
-	void allocate(size_t capacity)
-	{
-		NVBLAST_ASSERT(m_buffer == nullptr);
-		m_buffer = reinterpret_cast<T*>(NVBLASTTK_ALLOC(capacity*sizeof(T), "SplitMemory"));
-		m_capacity = capacity;
-	}
-
-	/**
-	Preserves the memory allocated but resets to reserve from the beginning of the array.
-	*/
-	void reset()
-	{
-		m_used = 0;
-	}
-
-	/**
-	Frees the preallocated array.
-	*/
-	void release()
-	{
-		NVBLAST_ASSERT(m_buffer != nullptr);
-		NVBLASTTK_FREE(m_buffer);
-		m_buffer = nullptr;
-		m_capacity = m_used = 0;
-	}
-
-private:
-	size_t				m_capacity;	//!< available elements in the buffer
-	std::atomic<size_t>	m_used;		//!< used elements in the buffer
-	T*					m_buffer;	//!< the memory containing T's
-};
-
-
-/**
-Allocates from a preallocated, externally owned memory block initialized with.
-When blocks run out of space, new ones are allocated and owned by this class.
-*/
-template<typename T>
-class LocalBuffer
-{
-public:
-	/**
-	Returns the pointer to the first element of an array of n elements.
-	Allocates a new block of memory when exhausted, its size being the larger of n and capacity set with initialize().
-	*/
-	T* allocate(size_t n)
-	{
-		if (m_used + n > m_capacity)
-		{
-			allocateNewBlock(n > m_capacity ? n : m_capacity);
-		}
-
-		size_t index = m_used;
-		m_used += n;
-		return &m_currentBlock[index];
-	}
-
-	/**
-	Release the additionally allocated memory blocks.
-	The externally owned memory block remains untouched.
-	*/
-	void clear()
-	{
-		for (void* block : m_memoryBlocks)
-		{
-			NVBLASTTK_FREE(block);
-		}
-		m_memoryBlocks.clear();
-	}
-
-	/**
-	Set the externally owned memory block to start allocating from,
-	with a size of capacity elements.
-	*/
-	void initialize(T* block, size_t capacity)
-	{
-		m_currentBlock = block;
-		m_capacity = capacity;
-		m_used = 0;
-	}
-
-private:
-	/**
-	Allocates space for capacity elements.
-	*/
-	void allocateNewBlock(size_t capacity)
-	{
-		PERF_SCOPE_L("Local Buffer allocation");
-		m_capacity = capacity;
-		m_currentBlock = static_cast<T*>(NVBLASTTK_ALLOC(capacity*sizeof(T), "Blast LocalBuffer"));
-		m_memoryBlocks.pushBack(m_currentBlock);
-		m_used = 0;
-	}
-
-	TkInlineArray<void*, 4>::type	m_memoryBlocks; //!< storage for memory blocks
-	T*								m_currentBlock;	//!< memory block used to allocate from
-	size_t							m_used;			//!< elements used in current block
-	size_t							m_capacity;		//!< elements available in current block
-};
-
-
-/**
-Holds the memory used by TkWorker for each family in each group.
-*/
-class SharedMemory
-{
-public:
-	SharedMemory() : m_eventsMemory(0), m_eventsCount(0), m_refCount(0) {}
-
-	/**
-	Reserves n entries from preallocated memory.
-	*/
-	NvBlastActor** reserveNewActors(size_t n)
-	{
-		return m_newActorBuffers.reserve(n);
-	}
-
-	/**
-	Reserves n entries from preallocated memory.
-	*/
-	TkActor** reserveNewTkActors(size_t n)
-	{
-		return m_newTkActorBuffers.reserve(n);
-	}
-
-	/**
-	Allocates buffers to hold 
-	*/
-	void allocate(TkFamilyImpl&);
-
-	/**
-	Resets the internal buffers to reserve from their beginning.
-	Preserves the allocated memory.
-	*/
-	void reset()
-	{
-		m_newActorBuffers.reset();
-		m_newTkActorBuffers.reset();
-	}
-
-	/**
-	Increments the reference count.
-	*/
-	void addReference()			{ m_refCount++; }
-
-	/**
-	Increments the reference count by n.
-	*/
-	void addReference(size_t n) { m_refCount += n; }
-
-	/**
-	Decrements the reference count.
-	Returns true if the count reached zero.
-	*/
-	bool removeReference()
-	{
-		m_refCount--;
-		return !isUsed();
-	}
-
-	/**
-	Checks if the reference count is not zero. 
-	*/
-	bool isUsed()
-	{
-		return m_refCount > 0;
-	}
-
-	/**
-	Release the internal buffers' memory.
-	*/
-	void release()
-	{
-		m_newActorBuffers.release();
-		m_newTkActorBuffers.release();
-	}
-
-	TkEventQueue				m_events;				//!< event queue shared across a group's actors of the same family
-	uint32_t					m_eventsMemory;			//!< expected memory size for event data
-	uint32_t					m_eventsCount;			//!< expected number of events
-
-private:
-	size_t						m_refCount;				//!< helper for usage and releasing memory
-
-	SharedBuffer<NvBlastActor*>	m_newActorBuffers;		//!< memory for splitting
-	SharedBuffer<TkActor*>		m_newTkActorBuffers;	//!< memory for split events
-};
-
-
-/**
-Shared job queue from which TkWorkers atomically fetch the next job.
-*/
-template <typename T>
-class TkAtomicQueue
-{
-public:
-	/**
-	Initialize for a new batch of jobs.
-	*/
-	void init(TkWorkerJob* jobs, uint32_t numJobs)
-	{
-		m_jobs = jobs;
-		m_maxCount = numJobs;
-		m_current = 0;
-	}
-
-	/**
-	Fetch a pointer to the next job. Returns nullptr when exhausted.
-	*/
-	T* next()
-	{
-		size_t index = m_current.fetch_add(1, std::memory_order_relaxed);
-		if (index < m_maxCount)
-		{
-			return &m_jobs[index];
-		}
-		return nullptr;
-	}
-
-private:
-	T*					m_jobs;			//!< the list of jobs
-	size_t				m_maxCount;		//!< number of jobs available in the list
-	std::atomic<size_t>	m_current;		//!< current job counter
-};
-
-typedef TkAtomicQueue<TkWorkerJob> TkAtomicJobQueue;
-
-
-/**
-Thread worker fracturing and splitting actors sequentially.
-The list of actual jobs is provided by the group owning this worker.
-*/
-class TkWorker : public physx::PxLightCpuTask
-{
-public:
-	void		run();
-	void		release();
-	const char*	getName() const { return "TkWorker"; }
-
-	uint32_t								m_id;			//!< this worker's id
-	TkGroupImpl*							m_group;		//!< the group owning this worker
-
-	LocalBuffer<NvBlastChunkFractureData>	m_chunkBuffer;	//!< memory manager for chunk event data
-	LocalBuffer<NvBlastBondFractureData>	m_bondBuffer;	//!< memory manager for bonds event data
-
-#if NV_PROFILE
-	TkGroupStats	m_stats;
-#endif
-};
-}
-}
-
-#endif // NVBLASTTKTASKIMPL_H
diff --git a/NvBlast/sdk/toolkit/source/NvBlastTkTypeImpl.h b/NvBlast/sdk/toolkit/source/NvBlastTkTypeImpl.h
deleted file mode 100644
index a29c32f..0000000
--- a/NvBlast/sdk/toolkit/source/NvBlastTkTypeImpl.h
+++ /dev/null
@@ -1,174 +0,0 @@
-/*
-* Copyright (c) 2016-2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, related documentation
-* and any modifications thereto.  Any use, reproduction, disclosure or
-* distribution of this software and related documentation without an express
-* license agreement from NVIDIA CORPORATION is strictly prohibited.
-*/
-
-#ifndef NVBLASTTKTYPEIMPL_H
-#define NVBLASTTKTYPEIMPL_H
-
-
-#include "NvPreprocessor.h"
-
-#include "NvBlastTkType.h"
-
-
-// Forward declarations
-namespace physx
-{
-namespace general_PxIOStream2
-{
-class PxFileBuf;
-}
-}
-
-
-namespace Nv
-{
-namespace Blast
-{
-
-// Forward declarations
-class TkSerializable;
-
-
-// Serialization function signature
-typedef TkSerializable* (*TkDeserializeFn)(physx::general_PxIOStream2::PxFileBuf&, const NvBlastID& id);
-
-
-/**
-Implementation of TkType, storing class information for TkIdentifiable-derived classes.
-*/
-class TkTypeImpl : public TkType
-{
-public:
-	TkTypeImpl(const char* typeName, uint32_t typeID, uint32_t version, TkDeserializeFn deserializeFn);
-
-	// Begin TkType
-	virtual const char*	getName() const override { return getNameInternal(); }
-
-	virtual uint32_t	getVersion() const override { return getVersionInternal(); }
-	// End TkType
-
-	// Public methods
-
-	/**
-	Access to the class name.
-
-	\return a C string pointer to the class name.
-	*/
-	const char*			getNameInternal() const;
-
-	/**
-	Access to the data format version for the class (used if it TkSerializable-derived).
-
-	\return the data format version.
-	*/
-	uint32_t			getVersionInternal() const;
-
-	/**
-	Access to a unique identifier for the class (set using the NVBLASTTK_IMPL_DEFINE_IDENTIFIABLE or NVBLASTTK_IMPL_DEFINE_SERIALIZABLE macro).
-
-	\return the class's unique identifier.
-	*/
-	uint32_t			getID() const;
-
-	/**
-	\return the class's deserialization function.
-	*/
-	TkDeserializeFn		getDeserializeFn() const;
-
-	/**
-	Access to a runtime-unique small index for the class.
-
-	\return the index for the class.
-	*/
-	uint32_t			getIndex() const;
-
-	/**
-	\return whether or not the index has been set (see setIndex) to a valid value.
-	*/
-	bool				indexIsValid() const;
-
-private:
-	enum { InvalidIndex = 0xFFFFFFFF };
-
-	/**
-	Sets the type index.
-
-	\param[in]	index	The index to set.
-	*/
-	void				setIndex(uint32_t index);
-
-	const char*		m_name;				//!<	The name of the class, set by the constructor.
-	uint32_t		m_ID;				//!<	The unique identifier for the class, set by the constructor. 
-	uint32_t		m_version;			//!<	The data format version for the class, set by the constructor.
-	TkDeserializeFn	m_deserializeFn;	//!<	The class deserialization function, set by the constructor.
-	uint32_t		m_index;			//!<	The index set for this class, set using setIndex().
-
-	friend class TkFrameworkImpl;
-};
-
-
-//////// TkTypeImpl inline methods ////////
-
-NV_INLINE TkTypeImpl::TkTypeImpl(const char* typeName, uint32_t typeID, uint32_t version, TkDeserializeFn deserializeFn)
-	: m_name(typeName)
-	, m_ID(typeID)
-	, m_version(version)
-	, m_deserializeFn(deserializeFn)
-	, m_index((uint32_t)InvalidIndex)
-{
-}
-
-
-NV_INLINE const char* TkTypeImpl::getNameInternal() const
-{
-	return m_name;
-}
-
-
-NV_INLINE uint32_t TkTypeImpl::getVersionInternal() const
-{
-	return m_version;
-}
-
-
-NV_INLINE uint32_t TkTypeImpl::getID() const
-{
-	return m_ID;
-}
-
-
-NV_INLINE TkDeserializeFn TkTypeImpl::getDeserializeFn() const
-{
-	return m_deserializeFn;
-}
-
-
-NV_INLINE uint32_t TkTypeImpl::getIndex() const
-{
-	return m_index;
-}
-
-
-NV_INLINE bool TkTypeImpl::indexIsValid() const
-{
-	return m_index != (uint32_t)InvalidIndex;
-}
-
-
-NV_INLINE void TkTypeImpl::setIndex(uint32_t index)
-{
-	m_index = index;
-}
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif // ifndef NVBLASTTKTYPEIMPL_H