diff options
Diffstat (limited to 'sourcemod/scripting/include/float.inc')
| -rw-r--r-- | sourcemod/scripting/include/float.inc | 460 |
1 files changed, 460 insertions, 0 deletions
diff --git a/sourcemod/scripting/include/float.inc b/sourcemod/scripting/include/float.inc new file mode 100644 index 0000000..0106827 --- /dev/null +++ b/sourcemod/scripting/include/float.inc @@ -0,0 +1,460 @@ +/** + * vim: set ts=4 : + * ============================================================================= + * SourceMod (C)2004-2008 AlliedModders LLC. All rights reserved. + * ============================================================================= + * + * This file is part of the SourceMod/SourcePawn SDK. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 3.0, as published by the + * Free Software Foundation. + * + * 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/>. + * + * As a special exception, AlliedModders LLC gives you permission to link the + * code of this program (as well as its derivative works) to "Half-Life 2," the + * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software + * by the Valve Corporation. You must obey the GNU General Public License in + * all respects for all other code used. Additionally, AlliedModders LLC grants + * this exception to all derivative works. AlliedModders LLC defines further + * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007), + * or <http://www.sourcemod.net/license.php>. + * + * Version: $Id$ + */ + +#if defined _float_included + #endinput +#endif +#define _float_included + +#if !defined __sourcepawn2__ +/** + * Converts an integer into a floating point value. + * + * @param value Integer to convert. + * @return Floating point value. + */ +native float float(int value); +#endif + +/** + * Multiplies two floats together. + * + * Note: This native is internal implementation. For multiplication use the '*' operator. + * + * @param oper1 First value. + * @param oper2 Second value. + * @return oper1*oper2. + * @deprecated This native is internal implementation. For multiplication use the '*' operator. + */ +#pragma deprecated This native is internal implementation. For multiplication use the '*' operator. +native float FloatMul(float oper1, float oper2); + +/** + * Divides the dividend by the divisor. + * + * Note: This native is internal implementation. For division use the '/' operator. + * + * @param dividend First value. + * @param divisor Second value. + * @return dividend/divisor. + * @deprecated This native is internal implementation. For division use the '/' operator. + */ +#pragma deprecated This native is internal implementation. For division use the '/' operator. +native float FloatDiv(float dividend, float divisor); + +/** + * Adds two floats together. + * + * Note: This native is internal implementation. For addition use the '+' operator. + * + * @param oper1 First value. + * @param oper2 Second value. + * @return oper1+oper2. + * @deprecated This native is internal implementation. For addition use the '+' operator. + */ +#pragma deprecated This native is internal implementation. For addition use the '+' operator. +native float FloatAdd(float oper1, float oper2); + +/** + * Subtracts oper2 from oper1. + * + * Note: This native is internal implementation. For subtraction use the '-' operator. + * + * @param oper1 First value. + * @param oper2 Second value. + * @return oper1-oper2. + * @deprecated This native is internal implementation. For subtraction use the '-' operator. + */ +#pragma deprecated This native is internal implementation. For subtraction use the '-' operator. +native float FloatSub(float oper1, float oper2); + +/** + * Returns the decimal part of a float. + * + * @param value Input value. + * @return Decimal part. + */ +native float FloatFraction(float value); + +/** + * Rounds a float to the closest integer to zero. + * + * @param value Input value to be rounded. + * @return Rounded value. + */ +native int RoundToZero(float value); + +/** + * Rounds a float to the next highest integer value. + * + * @param value Input value to be rounded. + * @return Rounded value. + */ +native int RoundToCeil(float value); + +/** + * Rounds a float to the next lowest integer value. + * + * @param value Input value to be rounded. + * @return Rounded value. + */ +native int RoundToFloor(float value); + +/** + * Standard IEEE rounding. + * + * @param value Input value to be rounded. + * @return Rounded value. + */ +native int RoundToNearest(float value); + +/** + * Compares two floats. + * + * @param fOne First value. + * @param fTwo Second value. + * @return Returns 1 if the first argument is greater than the second argument. + * Returns -1 if the first argument is smaller than the second argument. + * Returns 0 if both arguments are equal. + */ +native int FloatCompare(float fOne, float fTwo); + +/** + * Returns the square root of the input value, equivalent to floatpower(value, 0.5). + * + * @param value Input value. + * @return Square root of the value. + */ +native float SquareRoot(float value); + +/** + * Returns the value raised to the power of the exponent. + * + * @param value Value to be raised. + * @param exponent Value to raise the base. + * @return value^exponent. + */ +native float Pow(float value, float exponent); + +/** + * Returns the value of raising the input by e. + * + * @param value Input value. + * @return exp(value). + */ +native float Exponential(float value); + +/** + * Returns the logarithm of any base specified. + * + * @param value Input value. + * @param base Logarithm base to use, default is 10. + * @return log(value)/log(base). + */ +native float Logarithm(float value, float base=10.0); + +/** + * Returns the sine of the argument. + * + * @param value Input value in radians. + * @return sin(value). + */ +native float Sine(float value); + +/** + * Returns the cosine of the argument. + * + * @param value Input value in radians. + * @return cos(value). + */ +native float Cosine(float value); + +/** + * Returns the tangent of the argument. + * + * @param value Input value in radians. + * @return tan(value). + */ +native float Tangent(float value); + +/** + * Returns an absolute value. + * + * @param value Input value. + * @return Absolute value of the input. + */ +native float FloatAbs(float value); + +/** + * Returns the arctangent of the input value. + * + * @param angle Input value. + * @return atan(value) in radians. + */ +native float ArcTangent(float angle); + +/** + * Returns the arccosine of the input value. + * + * @param angle Input value. + * @return acos(value) in radians. + */ +native float ArcCosine(float angle); + +/** + * Returns the arcsine of the input value. + * + * @param angle Input value. + * @return asin(value) in radians. + */ +native float ArcSine(float angle); + +/** + * Returns the arctangent2 of the input values. + * + * @param x Horizontal value. + * @param y Vertical value. + * @return atan2(value) in radians. + */ +native float ArcTangent2(float x, float y); + +/** + * Rounds a floating point number using the "round to nearest" algorithm. + * + * @param value Floating point value to round. + * @return The value rounded to the nearest integer. + */ +stock int RoundFloat(float value) +{ + return RoundToNearest(value); +} + +/** + * User defined operators. + */ +#if !defined __sourcepawn2__ +#pragma rational Float + +// Internal aliases for backwards compatibility. +native float __FLOAT_MUL__(float a, float b) = FloatMul; +native float __FLOAT_DIV__(float a, float b) = FloatDiv; +native float __FLOAT_ADD__(float a, float b) = FloatAdd; +native float __FLOAT_SUB__(float a, float b) = FloatSub; + +native bool __FLOAT_GT__(float a, float b); +native bool __FLOAT_GE__(float a, float b); +native bool __FLOAT_LT__(float a, float b); +native bool __FLOAT_LE__(float a, float b); +native bool __FLOAT_EQ__(float a, float b); +native bool __FLOAT_NE__(float a, float b); +native bool __FLOAT_NOT__(float a); + +native float operator*(float oper1, float oper2) = FloatMul; +native float operator/(float oper1, float oper2) = FloatDiv; +native float operator+(float oper1, float oper2) = FloatAdd; +native float operator-(float oper1, float oper2) = FloatSub; +native bool operator!(float oper1) = __FLOAT_NOT__; +native bool operator>(float oper1, float oper2) = __FLOAT_GT__; +native bool operator>=(float oper1, float oper2) = __FLOAT_GE__; +native bool operator<(float oper1, float oper2) = __FLOAT_LT__; +native bool operator<=(float oper1, float oper2) = __FLOAT_LE__; +native bool operator!=(float oper1, float oper2) = __FLOAT_NE__; +native bool operator==(float oper1, float oper2) = __FLOAT_EQ__; + +stock float operator++(float oper) +{ + return oper+1.0; +} + +stock float operator--(float oper) +{ + return oper-1.0; +} + +stock float operator-(float oper) +{ + return oper^view_as<float>(cellmin); /* IEEE values are sign/magnitude */ +} + +// The stocks below are int->float converting versions of the above natives. + +stock float operator*(float oper1, int oper2) +{ + return __FLOAT_MUL__(oper1, float(oper2)); /* "*" is commutative */ +} + +stock float operator/(float oper1, int oper2) +{ + return __FLOAT_DIV__(oper1, float(oper2)); +} + +stock float operator/(int oper1, float oper2) +{ + return __FLOAT_DIV__(float(oper1), oper2); +} + +stock float operator+(float oper1, int oper2) +{ + return __FLOAT_ADD__(oper1, float(oper2)); /* "+" is commutative */ +} + +stock float operator-(float oper1, int oper2) +{ + return __FLOAT_SUB__(oper1, float(oper2)); +} + +stock float operator-(int oper1, float oper2) +{ + return __FLOAT_SUB__(float(oper1), oper2); +} + +stock bool operator==(float oper1, int oper2) +{ + return __FLOAT_EQ__(oper1, float(oper2)); +} + +stock bool operator!=(float oper1, int oper2) +{ + return __FLOAT_NE__(oper1, float(oper2)); +} + +stock bool operator>(float oper1, int oper2) +{ + return __FLOAT_GT__(oper1, float(oper2)); +} + +stock bool operator>(int oper1, float oper2) +{ + return __FLOAT_GT__(float(oper1), oper2); +} + +stock bool operator>=(float oper1, int oper2) +{ + return __FLOAT_GE__(oper1, float(oper2)); +} + +stock bool operator>=(int oper1, float oper2) +{ + return __FLOAT_GE__(float(oper1), oper2); +} + +stock bool operator<(float oper1, int oper2) +{ + return __FLOAT_LT__(oper1, float(oper2)); +} + +stock bool operator<(int oper1, float oper2) +{ + return __FLOAT_LT__(float(oper1), oper2); +} + +stock bool operator<=(float oper1, int oper2) +{ + return __FLOAT_LE__(oper1, float(oper2)); +} + +stock bool operator<=(int oper1, float oper2) +{ + return __FLOAT_LE__(float(oper1), oper2); +} + +/** + * Forbidden operators. + */ +forward operator%(float oper1, float oper2); +forward operator%(float oper1, int oper2); +forward operator%(int oper1, float oper2); +#endif // __sourcepawn2__ + +#define FLOAT_PI 3.1415926535897932384626433832795 + +/** + * Converts degrees to radians. + * + * @param angle Degrees. + * @return Radians. + */ +stock float DegToRad(float angle) +{ + return (angle*FLOAT_PI)/180; +} + +/** + * Converts radians to degrees. + * + * @param angle Radians. + * @return Degrees. + */ +stock float RadToDeg(float angle) +{ + return (angle*180)/FLOAT_PI; +} + +/** + * Returns a random integer in the range [0, 2^31-1]. + * + * Note: Uniform random number streams are seeded automatically per-plugin. + * + * @return Random integer. + */ +native int GetURandomInt(); + +/** + * Returns a uniform random float in the range [0, 1). + * + * Note: Uniform random number streams are seeded automatically per-plugin. + * + * @return Uniform random floating-point number. + */ +native float GetURandomFloat(); + +/** + * Seeds a plugin's uniform random number stream. This is done automatically, + * so normally it is totally unnecessary to call this. + * + * @param seeds Array of numbers to use as seeding data. + * @param numSeeds Number of seeds in the seeds array. + */ +native void SetURandomSeed(const int[] seeds, int numSeeds); + +/** + * Seeds a plugin's uniform random number stream. This is done automatically, + * so normally it is totally unnecessary to call this. + * + * @param seed Single seed value. + */ +stock void SetURandomSeedSimple(int seed) +{ + int seeds[1]; + seeds[0] = seed; + SetURandomSeed(seeds, 1); +} |