Initial Prey Game integration support.

neo/prey/idLib/math/prey_math.cpp

@@ -0,0 +1,248 @@
+
+#include "precompiled.h"
+#pragma hdrstop
+
+#include "../preylib.h"
+
+const float	hhMath::EXPONENTIAL		= 2.718281828459045f;
+
+
+/*
+===============
+hhMath::logBase
+===============
+*/
+float hhMath::logBase(float base, float x) {
+
+	// Compute logarithm of arbitrary base using the rule:
+	// Log (x) = Log (x) / Log (b)
+	//    b         c         c			for any c
+
+	return log10f(x) / log10f(base);
+}
+
+// Decibel conversion functions
+// Converts between linear volumes [0..INF) and doom's version of dB (base 6)
+float hhMath::dB2Scale( float dB ) {
+	if ( dB == 0.0f ) {
+		return 1.0f;				// most common
+	} else if ( dB <= -60.0f ) {
+		return 0.0f;				// infinitly quiet
+	}
+	return (Pow(2,(dB/6.0f))); 
+}
+
+float hhMath::Scale2dB( float scale ) {
+	if (scale <= 0.0f) {
+		return -60.0f;				// infinitely quiet
+	} else if (scale == 1.0f) {
+		return 0.0f;				// most common
+	}
+	return 6.0f * logBase(2.0f, scale);
+}
+
+/*
+===============
+hhMath::Frac
+	returns the fractional part of a float
+===============
+*/
+float hhMath::Frac( float a ) {
+	return a - ((int)a);
+}
+
+/*
+===============
+hhMath::Pow
+===============
+*/
+float hhMath::Pow( const float num, const float exponent ) {
+	return pow( num, exponent );
+}
+
+/*
+===============
+hhMath::MidPointLerp
+===============
+*/
+float hhMath::MidPointLerp( const float startVal, const float midVal, const float endVal, const float alpha ) {
+	if( alpha <= 0.0f ) {
+		return startVal;
+	}
+
+	if( alpha >= 1.0f ) {
+		return endVal;
+	}
+
+	return ( alpha < 0.5f ) ? Lerp( startVal, midVal, 2.0f * alpha ) : Lerp( midVal, endVal, 2.0f * ( alpha - 0.5f ) );	
+}
+
+/*
+===============
+hhMath::Lerp
+===============
+*/
+float hhMath::Lerp( const float startVal, const float endVal, const float alpha ) {
+	if( alpha <= 0.0f ) {
+		return startVal;
+	}
+
+	if( alpha >= 1.0f ) {
+		return endVal;
+	}
+
+	return startVal + ( endVal - startVal ) * alpha;
+}
+
+/*
+===============
+hhMath::Lerp
+===============
+*/
+float hhMath::Lerp( const idVec2& valRange, const float alpha ) {
+	return Lerp( valRange[0], valRange[1], alpha );
+}
+
+//
+// GetClosestPtOnBoundary()
+//
+// JRM - DID NOT FORCE INLINE. Let the compiler decide on this one
+//
+idVec3	hhMath::GetClosestPtOnBoundary(const idVec3 &pt, const idBounds &bnds )
+{
+	idVec3 closePt;
+
+	
+	idVec3 ul;
+	idVec3 lr;
+	int i;
+
+	ul = bnds[0];
+	lr = bnds[1];	
+	
+
+	// We are INSIDE looking for closest boundary
+	if(bnds.ContainsPoint(pt))
+	{
+		closePt = pt;
+		int closestSides[3];			// 0==ul 1==lr
+		float closestSideDists[3];
+
+		// JRM TODO: Could put this all in one loop....
+
+		// Find closest sides
+		for(i=0;i<3;i++)
+		{
+			float ulDist = pt[i] - ul[i];
+			float lrDist = lr[i] - pt[i];
+			if(ulDist < lrDist )			
+			{
+				closestSides[i]		= 0; 
+				closestSideDists[i]	= ulDist;
+			}
+			else
+			{
+				closestSides[i] = 1; 
+				closestSideDists[i]	= lrDist;
+			}		
+		}
+
+		// Now find closest axis
+		int closestAxis = 0;
+		for(i=1;i<3;i++)
+		{
+            if(closestSideDists[i] < closestSideDists[closestAxis])
+				closestAxis = i;
+		}
+
+		if(closestSides[closestAxis] == 0)
+			closePt[closestAxis] = ul[closestAxis];
+		else
+			closePt[closestAxis] = lr[closestAxis];
+        
+	}	
+	else // OUTSIDE looking for closest boundary - so just clamp
+	{
+		for(i=0;i<3;i++)
+		{			
+			if(pt[i] < ul[i])		
+				closePt[i] = ul[i];	
+			else if(pt[i] > lr[i])		
+				closePt[i] = lr[i];	
+			else // INSIDE
+			{
+				closePt[i] = pt[i];
+			}
+		}
+	}
+
+	return closePt;
+};
+
+/*
+================
+hhMath::ProjectPointOntoLine
+
+//HUMANHEAD: aob
+================
+*/
+idVec3 hhMath::ProjectPointOntoLine( const idVec3& point, const idVec3& line, const idVec3& lineStartPoint ) {
+	idVec3 lineDir = line;
+	lineDir.Normalize();
+	float dot = (point - lineStartPoint) * lineDir;
+
+	return (lineDir * dot) + lineStartPoint;
+}
+
+/*
+================
+hhMath::DistFromPointToLine
+
+//HUMANHEAD: aob
+================
+*/
+float hhMath::DistFromPointToLine( const idVec3& point, const idVec3& line, const idVec3& lineStartPoint ) {
+	assert( line.Length() );
+
+	return ( (point - lineStartPoint).Cross(line) ).Length() / line.Length();
+}
+
+/*
+================
+hhMath::BuildRotationMatrix
+
+//HUMANHEAD: rww
+================
+*/
+void hhMath::BuildRotationMatrix(float phi, int axis, idMat3 &mat) {
+	mat.Identity();
+
+	switch (axis) {
+	case 0: //x
+		mat[1][0] = 0.0f;
+		mat[1][1] = cos(phi);
+		mat[1][2] = sin(phi);
+		mat[2][0] = 0.0f;
+		mat[2][1] = -sin(phi);
+		mat[2][2] = cos(phi);
+		break;
+	case 1: //y
+		mat[0][0] = cos(phi);
+		mat[0][1] = 0.0f;
+		mat[0][2] = sin(phi);
+		mat[2][0] = -sin(phi);
+		mat[2][1] = 0.0f;
+		mat[2][2] = cos(phi);
+		break;
+	case 2: //z
+		mat[0][0] = cos(phi);
+		mat[0][1] = sin(phi);
+		mat[0][2] = 0.0f;
+		mat[1][0] = -sin(phi);
+		mat[1][1] = cos(phi);
+		mat[1][2] = 0.0f;
+		break;
+	default:
+		break;
+	}
+}