266 lines
7.1 KiB
C++
266 lines
7.1 KiB
C++
/* ScummVM - Graphic Adventure Engine
|
|
*
|
|
* ScummVM is the legal property of its developers, whose names
|
|
* are too numerous to list here. Please refer to the COPYRIGHT
|
|
* file distributed with this source distribution.
|
|
*
|
|
* 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/>.
|
|
*
|
|
*/
|
|
|
|
#include "common/config-manager.h"
|
|
#include "ags/engine/ac/math.h"
|
|
#include "ags/shared/ac/common.h" // quit
|
|
#include "ags/shared/util/math.h"
|
|
#include "ags/shared/debugging/out.h"
|
|
#include "ags/engine/script/script_api.h"
|
|
#include "ags/engine/script/script_runtime.h"
|
|
#include "ags/ags.h"
|
|
#include "ags/globals.h"
|
|
|
|
namespace AGS3 {
|
|
|
|
int FloatToInt(float value, int roundDirection) {
|
|
switch (roundDirection) {
|
|
case eRoundDown:
|
|
return static_cast<int>(floor(value));
|
|
case eRoundUp:
|
|
return static_cast<int>(ceil(value));
|
|
case eRoundNearest:
|
|
return static_cast<int>(round(value));
|
|
default:
|
|
quit("!FloatToInt: invalid round direction");
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
float IntToFloat(int value) {
|
|
return static_cast<float>(value);
|
|
}
|
|
|
|
float StringToFloat(const char *theString) {
|
|
return static_cast<float>(atof(theString));
|
|
}
|
|
|
|
float Math_Cos(float value) {
|
|
return cos(value);
|
|
}
|
|
|
|
float Math_Sin(float value) {
|
|
return sin(value);
|
|
}
|
|
|
|
float Math_Tan(float value) {
|
|
return tan(value);
|
|
}
|
|
|
|
float Math_ArcCos(float value) {
|
|
return acos(value);
|
|
}
|
|
|
|
float Math_ArcSin(float value) {
|
|
return asin(value);
|
|
}
|
|
|
|
float Math_ArcTan(float value) {
|
|
return atan(value);
|
|
}
|
|
|
|
float Math_ArcTan2(float yval, float xval) {
|
|
return atan2(yval, xval);
|
|
}
|
|
|
|
float Math_Log(float value) {
|
|
return log(value);
|
|
}
|
|
|
|
float Math_Log10(float value) {
|
|
return ::log10(value);
|
|
}
|
|
|
|
float Math_Exp(float value) {
|
|
return exp(value);
|
|
}
|
|
|
|
float Math_Cosh(float value) {
|
|
return cosh(value);
|
|
}
|
|
|
|
float Math_Sinh(float value) {
|
|
return sinh(value);
|
|
}
|
|
|
|
float Math_Tanh(float value) {
|
|
return tanh(value);
|
|
}
|
|
|
|
float Math_RaiseToPower(float base, float exp) {
|
|
return ::pow(base, exp);
|
|
}
|
|
|
|
float Math_DegreesToRadians(float value) {
|
|
return static_cast<float>(value * (M_PI / 180.0));
|
|
}
|
|
|
|
float Math_RadiansToDegrees(float value) {
|
|
return static_cast<float>(value * (180.0 / M_PI));
|
|
}
|
|
|
|
float Math_GetPi() {
|
|
return static_cast<float>(M_PI);
|
|
}
|
|
|
|
float Math_Sqrt(float value) {
|
|
if (value < 0.0)
|
|
error("!Sqrt: cannot perform square root of negative number");
|
|
|
|
return ::sqrt(value);
|
|
}
|
|
|
|
int __Rand(int upto) {
|
|
// WORKAROUND: Fix crash in Captain Disaster in Death Has a Million Stomping Boots
|
|
// at the start of Act 2, walking to Aquarium
|
|
if (upto == -1 && ConfMan.get("gameid") == "captaindisaster")
|
|
upto = INT32_MAX;
|
|
|
|
if (upto < 0)
|
|
error("!Random: invalid parameter passed -- must be at least 0.");
|
|
|
|
return ::AGS::g_vm->getRandomNumber(upto);
|
|
}
|
|
|
|
|
|
//=============================================================================
|
|
//
|
|
// Script API Functions
|
|
//
|
|
//=============================================================================
|
|
|
|
// float (float value)
|
|
RuntimeScriptValue Sc_Math_ArcCos(const RuntimeScriptValue *params, int32_t param_count) {
|
|
API_SCALL_FLOAT_PFLOAT(Math_ArcCos);
|
|
}
|
|
|
|
// float (float value)
|
|
RuntimeScriptValue Sc_Math_ArcSin(const RuntimeScriptValue *params, int32_t param_count) {
|
|
API_SCALL_FLOAT_PFLOAT(Math_ArcSin);
|
|
}
|
|
|
|
// float (float value)
|
|
RuntimeScriptValue Sc_Math_ArcTan(const RuntimeScriptValue *params, int32_t param_count) {
|
|
API_SCALL_FLOAT_PFLOAT(Math_ArcTan);
|
|
}
|
|
|
|
// float (SCRIPT_FLOAT(yval), SCRIPT_FLOAT(xval))
|
|
RuntimeScriptValue Sc_Math_ArcTan2(const RuntimeScriptValue *params, int32_t param_count) {
|
|
API_SCALL_FLOAT_PFLOAT2(Math_ArcTan2);
|
|
}
|
|
|
|
// float (float value)
|
|
RuntimeScriptValue Sc_Math_Cos(const RuntimeScriptValue *params, int32_t param_count) {
|
|
API_SCALL_FLOAT_PFLOAT(Math_Cos);
|
|
}
|
|
|
|
// float (float value)
|
|
RuntimeScriptValue Sc_Math_Cosh(const RuntimeScriptValue *params, int32_t param_count) {
|
|
API_SCALL_FLOAT_PFLOAT(Math_Cosh);
|
|
}
|
|
|
|
// float (float value)
|
|
RuntimeScriptValue Sc_Math_DegreesToRadians(const RuntimeScriptValue *params, int32_t param_count) {
|
|
API_SCALL_FLOAT_PFLOAT(Math_DegreesToRadians);
|
|
}
|
|
|
|
// float (float value)
|
|
RuntimeScriptValue Sc_Math_Exp(const RuntimeScriptValue *params, int32_t param_count) {
|
|
API_SCALL_FLOAT_PFLOAT(Math_Exp);
|
|
}
|
|
|
|
// float (float value)
|
|
RuntimeScriptValue Sc_Math_Log(const RuntimeScriptValue *params, int32_t param_count) {
|
|
API_SCALL_FLOAT_PFLOAT(Math_Log);
|
|
}
|
|
|
|
// float (float value)
|
|
RuntimeScriptValue Sc_Math_Log10(const RuntimeScriptValue *params, int32_t param_count) {
|
|
API_SCALL_FLOAT_PFLOAT(Math_Log10);
|
|
}
|
|
|
|
// float (float value)
|
|
RuntimeScriptValue Sc_Math_RadiansToDegrees(const RuntimeScriptValue *params, int32_t param_count) {
|
|
API_SCALL_FLOAT_PFLOAT(Math_RadiansToDegrees);
|
|
}
|
|
|
|
// float (SCRIPT_FLOAT(base), SCRIPT_FLOAT(exp))
|
|
RuntimeScriptValue Sc_Math_RaiseToPower(const RuntimeScriptValue *params, int32_t param_count) {
|
|
API_SCALL_FLOAT_PFLOAT2(Math_RaiseToPower);
|
|
}
|
|
|
|
// float (float value)
|
|
RuntimeScriptValue Sc_Math_Sin(const RuntimeScriptValue *params, int32_t param_count) {
|
|
API_SCALL_FLOAT_PFLOAT(Math_Sin);
|
|
}
|
|
|
|
// float (float value)
|
|
RuntimeScriptValue Sc_Math_Sinh(const RuntimeScriptValue *params, int32_t param_count) {
|
|
API_SCALL_FLOAT_PFLOAT(Math_Sinh);
|
|
}
|
|
|
|
// float (float value)
|
|
RuntimeScriptValue Sc_Math_Sqrt(const RuntimeScriptValue *params, int32_t param_count) {
|
|
API_SCALL_FLOAT_PFLOAT(Math_Sqrt);
|
|
}
|
|
|
|
// float (float value)
|
|
RuntimeScriptValue Sc_Math_Tan(const RuntimeScriptValue *params, int32_t param_count) {
|
|
API_SCALL_FLOAT_PFLOAT(Math_Tan);
|
|
}
|
|
|
|
// float (float value)
|
|
RuntimeScriptValue Sc_Math_Tanh(const RuntimeScriptValue *params, int32_t param_count) {
|
|
API_SCALL_FLOAT_PFLOAT(Math_Tanh);
|
|
}
|
|
|
|
// float ()
|
|
RuntimeScriptValue Sc_Math_GetPi(const RuntimeScriptValue *params, int32_t param_count) {
|
|
API_SCALL_FLOAT(Math_GetPi);
|
|
}
|
|
|
|
void RegisterMathAPI() {
|
|
ScFnRegister math_api[] = {
|
|
{"Maths::ArcCos^1", API_FN_PAIR(Math_ArcCos)},
|
|
{"Maths::ArcSin^1", API_FN_PAIR(Math_ArcSin)},
|
|
{"Maths::ArcTan^1", API_FN_PAIR(Math_ArcTan)},
|
|
{"Maths::ArcTan2^2", API_FN_PAIR(Math_ArcTan2)},
|
|
{"Maths::Cos^1", API_FN_PAIR(Math_Cos)},
|
|
{"Maths::Cosh^1", API_FN_PAIR(Math_Cosh)},
|
|
{"Maths::DegreesToRadians^1", API_FN_PAIR(Math_DegreesToRadians)},
|
|
{"Maths::Exp^1", API_FN_PAIR(Math_Exp)},
|
|
{"Maths::Log^1", API_FN_PAIR(Math_Log)},
|
|
{"Maths::Log10^1", API_FN_PAIR(Math_Log10)},
|
|
{"Maths::RadiansToDegrees^1", API_FN_PAIR(Math_RadiansToDegrees)},
|
|
{"Maths::RaiseToPower^2", API_FN_PAIR(Math_RaiseToPower)},
|
|
{"Maths::Sin^1", API_FN_PAIR(Math_Sin)},
|
|
{"Maths::Sinh^1", API_FN_PAIR(Math_Sinh)},
|
|
{"Maths::Sqrt^1", API_FN_PAIR(Math_Sqrt)},
|
|
{"Maths::Tan^1", API_FN_PAIR(Math_Tan)},
|
|
{"Maths::Tanh^1", API_FN_PAIR(Math_Tanh)},
|
|
{"Maths::get_Pi", API_FN_PAIR(Math_GetPi)},
|
|
};
|
|
|
|
ccAddExternalFunctions361(math_api);
|
|
}
|
|
|
|
} // namespace AGS3
|