CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/CoreLib/hsFastMath.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/

#include "hsTypes.h"
#include "hsScalar.h"
#include "hsGeometry3.h"
#include "hsFastMath.h"

const hsScalar hsFastMath::kSqrtTwo = hsSquareRoot(2.f);
const hsScalar hsFastMath::kInvSqrtTwo = hsScalarInvert(hsFastMath::kSqrtTwo);
const hsScalar hsFastMath::kTwoPI = hsScalarPI * 2.f;

hsPoint2 statCosSinTable[9] = // must match length in inline
{
	{ 1.f, 0.f },
	{ hsFastMath::kInvSqrtTwo, hsFastMath::kInvSqrtTwo },
	{ 0.f, 1.f },
	{ -hsFastMath::kInvSqrtTwo, hsFastMath::kInvSqrtTwo },
	{ -1.f, 0.f },
	{ -hsFastMath::kInvSqrtTwo, -hsFastMath::kInvSqrtTwo },
	{ 0.f, -1.f },
	{ hsFastMath::kInvSqrtTwo, -hsFastMath::kInvSqrtTwo },
	{ 1.f, 0.f }
};

const hsPoint2* hsFastMath::fCosSinTable = statCosSinTable;

unsigned char statSeedTable[] = {
	0x69,
	0x69,
	0x68,
	0x67,
	0x67,
	0x66,
	0x65,
	0x65,
	0x64,
	0x63,
	0x63,
	0x62,
	0x61,
	0x61,
	0x60,
	0x5f,
	0x5f,
	0x5e,
	0x5d,
	0x5d,
	0x5c,
	0x5b,
	0x5b,
	0x5a,
	0x5a,
	0x59,
	0x58,
	0x58,
	0x57,
	0x57,
	0x56,
	0x55,
	0x55,
	0x54,
	0x54,
	0x53,
	0x52,
	0x52,
	0x51,
	0x51,
	0x50,
	0x50,
	0x4f,
	0x4e,
	0x4e,
	0x4d,
	0x4d,
	0x4c,
	0x4c,
	0x4b,
	0x4b,
	0x4a,
	0x4a,
	0x49,
	0x48,
	0x48,
	0x47,
	0x47,
	0x46,
	0x46,
	0x45,
	0x45,
	0x44,
	0x44,
	0x43,
	0x43,
	0x42,
	0x42,
	0x41,
	0x41,
	0x40,
	0x40,
	0x3f,
	0x3f,
	0x3e,
	0x3e,
	0x3d,
	0x3d,
	0x3c,
	0x3c,
	0x3c,
	0x3b,
	0x3b,
	0x3a,
	0x3a,
	0x39,
	0x39,
	0x38,
	0x38,
	0x37,
	0x37,
	0x36,
	0x36,
	0x36,
	0x35,
	0x35,
	0x34,
	0x34,
	0x33,
	0x33,
	0x33,
	0x32,
	0x32,
	0x31,
	0x31,
	0x30,
	0x30,
	0x30,
	0x2f,
	0x2f,
	0x2e,
	0x2e,
	0x2e,
	0x2d,
	0x2d,
	0x2c,
	0x2c,
	0x2b,
	0x2b,
	0x2b,
	0x2a,
	0x2a,
	0x29,
	0x29,
	0x29,
	0x28,
	0x28,
	0x28,
	0x27,
	0x27,
	0x26,
	0x26,
	0x26,
	0x25,
	0x25,
	0x25,
	0x24,
	0x24,
	0x23,
	0x23,
	0x23,
	0x22,
	0x22,
	0x22,
	0x21,
	0x21,
	0x20,
	0x20,
	0x20,
	0x1f,
	0x1f,
	0x1f,
	0x1e,
	0x1e,
	0x1e,
	0x1d,
	0x1d,
	0x1d,
	0x1c,
	0x1c,
	0x1c,
	0x1b,
	0x1b,
	0x1b,
	0x1a,
	0x1a,
	0x1a,
	0x19,
	0x19,
	0x19,
	0x18,
	0x18,
	0x18,
	0x17,
	0x17,
	0x17,
	0x16,
	0x16,
	0x16,
	0x15,
	0x15,
	0x15,
	0x14,
	0x14,
	0x14,
	0x13,
	0x13,
	0x13,
	0x13,
	0x12,
	0x12,
	0x12,
	0x11,
	0x11,
	0x11,
	0x10,
	0x10,
	0x10,
	0xf,
	0xf,
	0xf,
	0xf,
	0xe,
	0xe,
	0xe,
	0xd,
	0xd,
	0xd,
	0xd,
	0xc,
	0xc,
	0xc,
	0xb,
	0xb,
	0xb,
	0xb,
	0xa,
	0xa,
	0xa,
	0x9,
	0x9,
	0x9,
	0x9,
	0x8,
	0x8,
	0x8,
	0x7,
	0x7,
	0x7,
	0x7,
	0x6,
	0x6,
	0x6,
	0x6,
	0x5,
	0x5,
	0x5,
	0x5,
	0x4,
	0x4,
	0x4,
	0x3,
	0x3,
	0x3,
	0x3,
	0x2,
	0x2,
	0x2,
	0x2,
	0x1,
	0x1,
	0x1,
	0x1,
	0x0,
	0x0,
	0x0,
	0xff,
	0xfe,
	0xfd,
	0xfc,
	0xfb,
	0xfa,
	0xf9,
	0xf8,
	0xf7,
	0xf7,
	0xf6,
	0xf5,
	0xf4,
	0xf3,
	0xf2,
	0xf1,
	0xf0,
	0xef,
	0xee,
	0xed,
	0xec,
	0xec,
	0xeb,
	0xea,
	0xe9,
	0xe8,
	0xe7,
	0xe6,
	0xe5,
	0xe5,
	0xe4,
	0xe3,
	0xe2,
	0xe1,
	0xe0,
	0xe0,
	0xdf,
	0xde,
	0xdd,
	0xdc,
	0xdb,
	0xdb,
	0xda,
	0xd9,
	0xd8,
	0xd8,
	0xd7,
	0xd6,
	0xd5,
	0xd4,
	0xd4,
	0xd3,
	0xd2,
	0xd1,
	0xd1,
	0xd0,
	0xcf,
	0xce,
	0xce,
	0xcd,
	0xcc,
	0xcb,
	0xcb,
	0xca,
	0xc9,
	0xc9,
	0xc8,
	0xc7,
	0xc7,
	0xc6,
	0xc5,
	0xc4,
	0xc4,
	0xc3,
	0xc2,
	0xc2,
	0xc1,
	0xc0,
	0xc0,
	0xbf,
	0xbe,
	0xbe,
	0xbd,
	0xbc,
	0xbc,
	0xbb,
	0xba,
	0xba,
	0xb9,
	0xb8,
	0xb8,
	0xb7,
	0xb7,
	0xb6,
	0xb5,
	0xb5,
	0xb4,
	0xb3,
	0xb3,
	0xb2,
	0xb2,
	0xb1,
	0xb0,
	0xb0,
	0xaf,
	0xaf,
	0xae,
	0xad,
	0xad,
	0xac,
	0xac,
	0xab,
	0xaa,
	0xaa,
	0xa9,
	0xa9,
	0xa8,
	0xa8,
	0xa7,
	0xa7,
	0xa6,
	0xa5,
	0xa5,
	0xa4,
	0xa4,
	0xa3,
	0xa3,
	0xa2,
	0xa2,
	0xa1,
	0xa0,
	0xa0,
	0x9f,
	0x9f,
	0x9e,
	0x9e,
	0x9d,
	0x9d,
	0x9c,
	0x9c,
	0x9b,
	0x9b,
	0x9a,
	0x9a,
	0x99,
	0x99,
	0x98,
	0x98,
	0x97,
	0x97,
	0x96,
	0x96,
	0x95,
	0x95,
	0x94,
	0x94,
	0x93,
	0x93,
	0x92,
	0x92,
	0x91,
	0x91,
	0x90,
	0x90,
	0x8f,
	0x8f,
	0x8e,
	0x8e,
	0x8d,
	0x8d,
	0x8c,
	0x8c,
	0x8b,
	0x8b,
	0x8b,
	0x8a,
	0x8a,
	0x89,
	0x89,
	0x88,
	0x88,
	0x87,
	0x87,
	0x87,
	0x86,
	0x86,
	0x85,
	0x85,
	0x84,
	0x84,
	0x83,
	0x83,
	0x83,
	0x82,
	0x82,
	0x81,
	0x81,
	0x80,
	0x80,
	0x80,
	0x7f,
	0x7f,
	0x7e,
	0x7e,
	0x7d,
	0x7d,
	0x7d,
	0x7c,
	0x7c,
	0x7b,
	0x7b,
	0x7b,
	0x7a,
	0x7a,
	0x79,
	0x79,
	0x79,
	0x78,
	0x78,
	0x77,
	0x77,
	0x77,
	0x76,
	0x76,
	0x75,
	0x75,
	0x75,
	0x74,
	0x74,
	0x74,
	0x73,
	0x73,
	0x72,
	0x72,
	0x72,
	0x71,
	0x71,
	0x71,
	0x70,
	0x70,
	0x6f,
	0x6f,
	0x6f,
	0x6e,
	0x6e,
	0x6e,
	0x6d,
	0x6d,
	0x6c,
	0x6c,
	0x6c,
	0x6b,
	0x6b,
	0x6b,
	0x6a,
	0x6a
};

hsScalar hsFastMath::IATan2OverTwoPi(hsScalar y, hsScalar x)
{
	const int tabSize = 16; // pad with one extra because hi can go hi
	const int tabMax = tabSize-1;
	static hsScalar tab[tabSize+1] = {
					0.f,
					0.0105947f,
					0.0210962f,
					0.0314165f,
					0.0414762f,
					0.0512082f,
					0.0605595f,
					0.0694914f,
					0.0779791f,
					0.0860104f,
					0.0935835f,
					0.100705f,
					0.107388f,
					0.113651f,
					0.119514f,
					0.125f,
					0 };

	if( (x == 0)&&(y == 0) )
		return 0;

	hsBool xNeg, yNeg;
	if( yNeg = (y < 0) )y = -y;
	if( xNeg = (x < 0) )x = -x;
	hsBool yBigger = y >= x;
	hsScalar div = yBigger ? x / y : y / x;

	hsScalar fInd = div * tabMax;
	int lo = int(fInd);
	int hi = lo+1;
	hsScalar frac = fInd - lo;

	hsScalar res = tab[lo];
	res += frac * (tab[hi] - res);

	// now move to proper half quadrant
	hsAssert((res >= 0)&&(res <= 0.25f), "Lookup atan2 out of bounds");
	if( yBigger )
		res = 0.25f - res;
	switch( (yNeg << 1)|xNeg )
	{
	case 0:
		break;
	case 1:
		res = 0.5f - res;
		break;
	case 3:
		res += 0.5f;
		break;
	case 2:
		res = 1.f - res;
		break;
	}
	return res;
}