@bloomengine/engine 0.4.0 → 0.4.2

package/native/third_party/JoltPhysics/Jolt/AABBTree/AABBTreeBuilder.cpp

@@ -1,242 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#include <Jolt/Jolt.h>
-
-#include <Jolt/AABBTree/AABBTreeBuilder.h>
-
-JPH_NAMESPACE_BEGIN
-
-uint AABBTreeBuilder::Node::GetMinDepth(const Array<Node> &inNodes) const
-{
-	if (HasChildren())
-	{
-		uint left = inNodes[mChild[0]].GetMinDepth(inNodes);
-		uint right = inNodes[mChild[1]].GetMinDepth(inNodes);
-		return min(left, right) + 1;
-	}
-	else
-		return 1;
-}
-
-uint AABBTreeBuilder::Node::GetMaxDepth(const Array<Node> &inNodes) const
-{
-	if (HasChildren())
-	{
-		uint left = inNodes[mChild[0]].GetMaxDepth(inNodes);
-		uint right = inNodes[mChild[1]].GetMaxDepth(inNodes);
-		return max(left, right) + 1;
-	}
-	else
-		return 1;
-}
-
-uint AABBTreeBuilder::Node::GetNodeCount(const Array<Node> &inNodes) const
-{
-	if (HasChildren())
-		return inNodes[mChild[0]].GetNodeCount(inNodes) + inNodes[mChild[1]].GetNodeCount(inNodes) + 1;
-	else
-		return 1;
-}
-
-uint AABBTreeBuilder::Node::GetLeafNodeCount(const Array<Node> &inNodes) const
-{
-	if (HasChildren())
-		return inNodes[mChild[0]].GetLeafNodeCount(inNodes) + inNodes[mChild[1]].GetLeafNodeCount(inNodes);
-	else
-		return 1;
-}
-
-uint AABBTreeBuilder::Node::GetTriangleCountInTree(const Array<Node> &inNodes) const
-{
-	if (HasChildren())
-		return inNodes[mChild[0]].GetTriangleCountInTree(inNodes) + inNodes[mChild[1]].GetTriangleCountInTree(inNodes);
-	else
-		return GetTriangleCount();
-}
-
-void AABBTreeBuilder::Node::GetTriangleCountPerNode(const Array<Node> &inNodes, float &outAverage, uint &outMin, uint &outMax) const
-{
-	outMin = INT_MAX;
-	outMax = 0;
-	outAverage = 0;
-	uint avg_divisor = 0;
-	GetTriangleCountPerNodeInternal(inNodes, outAverage, avg_divisor, outMin, outMax);
-	if (avg_divisor > 0)
-		outAverage /= avg_divisor;
-}
-
-float AABBTreeBuilder::Node::CalculateSAHCost(const Array<Node> &inNodes, float inCostTraversal, float inCostLeaf) const
-{
-	float surface_area = mBounds.GetSurfaceArea();
-	return surface_area > 0.0f? CalculateSAHCostInternal(inNodes, inCostTraversal / surface_area, inCostLeaf / surface_area) : 0.0f;
-}
-
-void AABBTreeBuilder::Node::GetNChildren(const Array<Node> &inNodes, uint inN, Array<const Node*> &outChildren) const
-{
-	JPH_ASSERT(outChildren.empty());
-
-	// Check if there is anything to expand
-	if (!HasChildren())
-		return;
-
-	// Start with the children of this node
-	outChildren.push_back(&inNodes[mChild[0]]);
-	outChildren.push_back(&inNodes[mChild[1]]);
-
-	size_t next = 0;
-	bool all_triangles = true;
-	while (outChildren.size() < inN)
-	{
-		// If we have looped over all nodes, start over with the first node again
-		if (next >= outChildren.size())
-		{
-			// If there only triangle nodes left, we have to terminate
-			if (all_triangles)
-				return;
-			next = 0;
-			all_triangles = true;
-		}
-
-		// Try to expand this node into its two children
-		const Node *to_expand = outChildren[next];
-		if (to_expand->HasChildren())
-		{
-			outChildren.erase(outChildren.begin() + next);
-			outChildren.push_back(&inNodes[to_expand->mChild[0]]);
-			outChildren.push_back(&inNodes[to_expand->mChild[1]]);
-			all_triangles = false;
-		}
-		else
-		{
-			++next;
-		}
-	}
-}
-
-float AABBTreeBuilder::Node::CalculateSAHCostInternal(const Array<Node> &inNodes, float inCostTraversalDivSurfaceArea, float inCostLeafDivSurfaceArea) const
-{
-	if (HasChildren())
-		return inCostTraversalDivSurfaceArea * mBounds.GetSurfaceArea()
-			+ inNodes[mChild[0]].CalculateSAHCostInternal(inNodes, inCostTraversalDivSurfaceArea, inCostLeafDivSurfaceArea)
-			+ inNodes[mChild[1]].CalculateSAHCostInternal(inNodes, inCostTraversalDivSurfaceArea, inCostLeafDivSurfaceArea);
-	else
-		return inCostLeafDivSurfaceArea * mBounds.GetSurfaceArea() * GetTriangleCount();
-}
-
-void AABBTreeBuilder::Node::GetTriangleCountPerNodeInternal(const Array<Node> &inNodes, float &outAverage, uint &outAverageDivisor, uint &outMin, uint &outMax) const
-{
-	if (HasChildren())
-	{
-		inNodes[mChild[0]].GetTriangleCountPerNodeInternal(inNodes, outAverage, outAverageDivisor, outMin, outMax);
-		inNodes[mChild[1]].GetTriangleCountPerNodeInternal(inNodes, outAverage, outAverageDivisor, outMin, outMax);
-	}
-	else
-	{
-		outAverage += GetTriangleCount();
-		outAverageDivisor++;
-		outMin = min(outMin, GetTriangleCount());
-		outMax = max(outMax, GetTriangleCount());
-	}
-}
-
-AABBTreeBuilder::AABBTreeBuilder(TriangleSplitter &inSplitter, uint inMaxTrianglesPerLeaf) :
-	mTriangleSplitter(inSplitter),
-	mMaxTrianglesPerLeaf(inMaxTrianglesPerLeaf)
-{
-}
-
-AABBTreeBuilder::Node *AABBTreeBuilder::Build(AABBTreeBuilderStats &outStats)
-{
-	TriangleSplitter::Range initial = mTriangleSplitter.GetInitialRange();
-
-	// Worst case for number of nodes: 1 leaf node per triangle. At each level above, the number of nodes is half that of the level below.
-	// This means that at most we'll be allocating 2x the number of triangles in nodes.
-	mNodes.reserve(2 * initial.Count());
-	mTriangles.reserve(initial.Count());
-
-	// Build the tree
-	Node &root = mNodes[BuildInternal(initial)];
-
-	// Collect stats
-	float avg_triangles_per_leaf;
-	uint min_triangles_per_leaf, max_triangles_per_leaf;
-	root.GetTriangleCountPerNode(mNodes, avg_triangles_per_leaf, min_triangles_per_leaf, max_triangles_per_leaf);
-
-	mTriangleSplitter.GetStats(outStats.mSplitterStats);
-
-	outStats.mSAHCost = root.CalculateSAHCost(mNodes, 1.0f, 1.0f);
-	outStats.mMinDepth = root.GetMinDepth(mNodes);
-	outStats.mMaxDepth = root.GetMaxDepth(mNodes);
-	outStats.mNodeCount = root.GetNodeCount(mNodes);
-	outStats.mLeafNodeCount = root.GetLeafNodeCount(mNodes);
-	outStats.mMaxTrianglesPerLeaf = mMaxTrianglesPerLeaf;
-	outStats.mTreeMinTrianglesPerLeaf = min_triangles_per_leaf;
-	outStats.mTreeMaxTrianglesPerLeaf = max_triangles_per_leaf;
-	outStats.mTreeAvgTrianglesPerLeaf = avg_triangles_per_leaf;
-
-	return &root;
-}
-
-uint AABBTreeBuilder::BuildInternal(const TriangleSplitter::Range &inTriangles)
-{
-	// Check if there are too many triangles left
-	if (inTriangles.Count() > mMaxTrianglesPerLeaf)
-	{
-		// Split triangles in two batches
-		TriangleSplitter::Range left, right;
-		if (!mTriangleSplitter.Split(inTriangles, left, right))
-		{
-			// When the trace below triggers:
-			//
-			// This code builds a tree structure to accelerate collision detection.
-			// At top level it will start with all triangles in a mesh and then divides the triangles into two batches.
-			// This process repeats until until the batch size is smaller than mMaxTrianglePerLeaf.
-			//
-			// It uses a TriangleSplitter to find a good split. When this warning triggers, the splitter was not able
-			// to create a reasonable split for the triangles. This usually happens when the triangles in a batch are
-			// intersecting. They could also be overlapping when projected on the 3 coordinate axis.
-			//
-			// To solve this issue, you could try to pass your mesh through a mesh cleaning / optimization algorithm.
-			// You could also inspect the triangles that cause this issue and see if that part of the mesh can be fixed manually.
-			//
-			// When you do not fix this warning, the tree will be less efficient for collision detection, but it will still work.
-			JPH_IF_DEBUG(Trace("AABBTreeBuilder: Doing random split for %d triangles (max per node: %u)!", (int)inTriangles.Count(), mMaxTrianglesPerLeaf);)
-			int half = inTriangles.Count() / 2;
-			JPH_ASSERT(half > 0);
-			left = TriangleSplitter::Range(inTriangles.mBegin, inTriangles.mBegin + half);
-			right = TriangleSplitter::Range(inTriangles.mBegin + half, inTriangles.mEnd);
-		}
-
-		// Recursively build
-		const uint node_index = (uint)mNodes.size();
-		mNodes.push_back(Node());
-		uint left_index = BuildInternal(left);
-		uint right_index = BuildInternal(right);
-		Node &node = mNodes[node_index];
-		node.mChild[0] = left_index;
-		node.mChild[1] = right_index;
-		node.mBounds = mNodes[node.mChild[0]].mBounds;
-		node.mBounds.Encapsulate(mNodes[node.mChild[1]].mBounds);
-		return node_index;
-	}
-
-	// Create leaf node
-	const uint node_index = (uint)mNodes.size();
-	mNodes.push_back(Node());
-	Node &node = mNodes.back();
-	node.mTrianglesBegin = (uint)mTriangles.size();
-	node.mNumTriangles = inTriangles.mEnd - inTriangles.mBegin;
-	const VertexList &v = mTriangleSplitter.GetVertices();
-	for (uint i = inTriangles.mBegin; i < inTriangles.mEnd; ++i)
-	{
-		const IndexedTriangle &t = mTriangleSplitter.GetTriangle(i);
-		mTriangles.push_back(t);
-		node.mBounds.Encapsulate(v, t);
-	}
-
-	return node_index;
-}
-
-JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/AABBTree/AABBTreeBuilder.h

@@ -1,121 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/TriangleSplitter/TriangleSplitter.h>
-#include <Jolt/Geometry/AABox.h>
-#include <Jolt/Core/NonCopyable.h>
-
-JPH_NAMESPACE_BEGIN
-
-struct AABBTreeBuilderStats
-{
-	///@name Splitter stats
-	TriangleSplitter::Stats	mSplitterStats;							///< Stats returned by the triangle splitter algorithm
-
-	///@name Tree structure
-	float					mSAHCost = 0.0f;						///< Surface Area Heuristic cost of this tree
-	int						mMinDepth = 0;							///< Minimal depth of tree (number of nodes)
-	int						mMaxDepth = 0;							///< Maximum depth of tree (number of nodes)
-	int						mNodeCount = 0;							///< Number of nodes in the tree
-	int						mLeafNodeCount = 0;						///< Number of leaf nodes (that contain triangles)
-
-	///@name Configured stats
-	int						mMaxTrianglesPerLeaf = 0;				///< Configured max triangles per leaf
-
-	///@name Actual stats
-	int						mTreeMinTrianglesPerLeaf = 0;			///< Minimal amount of triangles in a leaf
-	int						mTreeMaxTrianglesPerLeaf = 0;			///< Maximal amount of triangles in a leaf
-	float					mTreeAvgTrianglesPerLeaf = 0.0f;		///< Average amount of triangles in leaf nodes
-};
-
-/// Helper class to build an AABB tree
-class JPH_EXPORT AABBTreeBuilder
-{
-public:
-	/// A node in the tree, contains the AABox for the tree and any child nodes or triangles
-	class Node
-	{
-	public:
-		JPH_OVERRIDE_NEW_DELETE
-
-		/// Indicates that there is no child
-		static constexpr uint cInvalidNodeIndex = ~uint(0);
-
-		/// Get number of triangles in this node
-		inline uint			GetTriangleCount() const				{ return mNumTriangles; }
-
-		/// Check if this node has any children
-		inline bool			HasChildren() const						{ return mChild[0] != cInvalidNodeIndex || mChild[1] != cInvalidNodeIndex; }
-
-		/// Get child node
-		inline const Node * GetChild(uint inIdx, const Array<Node> &inNodes) const { return mChild[inIdx] != cInvalidNodeIndex? &inNodes[mChild[inIdx]] : nullptr; }
-
-		/// Min depth of tree
-		uint				GetMinDepth(const Array<Node> &inNodes) const;
-
-		/// Max depth of tree
-		uint				GetMaxDepth(const Array<Node> &inNodes) const;
-
-		/// Number of nodes in tree
-		uint				GetNodeCount(const Array<Node> &inNodes) const;
-
-		/// Number of leaf nodes in tree
-		uint				GetLeafNodeCount(const Array<Node> &inNodes) const;
-
-		/// Get triangle count in tree
-		uint				GetTriangleCountInTree(const Array<Node> &inNodes) const;
-
-		/// Calculate min and max triangles per node
-		void				GetTriangleCountPerNode(const Array<Node> &inNodes, float &outAverage, uint &outMin, uint &outMax) const;
-
-		/// Calculate the total cost of the tree using the surface area heuristic
-		float				CalculateSAHCost(const Array<Node> &inNodes, float inCostTraversal, float inCostLeaf) const;
-
-		/// Recursively get children (breadth first) to get in total inN children (or less if there are no more)
-		void				GetNChildren(const Array<Node> &inNodes, uint inN, Array<const Node *> &outChildren) const;
-
-		/// Bounding box
-		AABox				mBounds;
-
-		/// Triangles (if no child nodes)
-		uint				mTrianglesBegin; // Index into mTriangles
-		uint				mNumTriangles = 0;
-
-		/// Child node indices (if no triangles)
-		uint				mChild[2] = { cInvalidNodeIndex, cInvalidNodeIndex };
-
-	private:
-		friend class AABBTreeBuilder;
-
-		/// Recursive helper function to calculate cost of the tree
-		float				CalculateSAHCostInternal(const Array<Node> &inNodes, float inCostTraversalDivSurfaceArea, float inCostLeafDivSurfaceArea) const;
-
-		/// Recursive helper function to calculate min and max triangles per node
-		void				GetTriangleCountPerNodeInternal(const Array<Node> &inNodes, float &outAverage, uint &outAverageDivisor, uint &outMin, uint &outMax) const;
-	};
-
-	/// Constructor
-	explicit				AABBTreeBuilder(TriangleSplitter &inSplitter, uint inMaxTrianglesPerLeaf = 16);
-
-	/// Recursively build tree, returns the root node of the tree
-	Node *					Build(AABBTreeBuilderStats &outStats);
-
-	/// Get all nodes
-	const Array<Node> &		GetNodes() const						{ return mNodes; }
-
-	/// Get all triangles
-	const Array<IndexedTriangle> &GetTriangles() const				{ return mTriangles; }
-
-private:
-	uint					BuildInternal(const TriangleSplitter::Range &inTriangles);
-
-	TriangleSplitter &		mTriangleSplitter;
-	const uint				mMaxTrianglesPerLeaf;
-	Array<Node>				mNodes;
-	Array<IndexedTriangle>	mTriangles;
-};
-
-JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/AABBTree/AABBTreeToBuffer.h

@@ -1,296 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/AABBTree/AABBTreeBuilder.h>
-#include <Jolt/Core/ByteBuffer.h>
-#include <Jolt/Geometry/IndexedTriangle.h>
-
-JPH_NAMESPACE_BEGIN
-
-/// Conversion algorithm that converts an AABB tree to an optimized binary buffer
-template <class TriangleCodec, class NodeCodec>
-class AABBTreeToBuffer
-{
-public:
-	/// Header for the tree
-	using NodeHeader = typename NodeCodec::Header;
-
-	/// Size in bytes of the header of the tree
-	static const int HeaderSize = NodeCodec::HeaderSize;
-
-	/// Maximum number of children per node in the tree
-	static const int NumChildrenPerNode = NodeCodec::NumChildrenPerNode;
-
-	/// Header for the triangles
-	using TriangleHeader = typename TriangleCodec::TriangleHeader;
-
-	/// Size in bytes of the header for the triangles
-	static const int TriangleHeaderSize = TriangleCodec::TriangleHeaderSize;
-
-	/// Convert AABB tree. Returns false if failed.
-	bool							Convert(const Array<IndexedTriangle> &inTriangles, const Array<AABBTreeBuilder::Node> &inNodes, const VertexList &inVertices, const AABBTreeBuilder::Node *inRoot, bool inStoreUserData, const char *&outError)
-	{
-		typename NodeCodec::EncodingContext node_ctx;
-		typename TriangleCodec::EncodingContext tri_ctx(inVertices);
-
-		// Child nodes out of loop so we don't constantly realloc it
-		Array<const AABBTreeBuilder::Node *> child_nodes;
-		child_nodes.reserve(NumChildrenPerNode);
-
-		// First calculate how big the tree is going to be.
-		// Since the tree can be huge for very large meshes, we don't want
-		// to reallocate the buffer as it may cause out of memory situations.
-		// This loop mimics the construction loop below.
-		uint64 total_size = HeaderSize + TriangleHeaderSize;
-		size_t node_count = 1; // Start with root node
-		size_t to_process_max_size = 1; // Track size of queues so we can do a single reserve below
-		size_t to_process_triangles_max_size = 0;
-		{	// A scope to free the memory associated with to_estimate and to_estimate_triangles
-			Array<const AABBTreeBuilder::Node *> to_estimate;
-			Array<const AABBTreeBuilder::Node *> to_estimate_triangles;
-			to_estimate.push_back(inRoot);
-			for (;;)
-			{
-				while (!to_estimate.empty())
-				{
-					// Get the next node to process
-					const AABBTreeBuilder::Node *node = to_estimate.back();
-					to_estimate.pop_back();
-
-					// Update total size
-					node_ctx.PrepareNodeAllocate(node, total_size);
-
-					if (node->HasChildren())
-					{
-						// Collect the first NumChildrenPerNode sub-nodes in the tree
-						child_nodes.clear(); // Won't free the memory
-						node->GetNChildren(inNodes, NumChildrenPerNode, child_nodes);
-
-						// Increment the number of nodes we're going to store
-						node_count += child_nodes.size();
-
-						// Insert in reverse order so we estimate left child first when taking nodes from the back
-						for (int idx = int(child_nodes.size()) - 1; idx >= 0; --idx)
-						{
-							// Store triangles in separate list so we process them last
-							const AABBTreeBuilder::Node *child = child_nodes[idx];
-							if (child->HasChildren())
-							{
-								to_estimate.push_back(child);
-								to_process_max_size = max(to_estimate.size(), to_process_max_size);
-							}
-							else
-							{
-								to_estimate_triangles.push_back(child);
-								to_process_triangles_max_size = max(to_estimate_triangles.size(), to_process_triangles_max_size);
-							}
-						}
-					}
-					else
-					{
-						// Update total size
-						tri_ctx.PreparePack(&inTriangles[node->mTrianglesBegin], node->mNumTriangles, inStoreUserData, total_size);
-					}
-				}
-
-				// If we've got triangles to estimate, loop again with just the triangles
-				if (to_estimate_triangles.empty())
-					break;
-				else
-					to_estimate.swap(to_estimate_triangles);
-			}
-		}
-
-		// Finalize the prepare stage for the triangle context
-		tri_ctx.FinalizePreparePack(total_size);
-
-		// Reserve the buffer
-		if (size_t(total_size) != total_size)
-		{
-			outError = "AABBTreeToBuffer: Out of memory!";
-			return false;
-		}
-		mTree.reserve(size_t(total_size));
-
-		// Add headers
-		NodeHeader *header = HeaderSize > 0? mTree.Allocate<NodeHeader>() : nullptr;
-		TriangleHeader *triangle_header = TriangleHeaderSize > 0? mTree.Allocate<TriangleHeader>() : nullptr;
-
-		struct NodeData
-		{
-			const AABBTreeBuilder::Node *	mNode = nullptr;							// Node that this entry belongs to
-			Vec3							mNodeBoundsMin;								// Quantized node bounds
-			Vec3							mNodeBoundsMax;
-			size_t							mNodeStart = size_t(-1);					// Start of node in mTree
-			size_t							mTriangleStart = size_t(-1);				// Start of the triangle data in mTree
-			size_t							mChildNodeStart[NumChildrenPerNode];		// Start of the children of the node in mTree
-			size_t							mChildTrianglesStart[NumChildrenPerNode];	// Start of the triangle data in mTree
-			size_t *						mParentChildNodeStart = nullptr;			// Where to store mNodeStart (to patch mChildNodeStart of my parent)
-			size_t *						mParentTrianglesStart = nullptr;			// Where to store mTriangleStart (to patch mChildTrianglesStart of my parent)
-			uint							mNumChildren = 0;							// Number of children
-		};
-
-		Array<NodeData *> to_process;
-		to_process.reserve(to_process_max_size);
-		Array<NodeData *> to_process_triangles;
-		to_process_triangles.reserve(to_process_triangles_max_size);
-		Array<NodeData> node_list;
-		node_list.reserve(node_count); // Needed to ensure that array is not reallocated, so we can keep pointers in the array
-
-		NodeData root;
-		root.mNode = inRoot;
-		root.mNodeBoundsMin = inRoot->mBounds.mMin;
-		root.mNodeBoundsMax = inRoot->mBounds.mMax;
-		node_list.push_back(root);
-		to_process.push_back(&node_list.back());
-
-		for (;;)
-		{
-			while (!to_process.empty())
-			{
-				// Get the next node to process
-				NodeData *node_data = to_process.back();
-				to_process.pop_back();
-
-				// Due to quantization box could have become bigger, not smaller
-				JPH_ASSERT(AABox(node_data->mNodeBoundsMin, node_data->mNodeBoundsMax).Contains(node_data->mNode->mBounds), "AABBTreeToBuffer: Bounding box became smaller!");
-
-				// Collect the first NumChildrenPerNode sub-nodes in the tree
-				child_nodes.clear(); // Won't free the memory
-				node_data->mNode->GetNChildren(inNodes, NumChildrenPerNode, child_nodes);
-				node_data->mNumChildren = (uint)child_nodes.size();
-
-				// Fill in default child bounds
-				Vec3 child_bounds_min[NumChildrenPerNode], child_bounds_max[NumChildrenPerNode];
-				for (size_t i = 0; i < NumChildrenPerNode; ++i)
-					if (i < child_nodes.size())
-					{
-						child_bounds_min[i] = child_nodes[i]->mBounds.mMin;
-						child_bounds_max[i] = child_nodes[i]->mBounds.mMax;
-					}
-					else
-					{
-						child_bounds_min[i] = Vec3::sZero();
-						child_bounds_max[i] = Vec3::sZero();
-					}
-
-				// Start a new node
-				node_data->mNodeStart = node_ctx.NodeAllocate(node_data->mNode, node_data->mNodeBoundsMin, node_data->mNodeBoundsMax, child_nodes, child_bounds_min, child_bounds_max, mTree, outError);
-				if (node_data->mNodeStart == size_t(-1))
-					return false;
-
-				if (node_data->mNode->HasChildren())
-				{
-					// Insert in reverse order so we process left child first when taking nodes from the back
-					for (int idx = int(child_nodes.size()) - 1; idx >= 0; --idx)
-					{
-						const AABBTreeBuilder::Node *child_node = child_nodes[idx];
-
-						// Due to quantization box could have become bigger, not smaller
-						JPH_ASSERT(AABox(child_bounds_min[idx], child_bounds_max[idx]).Contains(child_node->mBounds), "AABBTreeToBuffer: Bounding box became smaller!");
-
-						// Add child to list of nodes to be processed
-						NodeData child;
-						child.mNode = child_node;
-						child.mNodeBoundsMin = child_bounds_min[idx];
-						child.mNodeBoundsMax = child_bounds_max[idx];
-						child.mParentChildNodeStart = &node_data->mChildNodeStart[idx];
-						child.mParentTrianglesStart = &node_data->mChildTrianglesStart[idx];
-						node_list.push_back(child);
-
-						// Store triangles in separate list so we process them last
-						if (child_node->HasChildren())
-							to_process.push_back(&node_list.back());
-						else
-							to_process_triangles.push_back(&node_list.back());
-					}
-				}
-				else
-				{
-					// Add triangles
-					node_data->mTriangleStart = tri_ctx.Pack(&inTriangles[node_data->mNode->mTrianglesBegin], node_data->mNode->mNumTriangles, inStoreUserData, mTree, outError);
-					if (node_data->mTriangleStart == size_t(-1))
-						return false;
-				}
-
-				// Patch offset into parent
-				if (node_data->mParentChildNodeStart != nullptr)
-				{
-					*node_data->mParentChildNodeStart = node_data->mNodeStart;
-					*node_data->mParentTrianglesStart = node_data->mTriangleStart;
-				}
-			}
-
-			// If we've got triangles to process, loop again with just the triangles
-			if (to_process_triangles.empty())
-				break;
-			else
-				to_process.swap(to_process_triangles);
-		}
-
-		// Assert that our reservation was correct (we don't know if we swapped the arrays or not)
-		JPH_ASSERT(to_process_max_size == to_process.capacity() || to_process_triangles_max_size == to_process.capacity());
-		JPH_ASSERT(to_process_max_size == to_process_triangles.capacity() || to_process_triangles_max_size == to_process_triangles.capacity());
-
-		// Finalize all nodes
-		for (NodeData &n : node_list)
-			if (!node_ctx.NodeFinalize(n.mNode, n.mNodeStart, n.mNumChildren, n.mChildNodeStart, n.mChildTrianglesStart, mTree, outError))
-				return false;
-
-		// Finalize the triangles
-		tri_ctx.Finalize(inVertices, triangle_header, mTree);
-
-		// Validate that our reservations were correct
-		if (node_count != node_list.size())
-		{
-			outError = "Internal Error: Node memory estimate was incorrect, memory corruption!";
-			return false;
-		}
-		if (total_size != mTree.size())
-		{
-			outError = "Internal Error: Tree memory estimate was incorrect, memory corruption!";
-			return false;
-		}
-
-		// Finalize the nodes
-		return node_ctx.Finalize(header, inRoot, node_list[0].mNodeStart, node_list[0].mTriangleStart, outError);
-	}
-
-	/// Get resulting data
-	inline const ByteBuffer &		GetBuffer() const
-	{
-		return mTree;
-	}
-
-	/// Get resulting data
-	inline ByteBuffer &				GetBuffer()
-	{
-		return mTree;
-	}
-
-	/// Get header for tree
-	inline const NodeHeader *		GetNodeHeader() const
-	{
-		return mTree.Get<NodeHeader>(0);
-	}
-
-	/// Get header for triangles
-	inline const TriangleHeader *	GetTriangleHeader() const
-	{
-		return mTree.Get<TriangleHeader>(HeaderSize);
-	}
-
-	/// Get root of resulting tree
-	inline const void *				GetRoot() const
-	{
-		return mTree.Get<void>(HeaderSize + TriangleHeaderSize);
-	}
-
-private:
-	ByteBuffer						mTree;									///< Resulting tree structure
-};
-
-JPH_NAMESPACE_END