From c01469dddabe404506ef3a64542e8423f9e11f2c Mon Sep 17 00:00:00 2001
From: Aki <please@ignore.pl>
Date: Sun, 30 Jan 2022 17:44:05 +0100
Subject: Converted Opcode and Ice into unix newlines format

---
 Opcode/OPC_TreeBuilders.cpp | 510 ++++++++++++++++++++++----------------------
 1 file changed, 255 insertions(+), 255 deletions(-)

(limited to 'Opcode/OPC_TreeBuilders.cpp')

diff --git a/Opcode/OPC_TreeBuilders.cpp b/Opcode/OPC_TreeBuilders.cpp
index 600f08b..89dd93b 100644
--- a/Opcode/OPC_TreeBuilders.cpp
+++ b/Opcode/OPC_TreeBuilders.cpp
@@ -1,255 +1,255 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- *	OPCODE - Optimized Collision Detection
- *	Copyright (C) 2001 Pierre Terdiman
- *	Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- *	Contains code for tree builders.
- *	\file		OPC_TreeBuilders.cpp
- *	\author		Pierre Terdiman
- *	\date		March, 20, 2001
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- *	A builder for AABB-trees of vertices.
- *
- *	\class		AABBTreeOfVerticesBuilder
- *	\author		Pierre Terdiman
- *	\version	1.3
- *	\date		March, 20, 2001
-*/
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- *	A builder for AABB-trees of AABBs.
- *
- *	\class		AABBTreeOfAABBsBuilder
- *	\author		Pierre Terdiman
- *	\version	1.3
- *	\date		March, 20, 2001
-*/
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- *	A builder for AABB-trees of triangles.
- *
- *	\class		AABBTreeOfTrianglesBuilder
- *	\author		Pierre Terdiman
- *	\version	1.3
- *	\date		March, 20, 2001
-*/
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Precompiled Header
-#include "StdAfx.h"
-
-using namespace Opcode;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- *	Computes the AABB of a set of primitives.
- *	\param		primitives		[in] list of indices of primitives
- *	\param		nb_prims		[in] number of indices
- *	\param		global_box		[out] global AABB enclosing the set of input primitives
- *	\return		true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABBTreeOfAABBsBuilder::ComputeGlobalBox(const udword* primitives, udword nb_prims, AABB& global_box) const
-{
-	// Checkings
-	if(!primitives || !nb_prims)	return false;
-
-	// Initialize global box
-	global_box = mAABBArray[primitives[0]];
-
-	// Loop through boxes
-	for(udword i=1;i<nb_prims;i++)
-	{
-		// Update global box
-		global_box.Add(mAABBArray[primitives[i]]);
-	}
-	return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- *	Computes the splitting value along a given axis for a given primitive.
- *	\param		index		[in] index of the primitive to split
- *	\param		axis		[in] axis index (0,1,2)
- *	\return		splitting value
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-float AABBTreeOfAABBsBuilder::GetSplittingValue(udword index, udword axis) const
-{
-	// For an AABB, the splitting value is the middle of the given axis,
-	// i.e. the corresponding component of the center IcePoint
-	return mAABBArray[index].GetCenter(axis);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- *	Computes the AABB of a set of primitives.
- *	\param		primitives		[in] list of indices of primitives
- *	\param		nb_prims		[in] number of indices
- *	\param		global_box		[out] global AABB enclosing the set of input primitives
- *	\return		true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABBTreeOfTrianglesBuilder::ComputeGlobalBox(const udword* primitives, udword nb_prims, AABB& global_box) const
-{
-	// Checkings
-	if(!primitives || !nb_prims)	return false;
-
-	// Initialize global box
-	IcePoint Min(MAX_FLOAT, MAX_FLOAT, MAX_FLOAT);
-	IcePoint Max(MIN_FLOAT, MIN_FLOAT, MIN_FLOAT);
-
-	// Loop through triangles
-	VertexPointers VP;
-	while(nb_prims--)
-	{
-		// Get current triangle-vertices
-		mIMesh->GetTriangle(VP, *primitives++);
-		// Update global box
-		Min.Min(*VP.Vertex[0]).Min(*VP.Vertex[1]).Min(*VP.Vertex[2]);
-		Max.Max(*VP.Vertex[0]).Max(*VP.Vertex[1]).Max(*VP.Vertex[2]);
-	}
-	global_box.SetMinMax(Min, Max);
-	return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- *	Computes the splitting value along a given axis for a given primitive.
- *	\param		index		[in] index of the primitive to split
- *	\param		axis		[in] axis index (0,1,2)
- *	\return		splitting value
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-float AABBTreeOfTrianglesBuilder::GetSplittingValue(udword index, udword axis) const
-{
-/*	// Compute center of triangle
-	IcePoint Center;
-	mTriList[index].Center(mVerts, Center);
-	// Return value
-	return Center[axis];*/
-
-	// Compute correct component from center of triangle
-//	return	(mVerts[mTriList[index].mVRef[0]][axis]
-//			+mVerts[mTriList[index].mVRef[1]][axis]
-//			+mVerts[mTriList[index].mVRef[2]][axis])*INV3;
-
-	VertexPointers VP;
-	mIMesh->GetTriangle(VP, index);
-
-	// Compute correct component from center of triangle
-	return	((*VP.Vertex[0])[axis]
-			+(*VP.Vertex[1])[axis]
-			+(*VP.Vertex[2])[axis])*INV3;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- *	Computes the splitting value along a given axis for a given node.
- *	\param		primitives		[in] list of indices of primitives
- *	\param		nb_prims		[in] number of indices
- *	\param		global_box		[in] global AABB enclosing the set of input primitives
- *	\param		axis			[in] axis index (0,1,2)
- *	\return		splitting value
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-float AABBTreeOfTrianglesBuilder::GetSplittingValue(const udword* primitives, udword nb_prims, const AABB& global_box, udword axis)	const
-{
-	if(mSettings.mRules&SPLIT_GEOM_CENTER)
-	{
-		// Loop through triangles
-		float SplitValue = 0.0f;
-		VertexPointers VP;
-		for(udword i=0;i<nb_prims;i++)
-		{
-			// Get current triangle-vertices
-			mIMesh->GetTriangle(VP, primitives[i]);
-			// Update split value
-			SplitValue += (*VP.Vertex[0])[axis];
-			SplitValue += (*VP.Vertex[1])[axis];
-			SplitValue += (*VP.Vertex[2])[axis];
-		}
-		return SplitValue / float(nb_prims*3);
-	}
-	else return AABBTreeBuilder::GetSplittingValue(primitives, nb_prims, global_box, axis);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- *	Computes the AABB of a set of primitives.
- *	\param		primitives		[in] list of indices of primitives
- *	\param		nb_prims		[in] number of indices
- *	\param		global_box		[out] global AABB enclosing the set of input primitives
- *	\return		true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABBTreeOfVerticesBuilder::ComputeGlobalBox(const udword* primitives, udword nb_prims, AABB& global_box) const
-{
-	// Checkings
-	if(!primitives || !nb_prims)	return false;
-
-	// Initialize global box
-	global_box.SetEmpty();
-
-	// Loop through vertices
-	for(udword i=0;i<nb_prims;i++)
-	{
-		// Update global box
-		global_box.Extend(mVertexArray[primitives[i]]);
-	}
-	return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- *	Computes the splitting value along a given axis for a given primitive.
- *	\param		index		[in] index of the primitive to split
- *	\param		axis		[in] axis index (0,1,2)
- *	\return		splitting value
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-float AABBTreeOfVerticesBuilder::GetSplittingValue(udword index, udword axis) const
-{
-	// For a vertex, the splitting value is simply the vertex coordinate.
-	return mVertexArray[index][axis];
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- *	Computes the splitting value along a given axis for a given node.
- *	\param		primitives		[in] list of indices of primitives
- *	\param		nb_prims		[in] number of indices
- *	\param		global_box		[in] global AABB enclosing the set of input primitives
- *	\param		axis			[in] axis index (0,1,2)
- *	\return		splitting value
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-float AABBTreeOfVerticesBuilder::GetSplittingValue(const udword* primitives, udword nb_prims, const AABB& global_box, udword axis)	const
-{
-	if(mSettings.mRules&SPLIT_GEOM_CENTER)
-	{
-		// Loop through vertices
-		float SplitValue = 0.0f;
-		for(udword i=0;i<nb_prims;i++)
-		{
-			// Update split value
-			SplitValue += mVertexArray[primitives[i]][axis];
-		}
-		return SplitValue / float(nb_prims);
-	}
-	else return AABBTreeBuilder::GetSplittingValue(primitives, nb_prims, global_box, axis);
-}
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/*
+ *	OPCODE - Optimized Collision Detection
+ *	Copyright (C) 2001 Pierre Terdiman
+ *	Homepage: http://www.codercorner.com/Opcode.htm
+ */
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ *	Contains code for tree builders.
+ *	\file		OPC_TreeBuilders.cpp
+ *	\author		Pierre Terdiman
+ *	\date		March, 20, 2001
+ */
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ *	A builder for AABB-trees of vertices.
+ *
+ *	\class		AABBTreeOfVerticesBuilder
+ *	\author		Pierre Terdiman
+ *	\version	1.3
+ *	\date		March, 20, 2001
+*/
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ *	A builder for AABB-trees of AABBs.
+ *
+ *	\class		AABBTreeOfAABBsBuilder
+ *	\author		Pierre Terdiman
+ *	\version	1.3
+ *	\date		March, 20, 2001
+*/
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ *	A builder for AABB-trees of triangles.
+ *
+ *	\class		AABBTreeOfTrianglesBuilder
+ *	\author		Pierre Terdiman
+ *	\version	1.3
+ *	\date		March, 20, 2001
+*/
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Precompiled Header
+#include "StdAfx.h"
+
+using namespace Opcode;
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ *	Computes the AABB of a set of primitives.
+ *	\param		primitives		[in] list of indices of primitives
+ *	\param		nb_prims		[in] number of indices
+ *	\param		global_box		[out] global AABB enclosing the set of input primitives
+ *	\return		true if success
+ */
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+bool AABBTreeOfAABBsBuilder::ComputeGlobalBox(const udword* primitives, udword nb_prims, AABB& global_box) const
+{
+	// Checkings
+	if(!primitives || !nb_prims)	return false;
+
+	// Initialize global box
+	global_box = mAABBArray[primitives[0]];
+
+	// Loop through boxes
+	for(udword i=1;i<nb_prims;i++)
+	{
+		// Update global box
+		global_box.Add(mAABBArray[primitives[i]]);
+	}
+	return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ *	Computes the splitting value along a given axis for a given primitive.
+ *	\param		index		[in] index of the primitive to split
+ *	\param		axis		[in] axis index (0,1,2)
+ *	\return		splitting value
+ */
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+float AABBTreeOfAABBsBuilder::GetSplittingValue(udword index, udword axis) const
+{
+	// For an AABB, the splitting value is the middle of the given axis,
+	// i.e. the corresponding component of the center IcePoint
+	return mAABBArray[index].GetCenter(axis);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ *	Computes the AABB of a set of primitives.
+ *	\param		primitives		[in] list of indices of primitives
+ *	\param		nb_prims		[in] number of indices
+ *	\param		global_box		[out] global AABB enclosing the set of input primitives
+ *	\return		true if success
+ */
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+bool AABBTreeOfTrianglesBuilder::ComputeGlobalBox(const udword* primitives, udword nb_prims, AABB& global_box) const
+{
+	// Checkings
+	if(!primitives || !nb_prims)	return false;
+
+	// Initialize global box
+	IcePoint Min(MAX_FLOAT, MAX_FLOAT, MAX_FLOAT);
+	IcePoint Max(MIN_FLOAT, MIN_FLOAT, MIN_FLOAT);
+
+	// Loop through triangles
+	VertexPointers VP;
+	while(nb_prims--)
+	{
+		// Get current triangle-vertices
+		mIMesh->GetTriangle(VP, *primitives++);
+		// Update global box
+		Min.Min(*VP.Vertex[0]).Min(*VP.Vertex[1]).Min(*VP.Vertex[2]);
+		Max.Max(*VP.Vertex[0]).Max(*VP.Vertex[1]).Max(*VP.Vertex[2]);
+	}
+	global_box.SetMinMax(Min, Max);
+	return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ *	Computes the splitting value along a given axis for a given primitive.
+ *	\param		index		[in] index of the primitive to split
+ *	\param		axis		[in] axis index (0,1,2)
+ *	\return		splitting value
+ */
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+float AABBTreeOfTrianglesBuilder::GetSplittingValue(udword index, udword axis) const
+{
+/*	// Compute center of triangle
+	IcePoint Center;
+	mTriList[index].Center(mVerts, Center);
+	// Return value
+	return Center[axis];*/
+
+	// Compute correct component from center of triangle
+//	return	(mVerts[mTriList[index].mVRef[0]][axis]
+//			+mVerts[mTriList[index].mVRef[1]][axis]
+//			+mVerts[mTriList[index].mVRef[2]][axis])*INV3;
+
+	VertexPointers VP;
+	mIMesh->GetTriangle(VP, index);
+
+	// Compute correct component from center of triangle
+	return	((*VP.Vertex[0])[axis]
+			+(*VP.Vertex[1])[axis]
+			+(*VP.Vertex[2])[axis])*INV3;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ *	Computes the splitting value along a given axis for a given node.
+ *	\param		primitives		[in] list of indices of primitives
+ *	\param		nb_prims		[in] number of indices
+ *	\param		global_box		[in] global AABB enclosing the set of input primitives
+ *	\param		axis			[in] axis index (0,1,2)
+ *	\return		splitting value
+ */
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+float AABBTreeOfTrianglesBuilder::GetSplittingValue(const udword* primitives, udword nb_prims, const AABB& global_box, udword axis)	const
+{
+	if(mSettings.mRules&SPLIT_GEOM_CENTER)
+	{
+		// Loop through triangles
+		float SplitValue = 0.0f;
+		VertexPointers VP;
+		for(udword i=0;i<nb_prims;i++)
+		{
+			// Get current triangle-vertices
+			mIMesh->GetTriangle(VP, primitives[i]);
+			// Update split value
+			SplitValue += (*VP.Vertex[0])[axis];
+			SplitValue += (*VP.Vertex[1])[axis];
+			SplitValue += (*VP.Vertex[2])[axis];
+		}
+		return SplitValue / float(nb_prims*3);
+	}
+	else return AABBTreeBuilder::GetSplittingValue(primitives, nb_prims, global_box, axis);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ *	Computes the AABB of a set of primitives.
+ *	\param		primitives		[in] list of indices of primitives
+ *	\param		nb_prims		[in] number of indices
+ *	\param		global_box		[out] global AABB enclosing the set of input primitives
+ *	\return		true if success
+ */
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+bool AABBTreeOfVerticesBuilder::ComputeGlobalBox(const udword* primitives, udword nb_prims, AABB& global_box) const
+{
+	// Checkings
+	if(!primitives || !nb_prims)	return false;
+
+	// Initialize global box
+	global_box.SetEmpty();
+
+	// Loop through vertices
+	for(udword i=0;i<nb_prims;i++)
+	{
+		// Update global box
+		global_box.Extend(mVertexArray[primitives[i]]);
+	}
+	return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ *	Computes the splitting value along a given axis for a given primitive.
+ *	\param		index		[in] index of the primitive to split
+ *	\param		axis		[in] axis index (0,1,2)
+ *	\return		splitting value
+ */
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+float AABBTreeOfVerticesBuilder::GetSplittingValue(udword index, udword axis) const
+{
+	// For a vertex, the splitting value is simply the vertex coordinate.
+	return mVertexArray[index][axis];
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ *	Computes the splitting value along a given axis for a given node.
+ *	\param		primitives		[in] list of indices of primitives
+ *	\param		nb_prims		[in] number of indices
+ *	\param		global_box		[in] global AABB enclosing the set of input primitives
+ *	\param		axis			[in] axis index (0,1,2)
+ *	\return		splitting value
+ */
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+float AABBTreeOfVerticesBuilder::GetSplittingValue(const udword* primitives, udword nb_prims, const AABB& global_box, udword axis)	const
+{
+	if(mSettings.mRules&SPLIT_GEOM_CENTER)
+	{
+		// Loop through vertices
+		float SplitValue = 0.0f;
+		for(udword i=0;i<nb_prims;i++)
+		{
+			// Update split value
+			SplitValue += mVertexArray[primitives[i]][axis];
+		}
+		return SplitValue / float(nb_prims);
+	}
+	else return AABBTreeBuilder::GetSplittingValue(primitives, nb_prims, global_box, axis);
+}
-- 
cgit v1.1