From 373dc625f82b47096893add42c4472e4a57ab7eb Mon Sep 17 00:00:00 2001
From: Aki <please@ignore.pl>
Date: Wed, 9 Feb 2022 22:23:03 +0100
Subject: Moved third-party libraries to a separate subdirectory

---
 Opcode/Ice/IceAABB.cpp | 405 -------------------------------------------------
 1 file changed, 405 deletions(-)
 delete mode 100644 Opcode/Ice/IceAABB.cpp

(limited to 'Opcode/Ice/IceAABB.cpp')

diff --git a/Opcode/Ice/IceAABB.cpp b/Opcode/Ice/IceAABB.cpp
deleted file mode 100644
index 03bca6c..0000000
--- a/Opcode/Ice/IceAABB.cpp
+++ /dev/null
@@ -1,405 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- *	Contains AABB-related code.
- *	\file		IceAABB.cpp
- *	\author		Pierre Terdiman
- *	\date		January, 29, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- *	AABB class.
- *	\class		AABB
- *	\author		Pierre Terdiman
- *	\version	1.0
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Precompiled Header
-#include "StdAfx.h"
-
-using namespace IceMaths;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- *	Computes the sum of two AABBs.
- *	\param		aabb	[in] the other AABB
- *	\return		Self-Reference
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-AABB& AABB::Add(const AABB& aabb)
-{
-	// Compute new min & max values
-	IcePoint Min;	GetMin(Min);
-	IcePoint Tmp;	aabb.GetMin(Tmp);
-	Min.Min(Tmp);
-
-	IcePoint Max;	GetMax(Max);
-	aabb.GetMax(Tmp);
-	Max.Max(Tmp);
-
-	// Update this
-	SetMinMax(Min, Max);
-	return *this;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- *	Makes a cube from the AABB.
- *	\param		cube	[out] the cube AABB
- *	\return		cube edge length
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-float AABB::MakeCube(AABB& cube) const
-{
-	IcePoint Ext;	GetExtents(Ext);
-	float Max = Ext.Max();
-
-	IcePoint Cnt;	GetCenter(Cnt);
-	cube.SetCenterExtents(Cnt, IcePoint(Max, Max, Max));
-	return Max;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- *	Makes a sphere from the AABB.
- *	\param		sphere	[out] sphere containing the AABB
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void AABB::MakeSphere(Sphere& sphere) const
-{
-	GetExtents(sphere.mCenter);
-	sphere.mRadius = sphere.mCenter.Magnitude() * 1.00001f;	// To make sure sphere::Contains(*this)	succeeds
-	GetCenter(sphere.mCenter);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- *	Checks a box is inside another box.
- *	\param		box		[in] the other AABB
- *	\return		true if current box is inside input box
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABB::IsInside(const AABB& box) const
-{
-	if(box.GetMin(0)>GetMin(0))	return false;
-	if(box.GetMin(1)>GetMin(1))	return false;
-	if(box.GetMin(2)>GetMin(2))	return false;
-	if(box.GetMax(0)<GetMax(0))	return false;
-	if(box.GetMax(1)<GetMax(1))	return false;
-	if(box.GetMax(2)<GetMax(2))	return false;
-	return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- *	Computes the AABB planes.
- *	\param		planes	[out] 6 planes surrounding the box
- *	\return		true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABB::ComputePlanes(IcePlane* planes)	const
-{
-	// Checkings
-	if(!planes)	return false;
-
-	IcePoint Center, Extents;
-	GetCenter(Center);
-	GetExtents(Extents);
-
-	// Writes normals
-	planes[0].n = IcePoint(1.0f, 0.0f, 0.0f);
-	planes[1].n = IcePoint(-1.0f, 0.0f, 0.0f);
-	planes[2].n = IcePoint(0.0f, 1.0f, 0.0f);
-	planes[3].n = IcePoint(0.0f, -1.0f, 0.0f);
-	planes[4].n = IcePoint(0.0f, 0.0f, 1.0f);
-	planes[5].n = IcePoint(0.0f, 0.0f, -1.0f);
-
-	// Compute a point on each plane
-	IcePoint p0 = IcePoint(Center.x+Extents.x, Center.y, Center.z);
-	IcePoint p1 = IcePoint(Center.x-Extents.x, Center.y, Center.z);
-	IcePoint p2 = IcePoint(Center.x, Center.y+Extents.y, Center.z);
-	IcePoint p3 = IcePoint(Center.x, Center.y-Extents.y, Center.z);
-	IcePoint p4 = IcePoint(Center.x, Center.y, Center.z+Extents.z);
-	IcePoint p5 = IcePoint(Center.x, Center.y, Center.z-Extents.z);
-
-	// Compute d
-	planes[0].d = -(planes[0].n|p0);
-	planes[1].d = -(planes[1].n|p1);
-	planes[2].d = -(planes[2].n|p2);
-	planes[3].d = -(planes[3].n|p3);
-	planes[4].d = -(planes[4].n|p4);
-	planes[5].d = -(planes[5].n|p5);
-
-	return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- *	Computes the aabb points.
- *	\param		pts	[out] 8 box points
- *	\return		true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABB::ComputePoints(IcePoint* pts)	const
-{
-	// Checkings
-	if(!pts)	return false;
-
-	// Get box corners
-	IcePoint min;	GetMin(min);
-	IcePoint max;	GetMax(max);
-
-	//     7+------+6			0 = ---
-	//     /|     /|			1 = +--
-	//    / |    / |			2 = ++-
-	//   / 4+---/--+5			3 = -+-
-	// 3+------+2 /    y   z	4 = --+
-	//  | /    | /     |  /		5 = +-+
-	//  |/     |/      |/		6 = +++
-	// 0+------+1      *---x	7 = -++
-
-	// Generate 8 corners of the bbox
-	pts[0] = IcePoint(min.x, min.y, min.z);
-	pts[1] = IcePoint(max.x, min.y, min.z);
-	pts[2] = IcePoint(max.x, max.y, min.z);
-	pts[3] = IcePoint(min.x, max.y, min.z);
-	pts[4] = IcePoint(min.x, min.y, max.z);
-	pts[5] = IcePoint(max.x, min.y, max.z);
-	pts[6] = IcePoint(max.x, max.y, max.z);
-	pts[7] = IcePoint(min.x, max.y, max.z);
-
-	return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- *	Gets vertex normals.
- *	\param		pts	[out] 8 box points
- *	\return		true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-const IcePoint* AABB::GetVertexNormals()	const
-{
-	static float VertexNormals[] = 
-	{
-		-INVSQRT3,	-INVSQRT3,	-INVSQRT3,
-		INVSQRT3,	-INVSQRT3,	-INVSQRT3,
-		INVSQRT3,	INVSQRT3,	-INVSQRT3,
-		-INVSQRT3,	INVSQRT3,	-INVSQRT3,
-		-INVSQRT3,	-INVSQRT3,	INVSQRT3,
-		INVSQRT3,	-INVSQRT3,	INVSQRT3,
-		INVSQRT3,	INVSQRT3,	INVSQRT3,
-		-INVSQRT3,	INVSQRT3,	INVSQRT3
-	};
-	return (const IcePoint*)VertexNormals;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- *	Returns edges.
- *	\return		24 indices (12 edges) indexing the list returned by ComputePoints()
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-const udword* AABB::GetEdges() const
-{
-	static udword Indices[] = {
-	0, 1,	1, 2,	2, 3,	3, 0,
-	7, 6,	6, 5,	5, 4,	4, 7,
-	1, 5,	6, 2,
-	3, 7,	4, 0
-	};
-	return Indices;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- *	Returns edge normals.
- *	\return		edge normals in local space
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-const IcePoint* AABB::GetEdgeNormals() const
-{
-	static float EdgeNormals[] = 
-	{
-		0,			-INVSQRT2,	-INVSQRT2,	// 0-1
-		INVSQRT2,	0,			-INVSQRT2,	// 1-2
-		0,			INVSQRT2,	-INVSQRT2,	// 2-3
-		-INVSQRT2,	0,			-INVSQRT2,	// 3-0
-
-		0,			INVSQRT2,	INVSQRT2,	// 7-6
-		INVSQRT2,	0,			INVSQRT2,	// 6-5
-		0,			-INVSQRT2,	INVSQRT2,	// 5-4
-		-INVSQRT2,	0,			INVSQRT2,	// 4-7
-
-		INVSQRT2,	-INVSQRT2,	0,			// 1-5
-		INVSQRT2,	INVSQRT2,	0,			// 6-2
-		-INVSQRT2,	INVSQRT2,	0,			// 3-7
-		-INVSQRT2,	-INVSQRT2,	0			// 4-0
-	};
-	return (const IcePoint*)EdgeNormals;
-}
-
-// ===========================================================================
-//  (C) 1996-98 Vienna University of Technology
-// ===========================================================================
-//  NAME:       bboxarea
-//  TYPE:       c++ code
-//  PROJECT:    Bounding Box Area
-//  CONTENT:    Computes area of 2D projection of 3D oriented bounding box
-//  VERSION:    1.0
-// ===========================================================================
-//  AUTHORS:    ds      Dieter Schmalstieg
-//              ep      Erik Pojar
-// ===========================================================================
-//  HISTORY:
-//
-//  19-sep-99 15:23:03  ds      last modification
-//  01-dec-98 15:23:03  ep      created
-// ===========================================================================
-
-//----------------------------------------------------------------------------
-// SAMPLE CODE STARTS HERE
-//----------------------------------------------------------------------------
-
-// NOTE: This sample program requires OPEN INVENTOR!
-
-//indexlist: this table stores the 64 possible cases of classification of
-//the eyepoint with respect to the 6 defining planes of the bbox (2^6=64)
-//only 26 (3^3-1, where 1 is "inside" cube) of these cases are valid.
-//the first 6 numbers in each row are the indices of the bbox vertices that
-//form the outline of which we want to compute the area (counterclockwise
-//ordering), the 7th entry means the number of vertices in the outline.
-//there are 6 cases with a single face and and a 4-vertex outline, and
-//20 cases with 2 or 3 faces and a 6-vertex outline. a value of 0 indicates
-//an invalid case.
-
-
-// Original list was made of 7 items, I added an 8th element:
-// - to padd on a cache line
-// - to repeat the first entry to avoid modulos
-//
-// I also replaced original ints with sbytes.
-
-static const sbyte gIndexList[64][8] =
-{
-    {-1,-1,-1,-1,-1,-1,-1,   0}, // 0 inside
-    { 0, 4, 7, 3, 0,-1,-1,   4}, // 1 left
-    { 1, 2, 6, 5, 1,-1,-1,   4}, // 2 right
-    {-1,-1,-1,-1,-1,-1,-1,   0}, // 3 -
-    { 0, 1, 5, 4, 0,-1,-1,   4}, // 4 bottom
-    { 0, 1, 5, 4, 7, 3, 0,   6}, // 5 bottom, left
-    { 0, 1, 2, 6, 5, 4, 0,   6}, // 6 bottom, right
-    {-1,-1,-1,-1,-1,-1,-1,   0}, // 7 -
-    { 2, 3, 7, 6, 2,-1,-1,   4}, // 8 top
-    { 0, 4, 7, 6, 2, 3, 0,   6}, // 9 top, left
-    { 1, 2, 3, 7, 6, 5, 1,   6}, //10 top, right
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //11 -
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //12 -
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //13 -
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //14 -
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //15 -
-    { 0, 3, 2, 1, 0,-1,-1,   4}, //16 front
-    { 0, 4, 7, 3, 2, 1, 0,   6}, //17 front, left
-    { 0, 3, 2, 6, 5, 1, 0,   6}, //18 front, right
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //19 -
-    { 0, 3, 2, 1, 5, 4, 0,   6}, //20 front, bottom
-    { 1, 5, 4, 7, 3, 2, 1,   6}, //21 front, bottom, left
-    { 0, 3, 2, 6, 5, 4, 0,   6}, //22 front, bottom, right
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //23 -
-    { 0, 3, 7, 6, 2, 1, 0,   6}, //24 front, top
-    { 0, 4, 7, 6, 2, 1, 0,   6}, //25 front, top, left
-    { 0, 3, 7, 6, 5, 1, 0,   6}, //26 front, top, right
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //27 -
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //28 -
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //29 -
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //30 -
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //31 -
-    { 4, 5, 6, 7, 4,-1,-1,   4}, //32 back
-    { 0, 4, 5, 6, 7, 3, 0,   6}, //33 back, left
-    { 1, 2, 6, 7, 4, 5, 1,   6}, //34 back, right
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //35 -
-    { 0, 1, 5, 6, 7, 4, 0,   6}, //36 back, bottom
-    { 0, 1, 5, 6, 7, 3, 0,   6}, //37 back, bottom, left
-    { 0, 1, 2, 6, 7, 4, 0,   6}, //38 back, bottom, right
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //39 -
-    { 2, 3, 7, 4, 5, 6, 2,   6}, //40 back, top
-    { 0, 4, 5, 6, 2, 3, 0,   6}, //41 back, top, left
-    { 1, 2, 3, 7, 4, 5, 1,   6}, //42 back, top, right
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //43 invalid
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //44 invalid
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //45 invalid
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //46 invalid
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //47 invalid
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //48 invalid
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //49 invalid
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //50 invalid
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //51 invalid
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //52 invalid
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //53 invalid
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //54 invalid
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //55 invalid
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //56 invalid
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //57 invalid
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //58 invalid
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //59 invalid
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //60 invalid
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //61 invalid
-    {-1,-1,-1,-1,-1,-1,-1,   0}, //62 invalid
-    {-1,-1,-1,-1,-1,-1,-1,   0}  //63 invalid
-};
-
-const sbyte* AABB::ComputeOutline(const IcePoint& local_eye, sdword& num)	const
-{
-	// Get box corners
-	IcePoint min;	GetMin(min);
-	IcePoint max;	GetMax(max);
-
-	// Compute 6-bit code to classify eye with respect to the 6 defining planes of the bbox
-	int pos = ((local_eye.x < min.x) ?  1 : 0)	// 1 = left
-			+ ((local_eye.x > max.x) ?  2 : 0)	// 2 = right
-			+ ((local_eye.y < min.y) ?  4 : 0)	// 4 = bottom
-			+ ((local_eye.y > max.y) ?  8 : 0)	// 8 = top
-			+ ((local_eye.z < min.z) ? 16 : 0)	// 16 = front
-			+ ((local_eye.z > max.z) ? 32 : 0);	// 32 = back
-
-	// Look up number of vertices in outline
-	num = (sdword)gIndexList[pos][7];
-	// Zero indicates invalid case
-	if(!num) return null;
-
-	return &gIndexList[pos][0];
-}
-
-// calculateBoxArea: computes the screen-projected 2D area of an oriented 3D bounding box
-
-//const IcePoint&		eye,		//eye point (in bbox object coordinates)
-//const AABB&			box,		//3d bbox
-//const Matrix4x4&	mat,		//free transformation for bbox
-//float width, float height, int& num)
-float AABB::ComputeBoxArea(const IcePoint& eye, const Matrix4x4& mat, float width, float height, sdword& num)	const
-{
-	const sbyte* Outline = ComputeOutline(eye, num);
-	if(!Outline)	return -1.0f;
-
-	// Compute box vertices
-	IcePoint vertexBox[8], dst[8];
-	ComputePoints(vertexBox);
-
-	// Transform all outline corners into 2D screen space
-	for(sdword i=0;i<num;i++)
-	{
-		HPoint Projected;
-		vertexBox[Outline[i]].ProjectToScreen(width, height, mat, Projected);
-		dst[i] = Projected;
-	}
-
-	float Sum = (dst[num-1][0] - dst[0][0]) * (dst[num-1][1] + dst[0][1]);
-
-	for(int i=0; i<num-1; i++)
-		Sum += (dst[i][0] - dst[i+1][0]) * (dst[i][1] + dst[i+1][1]);
-
-	return Sum * 0.5f;	//return computed value corrected by 0.5
-}
-- 
cgit v1.1