float almost_equals(float a, float b);
float almost_in_bounds(float a, float b, float c);
-vector rgb_to_hsl(vector rgb);
-vector hsl_to_rgb(vector hsl);
-vector rgb_to_hsv(vector rgb);
-vector hsv_to_rgb(vector hsv);
-string rgb_to_hexcolor(vector rgb);
-
float boxesoverlap(vector m1, vector m2, vector m3, vector m4);
float boxinsidebox(vector smins, vector smaxs, vector bmins, vector bmaxs);
/*
* Return a angle within +/- 360.
*/
+[[eraseable]]
float anglemods(float v)
{
v = v - 360 * floor(v / 360);
/*
* Return the short angle
*/
+[[eraseable]]
float shortangle_f(float ang1, float ang2)
{
if(ang1 > ang2)
return ang1;
}
+[[eraseable]]
vector shortangle_v(vector ang1, vector ang2)
{
vector vtmp;
return vtmp;
}
+[[eraseable]]
vector shortangle_vxy(vector ang1, vector ang2)
{
vector vtmp = '0 0 0';
* Return the angle offset between angle ang and angle of the vector from->to
*/
+[[eraseable]]
vector angleofs3(vector from, vector ang, vector to)
{
vector v_res;
#define BITSET(var, mask, flag) ((var) ^ (-(flag) ^ (var)) & (mask))
#endif
+[[eraseable]]
int lowestbit(int f)
{
f &= ~(f << 1);
return f;
}
+[[eraseable]]
int randombit(int bits)
{
if (!(bits & (bits - 1))) // this ONLY holds for powers of two!
return b;
}
+[[eraseable]]
int randombits(int bits, int k, bool error_return)
{
int r = 0;
OP_MINUS
};
+[[eraseable]]
bool GiveBit(entity e, .int fld, int bit, int op, int val)
{
int v0 = (e.(fld) & bit);
return v0 != v1;
}
+[[eraseable]]
bool GiveValue(entity e, .int fld, int op, int val)
{
int v0 = e.(fld);
#define boolean(value) ((value) != 0)
// get true/false value of a string with multiple different inputs
+[[eraseable]]
float InterpretBoolean(string input)
{
switch (strtolower(input))
#include "string.qh"
#define colormapPaletteColor(c, isPants) colormapPaletteColor_(c, isPants, time)
+[[eraseable]]
vector colormapPaletteColor_(int c, bool isPants, float t)
{
switch (c)
}
}
+[[eraseable]]
float rgb_mi_ma_to_hue(vector rgb, float mi, float ma)
{
if (mi == ma)
}
}
+[[eraseable]]
vector hue_mi_ma_to_rgb(float hue, float mi, float ma)
{
vector rgb;
return rgb;
}
+[[eraseable]]
vector rgb_to_hsv(vector rgb)
{
float mi, ma;
return hsv;
}
+[[eraseable]]
vector hsv_to_rgb(vector hsv)
{
return hue_mi_ma_to_rgb(hsv.x, hsv.z * (1 - hsv.y), hsv.z);
}
+[[eraseable]]
vector rgb_to_hsl(vector rgb)
{
float mi, ma;
return hsl;
}
+[[eraseable]]
vector hsl_to_rgb(vector hsl)
{
float mi, ma, maminusmi;
return hue_mi_ma_to_rgb(hsl.x, mi, ma);
}
+[[eraseable]]
string rgb_to_hexcolor(vector rgb)
{
return strcat(
_("CI_THI^%d seconds"), /* third */ \
_("CI_MUL^%d seconds")) /* multi */
+[[eraseable]]
string count_ordinal(int interval)
{
// This function is designed primarily for the English language, it's impossible
return "";
}
+[[eraseable]]
string count_fill(float interval, string zeroth, string first, string second, string third, string multi)
{
// This function is designed primarily for the English language, it's impossible
return "";
}
+[[eraseable]]
string process_time(float outputtype, float seconds)
{
float tmp_hours = 0, tmp_minutes = 0, tmp_seconds = 0;
#include "progname.qh"
#include "static.qh"
+[[eraseable]]
void RegisterCvars(void(string name, string def, string desc, bool archive, string file) f) {}
+[[eraseable]]
bool cvar_value_issafe(string s)
{
if (strstrofs(s, "\"", 0) >= 0) return false;
}
/** escape the string to make it safe for consoles */
+[[eraseable]]
string MakeConsoleSafe(string input)
{
input = strreplace("\n", "", input);
return input;
}
+[[eraseable]]
void cvar_describe(string name, string desc)
{
localcmd(sprintf("\nset %1$s \"$%1$s\" \"%2$s\"\n", name, MakeConsoleSafe(desc)));
}
+[[eraseable]]
void cvar_archive(string name)
{
localcmd(sprintf("\nseta %1$s \"$%1$s\"\n", name));
}
+[[eraseable]]
void RegisterCvars_Set(string name, string def, string desc, bool archive, string file)
{
cvar_describe(name, desc);
}
int RegisterCvars_Save_fd;
+[[eraseable]]
void RegisterCvars_Save(string name, string def, string desc, bool archive, string file)
{
if (!archive) return;
}
}
+ [[eraseable]]
void drawstringright(vector position, string text, vector theScale, vector rgb, float theAlpha, int flag)
{
position.x -= 2 / 3 * strlen(text) * theScale.x;
drawstring_builtin(position, text, theScale, rgb, theAlpha, flag);
}
+ [[eraseable]]
void drawstringcenter(vector position, string text, vector theScale, vector rgb, float theAlpha, int flag)
{
position.x = 0.5 * (vid_conwidth - 0.6025 * strlen(text) * theScale.x);
#pragma once
+[[eraseable]]
bool fexists(string f)
{
int fh = fopen(f, FILE_READ);
/**
* @deprecated prefer _("translated")
*/
+[[eraseable]]
string language_filename(string s)
{
string fn = prvm_language;
}
#endif
+[[eraseable]]
string CTX(string s)
{
#if CTX_CACHE
const int IL_MAX = 128;
+[[eraseable]]
void IL_INIT(entity this);
+[[eraseable]]
void IL_DTOR(entity this);
+[[eraseable]]
void IL_ENDFRAME();
/**
#define IL_LAST(this) (this.il_tail)
#define IL_PEEK(this) (this.il_tail)
+[[eraseable]]
bool IL_CONTAINS(IntrusiveList this, entity it)
{
assert(this, return false);
/**
* Push to tail
*/
+[[eraseable]]
entity IL_PUSH(IntrusiveList this, entity it)
{
assert(this, return NULL);
/**
* Push to head
*/
+[[eraseable]]
entity IL_UNSHIFT(IntrusiveList this, entity it)
{
assert(this, return NULL);
/**
* Pop from tail
*/
+[[eraseable]]
entity IL_POP(IntrusiveList this)
{
assert(this, return NULL);
/**
* Pop from head
*/
+[[eraseable]]
entity IL_SHIFT(IntrusiveList this)
{
assert(this, return NULL);
/**
* Remove any element, anywhere in the list
*/
+[[eraseable]]
void IL_REMOVE(IntrusiveList this, entity it)
{
assert(this, return);
#define IL_LISTS_PER_BIT IL_CEIL(IL_MAX / (3 * 24))
+[[eraseable]]
void IL_INIT(IntrusiveList this)
{
.entity nextfld, prevfld;
LOG_WARNF("IntrusiveList overflow");
}
+[[eraseable]]
void IL_DTOR(IntrusiveList this)
{
IL_CLEAR(this);
il_links[this.il_id] = NULL;
}
+[[eraseable]]
void IL_ENDFRAME()
{
#if 0
#endif
}
+[[eraseable]]
void ONREMOVE(entity this)
{
if (this.il_lists) {
// Current keys
int _json_keys;
+[[eraseable]]
bool _json_parse_object() {
JSON_BEGIN();
if (STRING_ITERATOR_GET(_json) != '{') JSON_FAIL("expected '{'");
JSON_END();
}
+ [[eraseable]]
bool _json_parse_members() {
JSON_BEGIN();
for (;;) {
JSON_END();
}
+ [[eraseable]]
bool _json_parse_pair() {
JSON_BEGIN();
if (!_json_parse_string(false)) JSON_FAIL("expected string");
JSON_END();
}
+[[eraseable]]
bool _json_parse_array() {
JSON_BEGIN();
if (STRING_ITERATOR_GET(_json) != '[') JSON_FAIL("expected '['");
JSON_END();
}
+[[eraseable]]
bool _json_parse_value() {
JSON_BEGIN();
if (!(_json_parse_string(true)
JSON_END();
}
+ [[eraseable]]
bool _json_parse_true() {
JSON_BEGIN();
if (!(STRING_ITERATOR_GET(_json) == 't'
JSON_END();
}
+ [[eraseable]]
bool _json_parse_false() {
JSON_BEGIN();
if (!(STRING_ITERATOR_GET(_json) == 'f'
JSON_END();
}
+ [[eraseable]]
bool _json_parse_null() {
JSON_BEGIN();
if (!(STRING_ITERATOR_GET(_json) == 'n'
JSON_END();
}
+[[eraseable]]
bool _json_parse_string(bool add) {
JSON_BEGIN();
if (STRING_ITERATOR_GET(_json) != '"') JSON_FAIL("expected opening '\"'");
JSON_END();
}
+[[eraseable]]
bool _json_parse_number() {
JSON_BEGIN();
if (!(_json_parse_float() || _json_parse_int())) JSON_FAIL("expected number");
JSON_END();
}
+ [[eraseable]]
bool _json_parse_float() {
JSON_BEGIN();
string s = "";
JSON_END();
}
+ [[eraseable]]
bool _json_parse_int() {
JSON_BEGIN();
string s = "";
JSON_END();
}
+[[eraseable]]
int json_parse(string in, bool() func) {
string trimmed = "";
LABEL(trim) {
return _json_buffer;
}
+[[eraseable]]
string json_get(int buf, string key)
{
for (int i = 1, n = buf_getsize(buf); i < n; i += 2) {
return string_null;
}
+[[eraseable]]
void json_del(int buf)
{
buf_del(buf);
}
+[[eraseable]]
void json_dump(int buf)
{
for (int i = 0, n = buf_getsize(buf); i < n; ++i) {
// Databases (hash tables)
const int DB_BUCKETS = 8192;
+[[eraseable]]
void db_save(int db, string filename)
{
int fh = fopen(filename, FILE_WRITE);
USING(HashMap, int);
+[[eraseable]]
int db_create()
{
return buf_create();
}
#define HM_NEW(this) (this = db_create())
+[[eraseable]]
void db_put(int db, string key, string value);
+[[eraseable]]
int db_load(string filename)
{
int db = buf_create();
return db;
}
+[[eraseable]]
void db_dump(int db, string filename)
{
int fh = fopen(filename, FILE_WRITE);
fclose(fh);
}
+[[eraseable]]
void db_close(int db)
{
buf_del(db);
}
#define HM_DELETE(this) db_close(this)
+[[eraseable]]
string db_get(int db, string key)
{
int h = crc16(false, key) % DB_BUCKETS;
#define db_remove(db, key) db_put(db, key, "")
+[[eraseable]]
void db_put(int db, string key, string value)
{
int h = crc16(false, key) % DB_BUCKETS;
}
#define HM_sets(this, key, val) db_put(this, key, val)
+/*
void db_test()
{
LOG_INFO("LOAD...\n");
db_close(db);
LOG_INFO("CLOSED.\n");
}
+*/
* - two spaces escape a linebreak (otherwise text wraps)
* - two linebreaks become a paragraph (remain unchanged)
*/
+[[eraseable]]
string markdown(string s)
{
string buf = "";
#include "lib/float.qh"
+[[eraseable]]
void mean_accumulate(entity e, .float a, .float c, float mean, float value, float weight)
{
if (weight == 0) return;
e.(c) += weight;
}
+[[eraseable]]
float mean_evaluate(entity e, .float a, .float c, float mean)
{
if (e.(c) == 0) return 0;
*/
+[[eraseable]]
float angc(float a1, float a2)
{
while (a1 > 180)
return a;
}
+[[eraseable]]
float fsnap(float val, float fsize)
{
return rint(val / fsize) * fsize;
}
+[[eraseable]]
vector vsnap(vector point, float fsize)
{
vector vret;
return vret;
}
+[[eraseable]]
vector lerpv(float t0, vector v0, float t1, vector v1, float t)
{
return v0 + (v1 - v0) * ((t - t0) / (t1 - t0));
}
+[[eraseable]]
vector bezier_quadratic_getpoint(vector a, vector b, vector c, float t)
{
return (c - 2 * b + a) * (t * t)
+ a;
}
+[[eraseable]]
vector bezier_quadratic_getderivative(vector a, vector b, vector c, float t)
{
return (c - 2 * b + a) * (2 * t)
+ (b - a) * 2;
}
+[[eraseable]]
float cubic_speedfunc(float startspeedfactor, float endspeedfactor, float spd)
{
return (((startspeedfactor + endspeedfactor - 2
) * spd;
}
+[[eraseable]]
bool cubic_speedfunc_is_sane(float startspeedfactor, float endspeedfactor)
{
if (startspeedfactor < 0 || endspeedfactor < 0) return false;
}
/** continuous function mapping all reals into -1..1 */
+[[eraseable]]
float float2range11(float f)
{
return f / (fabs(f) + 1);
}
/** continuous function mapping all reals into 0..1 */
+[[eraseable]]
float float2range01(float f)
{
return 0.5 + 0.5 * float2range11(f);
}
+[[eraseable]]
float median(float a, float b, float c)
{
return (a < c) ? bound(a, b, c) : bound(c, b, a);
}
+[[eraseable]]
float almost_equals(float a, float b)
{
float eps = (max(a, -a) + max(b, -b)) * 0.001;
return a - b < eps && b - a < eps;
}
+[[eraseable]]
float almost_equals_eps(float a, float b, float times_eps)
{
float eps = max(fabs(a), fabs(b)) * FLOAT_EPSILON * times_eps;
return a - b < eps && b - a < eps;
}
+[[eraseable]]
float almost_in_bounds(float a, float b, float c)
{
float eps = (max(a, -a) + max(c, -c)) * 0.001;
return b == median(a - eps, b, c + eps);
}
+[[eraseable]]
float ExponentialFalloff(float mindist, float maxdist, float halflifedist, float d)
{
if (halflifedist > 0) return (0.5 ** ((bound(mindist, d, maxdist) - mindist) / halflifedist));
#define power2of(e) (2 ** e)
+[[eraseable]]
float log2of(float e)
{
// NOTE: generated code
}
/** ax^2 + bx + c = 0 */
+[[eraseable]]
vector solve_quadratic(float a, float b, float c)
{
vector v;
class(Noise).float noise_paccum3;
class(Noise).float noise_bstate;
+[[eraseable]]
float Noise_Brown(entity e, float dt)
{
e.noise_baccum += random() * sqrt(dt); // same stddev for all dt
return e.noise_baccum;
}
+[[eraseable]]
float Noise_Pink(entity e, float dt)
{
float f;
if (random() > (0.9613 ** f)) e.noise_paccum3 = 0.43488 * (2 * random() - 1);
return e.noise_paccum + e.noise_paccum2 + e.noise_paccum3;
}
+[[eraseable]]
float Noise_White(entity e, float dt)
{
return random() * 2 - 1;
}
/** +1 or -1 */
+[[eraseable]]
float Noise_Burst(entity e, float dt, float p)
{
if (random() > (p ** dt)) e.noise_bstate = !e.noise_bstate;
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
+[[eraseable]]
vector vec_bias(vector v, float f)
{
vector c;
c.z = v.z + f;
return c;
}
+[[eraseable]]
vector vec_to_min(vector a, vector b)
{
vector c;
return c;
}
+[[eraseable]]
vector vec_to_max(vector a, vector b)
{
vector c;
}
// there may already be a function for bounding a vector in this manner, however my very quick search did not reveal one -- Player_2
+[[eraseable]]
vector vec_bounds_in(vector point, vector a, vector b)
{
vector d = vec_to_min(a, b);
return c;
}
+[[eraseable]]
vector vec_bounds_out(vector point, vector a, vector b)
{
vector d = vec_to_max(a, b);
return c;
}
+[[eraseable]]
float angle_snap_f(float f, float increment)
{
for (int j = 0; j <= 360; )
return 0;
}
+[[eraseable]]
vector angle_snap_vec(vector v, float increment)
{
vector c;
return c;
}
+[[eraseable]]
vector aim_vec(vector org, vector targ)
{
vector v;
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
+[[eraseable]]
vector vec_bias(vector v, float f);
+[[eraseable]]
vector vec_to_min(vector a, vector b);
+[[eraseable]]
vector vec_to_max(vector a, vector b);
// there may already be a function for bounding a vector in this manner, however my very quick search did not reveal one -- Player_2
+[[eraseable]]
vector vec_bounds_in(vector point, vector a, vector b);
+[[eraseable]]
vector vec_bounds_out(vector point, vector a, vector b);
+[[eraseable]]
float angle_snap_f(float f, float increment);
+[[eraseable]]
vector angle_snap_vec(vector v, float increment);
+[[eraseable]]
vector aim_vec(vector org, vector targ);
#include "random.qh"
+[[eraseable]]
void RandomSelection_Init()
{
RandomSelection_totalweight = 0;
RandomSelection_best_priority = -1;
}
+[[eraseable]]
void RandomSelection_Add(entity e, float f, string s, vector v, float weight, float priority)
{
if (priority > RandomSelection_best_priority)
float DistributeEvenly_amount;
float DistributeEvenly_totalweight;
+[[eraseable]]
void DistributeEvenly_Init(float amount, float totalweight)
{
if (DistributeEvenly_amount)
DistributeEvenly_totalweight = totalweight;
}
+[[eraseable]]
float DistributeEvenly_Get(float weight)
{
float f;
return f;
}
+[[eraseable]]
float DistributeEvenly_GetRandomized(float weight)
{
float f;
// from the GNU Scientific Library
float gsl_ran_gaussian_lastvalue;
float gsl_ran_gaussian_lastvalue_set;
+[[eraseable]]
float gsl_ran_gaussian(float sigma)
{
if (gsl_ran_gaussian_lastvalue_set)
string RandomSelection_chosen_string;
vector RandomSelection_chosen_vec;
+[[eraseable]]
void RandomSelection_Init();
+[[eraseable]]
void RandomSelection_Add(entity e, float f, string s, vector v, float weight, float priority);
#define RandomSelection_AddEnt(e, weight, priority) RandomSelection_Add(e, 0, string_null, '0 0 0', weight, priority)
#define RandomSelection_AddFloat(f, weight, priority) RandomSelection_Add(NULL, f, string_null, '0 0 0', weight, priority)
#define REGISTRY_HASH(id) Registry_hash_##id
+[[eraseable]]
[[accumulate]] void Registry_check(string r, string server) { }
+[[eraseable]]
[[accumulate]] void Registry_send_all() { }
#ifdef SVQC
/** <0 for <, ==0 for ==, >0 for > (like strcmp) */
USING(comparefunc_t, int (int i1, int i2, entity pass));
+[[eraseable]]
void heapsort(int n, swapfunc_t swap, comparefunc_t cmp, entity pass)
{
#define heapify(_count) \
}
}
+[[eraseable]]
void shuffle(float n, swapfunc_t swap, entity pass)
{
for (int i = 1; i < n; ++i)
#include "sortlist.qh"
+[[eraseable]]
entity Sort_Spawn()
{
entity sort = new_pure(sortlist);
float(int tmr) _gettime = #519;
#endif
+[[eraseable]]
void profile(string s)
{
static float g_starttime;
}
#endif
+[[eraseable]]
string seconds_tostring(float sec)
{
float minutes = floor(sec / 60);
return sprintf("%d:%02d", minutes, sec);
}
+[[eraseable]]
string format_time(float seconds)
{
seconds = floor(seconds + 0.5);
else return sprintf(_("%02d:%02d:%02d"), hours, minutes, seconds);
}
+[[eraseable]]
string mmsss(float tenths)
{
tenths = floor(tenths + 0.5);
return strcat(ftos(minutes), ":", substring(s, 1, 2), ".", substring(s, 3, 1));
}
+[[eraseable]]
string mmssss(float hundredths)
{
hundredths = floor(hundredths + 0.5);
int ColorTranslateMode;
+[[eraseable]]
string ColorTranslateRGB(string s)
{
return (ColorTranslateMode & 1) ? strdecolorize(s) : s;
#define startsWith(haystack, needle) (strstrofs(haystack, needle, 0) == 0)
+[[eraseable]]
bool startsWithNocase(string haystack, string needle)
{
return strcasecmp(substring(haystack, 0, strlen(needle)), needle) == 0;
#define endsWith(this, suffix) (_endsWith_suffix = suffix, substring(this, -strlen(_endsWith_suffix), -1) == _endsWith_suffix)
/** unzone the string, and return it as tempstring. Safe to be called on string_null */
+[[eraseable]]
string fstrunzone(string s)
{
if (!s) return s;
}
/** returns first word */
+[[eraseable]]
string car(string s)
{
int o = strstrofs(s, " ", 0);
}
/** returns all but first word */
+[[eraseable]]
string cdr(string s)
{
int o = strstrofs(s, " ", 0);
return substring(s, o + 1, strlen(s) - (o + 1));
}
+[[eraseable]]
string cons(string a, string b)
{
if (a == "") return b;
return strcat(a, " ", b);
}
+[[eraseable]]
string substring_range(string s, float b, float e)
{
return substring(s, b, e - b);
}
+[[eraseable]]
string swapwords(string str, float i, float j)
{
float n;
}
string _shufflewords_str;
+[[eraseable]]
void _shufflewords_swapfunc(float i, float j, entity pass)
{
_shufflewords_str = swapwords(_shufflewords_str, i, j);
}
+
+[[eraseable]]
string shufflewords(string str)
{
_shufflewords_str = str;
return str;
}
+[[eraseable]]
string unescape(string in)
{
in = strzone(in); // but it doesn't seem to be necessary in my tests at least
return str;
}
+[[eraseable]]
string strwords(string s, int w)
{
int endpos = 0;
#define strhasword(s, w) (strstrofs(strcat(" ", s, " "), strcat(" ", w, " "), 0) >= 0)
+[[eraseable]]
int u8_strsize(string s)
{
int l = 0;
return l;
}
+[[eraseable]]
bool isInvisibleString(string s)
{
s = strdecolorize(s);
// Multiline text file buffers
+[[eraseable]]
int buf_load(string pFilename)
{
int buf = buf_create();
return buf;
}
+[[eraseable]]
void buf_save(float buf, string pFilename)
{
int fh = fopen(pFilename, FILE_WRITE);
/**
* converts a number to a string with the indicated number of decimals
*/
+[[eraseable]]
string ftos_decimals(float number, int decimals)
{
// inhibit stupid negative zero
/**
* converts a number to a string with the minimum number of decimals
*/
+[[eraseable]]
string ftos_mindecimals(float number)
{
// inhibit stupid negative zero
return sprintf("%.7g", number);
}
+[[eraseable]]
int vercmp_recursive(string v1, string v2)
{
int dot1 = strstrofs(v1, ".", 0);
else return (dot2 == -1) ? 1 : vercmp_recursive(substring(v1, dot1 + 1, 999), substring(v2, dot2 + 1, 999));
}
+[[eraseable]]
int vercmp(string v1, string v2)
{
if (strcasecmp(v1, v2) == 0) return 0; // early out check
entity url_fromid[NUM_URL_ID];
int autocvar__urllib_nextslot;
+[[eraseable]]
float url_URI_Get_Callback(int id, float status, string data)
{
if (id < MIN_URL_ID) return 0;
}
}
+[[eraseable]]
void url_single_fopen(string url, int mode, url_ready_func rdy, entity pass)
{
entity e;
}
// close a file
+[[eraseable]]
void url_fclose(entity e)
{
int i;
}
// with \n (blame FRIK_FILE)
+[[eraseable]]
string url_fgets(entity e)
{
if (e.url_fh == URL_FH_CURL)
}
// without \n (blame FRIK_FILE)
+[[eraseable]]
void url_fputs(entity e, string s)
{
if (e.url_fh == URL_FH_CURL)
}
// multi URL object, tries URLs separated by space in sequence
+[[eraseable]]
void url_multi_ready(entity fh, entity me, float status)
{
float n;
}
me.url_ready(fh, me.url_ready_pass, status);
}
+
+[[eraseable]]
void url_multi_fopen(string url, int mode, url_ready_func rdy, entity pass)
{
float n;
// errors: -1, or negative HTTP status code
USING(url_ready_func, void (entity handle, entity pass, float status));
+[[eraseable]]
void url_single_fopen(string url, float mode, url_ready_func rdy, entity pass);
+[[eraseable]]
void url_fclose(entity e);
+[[eraseable]]
string url_fgets(entity e);
+[[eraseable]]
void url_fputs(entity e, string s);
// returns true if handled
+[[eraseable]]
float url_URI_Get_Callback(int id, float status, string data);
#define MIN_URL_ID URI_GET_URLLIB
#define NUM_URL_ID (URI_GET_URLLIB_END - URI_GET_URLLIB + 1)
+[[eraseable]]
void url_multi_fopen(string url, float mode, url_ready_func rdy, entity pass);
#if 1
#define cross(a, b) ((a) >< (b))
#else
+[[eraseable]]
vector cross(vector a, vector b)
{
return
const vector eY = '0 1 0';
const vector eZ = '0 0 1';
+[[eraseable]]
vector randompos(vector m1, vector m2)
{
vector v;
return v;
}
+[[eraseable]]
float vlen_maxnorm2d(vector v)
{
return max(v.x, v.y, -v.x, -v.y);
}
+[[eraseable]]
float vlen_minnorm2d(vector v)
{
return min(max(v.x, -v.x), max(v.y, -v.y));
}
+[[eraseable]]
float dist_point_line(vector p, vector l0, vector ldir)
{
ldir = normalize(ldir);
}
/** requires that m2>m1 in all coordinates, and that m4>m3 */
+[[eraseable]]
float boxesoverlap(vector m1, vector m2, vector m3, vector m4) { return m2_x >= m3_x && m1_x <= m4_x && m2_y >= m3_y && m1_y <= m4_y && m2_z >= m3_z && m1_z <= m4_z; }
/** requires the same as boxesoverlap, but is a stronger condition */
+[[eraseable]]
float boxinsidebox(vector smins, vector smaxs, vector bmins, vector bmaxs) { return smins.x >= bmins.x && smaxs.x <= bmaxs.x && smins.y >= bmins.y && smaxs.y <= bmaxs.y && smins.z >= bmins.z && smaxs.z <= bmaxs.z; }
#define PITCH(v) ((v).x)
noref vector _vec3;
#define vec3(_x, _y, _z) (_vec3.x = (_x), _vec3.y = (_y), _vec3.z = (_z), _vec3)
+[[eraseable]]
vector Rotate(vector v, float a)
{
float a_sin = sin(a), a_cos = cos(a);
* @param norm the normalized normal
* @returns dir reflected by norm
*/
+[[eraseable]]
vector reflect(vector dir, vector norm)
{
return dir - 2 * (dir * norm) * norm;
/**
* clip vel along the plane defined by norm (assuming 0 distance away), bounciness determined by bounce 0..1
*/
+[[eraseable]]
vector vec_reflect(vector vel, vector norm, float bounce)
{
return vel - (1 + bounce) * (vel * norm) * norm;
}
+[[eraseable]]
vector vec_epsilon(vector this, float eps)
{
if (this.x > -eps && this.x < eps) this.x = 0;
(out = vec_epsilon(vec_reflect(in, normal, (overbounce) - 1), 0.1))
#ifdef GAMEQC
+ [[eraseable]]
vector get_corner_position(entity box, int corner)
{
switch (corner)
}
}
+ [[eraseable]]
vector NearestPointOnBox(entity box, vector org)
{
vector m1 = box.mins + box.origin;
projects / xonotic / xonotic-data.pk3dir.git / commitdiff