bind_general.cpp
No OneTemporary
Actions

Authored By

Unknown

Size

42 KB

Referenced Files

None

Subscribers

None

bind_general.cpp
View Options

	#ifdef _MSC_VER
	#include <Windows.h>
	#endif

	#include "binds.h"
	#include "constants.h"
	#include "str_util.h"
	#include "obj/object.h"
	#include "util/random.h"
	#include "scripts/context_cache.h"
	#include "../source/as_scriptengine.h"
	#include "../source/as_scriptobject.h"
	#include "../../as_addons/include/scriptarray.h"
	#include "main/initialization.h"
	#include "main/references.h"
	#include "main/logging.h"
	#include "main/tick.h"
	#include "main/version.h"
	#include "main/game_platform.h"
	#include "util/format.h"
	#include "files.h"
	#include <algorithm>
	#include "main/console.h"
	#include "network/network_manager.h"
	#include <string>
	#include <limits.h>
	#include <limits>

	#ifdef __GNUC__
	#include <unistd.h>
	#endif

	extern unsigned reportVersion;
	extern bool isLoadedGame, gameEnding;
	extern int SAVE_VERSION, START_VERSION;
	int FindCubicRoots(const double coeff[4], double x[3]);
	int FindQuarticRoots(const double coeff[5], double x[4]);

	const bool _TRUE = true;
	const bool _FALSE = false;

	const int _INT_MAX = INT_MAX;
	const int _INT_MIN = INT_MIN;
	const unsigned _UINT_MAX = UINT_MAX;
	const float _F_INFINITY = std::numeric_limits<float>::infinity();
	const double _D_INFINITY = std::numeric_limits<double>::infinity();
	const std::string _BUILD_NAME(BUILD_VERSION);
	#ifdef NSTEAM
	const bool isSteamBuild = false;
	#else
	const bool isSteamBuild = true;
	#endif

	extern double frameTime_s;

	namespace scripts {

	double getExactTime() {
	return devices.driver->getAccurateTime();
	}

	double getGameTime() {
	return devices.driver->getGameTime();
	}

	double getFrameGameTime() {
	return frameTime_s;
	}

	double getFrameTime() {
	return devices.driver->getFrameTime();
	}

	double getFrameLength() {
	return realFrameLen;
	}

	unsigned getBasicTime() {
	return unsigned(devices.driver->getTime());
	}

	double getGameSpeed() {
	return devices.driver->getGameSpeed();
	}

	void setGameSpeed(double speed) {
	if(devices.network->isClient) {
	scripts::throwException("Cannot set game speed on client.");
	return;
	}
	if(devices.network->isServer) {
	if(devices.network->isSerializing())
	return;
	devices.network->setGameSpeed(speed);
	}
	return devices.driver->setGameSpeed(speed);
	}

	static bool mpClient() {
	return devices.network->isClient;
	}

	static bool mpServer() {
	return devices.network->isServer;
	}

	static bool isTestScripts() {
	return game_state == GS_Test_Scripts;
	}

	static bool isModdedGame() {
	if(devices.mods.activeMods.size() == 0)
	return true;
	return devices.mods.activeMods.size() > 1 \|\| devices.mods.activeMods[0] != devices.mods.getMod("base");
	}

	static unsigned mpGalaxiesInFlight() {
	return devices.network->galaxiesInFlight;
	}

	static bool mpIsSerializing() {
	return devices.network->isSerializing();
	}

	static void mpConnect(const std::string& address, int port, const std::string& password) {
	devices.network->connect(address, port, password, true);
	}

	static void mpDisconnect() {
	devices.network->disconnect();
	devices.network->resetNetState();
	}

	static bool mpIsConnected() {
	return devices.network->isClient && devices.network->connected;
	}

	static bool mpIsConnecting() {
	return devices.network->isClient && devices.network->client && !devices.network->connected;
	}

	static void mpSetPassword(const std::string& pwd) {
	devices.network->setPassword(pwd);
	}

	template<class T>
	T sqr(T x) {
	return x*x;
	}
	static std::string localize(const std::string& str, bool requireHash, bool doUnescape) {
	return devices.locale.localize(str, requireHash, doUnescape);
	}

	static std::string getStackTrace(bool verbose) {
	return getStackTrace(asGetActiveContext(), verbose);
	}

	static void logExc(bool verbose) {
	auto* ctx = asGetActiveContext();
	if(ctx) {
	error("Script Exception: %s", ctx->GetExceptionString());
	error(getStackTrace(asGetActiveContext(), verbose));
	}
	}

	static bool scriptFuncSplit(const std::string& input, std::string* name, CScriptArray* arguments, bool strip) {
	std::vector<std::string> args;
	if(!funcSplit(input, *name, args, strip))
	return false;

	arguments->Resize(args.size());
	for(unsigned i = 0, cnt = args.size(); i < cnt; ++i)
	(std::string)arguments->At(i) = args[i];
	return true;
	}

	#define a(n) const std::string& a##n
	#define v(n) a##n

	std::string format_1(const std::string& text, a(1)) {
	return format(text.c_str(), v(1));
	}

	std::string format_2(const std::string& text, a(1), a(2)) {
	return format(text.c_str(), v(1), v(2));
	}

	std::string format_3(const std::string& text, a(1), a(2), a(3)) {
	return format(text.c_str(), v(1), v(2), v(3));
	}

	std::string format_4(const std::string& text, a(1), a(2), a(3), a(4)) {
	return format(text.c_str(), v(1), v(2), v(3), v(4));
	}

	std::string format_5(const std::string& text, a(1), a(2), a(3), a(4), a(5)) {
	return format(text.c_str(), v(1), v(2), v(3), v(4), v(5));
	}

	std::string format_n(const std::string& text, CScriptArray* arguments) {
	FormatArg argbuf[32];
	unsigned argn = arguments->GetSize();
	for(unsigned i = 0; i < argn && i < 32; ++i)
	argbuf[i] = FormatArg((const std::string)arguments->At(i));

	std::string output;
	format(output, text.c_str(), argn, argbuf);
	return output;
	}

	template<class T>
	T absceil(T a) {
	return a > 0 ? ceil(a) : floor(a);
	}

	template<class T>
	T absfloor(T a) {
	return a > 0 ? floor(a) : ceil(a);
	}

	template<class T>
	T scr_max(T a, T b) {
	return a < b ? b : a;
	}

	template<class T, class S>
	T scr_mix_max(T a, S b) {
	return a < (T)b ? (T)b : a;
	}

	template<class T>
	T scr_min(T a, T b) {
	return b < a ? b : a;
	}

	template<class T, class S>
	T scr_mix_min(T a, S b) {
	return (T)b < a ? (T)b : a;
	}

	template<class T>
	T clamp(T val, T _min, T _max) {
	if(val < _min)
	return _min;
	if(val > _max)
	return _max;
	return val;
	}

	void QuarticRoots(double a, double b, double c, double d, double e, CScriptArray& out) {
	double coeffs[5] = {e,d,c,b,a};
	double roots[4];
	int rootCount = FindQuarticRoots(coeffs, roots);
	out.Resize((asUINT)rootCount);
	for(int i = 0; i < rootCount; ++i)
	(double)out.At(i) = roots[i];
	}

	const double straightDot = 0.99999;

	//Special case of quadratic root solution for newtonian motion
	double lowerQuadratic(double a, double b, double c) {
	double det = bb - 4.0a*c;
	if(det < 0.0)
	return 1000.0;
	double d = sqrt(det);
	double r = (-b - d) / (2.0 * a);
	if(r > 0.0)
	return r;
	else
	return 1000.0;
	}

	double newtonArrivalTime(double a, const vec3d& p, const vec3d& v) {
	if(a < 1.0e-4 \|\| a != a)
	a = 1.0e-4;
	double dist = p.getLength();
	double speed = v.getLengthSQ();
	if(speed < 0.004)
	return sqrt(4.0 * dist / a);
	speed = sqrt(speed);

	double velDot = 1.0;
	if(dist > 0.001)
	velDot = v.dot(p) / (dist * speed);

	if(velDot > straightDot) {
	//We must accelerate up to the target speed before hitting the point

	// d = 1/2 a * t^2 (where t = v/a)
	double accelDist = 0.5 * speed * speed / a;

	if(accelDist > dist) {
	return lowerQuadratic(-a, 2.0 * speed, dist - accelDist);
	}
	else {
	//We have enough distance
	//Accelerate until we must decelerate
	double totalTime = sqrt(4.0 * (dist - accelDist) / a);
	return totalTime + (speed / a);
	}
	}
	else if(velDot < -straightDot) {
	double deccelTime = speed / a;
	double deccelDist = deccelTime * speed * 0.5;

	//We either need to slow down, or accelerate to a maximum velocity
	if(deccelDist < dist) {
	double totalTime = sqrt(4.0 * (deccelDist + dist) / a);
	return totalTime - (speed / a);
	}
	else {
	return deccelTime + sqrt(4.0 * (deccelDist - dist) / a);
	}
	}
	else {
	vec3d linearVel = p.normalized(speed * velDot);
	vec3d latVel = v - linearVel;
	vec3d zero;

	double aToward = 0.7;

	double rangeLow = 0.0001, rangeHigh = 0.9999;
	double t = 0, leastErr = 99999999.0;
	for(unsigned i = 0; i < 15; ++i) {
	double aLat = sqrt(1.0 - (aToward * aToward));

	double tToward = newtonArrivalTime(aToward * a, p, linearVel);
	double tLat = newtonArrivalTime(aLat * a, zero, latVel);

	double err = abs(tToward - tLat);
	if(err < leastErr) {
	leastErr = err;
	t = (tToward + tLat) * 0.5;
	}

	if(err < 0.02)
	break;
	else if(tToward > tLat) {
	rangeLow = aToward;
	aToward = (rangeLow + rangeHigh) * 0.5;
	}
	else {
	rangeHigh = aToward;
	aToward = (rangeLow + rangeHigh) * 0.5;
	}
	}

	return t;
	}
	}

	void throwScriptError(const std::string& str) {
	scripts::throwException(str.c_str());
	}

	void _print(bool v) {
	if(v)
	print("true");
	else
	print("false");
	}

	void _print(int v) {
	std::string str =toString<int>(v);
	print(str);
	}

	void _print(unsigned v) {
	std::string str =toString<unsigned>(v);
	print(str);
	}

	void _print(float v) {
	std::string str =toString<float>(v);
	print(str);
	}

	void _print(double v) {
	std::string str =toString<double>(v);
	print(str);
	}

	void _print() {
	//Does nothing
	}

	void _print(void* ptr, int typeId) {
	auto* eng = asGetActiveContext()->GetEngine();
	auto* type = eng->GetTypeInfoById(typeId);

	if(ptr != nullptr && (typeId & asTYPEID_SCRIPTOBJECT))
	type = ((asIScriptObject*)ptr)->GetObjectType();
	print("%s at %p", type->GetName(), ptr);
	}

	std::string strPointer(void* ptr, int typeId) {
	auto* eng = asGetActiveContext()->GetEngine();
	auto* type = eng->GetTypeInfoById(typeId);
	if(ptr != nullptr && (typeId & asTYPEID_SCRIPTOBJECT))
	type = ((asIScriptObject*)ptr)->GetObjectType();

	std::stringstream ss;
	ss << '[';
	ss << type->GetName();
	ss << " at 0x";
	ss << std::hex << (size_t)ptr;
	ss << ']';

	return ss.str();
	}

	std::string dbgStr(void* ptr, int typeId) {
	auto* eng = asGetActiveContext()->GetEngine();
	return getScriptVariable(ptr, typeId, true, eng);
	}

	void dbgOut(void* ptr, int typeId, const std::string& prefix) {
	auto* eng = asGetActiveContext()->GetEngine();
	std::string err;
	if(!prefix.empty()) {
	err += prefix;
	err += " ";
	}
	err += eng->GetTypeDeclaration(typeId);
	err += " ";
	err += getScriptVariable(ptr, typeId, true, eng);
	error(err);
	}

	void dbgAll(const std::string& prefix) {
	if(!prefix.empty()) {
	error( "########################################");
	error(prefix);
	}
	error(getStackVariables(asGetActiveContext()));
	if(!prefix.empty()) {
	error( "########################################");
	}
	}

	int getRefCnt(void* ptr, int typeId) {
	if(ptr != nullptr && (typeId & asTYPEID_SCRIPTOBJECT))
	return (int)((asCScriptObject*)ptr)->GetRefCount();
	return -1;
	}

	long long dbgAddress(void* ptr, int typeId) {
	return (long long)ptr;
	}

	#ifdef WIN_MODE
	bool isWindows = true;
	#else
	bool isWindows = false;
	#endif
	#ifdef LIN_MODE
	bool isLinux = true;
	#else
	bool isLinux = false;
	#endif
	#ifdef MAC_MODE
	bool isMac = true;
	#else
	bool isMac = false;
	#endif

	static std::string archName = ARCH_NAME;
	static unsigned archBits = ARCH_BITS;

	template<class T>
	static T wrap_toNumber(const std::string& str) {
	return toNumber<T>(str);
	}

	static bool wrap_toBool(const std::string& str) {
	return toBool(str);
	}

	static vec3d toVec3d(const std::string& str) {
	vec3d v;
	int count = sscanf(str.c_str(), " ( %lf , %lf , %lf", &v.x, &v.y, &v.z);
	if(count == 3)
	return v;
	else
	return vec3d();
	}

	static void addConsComm(std::string& name, asIScriptObject* obj) {
	Manager* man = getActiveManager();
	asIScriptFunction* conCommandFunc = (asIScriptFunction*)man->engine->GetUserData(EDID_consoleCommand);

	if(!obj \|\| !conCommandFunc) {
	throwException("Unbound function called.");
	return;
	}

	obj->AddRef();

	Console::ConsoleFunction f;
	f.line = [obj,man,conCommandFunc](std::string& line) -> bool {
	Call cl = man->call(conCommandFunc);
	cl.setObject(obj);
	cl.push(&line);
	cl.call();
	return true;
	};

	f.destruct = [obj]() -> bool {
	obj->Release();
	return true;
	};

	console.addCommand(name, f);
	}

	static bool strIsWhitespace(const std::string& str, const std::string& substr) {
	return str.find_first_not_of(" \t\n\r") == std::string::npos;
	}

	static bool strContains(const std::string& str, const std::string& substr) {
	return str.find(substr) != std::string::npos;
	}

	static bool strContainsNC(const std::string& str, const std::string& substr) {
	return strfind_nocase(str, substr) != -1;
	}

	static bool startsWith(const std::string& str, const std::string& substr) {
	if(substr.size() > str.size())
	return false;
	return str.compare(0, substr.size(), substr) == 0;
	}

	static bool endsWith(const std::string& str, const std::string& substr) {
	if(substr.size() > str.size())
	return false;
	return str.compare(str.size() - substr.size(), substr.size(), substr) == 0;
	}

	static bool startsWithNC(const std::string& str, const std::string& substr) {
	return streq_nocase(str, substr, 0, substr.size());
	}

	static bool endsWithNC(const std::string& str, const std::string& substr) {
	return streq_nocase(str, substr, str.size() - substr.size(), substr.size());
	}

	static bool strEq_s(const std::string& str, const std::string& substr, int index) {
	if(substr.size() > str.size())
	return false;
	return str.compare(index, substr.size(), substr) == 0;
	}

	static bool strEq_sl(const std::string& str, const std::string& substr, int index, int length) {
	if(substr.size() > str.size())
	return false;
	return str.compare(index, length, substr) == 0;
	}

	static bool strEqNC_s(const std::string& str, const std::string& substr, int index) {
	return streq_nocase(str, substr, index);
	}

	static bool strEqNC_sl(const std::string& str, const std::string& substr, int index, int length) {
	return streq_nocase(str, substr, index, length);
	}

	static std::string getCurModule() {
	auto* ctx = asGetActiveContext();
	auto* func = ctx->GetFunction(ctx->GetCallstackSize() - 1);
	return std::string(func->GetModuleName());
	}

	void copyToClipboard(const std::string& str) {
	devices.driver->setClipboard(str);
	}

	std::string readFromClipboard() {
	return devices.driver->getClipboard();
	}

	static void toggleConsole() {
	console.toggle();
	}

	static double angleDiff(double a, double b) {
	double diff = a - b;
	if(diff < -pi) {
	do {
	diff += twopi;
	} while(diff < -pi);
	}
	else if(diff > pi) {
	do {
	diff -= twopi;
	} while(diff > pi);
	}

	return diff;
	}

	static bool isCloudActive() {
	return devices.cloud != nullptr;
	}

	static void inviteCloudFriend() {
	if(devices.cloud)
	devices.cloud->inviteFriend();
	}

	static std::string getCloudNickname() {
	if(devices.cloud == nullptr)
	return "";
	return devices.cloud->getNickname();
	}

	static bool inCloudLobby() {
	if(devices.cloud == nullptr)
	return false;
	return devices.cloud->getLobby() != 0;
	}

	static void enterCloudQueue(const std::string& type, unsigned players, const std::string& version) {
	if(devices.cloud == nullptr)
	return;
	devices.cloud->enterQueue(type, players, version);
	}

	static bool cloudQueueReady() {
	if(devices.cloud == nullptr)
	return false;
	return devices.cloud->queueReady();
	}

	static bool cloudQueueRequest() {
	if(devices.cloud == nullptr)
	return false;
	return devices.cloud->queueRequest();
	}

	static void cloudQLeave() {
	if(devices.cloud)
	devices.cloud->leaveQueue();
	}

	static void cloudQAccept() {
	if(devices.cloud)
	devices.cloud->acceptQueue();
	}

	static void cloudQReject() {
	if(devices.cloud)
	devices.cloud->rejectQueue();
	}

	static double cloudQTime() {
	if(devices.cloud == nullptr)
	return 0;
	return (double)devices.cloud->remainingTime() / 1000.0;
	}

	static unsigned cloudQPlayers() {
	if(devices.cloud == nullptr)
	return 0;
	return devices.cloud->queueTotalPlayers();
	}

	static bool cloudInQ() {
	if(devices.cloud == nullptr)
	return false;
	return devices.cloud->inQueue();
	}

	static bool cloudQWaiting(unsigned& ready, unsigned& cap) {
	ready = 0;
	cap = 0;

	if(devices.cloud == nullptr)
	return false;
	return devices.cloud->queuePlayerWait(ready, cap);
	}

	void cloudCreateItem(const std::string& folder) {
	if(!devices.cloud) return;
	if(!isAccessible(folder)) return;
	devices.cloud->createCloudItem(folder);
	}

	void cloudCloseItem() {
	if(devices.cloud) devices.cloud->closeItem();
	}

	bool cloudItemReady() {
	if(!devices.cloud)
	return false;
	return devices.cloud->isItemActive();
	}

	unsigned long long cloudItemID() {
	if(!devices.cloud)
	return 0;
	return devices.cloud->getItemID();
	}

	void cloudItemTitle(const std::string& title) {
	if(!devices.cloud) return;
	devices.cloud->setItemTitle(title);
	}

	void cloudItemDesc(const std::string& desc) {
	if(!devices.cloud) return;
	devices.cloud->setItemDescription(desc);
	}

	void cloudItemFolder(const std::string& folder) {
	if(!devices.cloud) return;
	if(!isAccessible(folder)) return;
	devices.cloud->setItemContents(folder);
	}

	void cloudItemImage(const std::string& image) {
	if(!devices.cloud) return;
	if(!isAccessible(image)) return;

	devices.cloud->setItemImage(devices.mods.resolve(image));
	}

	void cloudItemTags(CScriptArray& sTags) {
	if(!devices.cloud) return;

	std::vector<std::string> tags;
	tags.reserve(sTags.GetSize());
	for(unsigned i = 0; i < sTags.GetSize(); ++i)
	tags.push_back((std::string)sTags.At(i));

	devices.cloud->setItemTags(tags);
	}

	void cloudItemVisible() {
	if(!devices.cloud) return;
	devices.cloud->setItemVisibility();
	}

	void cloudItemCommit(const std::string& log) {
	if(!devices.cloud) return;
	devices.cloud->commitItem(log);
	}

	double cloudItemProgress() {
	if(!devices.cloud)
	return 0;
	return devices.cloud->getUploadProgress();
	}

	bool cloudItemUploading() {
	if(!devices.cloud)
	return false;
	return devices.cloud->isItemUpdating();
	}

	void cloudLegal() {
	if(devices.cloud) devices.cloud->openURL("http://steamcommunity.com/sharedfiles/workshoplegalagreement");
	}

	#ifdef _MSC_VER
	threads::threadreturn threadcall openURL(void* arg) {
	std::string* pStr = (std::string*)arg;
	ShellExecute(NULL, "open", pStr->c_str(), NULL, NULL, SW_SHOW);
	delete pStr;
	return 0;
	}
	#endif

	static void openBrowser(const std::string& url) {
	if(!startsWithNC(url, "http://") && !startsWithNC(url, "https://"))
	return;
	if(devices.cloud) {
	devices.cloud->openURL(url);
	return;
	}
	#ifdef __GNUC__
	if(fork() == 0) {
	execlp("xdg-open", "xdg-open", url.c_str(), (char*)nullptr);
	exit(1);
	}
	#else
	threads::createThread(openURL, new std::string(url));
	#endif
	}

	static void openFileManager(const std::string& folder) {
	if(!isDirectory(folder) \|\| !isAccessible(folder))
	return;
	#ifdef __GNUC__
	if(fork() == 0) {
	execlp("xdg-open", "xdg-open", folder.c_str(), (char*)nullptr);
	exit(1);
	}
	#else
	threads::async([folder]() -> int {
	ShellExecute(NULL, "explore", folder.c_str(), NULL, NULL, SW_SHOWNORMAL);
	return 0;
	});
	#endif
	}

	#ifdef _DEBUG
	static void scrAssert(void* ptr, int tid) {
	assert(false);
	}
	#endif

	static void dumpGC() {
	auto* ctx = asGetActiveContext();
	auto* eng = (asCScriptEngine*)ctx->GetEngine();

	ENTERCRITICALSECTION(eng->gc.gcCritical);
	for(unsigned i = 0, cnt = eng->gc.gcOldObjects.GetLength(); i < cnt; ++i) {
	auto* type = eng->gc.gcOldObjects[i].type;
	auto* mod = type->GetModule();
	if(mod)
	print("%s::%s", type->GetModule()->GetName(), type->GetName());
	else
	print("::%s", type->GetName());
	}
	for(unsigned i = 0, cnt = eng->gc.gcNewObjects.GetLength(); i < cnt; ++i) {
	auto* type = eng->gc.gcNewObjects[i].type;
	auto* mod = type->GetModule();
	if(mod)
	print("%s::%s", type->GetModule()->GetName(), type->GetName());
	else
	print("::%s", type->GetName());
	}
	LEAVECRITICALSECTION(eng->gc.gcCritical);
	}

	void RegisterGeneralBinds(bool server, bool shadow) {
	//Debugging functions
	bind("void print(const string &)", asFUNCTIONPR(print,(const std::string&),void));
	bind("void info(const string &)", asFUNCTIONPR(info,(const std::string&),void));
	bind("void warn(const string &)", asFUNCTIONPR(warn,(const std::string&),void));
	bind("void error(const string &)", asFUNCTIONPR(error,(const std::string&),void));
	bind("void throw(const string &)", asFUNCTION(throwScriptError));

	bind("void dumpGC()", asFUNCTION(dumpGC));

	bind("string getStackTrace(bool verbose = false)", asFUNCTIONPR(getStackTrace, (bool), std::string));
	bind("string get___module__()", asFUNCTION(getCurModule));

	bind("void openBrowser(const string& url)", asFUNCTION(openBrowser))
	doc("Open a URI in the user's configured browser.", "URI to open.");
	bind("void openFileManager(const string& folder)", asFUNCTION(openFileManager))
	doc("Open a folder in the user's configured file manager.", "Folder to open.");

	bindGlobal("uint errorVersion", &reportVersion)
	doc("Value reported to Steam when an exception occurs.");

	bind("bool hasDLC(const string& name)", asFUNCTION(hasDLC));

	#ifdef _DEBUG
	//Use temporarily while debugging to break from scripts
	bind("void __break(?&)", asFUNCTION(scrAssert));
	#endif

	//Bind all the locales
	{
	Namespace ns("locale");

	foreach(it, devices.locale.localizations)
	bindGlobal(format("::string $1", it->first).c_str(), it->second);
	}

	//Platform detection
	bindGlobal("bool isWindows", &isWindows);
	bindGlobal("bool isLinux", &isLinux);
	bindGlobal("bool isMac", &isMac);
	bindGlobal("uint ArchBits", &archBits);
	bindGlobal("string ArchName", &archName);

	//Global game state
	bindGlobal("bool isLoadedSave", &isLoadedGame);
	bindGlobal("int SAVE_VERSION", &SAVE_VERSION);
	bindGlobal("int START_VERSION", &START_VERSION);
	bindGlobal("bool game_running", &game_running);
	bindGlobal("bool game_ending", &gameEnding)
	doc("True while the game is being cleaned up for exit.");
	bindGlobal("bool inGalaxyCreation", &Object::GALAXY_CREATION);

	//Maximums
	bindGlobal("int INT_MAX", (void*)&_INT_MAX);
	bindGlobal("int INT_MIN", (void*)&_INT_MIN);
	bindGlobal("uint UINT_MAX", (void*)&_UINT_MAX);
	bindGlobal("double INFINITY", (void*)&_D_INFINITY);
	bindGlobal("float FLOAT_INFINITY", (void*)&_F_INFINITY);
	bindGlobal("const string BUILD_VERSION", (void*)&_BUILD_NAME);
	bindGlobal("const bool IS_STEAM_BUILD", (void*)&isSteamBuild);

	//Engine detection
	if(server) {
	bindGlobal("bool isServer", (void*)&_TRUE);
	bindGlobal("bool isClient", (void*)&_FALSE);
	}
	else {
	bindGlobal("bool isServer", (void*)&_FALSE);
	bindGlobal("bool isClient", (void*)&_TRUE);
	}

	if(shadow)
	bindGlobal("bool isShadow", (void*)&_TRUE);
	else
	bindGlobal("bool isShadow", (void*)&_FALSE);

	//Networking detection
	bind("bool get_mpClient()", asFUNCTION(mpClient));
	bind("bool get_mpServer()", asFUNCTION(mpServer));
	bind("uint get_mpGalaxiesInFlight()", asFUNCTION(mpGalaxiesInFlight));
	bind("bool get_mpIsSerializing()", asFUNCTION(mpIsSerializing));
	bind("bool get_isScriptDebug()", asFUNCTION(isTestScripts));
	bind("bool get_isModdedGame()", asFUNCTION(isModdedGame));

	if(!server && !shadow) {
	bind("void mpConnect(const string& address, int port = 2048, const string& password = \"\")", asFUNCTION(mpConnect));
	bind("void mpDisconnect()", asFUNCTION(mpDisconnect));
	bind("bool mpIsConnected()", asFUNCTION(mpIsConnected));
	bind("bool mpIsConnecting()", asFUNCTION(mpIsConnecting));
	bind("void mpSetPassword(const string& str)", asFUNCTION(mpSetPassword));
	}

	//Timing functions
	bind("double getExactTime()", asFUNCTION(getExactTime))
	doc("Returns nanosecond-accurate system time in seconds (slow).", "");

	bind("double get_gameTime()", asFUNCTION(getGameTime))
	doc("Returns the current game clock, updated periodically, in seconds.", "");
	bind("double get_frameGameTime()", asFUNCTION(getFrameGameTime))
	doc("Returns the current frame's game time, updated every frame, in seconds.", "");
	bind("double get_frameTime()", asFUNCTION(getFrameTime))
	doc("Returns the current frame time in seconds.", "");
	bind("double get_frameLength()", asFUNCTION(getFrameLength))
	doc("Returns the timespan represented by this frame in seconds.", "");
	bind("uint get_systemTime()", asFUNCTION(getBasicTime))
	doc("Returns millisecond-accurate system time in milliseconds.", "");

	bind("double get_gameSpeed()", asFUNCTION(getGameSpeed));
	bind("void set_gameSpeed(double speed)", asFUNCTION(setGameSpeed));

	//Randomness
	bind("double randomd()", asFUNCTIONPR(randomd, (), double))
	doc("Generate a random double value.", "Random value from [0.0,1.0).");

	bind("double randomd(double min, double max)", asFUNCTIONPR(randomd, (double, double), double))
	doc("Generate a random double value.", "Minimum return.", "Maximum return (non-inclusive).", "Random value from [min,max).");

	bind("float randomf()", asFUNCTIONPR(randomf, (), float))
	doc("Generate a random float value.", "Random value from [0.f,1.f).");

	bind("float randomf(float min, float max)", asFUNCTIONPR(randomf, (float, float), float))
	doc("Generate a random float value.", "Minimum return.", "Maximum return (non-inclusive).", "Random value from [min,max).");

	bind("uint randomi()", asFUNCTIONPR(randomi, (), unsigned))
	doc("Generate a random uint value.", "Random value from 0 to UINT_MAX, inclusive.");
	bind("int randomi(int min, int max)", asFUNCTIONPR(randomi, (int, int), int))
	doc("Generate a random int value.", "Minimum return.", "Maximum return (inclusive).", "Random value from min to max, inclusive.");

	bind("uint sysRandomi()", asFUNCTION(sysRandomi))
	doc("Attempts to generate a high-quality random number. May fall back to a weaker random generation. Slow.", "");

	bind("double normald(double min, double max, int steps = 3)", asFUNCTION(normald))
	doc("Generates an approximately normally distributed value within a range, within an average return at the mean of min and max.", "Minimum return", "Maximum return (non-inclusive)", "Number of steps to iterate (more is a tighter distribution)", "Random value from [min,max)");

	bind("vec3d random3d(double radius = 1.0)", asFUNCTIONPR(random3d, (double), vec3d))
	doc("Generates a random 3D rotation, uniformly distributed over a sphere surface.",
	"Radius of sphere.", "Random rotation vector.");

	bind("vec2d random2d(double radius = 1.0)", asFUNCTIONPR(random2d, (double), vec2d))
	doc("Generates a random 2D rotation, uniformly distributed over a circle's circumference.",
	"Radius of circle.", "Random rotation vector.");

	bind("vec3d random3d(double minRadius, double maxRadius)", asFUNCTIONPR(random3d, (double, double), vec3d))
	doc("Generates a random 3D rotation, distributed evenly on the volume between minRadius and maxRadius.",
	"Minimum radius of the vector.", "Maximum radius of the vector.", "Random rotation vector.");

	bind("vec2d random2d(double minRadius, double maxRadius)", asFUNCTIONPR(random2d, (double, double), vec2d))
	doc("Generates a random 2D rotation, distributed evenly on the area between minRadius and maxRadius.",
	"Minimum radius of the vector.", "Maximum radius of the vector.", "Random rotation vector.");

	//Math
	bind("double sqr(double)", asFUNCTION(sqr<double>));
	bind("float sqr(float)", asFUNCTION(sqr<float>));
	bind("int sqr(int)", asFUNCTION(sqr<int>));

	bind("double max(double, double)", asFUNCTION(scr_max<double>));
	bind("int max(int, int)", asFUNCTION(scr_max<int>));
	bind("uint max(uint, uint)", asFUNCTION(scr_max<unsigned>));
	bind("uint max(uint, int)", asFUNCTION((scr_mix_max<unsigned,int>)));
	bind("int max(int, uint)", asFUNCTION((scr_mix_max<int,unsigned>)));

	bind("double min(double, double)", asFUNCTION(scr_min<double>));
	bind("int min(int, int)", asFUNCTION(scr_min<int>));
	bind("uint min(uint, uint)", asFUNCTION(scr_min<unsigned>));
	bind("uint min(uint, int)", asFUNCTION((scr_mix_min<unsigned,int>)));
	bind("int min(int, uint)", asFUNCTION((scr_mix_min<int,unsigned>)));

	bind("double clamp(double value, double minimum, double maximum)", asFUNCTION(clamp<double>))
	doc("Clamps the value to within the specified range.", "", "", "", "");
	bind("int clamp(int value, int minimum, int maximum)", asFUNCTION(clamp<int>))
	doc("Clamps the value to within the specified range.", "", "", "", "");

	bind("int abs(int)", asFUNCTIONPR(abs, (int), int));

	bind("double absceil(double)", asFUNCTION(absceil<double>));
	bind("float absceil(float)", asFUNCTION(absceil<float>));

	bind("double absfloor(double)", asFUNCTION(absfloor<double>));
	bind("float absfloor(float)", asFUNCTION(absfloor<float>));

	bind("double angleDiff(double a, double b)", asFUNCTION(angleDiff));
	bind("void quarticRoots(double a, double b, double c, double d, double e, array<double>& roots)", asFUNCTION(QuarticRoots))
	doc("Calculates all real roots of a quartic polynomial.", "Coefficient A", "Coefficient B", "Coefficient C", "Coefficient D", "Coefficient E", "Array to return roots in.");

	bind("double newtonArrivalTime(double accel, const vec3d& offset, const vec3d& relativeVelocity)", asFUNCTION(newtonArrivalTime));

	//String manipulation
	bind("void u8append(string&, int)", asFUNCTION(u8append));
	bind("int u8pos(const string &in, int, int)", asFUNCTION(u8pos));
	bind("int u8get(const string &in, int)", asFUNCTION(u8get));
	bind("void u8next(const string &in, int&, int&)", asFUNCTION(u8next));
	bind("void u8prev(const string &in, int&, int&)", asFUNCTION(u8prev));
	bind("int u8(int)", asFUNCTION(u8prev));

	bind("void appendRoman(int num, const string& str)", asFUNCTIONPR(romanNumerals, (unsigned, std::string&), void));
	bind("void toLowercase(string&)", asFUNCTION(toLowercase));
	bind("void toUppercase(string&)", asFUNCTION(toUppercase));
	bind("uint8 uppercase(uint8)", asFUNCTION(uppercase));
	bind("uint8 lowercase(uint8)", asFUNCTION(lowercase));
	bind("string unescape(const string&in)", asFUNCTION(unescape));
	bind("string escape(const string&in)", asFUNCTION(escape));

	bind("string localize(const string& in, bool requireHash = false, bool doUnescape = true)", asFUNCTION(localize));
	bind("Color toColor(const string& in)", asFUNCTION(toColor));

	bind("string toString(double num, uint precision = 5)", asFUNCTION(toString<double>));
	bind("string toString(float num, uint precision = 5)", asFUNCTION(toString<float>));
	bind("string toString(int num, uint precision = 5)", asFUNCTION(toString<int>));
	bind("string toString(uint num, uint precision = 5)", asFUNCTION(toString<unsigned>));
	bind("string toString(Color color)", asFUNCTION(toString<Color>));

	bind("string standardize(double value, bool showIntegral = false, bool roundUp = false)", asFUNCTION(standardize));
	bind("bool funcSplit(const string& input, string&out funcName, array<string>& arguments, bool strip = true)", asFUNCTION(scriptFuncSplit));

	bind("float toFloat(const string &in str)", asFUNCTION(wrap_toNumber<float>));
	bind("double toDouble(const string &in str)", asFUNCTION(wrap_toNumber<double>));
	bind("int toInt(const string &in str)", asFUNCTION(wrap_toNumber<int>));
	bind("uint toUInt(const string &in str)", asFUNCTION(wrap_toNumber<unsigned>));

	bind("bool toBool(const string &in str)", asFUNCTION(wrap_toBool));

	bind("vec3d toVec3d(const string &in str)", asFUNCTION(toVec3d))
	doc("Parses a vec3d printed by vec3d::toString()", "", "");

	//Add stuff to string
	ClassBind str("string");
	str.addExternMethod("bool toBool() const", asFUNCTION(wrap_toBool));
	str.addExternMethod("int toInt() const", asFUNCTION(wrap_toNumber<int>));
	str.addExternMethod("uint toUint() const", asFUNCTION(wrap_toNumber<unsigned>));
	str.addExternMethod("float toFloat() const", asFUNCTION(wrap_toNumber<float>));
	str.addExternMethod("double toDouble() const", asFUNCTION(wrap_toNumber<double>));
	str.addExternMethod("vec3d toVec3d() const", asFUNCTION(toVec3d));

	str.addExternMethod("string trimmed() const", asFUNCTIONPR(trim, (const std::string&), std::string));
	str.addExternMethod("string& paragraphize(const string& parSep, const string& lineSep, bool startsParagraph = false)", asFUNCTION(paragraphize));
	str.addExternMethod("string& replace(const string& replace, const string& with)", asFUNCTION(replace));
	str.addExternMethod("string replaced(const string& replace, const string& with) const", asFUNCTION(replaced));
	str.addExternMethod("bool isWhitespace() const", asFUNCTION(strIsWhitespace));
	str.addExternMethod("bool contains(const string &in) const", asFUNCTION(strContains));
	str.addExternMethod("bool contains_nocase(const string &in) const", asFUNCTION(strContainsNC));
	str.addExternMethod("int findFirst_nocase(const string &in, uint start = 0) const", asFUNCTION(strfind_nocase));
	str.addExternMethod("bool startswith(const string &in) const", asFUNCTION(startsWith));
	str.addExternMethod("bool endswith(const string &in) const", asFUNCTION(endsWith));
	str.addExternMethod("bool startswith_nocase(const string &in) const", asFUNCTION(startsWithNC));
	str.addExternMethod("bool endswith_nocase(const string &in) const", asFUNCTION(endsWithNC));
	str.addExternMethod("bool equals(const string &in, int start) const", asFUNCTION(strEq_s));
	str.addExternMethod("bool equals(const string &in, int start, int length) const", asFUNCTION(strEq_sl));
	str.addExternMethod("bool equals_nocase(const string &in, int start = 0) const", asFUNCTION(strEqNC_s));
	str.addExternMethod("bool equals_nocase(const string &in, int start, int length) const", asFUNCTION(strEqNC_sl));

	if(!server) {
	bind("void setClipboard(const string &in)", asFUNCTION(copyToClipboard));
	bind("string getClipboard()", asFUNCTION(readFromClipboard));
	}

	//Adding console commands
	InterfaceBind ccomm("ConsoleCommand");
	classdoc(ccomm, "Interface to implement for script console commands.");

	asIScriptFunction* pConsoleCommand;
	ccomm.addMethod("void execute(const string& args)", &pConsoleCommand)
	doc("Called whenever this command was invoked, with all extra text passed to the command.", "Additional text passed after the command.");

	getEngine()->SetUserData(pConsoleCommand, EDID_consoleCommand);

	bind("void addConsoleCommand(const string& name, ConsoleCommand@ comm)", asFUNCTION(addConsComm))
	doc("Registers a script console command.", "Command name to use the command.", "Instance of a command to call.");
	bind("void toggleConsole()", asFUNCTION(toggleConsole));

	//Constants
	bindGlobal("const double e", (void*)&e);
	bindGlobal("const double pi", (void*)&pi);
	bindGlobal("const double twopi", (void*)&twopi);

	//Special print functions are used by the console
	//to print the resulting values of a command line
	bind("void print(bool)", asFUNCTIONPR(_print, (bool), void));
	bind("void print(int)", asFUNCTIONPR(_print, (int), void));
	bind("void print(uint)", asFUNCTIONPR(_print, (unsigned), void));
	bind("void print(float)", asFUNCTIONPR(_print, (float), void));
	bind("void print(double)", asFUNCTIONPR(_print, (double), void));
	bind("void print(const ?&)", asFUNCTIONPR(_print, (void*, int), void));
	bind("void print()", asFUNCTIONPR(_print, (), void));
	bind("void printTrace(bool verbose = false)", asFUNCTION(logExc));
	bind("uint64 addressof(const ?&)", asFUNCTION(dbgAddress));
	bind("string addrstr(const ?&)", asFUNCTION(strPointer));
	bind("string dbgstr(const ?&)", asFUNCTION(dbgStr));
	bind("void dbg(const ?&, const string& prefix = \"\")", asFUNCTION(dbgOut));
	bind("void dbg(const string& prefix = \"\")", asFUNCTION(dbgAll));
	bind("int refcnt(const ?&)", asFUNCTION(getRefCnt));

	//Locale access
	bind("string format(const string &in fmt, const string &in)", asFUNCTION(format_1))
	doc("Replaces $n in fmt with the related argument.", "Format to use.", "$1", "Formatted string.");
	bind("string format(const string &in fmt, const string &in, const string &in)", asFUNCTION(format_2))
	doc("Replaces $n in fmt with the related argument.", "Format to use.", "$1", "$2", "Formatted string.");
	bind("string format(const string &in fmt, const string &in, const string &in, const string &in)", asFUNCTION(format_3))
	doc("Replaces $n in fmt with the related argument.", "Format to use.", "$1", "$2", "$3", "Formatted string.");
	bind("string format(const string &in fmt, const string &in, const string &in, const string &in, const string &in)", asFUNCTION(format_4))
	doc("Replaces $n in fmt with the related argument.", "Format to use.", "$1", "$2", "$3", "$4", "Formatted string.");
	bind("string format(const string &in fmt, const string &in, const string &in, const string &in, const string &in, const string &in)", asFUNCTION(format_5))
	doc("Replaces $n in fmt with the related argument.", "Format to use.", "$1", "$2", "$3", "$4", "$5", "Formatted string.");
	bind("string format(const string &in fmt, const array<string>& args)", asFUNCTION(format_n))
	doc("Replaces $n in fmt with the related argument.", "Format to use.", "Arguments.", "Formatted string.");

	//Cloud stuff
	{
	Namespace ns("cloud");
	bind("bool get_isActive()", asFUNCTION(isCloudActive));
	bind("bool get_inLobby()", asFUNCTION(inCloudLobby));
	bind("string getNickname()", asFUNCTION(getCloudNickname));
	bind("void inviteFriend()", asFUNCTION(inviteCloudFriend));
	bind("void enterQueue(const string& type, uint players, const string& version)", asFUNCTION(enterCloudQueue));
	bind("bool get_isQueueReady()", asFUNCTION(cloudQueueReady));
	bind("bool get_queueRequest()", asFUNCTION(cloudQueueRequest));
	bind("bool get_inQueue()", asFUNCTION(cloudInQ));
	bind("void leaveQueue()", asFUNCTION(cloudQLeave));
	bind("void acceptQueue()", asFUNCTION(cloudQAccept));
	bind("void rejectQueue()", asFUNCTION(cloudQReject));
	bind("int queueTimer()", asFUNCTION(cloudQTime));
	bind("uint get_queuePlayers()", asFUNCTION(cloudQPlayers));
	bind("bool getQueuePlayerWait(uint &out ready, uint &out cap)", asFUNCTION(cloudQWaiting));

	bind("void prepItem(const string& folder)", asFUNCTION(cloudCreateItem))
	doc("Prepares an item for updating or creation. Wait a few frames for cloud::itemReady to be true.");
	bind("void closeItem()", asFUNCTION(cloudCloseItem));
	bind("bool get_itemReady()", asFUNCTION(cloudItemReady));
	bind("uint64 get_itemID()", asFUNCTION(cloudItemID));
	bind("void set_itemTitle(const string&)", asFUNCTION(cloudItemTitle));
	bind("void set_itemDescription(const string&)", asFUNCTION(cloudItemDesc));
	bind("void setItemContent(const string& folder)", asFUNCTION(cloudItemFolder));
	bind("void setItemImage(const string& filename)", asFUNCTION(cloudItemImage));
	bind("void setItemTags(array<string>& tags)", asFUNCTION(cloudItemTags));
	bind("void setItemPublic()", asFUNCTION(cloudItemVisible));
	bind("void commitItem(const string& changelog)", asFUNCTION(cloudItemCommit));
	bind("double get_uploadProgress()", asFUNCTION(cloudItemProgress));
	bind("bool get_isUploading()", asFUNCTION(cloudItemUploading));
	bind("void openLegalPrompt()", asFUNCTION(cloudLegal));
	}

	//Key actions
	EnumBind ka("KeyAction");
	ka["KA_Pressed"] = os::KA_Pressed;
	ka["KA_Released"] = os::KA_Released;
	ka["KA_Repeated"] = os::KA_Repeated;

	//Key constants
	EnumBind kc("KeyCode");
	for(unsigned int i = 0; i < 26; ++i) {
	std::string keyName = "KEY_";
	keyName.push_back(char('A' + i));

	std::string logicalName = "KEY_LOGICAL_";
	logicalName.push_back(char('A' + i));

	kc[keyName] = os::KEY_A + i;
	kc[logicalName] = devices.driver->getKeyForChar('A'+i);
	}

	kc["KEY_ESC"] = os::KEY_ESC;
	kc["KEY_F1"] = os::KEY_F1;
	kc["KEY_F2"] = os::KEY_F2;
	kc["KEY_F3"] = os::KEY_F3;
	kc["KEY_F4"] = os::KEY_F4;
	kc["KEY_F5"] = os::KEY_F5;
	kc["KEY_F6"] = os::KEY_F6;
	kc["KEY_F7"] = os::KEY_F7;
	kc["KEY_F8"] = os::KEY_F8;
	kc["KEY_F9"] = os::KEY_F9;
	kc["KEY_F10"] = os::KEY_F10;
	kc["KEY_F11"] = os::KEY_F11;
	kc["KEY_F12"] = os::KEY_F12;
	kc["KEY_F13"] = os::KEY_F13;
	kc["KEY_F14"] = os::KEY_F14;
	kc["KEY_F15"] = os::KEY_F15;
	kc["KEY_F16"] = os::KEY_F16;
	kc["KEY_F17"] = os::KEY_F17;
	kc["KEY_F18"] = os::KEY_F18;
	kc["KEY_F19"] = os::KEY_F19;
	kc["KEY_F20"] = os::KEY_F20;
	kc["KEY_F21"] = os::KEY_F21;
	kc["KEY_F22"] = os::KEY_F22;
	kc["KEY_F23"] = os::KEY_F23;
	kc["KEY_F24"] = os::KEY_F24;
	kc["KEY_F25"] = os::KEY_F25;
	kc["KEY_UP"] = os::KEY_UP;
	kc["KEY_DOWN"] = os::KEY_DOWN;
	kc["KEY_LEFT"] = os::KEY_LEFT;
	kc["KEY_RIGHT"] = os::KEY_RIGHT;
	kc["KEY_LSHIFT"] = os::KEY_LSHIFT;
	kc["KEY_RSHIFT"] = os::KEY_RSHIFT;
	kc["KEY_LCTRL"] = os::KEY_LCTRL;
	kc["KEY_RCTRL"] = os::KEY_RCTRL;
	kc["KEY_LALT"] = os::KEY_LALT;
	kc["KEY_RALT"] = os::KEY_RALT;
	kc["KEY_TAB"] = os::KEY_TAB;
	kc["KEY_ENTER"] = os::KEY_ENTER;
	kc["KEY_BACKSPACE"] = os::KEY_BACKSPACE;
	kc["KEY_INSERT"] = os::KEY_INSERT;
	kc["KEY_DEL"] = os::KEY_DEL;
	kc["KEY_PAGEUP"] = os::KEY_PAGEUP;
	kc["KEY_PAGEDOWN"] = os::KEY_PAGEDOWN;
	kc["KEY_HOME"] = os::KEY_HOME;
	kc["KEY_END"] = os::KEY_END;
	kc["KEY_KP_0"] = os::KEY_KP_0;
	kc["KEY_KP_1"] = os::KEY_KP_1;
	kc["KEY_KP_2"] = os::KEY_KP_2;
	kc["KEY_KP_3"] = os::KEY_KP_3;
	kc["KEY_KP_4"] = os::KEY_KP_4;
	kc["KEY_KP_5"] = os::KEY_KP_5;
	kc["KEY_KP_6"] = os::KEY_KP_6;
	kc["KEY_KP_7"] = os::KEY_KP_7;
	kc["KEY_KP_8"] = os::KEY_KP_8;
	kc["KEY_KP_9"] = os::KEY_KP_9;
	kc["KEY_KP_DIVIDE"] = os::KEY_KP_DIVIDE;
	kc["KEY_KP_MULTIPLY"] = os::KEY_KP_MULTIPLY;
	kc["KEY_KP_SUBTRACT"] = os::KEY_KP_SUBTRACT;
	kc["KEY_KP_ADD"] = os::KEY_KP_ADD;
	kc["KEY_KP_DECIMAL"] = os::KEY_KP_DECIMAL;
	kc["KEY_KP_EQUAL"] = os::KEY_KP_EQUAL;
	kc["KEY_KP_ENTER"] = os::KEY_KP_ENTER;
	kc["KEY_NUM_LOCK"] = os::KEY_NUM_LOCK;
	kc["KEY_CAPS_LOCK"] = os::KEY_CAPS_LOCK;
	kc["KEY_SCROLL_LOCK"] = os::KEY_SCROLL_LOCK;
	kc["KEY_PAUSE"] = os::KEY_PAUSE;
	kc["KEY_LSUPER"] = os::KEY_LSUPER;
	kc["KEY_RSUPER"] = os::KEY_RSUPER;
	kc["KEY_MENU"] = os::KEY_MENU;
	}

	};

	int FindCubicRoots(const double coeff[4], double x[3]) {
	/* Adjust coefficients */
	double a1 = coeff[2] / coeff[3];
	double a2 = coeff[1] / coeff[3];
	double a3 = coeff[0] / coeff[3];

	double Q = (a1 * a1 - 3 * a2) / 9;
	double R = (2 * a1 * a1 * a1 - 9 * a1 * a2 + 27 * a3) / 54;
	double Qcubed = Q * Q * Q;
	double d = Qcubed - R * R;

	/* Three real roots */
	if (d>=0)
	{
	double theta = acos(R / sqrt(Qcubed));
	double sqrtQ = sqrt(Q);

	x[0] = -2 * sqrtQ * cos( theta / 3) - a1 / 3;
	x[1] = -2 * sqrtQ * cos((theta + 2 * pi) / 3) - a1 / 3;
	x[2] = -2 * sqrtQ * cos((theta + 4 * pi) / 3) - a1 / 3;

	return (3);
	}
	/* One real root */
	else
	{
	double e = pow(sqrt(-d) + fabs(R), 1. / 3.);

	if (R > 0) e = -e;

	x[0] = (e + Q / e) - a1 / 3.;

	return (1);
	}
	}

	int FindQuarticRoots(const double coeff[5], double x[4]) {
	/* Adjust coefficients */

	double a1 = coeff[3] / coeff[4];
	double a2 = coeff[2] / coeff[4];
	double a3 = coeff[1] / coeff[4];
	double a4 = coeff[0] / coeff[4];

	/* Reduce to solving cubic equation */

	double q = a2 - a1a13/8;
	double r = a3 - a1a2/2 + a1a1*a1/8;
	double s = a4 - a1a3/4 + a1a1a2/16 - 3a1a1a1*a1/256;

	double coeff_cubic[4];
	double roots_cubic[3];
	double positive_root;

	coeff_cubic[3] = 1;
	coeff_cubic[2] = q/2;
	coeff_cubic[1] = (qq-4s)/16;
	coeff_cubic[0] = -r*r/64;

	int nRoots = FindCubicRoots(coeff_cubic,roots_cubic);

	for (int i=0; i<nRoots; i++)
	if (roots_cubic[i]>0) {
	positive_root = roots_cubic[i];
	break; //ADDED
	}

	/* Reduce to solving two quadratic equations */

	double k = sqrt(positive_root);
	double l = 2kk + q/2 - r/(4*k);
	double m = 2kk + q/2 + r/(4*k);

	nRoots = 0;

	if (k*k-l>0)
	{
	x[nRoots+0] = -k - sqrt(k*k-l) - a1/4;
	x[nRoots+1] = -k + sqrt(k*k-l) - a1/4;

	nRoots += 2;
	}

	if (k*k-m>0)
	{
	x[nRoots+0] = +k - sqrt(k*k-m) - a1/4;
	x[nRoots+1] = +k + sqrt(k*k-m) - a1/4;

	nRoots += 2;
	}

	return nRoots;
	}

File Metadata

Mime Type: text/x-c++
Expires: Sat, Nov 14, 11:29 PM (1 d, 12 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 130400
Default Alt Text: bind_general.cpp (42 KB)

bind_general.cppNo OneTemporaryActions

bind_general.cppView Options

File Metadata

Event Timeline

bind_general.cpp
No OneTemporary
Actions

bind_general.cpp
View Options