summaryrefslogtreecommitdiff
path: root/src/shared
diff options
context:
space:
mode:
Diffstat (limited to 'src/shared')
-rw-r--r--src/shared/command.h335
-rw-r--r--src/shared/crypto.cpp944
-rw-r--r--src/shared/cube.h68
-rw-r--r--src/shared/cube2font.c556
-rw-r--r--src/shared/ents.h237
-rw-r--r--src/shared/geom.cpp257
-rw-r--r--src/shared/geom.h1828
-rw-r--r--src/shared/glemu.cpp355
-rw-r--r--src/shared/glemu.h180
-rw-r--r--src/shared/glexts.h488
-rw-r--r--src/shared/iengine.h583
-rw-r--r--src/shared/igame.h130
-rw-r--r--src/shared/stream.cpp1264
-rw-r--r--src/shared/tools.cpp244
-rw-r--r--src/shared/tools.h1408
-rw-r--r--src/shared/zip.cpp588
16 files changed, 9465 insertions, 0 deletions
diff --git a/src/shared/command.h b/src/shared/command.h
new file mode 100644
index 0000000..475e492
--- /dev/null
+++ b/src/shared/command.h
@@ -0,0 +1,335 @@
+// script binding functionality
+
+enum { VAL_NULL = 0, VAL_INT, VAL_FLOAT, VAL_STR, VAL_ANY, VAL_CODE, VAL_MACRO, VAL_IDENT };
+
+enum
+{
+ CODE_START = 0,
+ CODE_OFFSET,
+ CODE_POP,
+ CODE_ENTER,
+ CODE_EXIT,
+ CODE_VAL,
+ CODE_VALI,
+ CODE_MACRO,
+ CODE_BOOL,
+ CODE_BLOCK,
+ CODE_COMPILE,
+ CODE_FORCE,
+ CODE_RESULT,
+ CODE_IDENT, CODE_IDENTU, CODE_IDENTARG,
+ CODE_COM, CODE_COMD, CODE_COMC, CODE_COMV,
+ CODE_CONC, CODE_CONCW, CODE_CONCM, CODE_DOWN,
+ CODE_SVAR, CODE_SVAR1,
+ CODE_IVAR, CODE_IVAR1, CODE_IVAR2, CODE_IVAR3,
+ CODE_FVAR, CODE_FVAR1,
+ CODE_LOOKUP, CODE_LOOKUPU, CODE_LOOKUPARG, CODE_ALIAS, CODE_ALIASU, CODE_ALIASARG, CODE_CALL, CODE_CALLU, CODE_CALLARG,
+ CODE_PRINT,
+ CODE_LOCAL,
+
+ CODE_OP_MASK = 0x3F,
+ CODE_RET = 6,
+ CODE_RET_MASK = 0xC0,
+
+ /* return type flags */
+ RET_NULL = VAL_NULL<<CODE_RET,
+ RET_STR = VAL_STR<<CODE_RET,
+ RET_INT = VAL_INT<<CODE_RET,
+ RET_FLOAT = VAL_FLOAT<<CODE_RET,
+};
+
+enum { ID_VAR, ID_FVAR, ID_SVAR, ID_COMMAND, ID_ALIAS, ID_LOCAL };
+
+enum { IDF_PERSIST = 1<<0, IDF_OVERRIDE = 1<<1, IDF_HEX = 1<<2, IDF_READONLY = 1<<3, IDF_OVERRIDDEN = 1<<4, IDF_UNKNOWN = 1<<5, IDF_ARG = 1<<6, IDF_EMUVAR = 1<<7 };
+
+struct ident;
+
+struct identval
+{
+ union
+ {
+ int i; // ID_VAR, VAL_INT
+ float f; // ID_FVAR, VAL_FLOAT
+ char *s; // ID_SVAR, VAL_STR
+ const uint *code; // VAL_CODE
+ ident *id; // VAL_IDENT
+ };
+};
+
+struct tagval : identval
+{
+ int type;
+
+ void setint(int val) { type = VAL_INT; i = val; }
+ void setfloat(float val) { type = VAL_FLOAT; f = val; }
+ void setstr(char *val) { type = VAL_STR; s = val; }
+ void setnull() { type = VAL_NULL; i = 0; }
+ void setcode(const uint *val) { type = VAL_CODE; code = val; }
+ void setmacro(const uint *val) { type = VAL_MACRO; code = val; }
+ void setident(ident *val) { type = VAL_IDENT; id = val; }
+
+ const char *getstr() const;
+ int getint() const;
+ float getfloat() const;
+ bool getbool() const;
+
+ void cleanup();
+};
+
+struct identstack
+{
+ identval val;
+ int valtype;
+ identstack *next;
+};
+
+union identvalptr
+{
+ int *i; // ID_VAR
+ float *f; // ID_FVAR
+ char **s; // ID_SVAR
+};
+
+typedef void (__cdecl *identfun)();
+
+struct ident
+{
+ uchar type; // one of ID_* above
+ union
+ {
+ uchar valtype; // ID_ALIAS
+ uchar numargs; // ID_COMMAND
+ };
+ ushort flags;
+ int index;
+ const char *name;
+ union
+ {
+ struct // ID_VAR, ID_FVAR, ID_SVAR
+ {
+ union
+ {
+ struct { int minval, maxval; }; // ID_VAR
+ struct { float minvalf, maxvalf; }; // ID_FVAR
+ };
+ identvalptr storage;
+ identval overrideval;
+ };
+ struct // ID_ALIAS
+ {
+ uint *code;
+ identval val;
+ identstack *stack;
+ };
+ struct // ID_COMMAND
+ {
+ const char *args;
+ uint argmask;
+ };
+ };
+ identfun fun; // ID_VAR, ID_FVAR, ID_SVAR, ID_COMMAND
+
+ ident() {}
+ // ID_VAR
+ ident(int t, const char *n, int m, int x, int *s, void *f = NULL, int flags = 0)
+ : type(t), flags(flags | (m > x ? IDF_READONLY : 0)), name(n), minval(m), maxval(x), fun((identfun)f)
+ { storage.i = s; }
+ // ID_FVAR
+ ident(int t, const char *n, float m, float x, float *s, void *f = NULL, int flags = 0)
+ : type(t), flags(flags | (m > x ? IDF_READONLY : 0)), name(n), minvalf(m), maxvalf(x), fun((identfun)f)
+ { storage.f = s; }
+ // ID_SVAR
+ ident(int t, const char *n, char **s, void *f = NULL, int flags = 0)
+ : type(t), flags(flags), name(n), fun((identfun)f)
+ { storage.s = s; }
+ // ID_ALIAS
+ ident(int t, const char *n, char *a, int flags)
+ : type(t), valtype(VAL_STR), flags(flags), name(n), code(NULL), stack(NULL)
+ { val.s = a; }
+ ident(int t, const char *n, int a, int flags)
+ : type(t), valtype(VAL_INT), flags(flags), name(n), code(NULL), stack(NULL)
+ { val.i = a; }
+ ident(int t, const char *n, float a, int flags)
+ : type(t), valtype(VAL_FLOAT), flags(flags), name(n), code(NULL), stack(NULL)
+ { val.f = a; }
+ ident(int t, const char *n, int flags)
+ : type(t), valtype(VAL_NULL), flags(flags), name(n), code(NULL), stack(NULL)
+ {}
+ ident(int t, const char *n, const tagval &v, int flags)
+ : type(t), valtype(v.type), flags(flags), name(n), code(NULL), stack(NULL)
+ { val = v; }
+ // ID_COMMAND
+ ident(int t, const char *n, const char *args, uint argmask, int numargs, void *f = NULL, int flags = 0)
+ : type(t), numargs(numargs), flags(flags), name(n), args(args), argmask(argmask), fun((identfun)f)
+ {}
+
+ void changed() { if(fun) fun(); }
+
+ void setval(const tagval &v)
+ {
+ valtype = v.type;
+ val = v;
+ }
+
+ void setval(const identstack &v)
+ {
+ valtype = v.valtype;
+ val = v.val;
+ }
+
+ void forcenull()
+ {
+ if(valtype==VAL_STR) delete[] val.s;
+ valtype = VAL_NULL;
+ }
+
+ float getfloat() const;
+ int getint() const;
+ const char *getstr() const;
+ void getval(tagval &v) const;
+};
+
+extern void addident(ident *id);
+
+extern tagval *commandret;
+extern const char *intstr(int v);
+extern void intret(int v);
+extern const char *floatstr(float v);
+extern void floatret(float v);
+extern void stringret(char *s);
+extern void result(tagval &v);
+extern void result(const char *s);
+
+static inline int parseint(const char *s)
+{
+ return int(strtoul(s, NULL, 0));
+}
+
+static inline float parsefloat(const char *s)
+{
+ // not all platforms (windows) can parse hexadecimal integers via strtod
+ char *end;
+ double val = strtod(s, &end);
+ return val || end==s || (*end!='x' && *end!='X') ? float(val) : float(parseint(s));
+}
+
+static inline void intformat(char *buf, int v, int len = 20) { nformatstring(buf, len, "%d", v); }
+static inline void floatformat(char *buf, float v, int len = 20) { nformatstring(buf, len, v==int(v) ? "%.1f" : "%.6g", v); }
+
+static inline const char *getstr(const identval &v, int type)
+{
+ switch(type)
+ {
+ case VAL_STR: case VAL_MACRO: return v.s;
+ case VAL_INT: return intstr(v.i);
+ case VAL_FLOAT: return floatstr(v.f);
+ default: return "";
+ }
+}
+inline const char *tagval::getstr() const { return ::getstr(*this, type); }
+inline const char *ident::getstr() const { return ::getstr(val, valtype); }
+
+static inline int getint(const identval &v, int type)
+{
+ switch(type)
+ {
+ case VAL_INT: return v.i;
+ case VAL_FLOAT: return int(v.f);
+ case VAL_STR: case VAL_MACRO: return parseint(v.s);
+ default: return 0;
+ }
+}
+inline int tagval::getint() const { return ::getint(*this, type); }
+inline int ident::getint() const { return ::getint(val, valtype); }
+
+static inline float getfloat(const identval &v, int type)
+{
+ switch(type)
+ {
+ case VAL_FLOAT: return v.f;
+ case VAL_INT: return float(v.i);
+ case VAL_STR: case VAL_MACRO: return parsefloat(v.s);
+ default: return 0.0f;
+ }
+}
+inline float tagval::getfloat() const { return ::getfloat(*this, type); }
+inline float ident::getfloat() const { return ::getfloat(val, valtype); }
+
+inline void ident::getval(tagval &v) const
+{
+ switch(valtype)
+ {
+ case VAL_STR: case VAL_MACRO: v.setstr(newstring(val.s)); break;
+ case VAL_INT: v.setint(val.i); break;
+ case VAL_FLOAT: v.setfloat(val.f); break;
+ default: v.setnull(); break;
+ }
+}
+
+// nasty macros for registering script functions, abuses globals to avoid excessive infrastructure
+#define KEYWORD(name, type) UNUSED static bool __dummy_##name = addkeyword(type, #name)
+#define COMMANDN(name, fun, nargs) UNUSED static bool __dummy_##fun = addcommand(#name, (identfun)fun, nargs)
+#define COMMAND(name, nargs) COMMANDN(name, name, nargs)
+
+#define _VAR(name, global, min, cur, max, persist) int global = variable(#name, min, cur, max, &global, NULL, persist)
+#define VARN(name, global, min, cur, max) _VAR(name, global, min, cur, max, 0)
+#define VARNP(name, global, min, cur, max) _VAR(name, global, min, cur, max, IDF_PERSIST)
+#define VARNR(name, global, min, cur, max) _VAR(name, global, min, cur, max, IDF_OVERRIDE)
+#define VAR(name, min, cur, max) _VAR(name, name, min, cur, max, 0)
+#define VARP(name, min, cur, max) _VAR(name, name, min, cur, max, IDF_PERSIST)
+#define VARR(name, min, cur, max) _VAR(name, name, min, cur, max, IDF_OVERRIDE)
+#define _VARF(name, global, min, cur, max, body, persist) void var_##name(); int global = variable(#name, min, cur, max, &global, var_##name, persist); void var_##name() { body; }
+#define VARFN(name, global, min, cur, max, body) _VARF(name, global, min, cur, max, body, 0)
+#define VARF(name, min, cur, max, body) _VARF(name, name, min, cur, max, body, 0)
+#define VARFP(name, min, cur, max, body) _VARF(name, name, min, cur, max, body, IDF_PERSIST)
+#define VARFR(name, min, cur, max, body) _VARF(name, name, min, cur, max, body, IDF_OVERRIDE)
+#define VARFNP(name, global, min, cur, max, body) _VARF(name, global, min, cur, max, body, IDF_PERSIST)
+
+#define _HVAR(name, global, min, cur, max, persist) int global = variable(#name, min, cur, max, &global, NULL, persist | IDF_HEX)
+#define HVARN(name, global, min, cur, max) _HVAR(name, global, min, cur, max, 0)
+#define HVARNP(name, global, min, cur, max) _HVAR(name, global, min, cur, max, IDF_PERSIST)
+#define HVARNR(name, global, min, cur, max) _HVAR(name, global, min, cur, max, IDF_OVERRIDE)
+#define HVAR(name, min, cur, max) _HVAR(name, name, min, cur, max, 0)
+#define HVARP(name, min, cur, max) _HVAR(name, name, min, cur, max, IDF_PERSIST)
+#define HVARR(name, min, cur, max) _HVAR(name, name, min, cur, max, IDF_OVERRIDE)
+#define _HVARF(name, global, min, cur, max, body, persist) void var_##name(); int global = variable(#name, min, cur, max, &global, var_##name, persist | IDF_HEX); void var_##name() { body; }
+#define HVARFN(name, global, min, cur, max, body) _HVARF(name, global, min, cur, max, body, 0)
+#define HVARF(name, min, cur, max, body) _HVARF(name, name, min, cur, max, body, 0)
+#define HVARFP(name, min, cur, max, body) _HVARF(name, name, min, cur, max, body, IDF_PERSIST)
+#define HVARFR(name, min, cur, max, body) _HVARF(name, name, min, cur, max, body, IDF_OVERRIDE)
+
+#define _FVAR(name, global, min, cur, max, persist) float global = fvariable(#name, min, cur, max, &global, NULL, persist)
+#define FVARN(name, global, min, cur, max) _FVAR(name, global, min, cur, max, 0)
+#define FVARNP(name, global, min, cur, max) _FVAR(name, global, min, cur, max, IDF_PERSIST)
+#define FVARNR(name, global, min, cur, max) _FVAR(name, global, min, cur, max, IDF_OVERRIDE)
+#define FVAR(name, min, cur, max) _FVAR(name, name, min, cur, max, 0)
+#define FVARP(name, min, cur, max) _FVAR(name, name, min, cur, max, IDF_PERSIST)
+#define FVARR(name, min, cur, max) _FVAR(name, name, min, cur, max, IDF_OVERRIDE)
+#define _FVARF(name, global, min, cur, max, body, persist) void var_##name(); float global = fvariable(#name, min, cur, max, &global, var_##name, persist); void var_##name() { body; }
+#define FVARFN(name, global, min, cur, max, body) _FVARF(name, global, min, cur, max, body, 0)
+#define FVARF(name, min, cur, max, body) _FVARF(name, name, min, cur, max, body, 0)
+#define FVARFP(name, min, cur, max, body) _FVARF(name, name, min, cur, max, body, IDF_PERSIST)
+#define FVARFR(name, min, cur, max, body) _FVARF(name, name, min, cur, max, body, IDF_OVERRIDE)
+
+#define _SVAR(name, global, cur, persist) char *global = svariable(#name, cur, &global, NULL, persist)
+#define SVARN(name, global, cur) _SVAR(name, global, cur, 0)
+#define SVARNP(name, global, cur) _SVAR(name, global, cur, IDF_PERSIST)
+#define SVARNR(name, global, cur) _SVAR(name, global, cur, IDF_OVERRIDE)
+#define SVAR(name, cur) _SVAR(name, name, cur, 0)
+#define SVARP(name, cur) _SVAR(name, name, cur, IDF_PERSIST)
+#define SVARR(name, cur) _SVAR(name, name, cur, IDF_OVERRIDE)
+#define _SVARF(name, global, cur, body, persist) void var_##name(); char *global = svariable(#name, cur, &global, var_##name, persist); void var_##name() { body; }
+#define SVARFN(name, global, cur, body) _SVARF(name, global, cur, body, 0)
+#define SVARF(name, cur, body) _SVARF(name, name, cur, body, 0)
+#define SVARFP(name, cur, body) _SVARF(name, name, cur, body, IDF_PERSIST)
+#define SVARFR(name, cur, body) _SVARF(name, name, cur, body, IDF_OVERRIDE)
+
+// anonymous inline commands, uses nasty template trick with line numbers to keep names unique
+#define ICOMMANDNS(name, cmdname, nargs, proto, b) template<int N> struct cmdname; template<> struct cmdname<__LINE__> { static bool init; static void run proto; }; bool cmdname<__LINE__>::init = addcommand(name, (identfun)cmdname<__LINE__>::run, nargs); void cmdname<__LINE__>::run proto \
+ { b; }
+#define ICOMMANDN(name, cmdname, nargs, proto, b) ICOMMANDNS(#name, cmdname, nargs, proto, b)
+#define ICOMMANDNAME(name) _icmd_##name
+#define ICOMMAND(name, nargs, proto, b) ICOMMANDN(name, ICOMMANDNAME(name), nargs, proto, b)
+#define ICOMMANDSNAME _icmds_
+#define ICOMMANDS(name, nargs, proto, b) ICOMMANDNS(name, ICOMMANDSNAME, nargs, proto, b)
+
diff --git a/src/shared/crypto.cpp b/src/shared/crypto.cpp
new file mode 100644
index 0000000..134afc5
--- /dev/null
+++ b/src/shared/crypto.cpp
@@ -0,0 +1,944 @@
+#include "cube.h"
+
+///////////////////////// cryptography /////////////////////////////////
+
+/* Based off the reference implementation of Tiger, a cryptographically
+ * secure 192 bit hash function by Ross Anderson and Eli Biham. More info at:
+ * http://www.cs.technion.ac.il/~biham/Reports/Tiger/
+ */
+
+#define TIGER_PASSES 3
+
+namespace tiger
+{
+ typedef unsigned long long int chunk;
+
+ union hashval
+ {
+ uchar bytes[3*8];
+ chunk chunks[3];
+ };
+
+ chunk sboxes[4*256];
+
+ void compress(const chunk *str, chunk state[3])
+ {
+ chunk a, b, c;
+ chunk aa, bb, cc;
+ chunk x0, x1, x2, x3, x4, x5, x6, x7;
+
+ a = state[0];
+ b = state[1];
+ c = state[2];
+
+ x0=str[0]; x1=str[1]; x2=str[2]; x3=str[3];
+ x4=str[4]; x5=str[5]; x6=str[6]; x7=str[7];
+
+ aa = a;
+ bb = b;
+ cc = c;
+
+ loop(pass_no, TIGER_PASSES)
+ {
+ if(pass_no)
+ {
+ x0 -= x7 ^ 0xA5A5A5A5A5A5A5A5ULL; x1 ^= x0; x2 += x1; x3 -= x2 ^ ((~x1)<<19);
+ x4 ^= x3; x5 += x4; x6 -= x5 ^ ((~x4)>>23); x7 ^= x6;
+ x0 += x7; x1 -= x0 ^ ((~x7)<<19); x2 ^= x1; x3 += x2;
+ x4 -= x3 ^ ((~x2)>>23); x5 ^= x4; x6 += x5; x7 -= x6 ^ 0x0123456789ABCDEFULL;
+ }
+
+#define sb1 (sboxes)
+#define sb2 (sboxes+256)
+#define sb3 (sboxes+256*2)
+#define sb4 (sboxes+256*3)
+
+#define round(a, b, c, x) \
+ c ^= x; \
+ a -= sb1[((c)>>(0*8))&0xFF] ^ sb2[((c)>>(2*8))&0xFF] ^ \
+ sb3[((c)>>(4*8))&0xFF] ^ sb4[((c)>>(6*8))&0xFF] ; \
+ b += sb4[((c)>>(1*8))&0xFF] ^ sb3[((c)>>(3*8))&0xFF] ^ \
+ sb2[((c)>>(5*8))&0xFF] ^ sb1[((c)>>(7*8))&0xFF] ; \
+ b *= mul;
+
+ uint mul = !pass_no ? 5 : (pass_no==1 ? 7 : 9);
+ round(a, b, c, x0) round(b, c, a, x1) round(c, a, b, x2) round(a, b, c, x3)
+ round(b, c, a, x4) round(c, a, b, x5) round(a, b, c, x6) round(b, c, a, x7)
+
+ chunk tmp = a; a = c; c = b; b = tmp;
+ }
+
+ a ^= aa;
+ b -= bb;
+ c += cc;
+
+ state[0] = a;
+ state[1] = b;
+ state[2] = c;
+ }
+
+ void gensboxes()
+ {
+ const char *str = "Tiger - A Fast New Hash Function, by Ross Anderson and Eli Biham";
+ chunk state[3] = { 0x0123456789ABCDEFULL, 0xFEDCBA9876543210ULL, 0xF096A5B4C3B2E187ULL };
+ uchar temp[64];
+
+ if(!*(const uchar *)&islittleendian) loopj(64) temp[j^7] = str[j];
+ else loopj(64) temp[j] = str[j];
+ loopi(1024) loop(col, 8) ((uchar *)&sboxes[i])[col] = i&0xFF;
+
+ int abc = 2;
+ loop(pass, 5) loopi(256) for(int sb = 0; sb < 1024; sb += 256)
+ {
+ abc++;
+ if(abc >= 3) { abc = 0; compress((chunk *)temp, state); }
+ loop(col, 8)
+ {
+ uchar val = ((uchar *)&sboxes[sb+i])[col];
+ ((uchar *)&sboxes[sb+i])[col] = ((uchar *)&sboxes[sb + ((uchar *)&state[abc])[col]])[col];
+ ((uchar *)&sboxes[sb + ((uchar *)&state[abc])[col]])[col] = val;
+ }
+ }
+ }
+
+ void hash(const uchar *str, int length, hashval &val)
+ {
+ static bool init = false;
+ if(!init) { gensboxes(); init = true; }
+
+ uchar temp[64];
+
+ val.chunks[0] = 0x0123456789ABCDEFULL;
+ val.chunks[1] = 0xFEDCBA9876543210ULL;
+ val.chunks[2] = 0xF096A5B4C3B2E187ULL;
+
+ int i = length;
+ for(; i >= 64; i -= 64, str += 64)
+ {
+ if(!*(const uchar *)&islittleendian)
+ {
+ loopj(64) temp[j^7] = str[j];
+ compress((chunk *)temp, val.chunks);
+ }
+ else compress((chunk *)str, val.chunks);
+ }
+
+ int j;
+ if(!*(const uchar *)&islittleendian)
+ {
+ for(j = 0; j < i; j++) temp[j^7] = str[j];
+ temp[j^7] = 0x01;
+ while(++j&7) temp[j^7] = 0;
+ }
+ else
+ {
+ for(j = 0; j < i; j++) temp[j] = str[j];
+ temp[j] = 0x01;
+ while(++j&7) temp[j] = 0;
+ }
+
+ if(j > 56)
+ {
+ while(j < 64) temp[j++] = 0;
+ compress((chunk *)temp, val.chunks);
+ j = 0;
+ }
+ while(j < 56) temp[j++] = 0;
+ *(chunk *)(temp+56) = (chunk)length<<3;
+ compress((chunk *)temp, val.chunks);
+ if(!*(const uchar *)&islittleendian)
+ {
+ loopk(3)
+ {
+ uchar *c = &val.bytes[k*sizeof(chunk)];
+ loopl(sizeof(chunk)/2) swap(c[l], c[sizeof(chunk)-1-l]);
+ }
+ }
+ }
+}
+
+/* Elliptic curve cryptography based on NIST DSS prime curves. */
+
+#define BI_DIGIT_BITS 16
+#define BI_DIGIT_MASK ((1<<BI_DIGIT_BITS)-1)
+
+template<int BI_DIGITS> struct bigint
+{
+ typedef ushort digit;
+ typedef uint dbldigit;
+
+ int len;
+ digit digits[BI_DIGITS];
+
+ bigint() {}
+ bigint(digit n) { if(n) { len = 1; digits[0] = n; } else len = 0; }
+ bigint(const char *s) { parse(s); }
+ template<int Y_DIGITS> bigint(const bigint<Y_DIGITS> &y) { *this = y; }
+
+ static int parsedigits(ushort *digits, int maxlen, const char *s)
+ {
+ int slen = 0;
+ while(isxdigit(s[slen])) slen++;
+ int len = (slen+2*sizeof(ushort)-1)/(2*sizeof(ushort));
+ if(len>maxlen) return 0;
+ memset(digits, 0, len*sizeof(ushort));
+ loopi(slen)
+ {
+ int c = s[slen-i-1];
+ if(isalpha(c)) c = toupper(c) - 'A' + 10;
+ else if(isdigit(c)) c -= '0';
+ else return 0;
+ digits[i/(2*sizeof(ushort))] |= c<<(4*(i%(2*sizeof(ushort))));
+ }
+ return len;
+ }
+
+ void parse(const char *s)
+ {
+ len = parsedigits(digits, BI_DIGITS, s);
+ shrink();
+ }
+
+ void zero() { len = 0; }
+
+ void print(stream *out) const
+ {
+ vector<char> buf;
+ printdigits(buf);
+ out->write(buf.getbuf(), buf.length());
+ }
+
+ void printdigits(vector<char> &buf) const
+ {
+ loopi(len)
+ {
+ digit d = digits[len-i-1];
+ loopj(BI_DIGIT_BITS/4)
+ {
+ uint shift = BI_DIGIT_BITS - (j+1)*4;
+ int val = (d >> shift) & 0xF;
+ if(val < 10) buf.add('0' + val);
+ else buf.add('a' + val - 10);
+ }
+ }
+ }
+
+ template<int Y_DIGITS> bigint &operator=(const bigint<Y_DIGITS> &y)
+ {
+ len = y.len;
+ memcpy(digits, y.digits, len*sizeof(digit));
+ return *this;
+ }
+
+ bool iszero() const { return !len; }
+ bool isone() const { return len==1 && digits[0]==1; }
+
+ int numbits() const
+ {
+ if(!len) return 0;
+ int bits = len*BI_DIGIT_BITS;
+ digit last = digits[len-1], mask = 1<<(BI_DIGIT_BITS-1);
+ while(mask)
+ {
+ if(last&mask) return bits;
+ bits--;
+ mask >>= 1;
+ }
+ return 0;
+ }
+
+ bool hasbit(int n) const { return n/BI_DIGIT_BITS < len && ((digits[n/BI_DIGIT_BITS]>>(n%BI_DIGIT_BITS))&1); }
+
+ bool morebits(int n) const { return len > n/BI_DIGIT_BITS; }
+
+ template<int X_DIGITS, int Y_DIGITS> bigint &add(const bigint<X_DIGITS> &x, const bigint<Y_DIGITS> &y)
+ {
+ dbldigit carry = 0;
+ int maxlen = max(x.len, y.len), i;
+ for(i = 0; i < y.len || carry; i++)
+ {
+ carry += (i < x.len ? (dbldigit)x.digits[i] : 0) + (i < y.len ? (dbldigit)y.digits[i] : 0);
+ digits[i] = (digit)carry;
+ carry >>= BI_DIGIT_BITS;
+ }
+ if(i < x.len && this != &x) memcpy(&digits[i], &x.digits[i], (x.len - i)*sizeof(digit));
+ len = max(i, maxlen);
+ return *this;
+ }
+ template<int Y_DIGITS> bigint &add(const bigint<Y_DIGITS> &y) { return add(*this, y); }
+
+ template<int X_DIGITS, int Y_DIGITS> bigint &sub(const bigint<X_DIGITS> &x, const bigint<Y_DIGITS> &y)
+ {
+ ASSERT(x >= y);
+ dbldigit borrow = 0;
+ int i;
+ for(i = 0; i < y.len || borrow; i++)
+ {
+ borrow = (1<<BI_DIGIT_BITS) + (dbldigit)x.digits[i] - (i<y.len ? (dbldigit)y.digits[i] : 0) - borrow;
+ digits[i] = (digit)borrow;
+ borrow = (borrow>>BI_DIGIT_BITS)^1;
+ }
+ if(i < x.len && this != &x) memcpy(&digits[i], &x.digits[i], (x.len - i)*sizeof(digit));
+ len = x.len;
+ shrink();
+ return *this;
+ }
+ template<int Y_DIGITS> bigint &sub(const bigint<Y_DIGITS> &y) { return sub(*this, y); }
+
+ void shrink() { while(len > 0 && !digits[len-1]) len--; }
+ void shrinkdigits(int n) { len = n; shrink(); }
+ void shrinkbits(int n) { shrinkdigits(n/BI_DIGIT_BITS); }
+
+ template<int Y_DIGITS> void copyshrinkdigits(const bigint<Y_DIGITS> &y, int n)
+ {
+ len = clamp(y.len, 0, n);
+ memcpy(digits, y.digits, len*sizeof(digit));
+ shrink();
+ }
+ template<int Y_DIGITS> void copyshrinkbits(const bigint<Y_DIGITS> &y, int n)
+ {
+ copyshrinkdigits(y, n/BI_DIGIT_BITS);
+ }
+
+ template<int X_DIGITS, int Y_DIGITS> bigint &mul(const bigint<X_DIGITS> &x, const bigint<Y_DIGITS> &y)
+ {
+ if(!x.len || !y.len) { len = 0; return *this; }
+ memset(digits, 0, y.len*sizeof(digit));
+ loopi(x.len)
+ {
+ dbldigit carry = 0;
+ loopj(y.len)
+ {
+ carry += (dbldigit)x.digits[i] * (dbldigit)y.digits[j] + (dbldigit)digits[i+j];
+ digits[i+j] = (digit)carry;
+ carry >>= BI_DIGIT_BITS;
+ }
+ digits[i+y.len] = carry;
+ }
+ len = x.len + y.len;
+ shrink();
+ return *this;
+ }
+
+ bigint &rshift(int n)
+ {
+ assert(len <= BI_DIGITS);
+ if(!len || n<=0) return *this;
+ if(n >= len*BI_DIGIT_BITS) { len = 0; return *this; }
+ int dig = (n-1)/BI_DIGIT_BITS;
+ n = ((n-1) % BI_DIGIT_BITS)+1;
+ digit carry = digit(digits[dig]>>n);
+ for(int i = dig+1; i < len; i++)
+ {
+ digit tmp = digits[i];
+ digits[i-dig-1] = digit((tmp<<(BI_DIGIT_BITS-n)) | carry);
+ carry = digit(tmp>>n);
+ }
+ digits[len-dig-1] = carry;
+ len -= dig + (n/BI_DIGIT_BITS);
+ shrink();
+ return *this;
+ }
+
+ bigint &lshift(int n)
+ {
+ if(!len || n<=0) return *this;
+ int dig = n/BI_DIGIT_BITS;
+ n %= BI_DIGIT_BITS;
+ digit carry = 0;
+ loopirev(len)
+ {
+ digit tmp = digits[i];
+ digits[i+dig] = digit((tmp<<n) | carry);
+ carry = digit(tmp>>(BI_DIGIT_BITS-n));
+ }
+ len += dig;
+ if(carry) digits[len++] = carry;
+ if(dig) memset(digits, 0, dig*sizeof(digit));
+ return *this;
+ }
+
+ void zerodigits(int i, int n)
+ {
+ memset(&digits[i], 0, n*sizeof(digit));
+ }
+ void zerobits(int i, int n)
+ {
+ zerodigits(i/BI_DIGIT_BITS, n/BI_DIGIT_BITS);
+ }
+
+ template<int Y_DIGITS> void copydigits(int to, const bigint<Y_DIGITS> &y, int from, int n)
+ {
+ int avail = clamp(y.len-from, 0, n);
+ memcpy(&digits[to], &y.digits[from], avail*sizeof(digit));
+ if(avail < n) memset(&digits[to+avail], 0, (n-avail)*sizeof(digit));
+ }
+ template<int Y_DIGITS> void copybits(int to, const bigint<Y_DIGITS> &y, int from, int n)
+ {
+ copydigits(to/BI_DIGIT_BITS, y, from/BI_DIGIT_BITS, n/BI_DIGIT_BITS);
+ }
+
+ void dupdigits(int to, int from, int n)
+ {
+ memcpy(&digits[to], &digits[from], n*sizeof(digit));
+ }
+ void dupbits(int to, int from, int n)
+ {
+ dupdigits(to/BI_DIGIT_BITS, from/BI_DIGIT_BITS, n/BI_DIGIT_BITS);
+ }
+
+ template<int Y_DIGITS> bool operator==(const bigint<Y_DIGITS> &y) const
+ {
+ if(len!=y.len) return false;
+ loopirev(len) if(digits[i]!=y.digits[i]) return false;
+ return true;
+ }
+ template<int Y_DIGITS> bool operator!=(const bigint<Y_DIGITS> &y) const { return !(*this==y); }
+ template<int Y_DIGITS> bool operator<(const bigint<Y_DIGITS> &y) const
+ {
+ if(len<y.len) return true;
+ if(len>y.len) return false;
+ loopirev(len)
+ {
+ if(digits[i]<y.digits[i]) return true;
+ if(digits[i]>y.digits[i]) return false;
+ }
+ return false;
+ }
+ template<int Y_DIGITS> bool operator>(const bigint<Y_DIGITS> &y) const { return y<*this; }
+ template<int Y_DIGITS> bool operator<=(const bigint<Y_DIGITS> &y) const { return !(y<*this); }
+ template<int Y_DIGITS> bool operator>=(const bigint<Y_DIGITS> &y) const { return !(*this<y); }
+};
+
+#define GF_BITS 192
+#define GF_DIGITS ((GF_BITS+BI_DIGIT_BITS-1)/BI_DIGIT_BITS)
+
+typedef bigint<GF_DIGITS+1> gfint;
+
+/* NIST prime Galois fields.
+ * Currently only supports NIST P-192, where P=2^192-2^64-1, and P-256, where P=2^256-2^224+2^192+2^96-1.
+ */
+struct gfield : gfint
+{
+ static const gfield P;
+
+ gfield() {}
+ gfield(digit n) : gfint(n) {}
+ gfield(const char *s) : gfint(s) {}
+
+ template<int Y_DIGITS> gfield(const bigint<Y_DIGITS> &y) : gfint(y) {}
+
+ template<int Y_DIGITS> gfield &operator=(const bigint<Y_DIGITS> &y)
+ {
+ gfint::operator=(y);
+ return *this;
+ }
+
+ template<int X_DIGITS, int Y_DIGITS> gfield &add(const bigint<X_DIGITS> &x, const bigint<Y_DIGITS> &y)
+ {
+ gfint::add(x, y);
+ if(*this >= P) gfint::sub(*this, P);
+ return *this;
+ }
+ template<int Y_DIGITS> gfield &add(const bigint<Y_DIGITS> &y) { return add(*this, y); }
+
+ template<int X_DIGITS> gfield &mul2(const bigint<X_DIGITS> &x) { return add(x, x); }
+ gfield &mul2() { return mul2(*this); }
+
+ gfield &div2()
+ {
+ if(hasbit(0)) gfint::add(*this, P);
+ rshift(1);
+ return *this;
+ }
+
+ template<int X_DIGITS, int Y_DIGITS> gfield &sub(const bigint<X_DIGITS> &x, const bigint<Y_DIGITS> &y)
+ {
+ if(x < y)
+ {
+ gfint tmp; /* necessary if this==&y, using this instead would clobber y */
+ tmp.add(x, P);
+ gfint::sub(tmp, y);
+ }
+ else gfint::sub(x, y);
+ return *this;
+ }
+ template<int Y_DIGITS> gfield &sub(const bigint<Y_DIGITS> &y) { return sub(*this, y); }
+
+ template<int X_DIGITS> gfield &neg(const bigint<X_DIGITS> &x)
+ {
+ gfint::sub(P, x);
+ return *this;
+ }
+ gfield &neg() { return neg(*this); }
+
+ template<int X_DIGITS> gfield &square(const bigint<X_DIGITS> &x) { return mul(x, x); }
+ gfield &square() { return square(*this); }
+
+ template<int X_DIGITS, int Y_DIGITS> gfield &mul(const bigint<X_DIGITS> &x, const bigint<Y_DIGITS> &y)
+ {
+ bigint<X_DIGITS+Y_DIGITS> result;
+ result.mul(x, y);
+ reduce(result);
+ return *this;
+ }
+ template<int Y_DIGITS> gfield &mul(const bigint<Y_DIGITS> &y) { return mul(*this, y); }
+
+ template<int RESULT_DIGITS> void reduce(const bigint<RESULT_DIGITS> &result)
+ {
+#if GF_BITS==192
+ // B = T + S1 + S2 + S3 mod p
+ copyshrinkdigits(result, GF_DIGITS); // T
+
+ if(result.morebits(192))
+ {
+ gfield s;
+ s.copybits(0, result, 192, 64);
+ s.dupbits(64, 0, 64);
+ s.shrinkbits(128);
+ add(s); // S1
+
+ if(result.morebits(256))
+ {
+ s.zerobits(0, 64);
+ s.copybits(64, result, 256, 64);
+ s.dupbits(128, 64, 64);
+ s.shrinkdigits(GF_DIGITS);
+ add(s); // S2
+
+ if(result.morebits(320))
+ {
+ s.copybits(0, result, 320, 64);
+ s.dupbits(64, 0, 64);
+ s.dupbits(128, 0, 64);
+ s.shrinkdigits(GF_DIGITS);
+ add(s); // S3
+ }
+ }
+ }
+ else if(*this >= P) gfint::sub(*this, P);
+#elif GF_BITS==256
+ // B = T + 2*S1 + 2*S2 + S3 + S4 - D1 - D2 - D3 - D4 mod p
+ copyshrinkdigits(result, GF_DIGITS); // T
+
+ if(result.morebits(256))
+ {
+ gfield s;
+ if(result.morebits(352))
+ {
+ s.zerobits(0, 96);
+ s.copybits(96, result, 352, 160);
+ s.shrinkdigits(GF_DIGITS);
+ add(s); add(s); // S1
+
+ if(result.morebits(384))
+ {
+ //s.zerobits(0, 96);
+ s.copybits(96, result, 384, 128);
+ s.shrinkbits(224);
+ add(s); add(s); // S2
+ }
+ }
+
+ s.copybits(0, result, 256, 96);
+ s.zerobits(96, 96);
+ s.copybits(192, result, 448, 64);
+ s.shrinkdigits(GF_DIGITS);
+ add(s); // S3
+
+ s.copybits(0, result, 288, 96);
+ s.copybits(96, result, 416, 96);
+ s.dupbits(192, 96, 32);
+ s.copybits(224, result, 256, 32);
+ s.shrinkdigits(GF_DIGITS);
+ add(s); // S4
+
+ s.copybits(0, result, 352, 96);
+ s.zerobits(96, 96);
+ s.copybits(192, result, 256, 32);
+ s.copybits(224, result, 320, 32);
+ s.shrinkdigits(GF_DIGITS);
+ sub(s); // D1
+
+ s.copybits(0, result, 384, 128);
+ //s.zerobits(128, 64);
+ s.copybits(192, result, 288, 32);
+ s.copybits(224, result, 352, 32);
+ s.shrinkdigits(GF_DIGITS);
+ sub(s); // D2
+
+ s.copybits(0, result, 416, 96);
+ s.copybits(96, result, 256, 96);
+ s.zerobits(192, 32);
+ s.copybits(224, result, 384, 32);
+ s.shrinkdigits(GF_DIGITS);
+ sub(s); // D3
+
+ s.copybits(0, result, 448, 64);
+ s.zerobits(64, 32);
+ s.copybits(96, result, 288, 96);
+ //s.zerobits(192, 32);
+ s.copybits(224, result, 416, 32);
+ s.shrinkdigits(GF_DIGITS);
+ sub(s); // D4
+ }
+ else if(*this >= P) gfint::sub(*this, P);
+#else
+#error Unsupported GF
+#endif
+ }
+
+ template<int X_DIGITS, int Y_DIGITS> gfield &pow(const bigint<X_DIGITS> &x, const bigint<Y_DIGITS> &y)
+ {
+ gfield a(x);
+ if(y.hasbit(0)) *this = a;
+ else
+ {
+ len = 1;
+ digits[0] = 1;
+ if(!y.len) return *this;
+ }
+ for(int i = 1, j = y.numbits(); i < j; i++)
+ {
+ a.square();
+ if(y.hasbit(i)) mul(a);
+ }
+ return *this;
+ }
+ template<int Y_DIGITS> gfield &pow(const bigint<Y_DIGITS> &y) { return pow(*this, y); }
+
+ bool invert(const gfield &x)
+ {
+ if(!x.len) return false;
+ gfint u(x), v(P), A((gfint::digit)1), C((gfint::digit)0);
+ while(!u.iszero())
+ {
+ int ushift = 0, ashift = 0;
+ while(!u.hasbit(ushift))
+ {
+ ushift++;
+ if(A.hasbit(ashift))
+ {
+ if(ashift) { A.rshift(ashift); ashift = 0; }
+ A.add(P);
+ }
+ ashift++;
+ }
+ if(ushift) u.rshift(ushift);
+ if(ashift) A.rshift(ashift);
+ int vshift = 0, cshift = 0;
+ while(!v.hasbit(vshift))
+ {
+ vshift++;
+ if(C.hasbit(cshift))
+ {
+ if(cshift) { C.rshift(cshift); cshift = 0; }
+ C.add(P);
+ }
+ cshift++;
+ }
+ if(vshift) v.rshift(vshift);
+ if(cshift) C.rshift(cshift);
+ if(u >= v)
+ {
+ u.sub(v);
+ if(A < C) A.add(P);
+ A.sub(C);
+ }
+ else
+ {
+ v.sub(v, u);
+ if(C < A) C.add(P);
+ C.sub(A);
+ }
+ }
+ if(C >= P) gfint::sub(C, P);
+ else { len = C.len; memcpy(digits, C.digits, len*sizeof(digit)); }
+ ASSERT(*this < P);
+ return true;
+ }
+ void invert() { invert(*this); }
+
+ template<int X_DIGITS> static int legendre(const bigint<X_DIGITS> &x)
+ {
+ static const gfint Psub1div2(gfint(P).sub(bigint<1>(1)).rshift(1));
+ gfield L;
+ L.pow(x, Psub1div2);
+ if(!L.len) return 0;
+ if(L.len==1) return 1;
+ return -1;
+ }
+ int legendre() const { return legendre(*this); }
+
+ bool sqrt(const gfield &x)
+ {
+ if(!x.len) { len = 0; return true; }
+#if GF_BITS==224
+#error Unsupported GF
+#else
+ ASSERT((P.digits[0]%4)==3);
+ static const gfint Padd1div4(gfint(P).add(bigint<1>(1)).rshift(2));
+ switch(legendre(x))
+ {
+ case 0: len = 0; return true;
+ case -1: return false;
+ default: pow(x, Padd1div4); return true;
+ }
+#endif
+ }
+ bool sqrt() { return sqrt(*this); }
+};
+
+struct ecjacobian
+{
+ static const gfield B;
+ static const ecjacobian base;
+ static const ecjacobian origin;
+
+ gfield x, y, z;
+
+ ecjacobian() {}
+ ecjacobian(const gfield &x, const gfield &y) : x(x), y(y), z(bigint<1>(1)) {}
+ ecjacobian(const gfield &x, const gfield &y, const gfield &z) : x(x), y(y), z(z) {}
+
+ void mul2()
+ {
+ if(z.iszero()) return;
+ else if(y.iszero()) { *this = origin; return; }
+ gfield a, b, c, d;
+ d.sub(x, c.square(z));
+ d.mul(c.add(x));
+ c.mul2(d).add(d);
+ z.mul(y).add(z);
+ a.square(y);
+ b.mul2(a);
+ d.mul2(x).mul(b);
+ x.square(c).sub(d).sub(d);
+ a.square(b).add(a);
+ y.sub(d, x).mul(c).sub(a);
+ }
+
+ void add(const ecjacobian &q)
+ {
+ if(q.z.iszero()) return;
+ else if(z.iszero()) { *this = q; return; }
+ gfield a, b, c, d, e, f;
+ a.square(z);
+ b.mul(q.y, a).mul(z);
+ a.mul(q.x);
+ if(q.z.isone())
+ {
+ c.add(x, a);
+ d.add(y, b);
+ a.sub(x, a);
+ b.sub(y, b);
+ }
+ else
+ {
+ f.mul(y, e.square(q.z)).mul(q.z);
+ e.mul(x);
+ c.add(e, a);
+ d.add(f, b);
+ a.sub(e, a);
+ b.sub(f, b);
+ }
+ if(a.iszero()) { if(b.iszero()) mul2(); else *this = origin; return; }
+ if(!q.z.isone()) z.mul(q.z);
+ z.mul(a);
+ x.square(b).sub(f.mul(c, e.square(a)));
+ y.sub(f, x).sub(x).mul(b).sub(e.mul(a).mul(d)).div2();
+ }
+
+ template<int Q_DIGITS> void mul(const ecjacobian &p, const bigint<Q_DIGITS> &q)
+ {
+ *this = origin;
+ loopirev(q.numbits())
+ {
+ mul2();
+ if(q.hasbit(i)) add(p);
+ }
+ }
+ template<int Q_DIGITS> void mul(const bigint<Q_DIGITS> &q) { ecjacobian tmp(*this); mul(tmp, q); }
+
+ void normalize()
+ {
+ if(z.iszero() || z.isone()) return;
+ gfield tmp;
+ z.invert();
+ tmp.square(z);
+ x.mul(tmp);
+ y.mul(tmp).mul(z);
+ z = bigint<1>(1);
+ }
+
+ bool calcy(bool ybit)
+ {
+ gfield y2, tmp;
+ y2.square(x).mul(x).sub(tmp.add(x, x).add(x)).add(B);
+ if(!y.sqrt(y2)) { y.zero(); return false; }
+ if(y.hasbit(0) != ybit) y.neg();
+ return true;
+ }
+
+ void print(vector<char> &buf)
+ {
+ normalize();
+ buf.add(y.hasbit(0) ? '-' : '+');
+ x.printdigits(buf);
+ }
+
+ void parse(const char *s)
+ {
+ bool ybit = *s++ == '-';
+ x.parse(s);
+ calcy(ybit);
+ z = bigint<1>(1);
+ }
+};
+
+const ecjacobian ecjacobian::origin(gfield((gfield::digit)1), gfield((gfield::digit)1), gfield((gfield::digit)0));
+
+#if GF_BITS==192
+const gfield gfield::P("fffffffffffffffffffffffffffffffeffffffffffffffff");
+const gfield ecjacobian::B("64210519e59c80e70fa7e9ab72243049feb8deecc146b9b1");
+const ecjacobian ecjacobian::base(
+ gfield("188da80eb03090f67cbf20eb43a18800f4ff0afd82ff1012"),
+ gfield("07192b95ffc8da78631011ed6b24cdd573f977a11e794811")
+);
+#elif GF_BITS==224
+const gfield gfield::P("ffffffffffffffffffffffffffffffff000000000000000000000001");
+const gfield ecjacobian::B("b4050a850c04b3abf54132565044b0b7d7bfd8ba270b39432355ffb4");
+const ecjacobian ecjacobian::base(
+ gfield("b70e0cbd6bb4bf7f321390b94a03c1d356c21122343280d6115c1d21"),
+ gfield("bd376388b5f723fb4c22dfe6cd4375a05a07476444d5819985007e34")
+);
+#elif GF_BITS==256
+const gfield gfield::P("ffffffff00000001000000000000000000000000ffffffffffffffffffffffff");
+const gfield ecjacobian::B("5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b");
+const ecjacobian ecjacobian::base(
+ gfield("6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296"),
+ gfield("4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5")
+);
+#elif GF_BITS==384
+const gfield gfield::P("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffeffffffff0000000000000000ffffffff");
+const gfield ecjacobian::B("b3312fa7e23ee7e4988e056be3f82d19181d9c6efe8141120314088f5013875ac656398d8a2ed19d2a85c8edd3ec2aef");
+const ecjacobian ecjacobian::base(
+ gfield("aa87ca22be8b05378eb1c71ef320ad746e1d3b628ba79b9859f741e082542a385502f25dbf55296c3a545e3872760ab7"),
+ gfield("3617de4a96262c6f5d9e98bf9292dc29f8f41dbd289a147ce9da3113b5f0b8c00a60b1ce1d7e819d7a431d7c90ea0e5f")
+);
+#elif GF_BITS==521
+const gfield gfield::P("1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+const gfield ecjacobian::B("051953eb968e1c9a1f929a21a0b68540eea2da725b99b315f3b8b489918ef109e156193951ec7e937b1652c0bd3bb1bf073573df883d2c34f1ef451fd46b503f00");
+const ecjacobian ecjacobian::base(
+ gfield("c6858e06b70404e9cd9e3ecb662395b4429c648139053fb521f828af606b4d3dbaa14b5e77efe75928fe1dc127a2ffa8de3348b3c1856a429bf97e7e31c2e5bd66"),
+ gfield("11839296a789a3bc0045c8a5fb42c7d1bd998f54449579b446817afbd17273e662c97ee72995ef42640c550b9013fad0761353c7086a272c24088be94769fd16650")
+);
+#else
+#error Unsupported GF
+#endif
+
+void calcpubkey(gfint privkey, vector<char> &pubstr)
+{
+ ecjacobian c(ecjacobian::base);
+ c.mul(privkey);
+ c.normalize();
+ c.print(pubstr);
+ pubstr.add('\0');
+}
+
+bool calcpubkey(const char *privstr, vector<char> &pubstr)
+{
+ if(!privstr[0]) return false;
+ gfint privkey;
+ privkey.parse(privstr);
+ calcpubkey(privkey, pubstr);
+ return true;
+}
+
+void genprivkey(const char *seed, vector<char> &privstr, vector<char> &pubstr)
+{
+ tiger::hashval hash;
+ tiger::hash((const uchar *)seed, (int)strlen(seed), hash);
+ bigint<8*sizeof(hash.bytes)/BI_DIGIT_BITS> privkey;
+ memcpy(privkey.digits, hash.bytes, sizeof(hash.bytes));
+ privkey.len = 8*sizeof(hash.bytes)/BI_DIGIT_BITS;
+ privkey.shrink();
+ privkey.printdigits(privstr);
+ privstr.add('\0');
+
+ calcpubkey(privkey, pubstr);
+}
+
+bool hashstring(const char *str, char *result, int maxlen)
+{
+ tiger::hashval hv;
+ if(maxlen < 2*(int)sizeof(hv.bytes) + 1) return false;
+ tiger::hash((uchar *)str, strlen(str), hv);
+ loopi(sizeof(hv.bytes))
+ {
+ uchar c = hv.bytes[i];
+ *result++ = "0123456789abcdef"[c&0xF];
+ *result++ = "0123456789abcdef"[c>>4];
+ }
+ *result = '\0';
+ return true;
+}
+
+void answerchallenge(const char *privstr, const char *challenge, vector<char> &answerstr)
+{
+ gfint privkey;
+ privkey.parse(privstr);
+ ecjacobian answer;
+ answer.parse(challenge);
+ answer.mul(privkey);
+ answer.normalize();
+ answer.x.printdigits(answerstr);
+ answerstr.add('\0');
+}
+
+void *parsepubkey(const char *pubstr)
+{
+ ecjacobian *pubkey = new ecjacobian;
+ pubkey->parse(pubstr);
+ return pubkey;
+}
+
+void freepubkey(void *pubkey)
+{
+ delete (ecjacobian *)pubkey;
+}
+
+void *genchallenge(void *pubkey, const void *seed, int seedlen, vector<char> &challengestr)
+{
+ tiger::hashval hash;
+ tiger::hash((const uchar *)seed, seedlen, hash);
+ gfint challenge;
+ memcpy(challenge.digits, hash.bytes, sizeof(hash.bytes));
+ challenge.len = 8*sizeof(hash.bytes)/BI_DIGIT_BITS;
+ challenge.shrink();
+
+ ecjacobian answer(*(ecjacobian *)pubkey);
+ answer.mul(challenge);
+ answer.normalize();
+
+ ecjacobian secret(ecjacobian::base);
+ secret.mul(challenge);
+ secret.normalize();
+
+ secret.print(challengestr);
+ challengestr.add('\0');
+
+ return new gfield(answer.x);
+}
+
+void freechallenge(void *answer)
+{
+ delete (gfint *)answer;
+}
+
+bool checkchallenge(const char *answerstr, void *correct)
+{
+ gfint answer(answerstr);
+ return answer == *(gfint *)correct;
+}
+
diff --git a/src/shared/cube.h b/src/shared/cube.h
new file mode 100644
index 0000000..ed1c207
--- /dev/null
+++ b/src/shared/cube.h
@@ -0,0 +1,68 @@
+#ifndef __CUBE_H__
+#define __CUBE_H__
+
+#define _FILE_OFFSET_BITS 64
+
+#ifdef WIN32
+#define _USE_MATH_DEFINES
+#endif
+#include <math.h>
+
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <stdarg.h>
+#include <limits.h>
+#include <assert.h>
+#include <time.h>
+
+#ifdef WIN32
+ #define WIN32_LEAN_AND_MEAN
+ #ifdef _WIN32_WINNT
+ #undef _WIN32_WINNT
+ #endif
+ #define _WIN32_WINNT 0x0500
+ #include "windows.h"
+ #ifndef _WINDOWS
+ #define _WINDOWS
+ #endif
+ #ifndef __GNUC__
+ #include <eh.h>
+ #include <dbghelp.h>
+ #include <intrin.h>
+ #endif
+ #define ZLIB_DLL
+#endif
+
+#ifndef STANDALONE
+ #ifdef __APPLE__
+ #include "SDL.h"
+ #define GL_GLEXT_LEGACY
+ #define __glext_h_
+ #include <OpenGL/gl.h>
+ #else
+ #include <SDL.h>
+ #include <SDL_opengl.h>
+ #endif
+#endif
+
+#include <enet/enet.h>
+
+#include <zlib.h>
+
+#include "tools.h"
+#include "geom.h"
+#include "ents.h"
+#include "command.h"
+
+#ifndef STANDALONE
+#include "glexts.h"
+#include "glemu.h"
+#endif
+
+#include "iengine.h"
+#include "igame.h"
+
+#endif
+
diff --git a/src/shared/cube2font.c b/src/shared/cube2font.c
new file mode 100644
index 0000000..94e407d
--- /dev/null
+++ b/src/shared/cube2font.c
@@ -0,0 +1,556 @@
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <limits.h>
+#include <zlib.h>
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_STROKER_H
+#include FT_GLYPH_H
+
+typedef unsigned char uchar;
+typedef unsigned short ushort;
+typedef unsigned int uint;
+
+int imin(int a, int b) { return a < b ? a : b; }
+int imax(int a, int b) { return a > b ? a : b; }
+
+void fatal(const char *fmt, ...)
+{
+ va_list v;
+ va_start(v, fmt);
+ vfprintf(stderr, fmt, v);
+ va_end(v);
+ fputc('\n', stderr);
+
+ exit(EXIT_FAILURE);
+}
+
+uint bigswap(uint n)
+{
+ const int islittleendian = 1;
+ return *(const uchar *)&islittleendian ? (n<<24) | (n>>24) | ((n>>8)&0xFF00) | ((n<<8)&0xFF0000) : n;
+}
+
+size_t writebig(FILE *f, uint n)
+{
+ n = bigswap(n);
+ return fwrite(&n, 1, sizeof(n), f);
+}
+
+void writepngchunk(FILE *f, const char *type, uchar *data, uint len)
+{
+ uint crc;
+ writebig(f, len);
+ fwrite(type, 1, 4, f);
+ fwrite(data, 1, len, f);
+
+ crc = crc32(0, Z_NULL, 0);
+ crc = crc32(crc, (const Bytef *)type, 4);
+ if(data) crc = crc32(crc, data, len);
+ writebig(f, crc);
+}
+
+struct pngihdr
+{
+ uint width, height;
+ uchar bitdepth, colortype, compress, filter, interlace;
+};
+
+void savepng(const char *filename, uchar *data, int w, int h, int bpp, int flip)
+{
+ const uchar signature[] = { 137, 80, 78, 71, 13, 10, 26, 10 };
+ struct pngihdr ihdr;
+ FILE *f;
+ long idat;
+ uint len, crc;
+ z_stream z;
+ uchar buf[1<<12];
+ int i, j;
+
+ memset(&ihdr, 0, sizeof(ihdr));
+ ihdr.width = bigswap(w);
+ ihdr.height = bigswap(h);
+ ihdr.bitdepth = 8;
+ switch(bpp)
+ {
+ case 1: ihdr.colortype = 0; break;
+ case 2: ihdr.colortype = 4; break;
+ case 3: ihdr.colortype = 2; break;
+ case 4: ihdr.colortype = 6; break;
+ default: fatal("cube2font: invalid PNG bpp"); return;
+ }
+ f = fopen(filename, "wb");
+ if(!f) { fatal("cube2font: could not write to %s", filename); return; }
+
+ fwrite(signature, 1, sizeof(signature), f);
+
+ writepngchunk(f, "IHDR", (uchar *)&ihdr, 13);
+
+ idat = ftell(f);
+ len = 0;
+ fwrite("\0\0\0\0IDAT", 1, 8, f);
+ crc = crc32(0, Z_NULL, 0);
+ crc = crc32(crc, (const Bytef *)"IDAT", 4);
+
+ z.zalloc = NULL;
+ z.zfree = NULL;
+ z.opaque = NULL;
+
+ if(deflateInit(&z, Z_BEST_COMPRESSION) != Z_OK)
+ goto error;
+
+ z.next_out = (Bytef *)buf;
+ z.avail_out = sizeof(buf);
+
+ for(i = 0; i < h; i++)
+ {
+ uchar filter = 0;
+ for(j = 0; j < 2; j++)
+ {
+ z.next_in = j ? (Bytef *)data + (flip ? h-i-1 : i)*w*bpp : (Bytef *)&filter;
+ z.avail_in = j ? w*bpp : 1;
+ while(z.avail_in > 0)
+ {
+ if(deflate(&z, Z_NO_FLUSH) != Z_OK) goto cleanuperror;
+ #define FLUSHZ do { \
+ int flush = sizeof(buf) - z.avail_out; \
+ crc = crc32(crc, buf, flush); \
+ len += flush; \
+ fwrite(buf, 1, flush, f); \
+ z.next_out = (Bytef *)buf; \
+ z.avail_out = sizeof(buf); \
+ } while(0)
+ FLUSHZ;
+ }
+ }
+ }
+
+ for(;;)
+ {
+ int err = deflate(&z, Z_FINISH);
+ if(err != Z_OK && err != Z_STREAM_END) goto cleanuperror;
+ FLUSHZ;
+ if(err == Z_STREAM_END) break;
+ }
+
+ deflateEnd(&z);
+
+ fseek(f, idat, SEEK_SET);
+ writebig(f, len);
+ fseek(f, 0, SEEK_END);
+ writebig(f, crc);
+
+ writepngchunk(f, "IEND", NULL, 0);
+
+ fclose(f);
+ return;
+
+cleanuperror:
+ deflateEnd(&z);
+
+error:
+ fclose(f);
+
+ fatal("cube2font: failed saving PNG to %s", filename);
+}
+
+enum
+{
+ CT_PRINT = 1<<0,
+ CT_SPACE = 1<<1,
+ CT_DIGIT = 1<<2,
+ CT_ALPHA = 1<<3,
+ CT_LOWER = 1<<4,
+ CT_UPPER = 1<<5,
+ CT_UNICODE = 1<<6
+};
+#define CUBECTYPE(s, p, d, a, A, u, U) \
+ 0, U, U, U, U, U, U, U, U, s, s, s, s, s, U, U, \
+ U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, \
+ s, p, p, p, p, p, p, p, p, p, p, p, p, p, p, p, \
+ d, d, d, d, d, d, d, d, d, d, p, p, p, p, p, p, \
+ p, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, \
+ A, A, A, A, A, A, A, A, A, A, A, p, p, p, p, p, \
+ p, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, \
+ a, a, a, a, a, a, a, a, a, a, a, p, p, p, p, U, \
+ U, u, u, u, u, u, u, u, u, u, u, u, u, u, u, u, \
+ u, u, u, u, u, u, u, u, u, u, u, u, u, u, u, U, \
+ u, U, u, U, u, U, u, U, u, U, u, U, u, U, u, U, \
+ u, U, u, U, u, U, u, U, u, U, u, U, u, U, u, U, \
+ u, U, u, U, u, U, u, U, U, u, U, u, U, u, U, U, \
+ U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, \
+ U, U, U, U, u, u, u, u, u, u, u, u, u, u, u, u, \
+ u, u, u, u, u, u, u, u, u, u, u, u, u, u, U, u
+const uchar cubectype[256] =
+{
+ CUBECTYPE(CT_SPACE,
+ CT_PRINT,
+ CT_PRINT|CT_DIGIT,
+ CT_PRINT|CT_ALPHA|CT_LOWER,
+ CT_PRINT|CT_ALPHA|CT_UPPER,
+ CT_PRINT|CT_UNICODE|CT_ALPHA|CT_LOWER,
+ CT_PRINT|CT_UNICODE|CT_ALPHA|CT_UPPER)
+};
+int iscubeprint(uchar c) { return cubectype[c]&CT_PRINT; }
+int iscubespace(uchar c) { return cubectype[c]&CT_SPACE; }
+int iscubealpha(uchar c) { return cubectype[c]&CT_ALPHA; }
+int iscubealnum(uchar c) { return cubectype[c]&(CT_ALPHA|CT_DIGIT); }
+int iscubelower(uchar c) { return cubectype[c]&CT_LOWER; }
+int iscubeupper(uchar c) { return cubectype[c]&CT_UPPER; }
+const int cube2unichars[256] =
+{
+ 0, 192, 193, 194, 195, 196, 197, 198, 199, 9, 10, 11, 12, 13, 200, 201,
+ 202, 203, 204, 205, 206, 207, 209, 210, 211, 212, 213, 214, 216, 217, 218, 219,
+ 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
+ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
+ 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
+ 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
+ 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
+ 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 220,
+ 221, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237,
+ 238, 239, 241, 242, 243, 244, 245, 246, 248, 249, 250, 251, 252, 253, 255, 0x104,
+ 0x105, 0x106, 0x107, 0x10C, 0x10D, 0x10E, 0x10F, 0x118, 0x119, 0x11A, 0x11B, 0x11E, 0x11F, 0x130, 0x131, 0x141,
+ 0x142, 0x143, 0x144, 0x147, 0x148, 0x150, 0x151, 0x152, 0x153, 0x158, 0x159, 0x15A, 0x15B, 0x15E, 0x15F, 0x160,
+ 0x161, 0x164, 0x165, 0x16E, 0x16F, 0x170, 0x171, 0x178, 0x179, 0x17A, 0x17B, 0x17C, 0x17D, 0x17E, 0x404, 0x411,
+ 0x413, 0x414, 0x416, 0x417, 0x418, 0x419, 0x41B, 0x41F, 0x423, 0x424, 0x426, 0x427, 0x428, 0x429, 0x42A, 0x42B,
+ 0x42C, 0x42D, 0x42E, 0x42F, 0x431, 0x432, 0x433, 0x434, 0x436, 0x437, 0x438, 0x439, 0x43A, 0x43B, 0x43C, 0x43D,
+ 0x43F, 0x442, 0x444, 0x446, 0x447, 0x448, 0x449, 0x44A, 0x44B, 0x44C, 0x44D, 0x44E, 0x44F, 0x454, 0x490, 0x491
+};
+int cube2uni(uchar c)
+{
+ return cube2unichars[c];
+}
+
+const char *encodeutf8(int uni)
+{
+ static char buf[7];
+ char *dst = buf;
+ if(uni <= 0x7F) { *dst++ = uni; goto uni1; }
+ else if(uni <= 0x7FF) { *dst++ = 0xC0 | (uni>>6); goto uni2; }
+ else if(uni <= 0xFFFF) { *dst++ = 0xE0 | (uni>>12); goto uni3; }
+ else if(uni <= 0x1FFFFF) { *dst++ = 0xF0 | (uni>>18); goto uni4; }
+ else if(uni <= 0x3FFFFFF) { *dst++ = 0xF8 | (uni>>24); goto uni5; }
+ else if(uni <= 0x7FFFFFFF) { *dst++ = 0xFC | (uni>>30); goto uni6; }
+ else goto uni1;
+uni6: *dst++ = 0x80 | ((uni>>24)&0x3F);
+uni5: *dst++ = 0x80 | ((uni>>18)&0x3F);
+uni4: *dst++ = 0x80 | ((uni>>12)&0x3F);
+uni3: *dst++ = 0x80 | ((uni>>6)&0x3F);
+uni2: *dst++ = 0x80 | (uni&0x3F);
+uni1: *dst++ = '\0';
+ return buf;
+}
+
+struct fontchar { int code, uni, tex, x, y, w, h, offx, offy, offset, advance; FT_BitmapGlyph color, alpha; };
+
+const char *texdir = "";
+
+const char *texfilename(const char *name, int texnum)
+{
+ static char file[256];
+ snprintf(file, sizeof(file), "%s%d.png", name, texnum);
+ return file;
+}
+
+const char *texname(const char *name, int texnum)
+{
+ static char file[512];
+ snprintf(file, sizeof(file), "<grey>%s%s", texdir, texfilename(name, texnum));
+ return file;
+}
+
+void writetexs(const char *name, struct fontchar *chars, int numchars, int numtexs, int tw, int th)
+{
+ int tex;
+ uchar *pixels = (uchar *)malloc(tw*th*2);
+ if(!pixels) fatal("cube2font: failed allocating textures");
+ for(tex = 0; tex < numtexs; tex++)
+ {
+ const char *file = texfilename(name, tex);
+ int texchars = 0, i;
+ uchar *dst, *src;
+ memset(pixels, 0, tw*th*2);
+ for(i = 0; i < numchars; i++)
+ {
+ struct fontchar *c = &chars[i];
+ int x, y;
+ if(c->tex != tex) continue;
+ texchars++;
+ dst = &pixels[2*((c->y + c->offy - c->color->top)*tw + c->x + c->color->left - c->offx)];
+ src = (uchar *)c->color->bitmap.buffer;
+ for(y = 0; y < c->color->bitmap.rows; y++)
+ {
+ for(x = 0; x < c->color->bitmap.width; x++)
+ dst[2*x] = src[x];
+ src += c->color->bitmap.pitch;
+ dst += 2*tw;
+ }
+ dst = &pixels[2*((c->y + c->offy - c->alpha->top)*tw + c->x + c->alpha->left - c->offx)];
+ src = (uchar *)c->alpha->bitmap.buffer;
+ for(y = 0; y < c->alpha->bitmap.rows; y++)
+ {
+ for(x = 0; x < c->alpha->bitmap.width; x++)
+ dst[2*x+1] = src[x];
+ src += c->alpha->bitmap.pitch;
+ dst += 2*tw;
+ }
+ }
+ printf("cube2font: writing %d chars to %s\n", texchars, file);
+ savepng(file, pixels, tw, th, 2, 0);
+ }
+ free(pixels);
+}
+
+void writecfg(const char *name, struct fontchar *chars, int numchars, int x1, int y1, int x2, int y2, int sw, int sh, int argc, char **argv)
+{
+ FILE *f;
+ char file[256];
+ int i, lastcode = 0, lasttex = 0;
+ snprintf(file, sizeof(file), "%s.cfg", name);
+ f = fopen(file, "w");
+ if(!f) fatal("cube2font: failed writing %s", file);
+ printf("cube2font: writing %d chars to %s\n", numchars, file);
+ fprintf(f, "//");
+ for(i = 1; i < argc; i++)
+ fprintf(f, " %s", argv[i]);
+ fprintf(f, "\n");
+ fprintf(f, "font \"%s\" \"%s\" %d %d\n", name, texname(name, 0), sw, sh);
+ for(i = 0; i < numchars; i++)
+ {
+ struct fontchar *c = &chars[i];
+ if(!lastcode && lastcode < c->code)
+ {
+ fprintf(f, "fontoffset \"%s\"\n", encodeutf8(c->uni));
+ lastcode = c->code;
+ }
+ else if(lastcode < c->code)
+ {
+ if(lastcode + 1 == c->code)
+ fprintf(f, "fontskip // %d\n", lastcode);
+ else
+ fprintf(f, "fontskip %d // %d .. %d\n", c->code - lastcode, lastcode, c->code-1);
+ lastcode = c->code;
+ }
+ if(lasttex != c->tex)
+ {
+ fprintf(f, "\nfonttex \"%s\"\n", texname(name, c->tex));
+ lasttex = c->tex;
+ }
+ if(c->code != c->uni)
+ fprintf(f, "fontchar %d %d %d %d %d %d %d // %s (%d -> 0x%X)\n", c->x, c->y, c->w, c->h, c->offx+c->offset, y2-c->offy, c->advance, encodeutf8(c->uni), c->code, c->uni);
+ else
+ fprintf(f, "fontchar %d %d %d %d %d %d %d // %s (%d)\n", c->x, c->y, c->w, c->h, c->offx+c->offset, y2-c->offy, c->advance, encodeutf8(c->uni), c->code);
+ lastcode++;
+ }
+ fclose(f);
+}
+
+int groupchar(int c)
+{
+ switch(c)
+ {
+ case 0x152: case 0x153: case 0x178: return 1;
+ }
+ if(c < 127 || c >= 0x2000) return 0;
+ if(c < 0x100) return 1;
+ if(c < 0x400) return 2;
+ return 3;
+}
+
+int sortchars(const void *x, const void *y)
+{
+ const struct fontchar *xc = *(const struct fontchar **)x, *yc = *(const struct fontchar **)y;
+ int xg = groupchar(xc->uni), yg = groupchar(yc->uni);
+ if(xg < yg) return -1;
+ if(xg > yg) return 1;
+ if(xc->h != yc->h) return yc->h - xc->h;
+ if(xc->w != yc->w) return yc->w - xc->w;
+ return yc->uni - xc->uni;
+}
+
+int scorechar(struct fontchar *f, int pad, int tw, int th, int rw, int rh, int ry)
+{
+ int score = 0;
+ if(rw + f->w > tw) { ry += rh + pad; score = 1; }
+ if(ry + f->h > th) score = 2;
+ return score;
+}
+
+int main(int argc, char **argv)
+{
+ FT_Library l;
+ FT_Face f;
+ FT_Stroker s, s2;
+ int i, pad, offset, advance, w, h, tw, th, c, trial = -2, rw = 0, rh = 0, ry = 0, x1 = INT_MAX, x2 = INT_MIN, y1 = INT_MAX, y2 = INT_MIN, w2 = 0, h2 = 0, sw = 0, sh = 0;
+ float outborder = 0, inborder = 0;
+ struct fontchar chars[256];
+ struct fontchar *order[256];
+ int numchars = 0, numtex = 0;
+ if(argc < 11)
+ fatal("Usage: cube2font infile outfile outborder[:inborder] pad offset advance charwidth charheight texwidth texheight [spacewidth spaceheight texdir]");
+ sscanf(argv[3], "%f:%f", &outborder, &inborder);
+ pad = atoi(argv[4]);
+ offset = atoi(argv[5]);
+ advance = atoi(argv[6]);
+ w = atoi(argv[7]);
+ h = atoi(argv[8]);
+ tw = atoi(argv[9]);
+ th = atoi(argv[10]);
+ if(argc > 11) sw = atoi(argv[11]);
+ if(argc > 12) sh = atoi(argv[12]);
+ if(argc > 13) texdir = argv[13];
+ if(FT_Init_FreeType(&l))
+ fatal("cube2font: failed initing freetype");
+ if(FT_New_Face(l, argv[1], 0, &f) ||
+ FT_Set_Charmap(f, f->charmaps[0]) ||
+ FT_Set_Pixel_Sizes(f, w, h) ||
+ FT_Stroker_New(l, &s) ||
+ FT_Stroker_New(l, &s2))
+ fatal("cube2font: failed loading font %s", argv[1]);
+ if(outborder > 0) FT_Stroker_Set(s, (FT_Fixed)(outborder * 64), FT_STROKER_LINECAP_ROUND, FT_STROKER_LINEJOIN_ROUND, 0);
+ if(inborder > 0) FT_Stroker_Set(s2, (FT_Fixed)(inborder * 64), FT_STROKER_LINECAP_ROUND, FT_STROKER_LINEJOIN_ROUND, 0);
+ for(c = 0; c < 256; c++) if(iscubeprint(c))
+ {
+ FT_Glyph p, p2;
+ FT_BitmapGlyph b, b2;
+ struct fontchar *dst = &chars[numchars];
+ dst->code = c;
+ dst->uni = cube2uni(c);
+ if(FT_Load_Char(f, dst->uni, FT_LOAD_DEFAULT))
+ fatal("cube2font: failed loading character %s", encodeutf8(dst->uni));
+ FT_Get_Glyph(f->glyph, &p);
+ p2 = p;
+ if(outborder > 0) FT_Glyph_StrokeBorder(&p, s, 0, 0);
+ if(inborder > 0) FT_Glyph_StrokeBorder(&p2, s2, 1, 0);
+ FT_Glyph_To_Bitmap(&p, FT_RENDER_MODE_NORMAL, 0, 1);
+ if(inborder > 0 || outborder > 0) FT_Glyph_To_Bitmap(&p2, FT_RENDER_MODE_NORMAL, 0, 1);
+ else p2 = p;
+ b = (FT_BitmapGlyph)p;
+ b2 = (FT_BitmapGlyph)p2;
+ dst->tex = -1;
+ dst->x = INT_MIN;
+ dst->y = INT_MIN;
+ dst->offx = imin(b->left, b2->left);
+ dst->offy = imax(b->top, b2->top);
+ dst->offset = offset;
+ dst->advance = offset + ((p->advance.x+0xFFFF)>>16) + advance;
+ dst->w = imax(b->left + b->bitmap.width, b2->left + b2->bitmap.width) - dst->offx;
+ dst->h = dst->offy - imin(b->top - b->bitmap.rows, b2->top - b2->bitmap.rows);
+ dst->alpha = b;
+ dst->color = b2;
+ order[numchars++] = dst;
+ }
+ qsort(order, numchars, sizeof(order[0]), sortchars);
+ for(i = 0; i < numchars;)
+ {
+ struct fontchar *dst;
+ int j, k, trial0, prevscore, dstscore, fitscore;
+ for(trial0 = trial, prevscore = -1; (trial -= 2) >= trial0-512;)
+ {
+ int g, fw = rw, fh = rh, fy = ry, curscore = 0, reused = 0;
+ for(j = i; j < numchars; j++)
+ {
+ dst = order[j];
+ if(dst->tex >= 0 || dst->tex <= trial) continue;
+ g = groupchar(dst->uni);
+ dstscore = scorechar(dst, pad, tw, th, fw, fh, fy);
+ for(k = j; k < numchars; k++)
+ {
+ struct fontchar *fit = order[k];
+ if(fit->tex >= 0 || fit->tex <= trial) continue;
+ if(fit->tex >= trial0 && groupchar(fit->uni) != g) break;
+ fitscore = scorechar(fit, pad, tw, th, fw, fh, fy);
+ if(fitscore < dstscore || (fitscore == dstscore && fit->h > dst->h))
+ {
+ dst = fit;
+ dstscore = fitscore;
+ }
+ }
+ if(fw + dst->w > tw)
+ {
+ fy += fh + pad;
+ fw = fh = 0;
+ }
+ if(fy + dst->h > th)
+ {
+ fy = fw = fh = 0;
+ if(curscore > 0) break;
+ }
+ if(dst->tex >= trial+1 && dst->tex <= trial+2) { dst->tex = trial; reused++; }
+ else dst->tex = trial;
+ fw += dst->w + pad;
+ fh = imax(fh, dst->h);
+ if(dst != order[j]) --j;
+ curscore++;
+ }
+ if(reused < prevscore || curscore <= prevscore) break;
+ prevscore = curscore;
+ }
+ for(; i < numchars; i++)
+ {
+ dst = order[i];
+ if(dst->tex >= 0) continue;
+ dstscore = scorechar(dst, pad, tw, th, rw, rh, ry);
+ for(j = i; j < numchars; j++)
+ {
+ struct fontchar *fit = order[j];
+ if(fit->tex < trial || fit->tex > trial+2) continue;
+ fitscore = scorechar(fit, pad, tw, th, rw, rh, ry);
+ if(fitscore < dstscore || (fitscore == dstscore && fit->h > dst->h))
+ {
+ dst = fit;
+ dstscore = fitscore;
+ }
+ }
+ if(dst->tex < trial || dst->tex > trial+2) break;
+ if(rw + dst->w > tw)
+ {
+ ry += rh + pad;
+ rw = rh = 0;
+ }
+ if(ry + dst->h > th)
+ {
+ ry = rw = rh = 0;
+ numtex++;
+ }
+ dst->tex = numtex;
+ dst->x = rw;
+ dst->y = ry;
+ rw += dst->w + pad;
+ rh = imax(rh, dst->h);
+ y1 = imin(y1, dst->offy - dst->h);
+ y2 = imax(y2, dst->offy);
+ x1 = imin(x1, dst->offx);
+ x2 = imax(x2, dst->offx + dst->w);
+ w2 = imax(w2, dst->w);
+ h2 = imax(h2, dst->h);
+ if(dst != order[i]) --i;
+ }
+ }
+ if(rh > 0) numtex++;
+#if 0
+ if(sw <= 0)
+ {
+ if(FT_Load_Char(f, ' ', FT_LOAD_DEFAULT))
+ fatal("cube2font: failed loading space character");
+ sw = (f->glyph->advance.x+0x3F)>>6;
+ }
+#endif
+ if(sh <= 0) sh = y2 - y1;
+ if(sw <= 0) sw = sh/3;
+ writetexs(argv[2], chars, numchars, numtex, tw, th);
+ writecfg(argv[2], chars, numchars, x1, y1, x2, y2, sw, sh, argc, argv);
+ for(i = 0; i < numchars; i++)
+ {
+ if(chars[i].alpha != chars[i].color) FT_Done_Glyph((FT_Glyph)chars[i].alpha);
+ FT_Done_Glyph((FT_Glyph)chars[i].color);
+ }
+ FT_Stroker_Done(s);
+ FT_Stroker_Done(s2);
+ FT_Done_FreeType(l);
+ printf("cube2font: (%d, %d) .. (%d, %d) = (%d, %d) / (%d, %d), %d texs\n", x1, y1, x2, y2, x2 - x1, y2 - y1, w2, h2, numtex);
+ return EXIT_SUCCESS;
+}
+
diff --git a/src/shared/ents.h b/src/shared/ents.h
new file mode 100644
index 0000000..f4da8f5
--- /dev/null
+++ b/src/shared/ents.h
@@ -0,0 +1,237 @@
+// this file defines static map entities ("entity") and dynamic entities (players/monsters, "dynent")
+// the gamecode extends these types to add game specific functionality
+
+// ET_*: the only static entity types dictated by the engine... rest are gamecode dependent
+
+enum { ET_EMPTY=0, ET_LIGHT, ET_MAPMODEL, ET_PLAYERSTART, ET_ENVMAP, ET_PARTICLES, ET_SOUND, ET_SPOTLIGHT, ET_GAMESPECIFIC };
+
+struct entity // persistent map entity
+{
+ vec o; // position
+ short attr1, attr2, attr3, attr4, attr5;
+ uchar type; // type is one of the above
+ uchar reserved;
+};
+
+struct entitylight
+{
+ vec color, dir;
+ int millis;
+
+ entitylight() : color(1, 1, 1), dir(0, 0, 1), millis(-1) {}
+};
+
+enum
+{
+ EF_NOVIS = 1<<0,
+ EF_NOSHADOW = 1<<1,
+ EF_NOCOLLIDE = 1<<2,
+ EF_ANIM = 1<<3,
+ EF_OCTA = 1<<4,
+ EF_RENDER = 1<<5,
+ EF_SOUND = 1<<6,
+ EF_SPAWNED = 1<<7,
+ EF_NOPICKUP = 1<<8
+};
+
+struct extentity : entity // part of the entity that doesn't get saved to disk
+{
+ int flags; // the only dynamic state of a map entity
+ entitylight light;
+ extentity *attached;
+
+ extentity() : flags(0), attached(NULL) {}
+
+ bool spawned() const { return (flags&EF_SPAWNED) != 0; }
+ void setspawned(bool val) { if(val) flags |= EF_SPAWNED; else flags &= ~EF_SPAWNED; }
+ void setspawned() { flags |= EF_SPAWNED; }
+ void clearspawned() { flags &= ~EF_SPAWNED; }
+
+ bool nopickup() const { return (flags&EF_NOPICKUP) != 0; }
+ void setnopickup(bool val) { if(val) flags |= EF_NOPICKUP; else flags &= ~EF_NOPICKUP; }
+ void setnopickup() { flags |= EF_NOPICKUP; }
+ void clearnopickup() { flags &= ~EF_NOPICKUP; }
+};
+
+#define MAXENTS 10000
+
+//extern vector<extentity *> ents; // map entities
+
+enum { CS_ALIVE = 0, CS_DEAD, CS_SPAWNING, CS_LAGGED, CS_EDITING, CS_SPECTATOR };
+
+enum { PHYS_FLOAT = 0, PHYS_FALL, PHYS_SLIDE, PHYS_SLOPE, PHYS_FLOOR, PHYS_STEP_UP, PHYS_STEP_DOWN, PHYS_BOUNCE };
+
+enum { ENT_PLAYER = 0, ENT_AI, ENT_INANIMATE, ENT_CAMERA, ENT_BOUNCE };
+
+enum { COLLIDE_NONE = 0, COLLIDE_ELLIPSE, COLLIDE_OBB, COLLIDE_ELLIPSE_PRECISE };
+
+struct physent // base entity type, can be affected by physics
+{
+ vec o, vel, falling; // origin, velocity
+ vec deltapos, newpos; // movement interpolation
+ float yaw, pitch, roll;
+ float maxspeed; // cubes per second, 100 for player
+ float radius, eyeheight, aboveeye; // bounding box size
+ float xradius, yradius, zmargin;
+ vec floor; // the normal of floor the dynent is on
+
+ ushort timeinair;
+ uchar inwater;
+ bool jumping;
+ schar move, strafe;
+
+ uchar physstate; // one of PHYS_* above
+ uchar state, editstate; // one of CS_* above
+ uchar type; // one of ENT_* above
+ uchar collidetype; // one of COLLIDE_* above
+
+ bool blocked; // used by physics to signal ai
+
+ physent() : o(0, 0, 0), deltapos(0, 0, 0), newpos(0, 0, 0), yaw(0), pitch(0), roll(0), maxspeed(100),
+ radius(4.1f), eyeheight(14), aboveeye(1), xradius(4.1f), yradius(4.1f), zmargin(0),
+ state(CS_ALIVE), editstate(CS_ALIVE), type(ENT_PLAYER),
+ collidetype(COLLIDE_ELLIPSE),
+ blocked(false)
+ { reset(); }
+
+ void resetinterp()
+ {
+ newpos = o;
+ deltapos = vec(0, 0, 0);
+ }
+
+ void reset()
+ {
+ inwater = 0;
+ timeinair = 0;
+ jumping = false;
+ strafe = move = 0;
+ physstate = PHYS_FALL;
+ vel = falling = vec(0, 0, 0);
+ floor = vec(0, 0, 1);
+ }
+
+ vec feetpos(float offset = 0) const { return vec(o).add(vec(0, 0, offset - eyeheight)); }
+ vec headpos(float offset = 0) const { return vec(o).add(vec(0, 0, offset)); }
+
+ bool maymove() const { return timeinair || physstate < PHYS_FLOOR || vel.squaredlen() > 1e-4f || deltapos.squaredlen() > 1e-4f; }
+};
+
+enum
+{
+ ANIM_DEAD = 0, ANIM_DYING, ANIM_IDLE,
+ ANIM_FORWARD, ANIM_BACKWARD, ANIM_LEFT, ANIM_RIGHT,
+ ANIM_HOLD1, ANIM_HOLD2, ANIM_HOLD3, ANIM_HOLD4, ANIM_HOLD5, ANIM_HOLD6, ANIM_HOLD7,
+ ANIM_ATTACK1, ANIM_ATTACK2, ANIM_ATTACK3, ANIM_ATTACK4, ANIM_ATTACK5, ANIM_ATTACK6, ANIM_ATTACK7,
+ ANIM_PAIN,
+ ANIM_JUMP, ANIM_SINK, ANIM_SWIM,
+ ANIM_EDIT, ANIM_LAG, ANIM_TAUNT, ANIM_WIN, ANIM_LOSE,
+ ANIM_GUN_IDLE, ANIM_GUN_SHOOT,
+ ANIM_VWEP_IDLE, ANIM_VWEP_SHOOT, ANIM_SHIELD, ANIM_POWERUP,
+ ANIM_MAPMODEL, ANIM_TRIGGER,
+ NUMANIMS
+};
+
+static const char * const animnames[] =
+{
+ "dead", "dying", "idle",
+ "forward", "backward", "left", "right",
+ "hold 1", "hold 2", "hold 3", "hold 4", "hold 5", "hold 6", "hold 7",
+ "attack 1", "attack 2", "attack 3", "attack 4", "attack 5", "attack 6", "attack 7",
+ "pain",
+ "jump", "sink", "swim",
+ "edit", "lag", "taunt", "win", "lose",
+ "gun idle", "gun shoot",
+ "vwep idle", "vwep shoot", "shield", "powerup",
+ "mapmodel", "trigger"
+};
+
+#define ANIM_ALL 0x7F
+#define ANIM_INDEX 0x7F
+#define ANIM_LOOP (1<<7)
+#define ANIM_START (1<<8)
+#define ANIM_END (1<<9)
+#define ANIM_REVERSE (1<<10)
+#define ANIM_CLAMP (ANIM_START|ANIM_END)
+#define ANIM_DIR 0x780
+#define ANIM_SECONDARY 11
+#define ANIM_NOSKIN (1<<22)
+#define ANIM_SETTIME (1<<23)
+#define ANIM_FULLBRIGHT (1<<24)
+#define ANIM_REUSE (1<<25)
+#define ANIM_NORENDER (1<<26)
+#define ANIM_RAGDOLL (1<<27)
+#define ANIM_SETSPEED (1<<28)
+#define ANIM_NOPITCH (1<<29)
+#define ANIM_GHOST (1<<30)
+#define ANIM_FLAGS (0x1FF<<22)
+
+struct animinfo // description of a character's animation
+{
+ int anim, frame, range, basetime;
+ float speed;
+ uint varseed;
+
+ animinfo() : anim(0), frame(0), range(0), basetime(0), speed(100.0f), varseed(0) { }
+
+ bool operator==(const animinfo &o) const { return frame==o.frame && range==o.range && (anim&(ANIM_SETTIME|ANIM_DIR))==(o.anim&(ANIM_SETTIME|ANIM_DIR)) && (anim&ANIM_SETTIME || basetime==o.basetime) && speed==o.speed; }
+ bool operator!=(const animinfo &o) const { return frame!=o.frame || range!=o.range || (anim&(ANIM_SETTIME|ANIM_DIR))!=(o.anim&(ANIM_SETTIME|ANIM_DIR)) || (!(anim&ANIM_SETTIME) && basetime!=o.basetime) || speed!=o.speed; }
+};
+
+struct animinterpinfo // used for animation blending of animated characters
+{
+ animinfo prev, cur;
+ int lastswitch;
+ void *lastmodel;
+
+ animinterpinfo() : lastswitch(-1), lastmodel(NULL) {}
+
+ void reset() { lastswitch = -1; }
+};
+
+#define MAXANIMPARTS 3
+
+struct occludequery;
+struct ragdolldata;
+
+struct dynent : physent // animated characters, or characters that can receive input
+{
+ bool k_left, k_right, k_up, k_down; // see input code
+
+ entitylight light;
+ animinterpinfo animinterp[MAXANIMPARTS];
+ ragdolldata *ragdoll;
+ occludequery *query;
+ int lastrendered;
+ uchar occluded;
+
+ dynent() : ragdoll(NULL), query(NULL), lastrendered(0), occluded(0)
+ {
+ reset();
+ }
+
+ ~dynent()
+ {
+#ifndef STANDALONE
+ extern void cleanragdoll(dynent *d);
+ if(ragdoll) cleanragdoll(this);
+#endif
+ }
+
+ void stopmoving()
+ {
+ k_left = k_right = k_up = k_down = jumping = false;
+ move = strafe = 0;
+ }
+
+ void reset()
+ {
+ physent::reset();
+ stopmoving();
+ loopi(MAXANIMPARTS) animinterp[i].reset();
+ }
+
+ vec abovehead() { return vec(o).add(vec(0, 0, aboveeye+4)); }
+};
+
+
diff --git a/src/shared/geom.cpp b/src/shared/geom.cpp
new file mode 100644
index 0000000..43206e1
--- /dev/null
+++ b/src/shared/geom.cpp
@@ -0,0 +1,257 @@
+
+#include "cube.h"
+
+static inline double det2x2(double a, double b, double c, double d) { return a*d - b*c; }
+static inline double det3x3(double a1, double a2, double a3,
+ double b1, double b2, double b3,
+ double c1, double c2, double c3)
+{
+ return a1 * det2x2(b2, b3, c2, c3)
+ - b1 * det2x2(a2, a3, c2, c3)
+ + c1 * det2x2(a2, a3, b2, b3);
+}
+
+bool matrix4::invert(const matrix4 &m, double mindet)
+{
+ double a1 = m.a.x, a2 = m.a.y, a3 = m.a.z, a4 = m.a.w,
+ b1 = m.b.x, b2 = m.b.y, b3 = m.b.z, b4 = m.b.w,
+ c1 = m.c.x, c2 = m.c.y, c3 = m.c.z, c4 = m.c.w,
+ d1 = m.d.x, d2 = m.d.y, d3 = m.d.z, d4 = m.d.w,
+ det1 = det3x3(b2, b3, b4, c2, c3, c4, d2, d3, d4),
+ det2 = -det3x3(a2, a3, a4, c2, c3, c4, d2, d3, d4),
+ det3 = det3x3(a2, a3, a4, b2, b3, b4, d2, d3, d4),
+ det4 = -det3x3(a2, a3, a4, b2, b3, b4, c2, c3, c4),
+ det = a1*det1 + b1*det2 + c1*det3 + d1*det4;
+
+ if(fabs(det) < mindet) return false;
+
+ double invdet = 1/det;
+
+ a.x = det1 * invdet;
+ a.y = det2 * invdet;
+ a.z = det3 * invdet;
+ a.w = det4 * invdet;
+
+ b.x = -det3x3(b1, b3, b4, c1, c3, c4, d1, d3, d4) * invdet;
+ b.y = det3x3(a1, a3, a4, c1, c3, c4, d1, d3, d4) * invdet;
+ b.z = -det3x3(a1, a3, a4, b1, b3, b4, d1, d3, d4) * invdet;
+ b.w = det3x3(a1, a3, a4, b1, b3, b4, c1, c3, c4) * invdet;
+
+ c.x = det3x3(b1, b2, b4, c1, c2, c4, d1, d2, d4) * invdet;
+ c.y = -det3x3(a1, a2, a4, c1, c2, c4, d1, d2, d4) * invdet;
+ c.z = det3x3(a1, a2, a4, b1, b2, b4, d1, d2, d4) * invdet;
+ c.w = -det3x3(a1, a2, a4, b1, b2, b4, c1, c2, c4) * invdet;
+
+ d.x = -det3x3(b1, b2, b3, c1, c2, c3, d1, d2, d3) * invdet;
+ d.y = det3x3(a1, a2, a3, c1, c2, c3, d1, d2, d3) * invdet;
+ d.z = -det3x3(a1, a2, a3, b1, b2, b3, d1, d2, d3) * invdet;
+ d.w = det3x3(a1, a2, a3, b1, b2, b3, c1, c2, c3) * invdet;
+
+ return true;
+}
+
+bool raysphereintersect(const vec &center, float radius, const vec &o, const vec &ray, float &dist)
+{
+ vec c(center);
+ c.sub(o);
+ float v = c.dot(ray),
+ inside = radius*radius - c.squaredlen();
+ if(inside<0 && v<0) return false;
+ float d = inside + v*v;
+ if(d<0) return false;
+ dist = v - sqrt(d);
+ return true;
+}
+
+bool rayboxintersect(const vec &b, const vec &s, const vec &o, const vec &ray, float &dist, int &orient)
+{
+ loop(d, 3) if(ray[d])
+ {
+ int dc = ray[d]<0 ? 1 : 0;
+ float pdist = (b[d]+s[d]*dc - o[d]) / ray[d];
+ vec v(ray);
+ v.mul(pdist).add(o);
+ if(v[R[d]] >= b[R[d]] && v[R[d]] <= b[R[d]]+s[R[d]]
+ && v[C[d]] >= b[C[d]] && v[C[d]] <= b[C[d]]+s[C[d]])
+ {
+ dist = pdist;
+ orient = 2*d+dc;
+ return true;
+ }
+ }
+ return false;
+}
+
+bool linecylinderintersect(const vec &from, const vec &to, const vec &start, const vec &end, float radius, float &dist)
+{
+ vec d(end), m(from), n(to);
+ d.sub(start);
+ m.sub(start);
+ n.sub(from);
+ float md = m.dot(d),
+ nd = n.dot(d),
+ dd = d.squaredlen();
+ if(md < 0 && md + nd < 0) return false;
+ if(md > dd && md + nd > dd) return false;
+ float nn = n.squaredlen(),
+ mn = m.dot(n),
+ a = dd*nn - nd*nd,
+ k = m.squaredlen() - radius*radius,
+ c = dd*k - md*md;
+ if(fabs(a) < 0.005f)
+ {
+ if(c > 0) return false;
+ if(md < 0) dist = -mn / nn;
+ else if(md > dd) dist = (nd - mn) / nn;
+ else dist = 0;
+ return true;
+ }
+ else if(c > 0)
+ {
+ float b = dd*mn - nd*md,
+ discrim = b*b - a*c;
+ if(discrim < 0) return false;
+ dist = (-b - sqrtf(discrim)) / a;
+ }
+ else dist = 0;
+ float offset = md + dist*nd;
+ if(offset < 0)
+ {
+ if(nd <= 0) return false;
+ dist = -md / nd;
+ if(k + dist*(2*mn + dist*nn) > 0) return false;
+ }
+ else if(offset > dd)
+ {
+ if(nd >= 0) return false;
+ dist = (dd - md) / nd;
+ if(k + dd - 2*md + dist*(2*(mn-nd) + dist*nn) > 0) return false;
+ }
+ return dist >= 0 && dist <= 1;
+}
+
+extern const vec2 sincos360[721] =
+{
+ vec2(1.00000000, 0.00000000), vec2(0.99984770, 0.01745241), vec2(0.99939083, 0.03489950), vec2(0.99862953, 0.05233596), vec2(0.99756405, 0.06975647), vec2(0.99619470, 0.08715574), // 0
+ vec2(0.99452190, 0.10452846), vec2(0.99254615, 0.12186934), vec2(0.99026807, 0.13917310), vec2(0.98768834, 0.15643447), vec2(0.98480775, 0.17364818), vec2(0.98162718, 0.19080900), // 6
+ vec2(0.97814760, 0.20791169), vec2(0.97437006, 0.22495105), vec2(0.97029573, 0.24192190), vec2(0.96592583, 0.25881905), vec2(0.96126170, 0.27563736), vec2(0.95630476, 0.29237170), // 12
+ vec2(0.95105652, 0.30901699), vec2(0.94551858, 0.32556815), vec2(0.93969262, 0.34202014), vec2(0.93358043, 0.35836795), vec2(0.92718385, 0.37460659), vec2(0.92050485, 0.39073113), // 18
+ vec2(0.91354546, 0.40673664), vec2(0.90630779, 0.42261826), vec2(0.89879405, 0.43837115), vec2(0.89100652, 0.45399050), vec2(0.88294759, 0.46947156), vec2(0.87461971, 0.48480962), // 24
+ vec2(0.86602540, 0.50000000), vec2(0.85716730, 0.51503807), vec2(0.84804810, 0.52991926), vec2(0.83867057, 0.54463904), vec2(0.82903757, 0.55919290), vec2(0.81915204, 0.57357644), // 30
+ vec2(0.80901699, 0.58778525), vec2(0.79863551, 0.60181502), vec2(0.78801075, 0.61566148), vec2(0.77714596, 0.62932039), vec2(0.76604444, 0.64278761), vec2(0.75470958, 0.65605903), // 36
+ vec2(0.74314483, 0.66913061), vec2(0.73135370, 0.68199836), vec2(0.71933980, 0.69465837), vec2(0.70710678, 0.70710678), vec2(0.69465837, 0.71933980), vec2(0.68199836, 0.73135370), // 42
+ vec2(0.66913061, 0.74314483), vec2(0.65605903, 0.75470958), vec2(0.64278761, 0.76604444), vec2(0.62932039, 0.77714596), vec2(0.61566148, 0.78801075), vec2(0.60181502, 0.79863551), // 48
+ vec2(0.58778525, 0.80901699), vec2(0.57357644, 0.81915204), vec2(0.55919290, 0.82903757), vec2(0.54463904, 0.83867057), vec2(0.52991926, 0.84804810), vec2(0.51503807, 0.85716730), // 54
+ vec2(0.50000000, 0.86602540), vec2(0.48480962, 0.87461971), vec2(0.46947156, 0.88294759), vec2(0.45399050, 0.89100652), vec2(0.43837115, 0.89879405), vec2(0.42261826, 0.90630779), // 60
+ vec2(0.40673664, 0.91354546), vec2(0.39073113, 0.92050485), vec2(0.37460659, 0.92718385), vec2(0.35836795, 0.93358043), vec2(0.34202014, 0.93969262), vec2(0.32556815, 0.94551858), // 66
+ vec2(0.30901699, 0.95105652), vec2(0.29237170, 0.95630476), vec2(0.27563736, 0.96126170), vec2(0.25881905, 0.96592583), vec2(0.24192190, 0.97029573), vec2(0.22495105, 0.97437006), // 72
+ vec2(0.20791169, 0.97814760), vec2(0.19080900, 0.98162718), vec2(0.17364818, 0.98480775), vec2(0.15643447, 0.98768834), vec2(0.13917310, 0.99026807), vec2(0.12186934, 0.99254615), // 78
+ vec2(0.10452846, 0.99452190), vec2(0.08715574, 0.99619470), vec2(0.06975647, 0.99756405), vec2(0.05233596, 0.99862953), vec2(0.03489950, 0.99939083), vec2(0.01745241, 0.99984770), // 84
+ vec2(0.00000000, 1.00000000), vec2(-0.01745241, 0.99984770), vec2(-0.03489950, 0.99939083), vec2(-0.05233596, 0.99862953), vec2(-0.06975647, 0.99756405), vec2(-0.08715574, 0.99619470), // 90
+ vec2(-0.10452846, 0.99452190), vec2(-0.12186934, 0.99254615), vec2(-0.13917310, 0.99026807), vec2(-0.15643447, 0.98768834), vec2(-0.17364818, 0.98480775), vec2(-0.19080900, 0.98162718), // 96
+ vec2(-0.20791169, 0.97814760), vec2(-0.22495105, 0.97437006), vec2(-0.24192190, 0.97029573), vec2(-0.25881905, 0.96592583), vec2(-0.27563736, 0.96126170), vec2(-0.29237170, 0.95630476), // 102
+ vec2(-0.30901699, 0.95105652), vec2(-0.32556815, 0.94551858), vec2(-0.34202014, 0.93969262), vec2(-0.35836795, 0.93358043), vec2(-0.37460659, 0.92718385), vec2(-0.39073113, 0.92050485), // 108
+ vec2(-0.40673664, 0.91354546), vec2(-0.42261826, 0.90630779), vec2(-0.43837115, 0.89879405), vec2(-0.45399050, 0.89100652), vec2(-0.46947156, 0.88294759), vec2(-0.48480962, 0.87461971), // 114
+ vec2(-0.50000000, 0.86602540), vec2(-0.51503807, 0.85716730), vec2(-0.52991926, 0.84804810), vec2(-0.54463904, 0.83867057), vec2(-0.55919290, 0.82903757), vec2(-0.57357644, 0.81915204), // 120
+ vec2(-0.58778525, 0.80901699), vec2(-0.60181502, 0.79863551), vec2(-0.61566148, 0.78801075), vec2(-0.62932039, 0.77714596), vec2(-0.64278761, 0.76604444), vec2(-0.65605903, 0.75470958), // 126
+ vec2(-0.66913061, 0.74314483), vec2(-0.68199836, 0.73135370), vec2(-0.69465837, 0.71933980), vec2(-0.70710678, 0.70710678), vec2(-0.71933980, 0.69465837), vec2(-0.73135370, 0.68199836), // 132
+ vec2(-0.74314483, 0.66913061), vec2(-0.75470958, 0.65605903), vec2(-0.76604444, 0.64278761), vec2(-0.77714596, 0.62932039), vec2(-0.78801075, 0.61566148), vec2(-0.79863551, 0.60181502), // 138
+ vec2(-0.80901699, 0.58778525), vec2(-0.81915204, 0.57357644), vec2(-0.82903757, 0.55919290), vec2(-0.83867057, 0.54463904), vec2(-0.84804810, 0.52991926), vec2(-0.85716730, 0.51503807), // 144
+ vec2(-0.86602540, 0.50000000), vec2(-0.87461971, 0.48480962), vec2(-0.88294759, 0.46947156), vec2(-0.89100652, 0.45399050), vec2(-0.89879405, 0.43837115), vec2(-0.90630779, 0.42261826), // 150
+ vec2(-0.91354546, 0.40673664), vec2(-0.92050485, 0.39073113), vec2(-0.92718385, 0.37460659), vec2(-0.93358043, 0.35836795), vec2(-0.93969262, 0.34202014), vec2(-0.94551858, 0.32556815), // 156
+ vec2(-0.95105652, 0.30901699), vec2(-0.95630476, 0.29237170), vec2(-0.96126170, 0.27563736), vec2(-0.96592583, 0.25881905), vec2(-0.97029573, 0.24192190), vec2(-0.97437006, 0.22495105), // 162
+ vec2(-0.97814760, 0.20791169), vec2(-0.98162718, 0.19080900), vec2(-0.98480775, 0.17364818), vec2(-0.98768834, 0.15643447), vec2(-0.99026807, 0.13917310), vec2(-0.99254615, 0.12186934), // 168
+ vec2(-0.99452190, 0.10452846), vec2(-0.99619470, 0.08715574), vec2(-0.99756405, 0.06975647), vec2(-0.99862953, 0.05233596), vec2(-0.99939083, 0.03489950), vec2(-0.99984770, 0.01745241), // 174
+ vec2(-1.00000000, 0.00000000), vec2(-0.99984770, -0.01745241), vec2(-0.99939083, -0.03489950), vec2(-0.99862953, -0.05233596), vec2(-0.99756405, -0.06975647), vec2(-0.99619470, -0.08715574), // 180
+ vec2(-0.99452190, -0.10452846), vec2(-0.99254615, -0.12186934), vec2(-0.99026807, -0.13917310), vec2(-0.98768834, -0.15643447), vec2(-0.98480775, -0.17364818), vec2(-0.98162718, -0.19080900), // 186
+ vec2(-0.97814760, -0.20791169), vec2(-0.97437006, -0.22495105), vec2(-0.97029573, -0.24192190), vec2(-0.96592583, -0.25881905), vec2(-0.96126170, -0.27563736), vec2(-0.95630476, -0.29237170), // 192
+ vec2(-0.95105652, -0.30901699), vec2(-0.94551858, -0.32556815), vec2(-0.93969262, -0.34202014), vec2(-0.93358043, -0.35836795), vec2(-0.92718385, -0.37460659), vec2(-0.92050485, -0.39073113), // 198
+ vec2(-0.91354546, -0.40673664), vec2(-0.90630779, -0.42261826), vec2(-0.89879405, -0.43837115), vec2(-0.89100652, -0.45399050), vec2(-0.88294759, -0.46947156), vec2(-0.87461971, -0.48480962), // 204
+ vec2(-0.86602540, -0.50000000), vec2(-0.85716730, -0.51503807), vec2(-0.84804810, -0.52991926), vec2(-0.83867057, -0.54463904), vec2(-0.82903757, -0.55919290), vec2(-0.81915204, -0.57357644), // 210
+ vec2(-0.80901699, -0.58778525), vec2(-0.79863551, -0.60181502), vec2(-0.78801075, -0.61566148), vec2(-0.77714596, -0.62932039), vec2(-0.76604444, -0.64278761), vec2(-0.75470958, -0.65605903), // 216
+ vec2(-0.74314483, -0.66913061), vec2(-0.73135370, -0.68199836), vec2(-0.71933980, -0.69465837), vec2(-0.70710678, -0.70710678), vec2(-0.69465837, -0.71933980), vec2(-0.68199836, -0.73135370), // 222
+ vec2(-0.66913061, -0.74314483), vec2(-0.65605903, -0.75470958), vec2(-0.64278761, -0.76604444), vec2(-0.62932039, -0.77714596), vec2(-0.61566148, -0.78801075), vec2(-0.60181502, -0.79863551), // 228
+ vec2(-0.58778525, -0.80901699), vec2(-0.57357644, -0.81915204), vec2(-0.55919290, -0.82903757), vec2(-0.54463904, -0.83867057), vec2(-0.52991926, -0.84804810), vec2(-0.51503807, -0.85716730), // 234
+ vec2(-0.50000000, -0.86602540), vec2(-0.48480962, -0.87461971), vec2(-0.46947156, -0.88294759), vec2(-0.45399050, -0.89100652), vec2(-0.43837115, -0.89879405), vec2(-0.42261826, -0.90630779), // 240
+ vec2(-0.40673664, -0.91354546), vec2(-0.39073113, -0.92050485), vec2(-0.37460659, -0.92718385), vec2(-0.35836795, -0.93358043), vec2(-0.34202014, -0.93969262), vec2(-0.32556815, -0.94551858), // 246
+ vec2(-0.30901699, -0.95105652), vec2(-0.29237170, -0.95630476), vec2(-0.27563736, -0.96126170), vec2(-0.25881905, -0.96592583), vec2(-0.24192190, -0.97029573), vec2(-0.22495105, -0.97437006), // 252
+ vec2(-0.20791169, -0.97814760), vec2(-0.19080900, -0.98162718), vec2(-0.17364818, -0.98480775), vec2(-0.15643447, -0.98768834), vec2(-0.13917310, -0.99026807), vec2(-0.12186934, -0.99254615), // 258
+ vec2(-0.10452846, -0.99452190), vec2(-0.08715574, -0.99619470), vec2(-0.06975647, -0.99756405), vec2(-0.05233596, -0.99862953), vec2(-0.03489950, -0.99939083), vec2(-0.01745241, -0.99984770), // 264
+ vec2(-0.00000000, -1.00000000), vec2(0.01745241, -0.99984770), vec2(0.03489950, -0.99939083), vec2(0.05233596, -0.99862953), vec2(0.06975647, -0.99756405), vec2(0.08715574, -0.99619470), // 270
+ vec2(0.10452846, -0.99452190), vec2(0.12186934, -0.99254615), vec2(0.13917310, -0.99026807), vec2(0.15643447, -0.98768834), vec2(0.17364818, -0.98480775), vec2(0.19080900, -0.98162718), // 276
+ vec2(0.20791169, -0.97814760), vec2(0.22495105, -0.97437006), vec2(0.24192190, -0.97029573), vec2(0.25881905, -0.96592583), vec2(0.27563736, -0.96126170), vec2(0.29237170, -0.95630476), // 282
+ vec2(0.30901699, -0.95105652), vec2(0.32556815, -0.94551858), vec2(0.34202014, -0.93969262), vec2(0.35836795, -0.93358043), vec2(0.37460659, -0.92718385), vec2(0.39073113, -0.92050485), // 288
+ vec2(0.40673664, -0.91354546), vec2(0.42261826, -0.90630779), vec2(0.43837115, -0.89879405), vec2(0.45399050, -0.89100652), vec2(0.46947156, -0.88294759), vec2(0.48480962, -0.87461971), // 294
+ vec2(0.50000000, -0.86602540), vec2(0.51503807, -0.85716730), vec2(0.52991926, -0.84804810), vec2(0.54463904, -0.83867057), vec2(0.55919290, -0.82903757), vec2(0.57357644, -0.81915204), // 300
+ vec2(0.58778525, -0.80901699), vec2(0.60181502, -0.79863551), vec2(0.61566148, -0.78801075), vec2(0.62932039, -0.77714596), vec2(0.64278761, -0.76604444), vec2(0.65605903, -0.75470958), // 306
+ vec2(0.66913061, -0.74314483), vec2(0.68199836, -0.73135370), vec2(0.69465837, -0.71933980), vec2(0.70710678, -0.70710678), vec2(0.71933980, -0.69465837), vec2(0.73135370, -0.68199836), // 312
+ vec2(0.74314483, -0.66913061), vec2(0.75470958, -0.65605903), vec2(0.76604444, -0.64278761), vec2(0.77714596, -0.62932039), vec2(0.78801075, -0.61566148), vec2(0.79863551, -0.60181502), // 318
+ vec2(0.80901699, -0.58778525), vec2(0.81915204, -0.57357644), vec2(0.82903757, -0.55919290), vec2(0.83867057, -0.54463904), vec2(0.84804810, -0.52991926), vec2(0.85716730, -0.51503807), // 324
+ vec2(0.86602540, -0.50000000), vec2(0.87461971, -0.48480962), vec2(0.88294759, -0.46947156), vec2(0.89100652, -0.45399050), vec2(0.89879405, -0.43837115), vec2(0.90630779, -0.42261826), // 330
+ vec2(0.91354546, -0.40673664), vec2(0.92050485, -0.39073113), vec2(0.92718385, -0.37460659), vec2(0.93358043, -0.35836795), vec2(0.93969262, -0.34202014), vec2(0.94551858, -0.32556815), // 336
+ vec2(0.95105652, -0.30901699), vec2(0.95630476, -0.29237170), vec2(0.96126170, -0.27563736), vec2(0.96592583, -0.25881905), vec2(0.97029573, -0.24192190), vec2(0.97437006, -0.22495105), // 342
+ vec2(0.97814760, -0.20791169), vec2(0.98162718, -0.19080900), vec2(0.98480775, -0.17364818), vec2(0.98768834, -0.15643447), vec2(0.99026807, -0.13917310), vec2(0.99254615, -0.12186934), // 348
+ vec2(0.99452190, -0.10452846), vec2(0.99619470, -0.08715574), vec2(0.99756405, -0.06975647), vec2(0.99862953, -0.05233596), vec2(0.99939083, -0.03489950), vec2(0.99984770, -0.01745241), // 354
+ vec2(1.00000000, 0.00000000), vec2(0.99984770, 0.01745241), vec2(0.99939083, 0.03489950), vec2(0.99862953, 0.05233596), vec2(0.99756405, 0.06975647), vec2(0.99619470, 0.08715574), // 360
+ vec2(0.99452190, 0.10452846), vec2(0.99254615, 0.12186934), vec2(0.99026807, 0.13917310), vec2(0.98768834, 0.15643447), vec2(0.98480775, 0.17364818), vec2(0.98162718, 0.19080900), // 366
+ vec2(0.97814760, 0.20791169), vec2(0.97437006, 0.22495105), vec2(0.97029573, 0.24192190), vec2(0.96592583, 0.25881905), vec2(0.96126170, 0.27563736), vec2(0.95630476, 0.29237170), // 372
+ vec2(0.95105652, 0.30901699), vec2(0.94551858, 0.32556815), vec2(0.93969262, 0.34202014), vec2(0.93358043, 0.35836795), vec2(0.92718385, 0.37460659), vec2(0.92050485, 0.39073113), // 378
+ vec2(0.91354546, 0.40673664), vec2(0.90630779, 0.42261826), vec2(0.89879405, 0.43837115), vec2(0.89100652, 0.45399050), vec2(0.88294759, 0.46947156), vec2(0.87461971, 0.48480962), // 384
+ vec2(0.86602540, 0.50000000), vec2(0.85716730, 0.51503807), vec2(0.84804810, 0.52991926), vec2(0.83867057, 0.54463904), vec2(0.82903757, 0.55919290), vec2(0.81915204, 0.57357644), // 390
+ vec2(0.80901699, 0.58778525), vec2(0.79863551, 0.60181502), vec2(0.78801075, 0.61566148), vec2(0.77714596, 0.62932039), vec2(0.76604444, 0.64278761), vec2(0.75470958, 0.65605903), // 396
+ vec2(0.74314483, 0.66913061), vec2(0.73135370, 0.68199836), vec2(0.71933980, 0.69465837), vec2(0.70710678, 0.70710678), vec2(0.69465837, 0.71933980), vec2(0.68199836, 0.73135370), // 402
+ vec2(0.66913061, 0.74314483), vec2(0.65605903, 0.75470958), vec2(0.64278761, 0.76604444), vec2(0.62932039, 0.77714596), vec2(0.61566148, 0.78801075), vec2(0.60181502, 0.79863551), // 408
+ vec2(0.58778525, 0.80901699), vec2(0.57357644, 0.81915204), vec2(0.55919290, 0.82903757), vec2(0.54463904, 0.83867057), vec2(0.52991926, 0.84804810), vec2(0.51503807, 0.85716730), // 414
+ vec2(0.50000000, 0.86602540), vec2(0.48480962, 0.87461971), vec2(0.46947156, 0.88294759), vec2(0.45399050, 0.89100652), vec2(0.43837115, 0.89879405), vec2(0.42261826, 0.90630779), // 420
+ vec2(0.40673664, 0.91354546), vec2(0.39073113, 0.92050485), vec2(0.37460659, 0.92718385), vec2(0.35836795, 0.93358043), vec2(0.34202014, 0.93969262), vec2(0.32556815, 0.94551858), // 426
+ vec2(0.30901699, 0.95105652), vec2(0.29237170, 0.95630476), vec2(0.27563736, 0.96126170), vec2(0.25881905, 0.96592583), vec2(0.24192190, 0.97029573), vec2(0.22495105, 0.97437006), // 432
+ vec2(0.20791169, 0.97814760), vec2(0.19080900, 0.98162718), vec2(0.17364818, 0.98480775), vec2(0.15643447, 0.98768834), vec2(0.13917310, 0.99026807), vec2(0.12186934, 0.99254615), // 438
+ vec2(0.10452846, 0.99452190), vec2(0.08715574, 0.99619470), vec2(0.06975647, 0.99756405), vec2(0.05233596, 0.99862953), vec2(0.03489950, 0.99939083), vec2(0.01745241, 0.99984770), // 444
+ vec2(0.00000000, 1.00000000), vec2(-0.01745241, 0.99984770), vec2(-0.03489950, 0.99939083), vec2(-0.05233596, 0.99862953), vec2(-0.06975647, 0.99756405), vec2(-0.08715574, 0.99619470), // 450
+ vec2(-0.10452846, 0.99452190), vec2(-0.12186934, 0.99254615), vec2(-0.13917310, 0.99026807), vec2(-0.15643447, 0.98768834), vec2(-0.17364818, 0.98480775), vec2(-0.19080900, 0.98162718), // 456
+ vec2(-0.20791169, 0.97814760), vec2(-0.22495105, 0.97437006), vec2(-0.24192190, 0.97029573), vec2(-0.25881905, 0.96592583), vec2(-0.27563736, 0.96126170), vec2(-0.29237170, 0.95630476), // 462
+ vec2(-0.30901699, 0.95105652), vec2(-0.32556815, 0.94551858), vec2(-0.34202014, 0.93969262), vec2(-0.35836795, 0.93358043), vec2(-0.37460659, 0.92718385), vec2(-0.39073113, 0.92050485), // 468
+ vec2(-0.40673664, 0.91354546), vec2(-0.42261826, 0.90630779), vec2(-0.43837115, 0.89879405), vec2(-0.45399050, 0.89100652), vec2(-0.46947156, 0.88294759), vec2(-0.48480962, 0.87461971), // 474
+ vec2(-0.50000000, 0.86602540), vec2(-0.51503807, 0.85716730), vec2(-0.52991926, 0.84804810), vec2(-0.54463904, 0.83867057), vec2(-0.55919290, 0.82903757), vec2(-0.57357644, 0.81915204), // 480
+ vec2(-0.58778525, 0.80901699), vec2(-0.60181502, 0.79863551), vec2(-0.61566148, 0.78801075), vec2(-0.62932039, 0.77714596), vec2(-0.64278761, 0.76604444), vec2(-0.65605903, 0.75470958), // 486
+ vec2(-0.66913061, 0.74314483), vec2(-0.68199836, 0.73135370), vec2(-0.69465837, 0.71933980), vec2(-0.70710678, 0.70710678), vec2(-0.71933980, 0.69465837), vec2(-0.73135370, 0.68199836), // 492
+ vec2(-0.74314483, 0.66913061), vec2(-0.75470958, 0.65605903), vec2(-0.76604444, 0.64278761), vec2(-0.77714596, 0.62932039), vec2(-0.78801075, 0.61566148), vec2(-0.79863551, 0.60181502), // 498
+ vec2(-0.80901699, 0.58778525), vec2(-0.81915204, 0.57357644), vec2(-0.82903757, 0.55919290), vec2(-0.83867057, 0.54463904), vec2(-0.84804810, 0.52991926), vec2(-0.85716730, 0.51503807), // 504
+ vec2(-0.86602540, 0.50000000), vec2(-0.87461971, 0.48480962), vec2(-0.88294759, 0.46947156), vec2(-0.89100652, 0.45399050), vec2(-0.89879405, 0.43837115), vec2(-0.90630779, 0.42261826), // 510
+ vec2(-0.91354546, 0.40673664), vec2(-0.92050485, 0.39073113), vec2(-0.92718385, 0.37460659), vec2(-0.93358043, 0.35836795), vec2(-0.93969262, 0.34202014), vec2(-0.94551858, 0.32556815), // 516
+ vec2(-0.95105652, 0.30901699), vec2(-0.95630476, 0.29237170), vec2(-0.96126170, 0.27563736), vec2(-0.96592583, 0.25881905), vec2(-0.97029573, 0.24192190), vec2(-0.97437006, 0.22495105), // 522
+ vec2(-0.97814760, 0.20791169), vec2(-0.98162718, 0.19080900), vec2(-0.98480775, 0.17364818), vec2(-0.98768834, 0.15643447), vec2(-0.99026807, 0.13917310), vec2(-0.99254615, 0.12186934), // 528
+ vec2(-0.99452190, 0.10452846), vec2(-0.99619470, 0.08715574), vec2(-0.99756405, 0.06975647), vec2(-0.99862953, 0.05233596), vec2(-0.99939083, 0.03489950), vec2(-0.99984770, 0.01745241), // 534
+ vec2(-1.00000000, 0.00000000), vec2(-0.99984770, -0.01745241), vec2(-0.99939083, -0.03489950), vec2(-0.99862953, -0.05233596), vec2(-0.99756405, -0.06975647), vec2(-0.99619470, -0.08715574), // 540
+ vec2(-0.99452190, -0.10452846), vec2(-0.99254615, -0.12186934), vec2(-0.99026807, -0.13917310), vec2(-0.98768834, -0.15643447), vec2(-0.98480775, -0.17364818), vec2(-0.98162718, -0.19080900), // 546
+ vec2(-0.97814760, -0.20791169), vec2(-0.97437006, -0.22495105), vec2(-0.97029573, -0.24192190), vec2(-0.96592583, -0.25881905), vec2(-0.96126170, -0.27563736), vec2(-0.95630476, -0.29237170), // 552
+ vec2(-0.95105652, -0.30901699), vec2(-0.94551858, -0.32556815), vec2(-0.93969262, -0.34202014), vec2(-0.93358043, -0.35836795), vec2(-0.92718385, -0.37460659), vec2(-0.92050485, -0.39073113), // 558
+ vec2(-0.91354546, -0.40673664), vec2(-0.90630779, -0.42261826), vec2(-0.89879405, -0.43837115), vec2(-0.89100652, -0.45399050), vec2(-0.88294759, -0.46947156), vec2(-0.87461971, -0.48480962), // 564
+ vec2(-0.86602540, -0.50000000), vec2(-0.85716730, -0.51503807), vec2(-0.84804810, -0.52991926), vec2(-0.83867057, -0.54463904), vec2(-0.82903757, -0.55919290), vec2(-0.81915204, -0.57357644), // 570
+ vec2(-0.80901699, -0.58778525), vec2(-0.79863551, -0.60181502), vec2(-0.78801075, -0.61566148), vec2(-0.77714596, -0.62932039), vec2(-0.76604444, -0.64278761), vec2(-0.75470958, -0.65605903), // 576
+ vec2(-0.74314483, -0.66913061), vec2(-0.73135370, -0.68199836), vec2(-0.71933980, -0.69465837), vec2(-0.70710678, -0.70710678), vec2(-0.69465837, -0.71933980), vec2(-0.68199836, -0.73135370), // 582
+ vec2(-0.66913061, -0.74314483), vec2(-0.65605903, -0.75470958), vec2(-0.64278761, -0.76604444), vec2(-0.62932039, -0.77714596), vec2(-0.61566148, -0.78801075), vec2(-0.60181502, -0.79863551), // 588
+ vec2(-0.58778525, -0.80901699), vec2(-0.57357644, -0.81915204), vec2(-0.55919290, -0.82903757), vec2(-0.54463904, -0.83867057), vec2(-0.52991926, -0.84804810), vec2(-0.51503807, -0.85716730), // 594
+ vec2(-0.50000000, -0.86602540), vec2(-0.48480962, -0.87461971), vec2(-0.46947156, -0.88294759), vec2(-0.45399050, -0.89100652), vec2(-0.43837115, -0.89879405), vec2(-0.42261826, -0.90630779), // 600
+ vec2(-0.40673664, -0.91354546), vec2(-0.39073113, -0.92050485), vec2(-0.37460659, -0.92718385), vec2(-0.35836795, -0.93358043), vec2(-0.34202014, -0.93969262), vec2(-0.32556815, -0.94551858), // 606
+ vec2(-0.30901699, -0.95105652), vec2(-0.29237170, -0.95630476), vec2(-0.27563736, -0.96126170), vec2(-0.25881905, -0.96592583), vec2(-0.24192190, -0.97029573), vec2(-0.22495105, -0.97437006), // 612
+ vec2(-0.20791169, -0.97814760), vec2(-0.19080900, -0.98162718), vec2(-0.17364818, -0.98480775), vec2(-0.15643447, -0.98768834), vec2(-0.13917310, -0.99026807), vec2(-0.12186934, -0.99254615), // 618
+ vec2(-0.10452846, -0.99452190), vec2(-0.08715574, -0.99619470), vec2(-0.06975647, -0.99756405), vec2(-0.05233596, -0.99862953), vec2(-0.03489950, -0.99939083), vec2(-0.01745241, -0.99984770), // 624
+ vec2(-0.00000000, -1.00000000), vec2(0.01745241, -0.99984770), vec2(0.03489950, -0.99939083), vec2(0.05233596, -0.99862953), vec2(0.06975647, -0.99756405), vec2(0.08715574, -0.99619470), // 630
+ vec2(0.10452846, -0.99452190), vec2(0.12186934, -0.99254615), vec2(0.13917310, -0.99026807), vec2(0.15643447, -0.98768834), vec2(0.17364818, -0.98480775), vec2(0.19080900, -0.98162718), // 636
+ vec2(0.20791169, -0.97814760), vec2(0.22495105, -0.97437006), vec2(0.24192190, -0.97029573), vec2(0.25881905, -0.96592583), vec2(0.27563736, -0.96126170), vec2(0.29237170, -0.95630476), // 642
+ vec2(0.30901699, -0.95105652), vec2(0.32556815, -0.94551858), vec2(0.34202014, -0.93969262), vec2(0.35836795, -0.93358043), vec2(0.37460659, -0.92718385), vec2(0.39073113, -0.92050485), // 648
+ vec2(0.40673664, -0.91354546), vec2(0.42261826, -0.90630779), vec2(0.43837115, -0.89879405), vec2(0.45399050, -0.89100652), vec2(0.46947156, -0.88294759), vec2(0.48480962, -0.87461971), // 654
+ vec2(0.50000000, -0.86602540), vec2(0.51503807, -0.85716730), vec2(0.52991926, -0.84804810), vec2(0.54463904, -0.83867057), vec2(0.55919290, -0.82903757), vec2(0.57357644, -0.81915204), // 660
+ vec2(0.58778525, -0.80901699), vec2(0.60181502, -0.79863551), vec2(0.61566148, -0.78801075), vec2(0.62932039, -0.77714596), vec2(0.64278761, -0.76604444), vec2(0.65605903, -0.75470958), // 666
+ vec2(0.66913061, -0.74314483), vec2(0.68199836, -0.73135370), vec2(0.69465837, -0.71933980), vec2(0.70710678, -0.70710678), vec2(0.71933980, -0.69465837), vec2(0.73135370, -0.68199836), // 672
+ vec2(0.74314483, -0.66913061), vec2(0.75470958, -0.65605903), vec2(0.76604444, -0.64278761), vec2(0.77714596, -0.62932039), vec2(0.78801075, -0.61566148), vec2(0.79863551, -0.60181502), // 678
+ vec2(0.80901699, -0.58778525), vec2(0.81915204, -0.57357644), vec2(0.82903757, -0.55919290), vec2(0.83867057, -0.54463904), vec2(0.84804810, -0.52991926), vec2(0.85716730, -0.51503807), // 684
+ vec2(0.86602540, -0.50000000), vec2(0.87461971, -0.48480962), vec2(0.88294759, -0.46947156), vec2(0.89100652, -0.45399050), vec2(0.89879405, -0.43837115), vec2(0.90630779, -0.42261826), // 690
+ vec2(0.91354546, -0.40673664), vec2(0.92050485, -0.39073113), vec2(0.92718385, -0.37460659), vec2(0.93358043, -0.35836795), vec2(0.93969262, -0.34202014), vec2(0.94551858, -0.32556815), // 696
+ vec2(0.95105652, -0.30901699), vec2(0.95630476, -0.29237170), vec2(0.96126170, -0.27563736), vec2(0.96592583, -0.25881905), vec2(0.97029573, -0.24192190), vec2(0.97437006, -0.22495105), // 702
+ vec2(0.97814760, -0.20791169), vec2(0.98162718, -0.19080900), vec2(0.98480775, -0.17364818), vec2(0.98768834, -0.15643447), vec2(0.99026807, -0.13917310), vec2(0.99254615, -0.12186934), // 708
+ vec2(0.99452190, -0.10452846), vec2(0.99619470, -0.08715574), vec2(0.99756405, -0.06975647), vec2(0.99862953, -0.05233596), vec2(0.99939083, -0.03489950), vec2(0.99984770, -0.01745241), // 714
+ vec2(1.00000000, 0.00000000) // 720
+};
+
diff --git a/src/shared/geom.h b/src/shared/geom.h
new file mode 100644
index 0000000..3adccc6
--- /dev/null
+++ b/src/shared/geom.h
@@ -0,0 +1,1828 @@
+struct vec;
+struct vec4;
+
+struct vec2
+{
+ union
+ {
+ struct { float x, y; };
+ float v[2];
+ };
+
+ vec2() {}
+ vec2(float x, float y) : x(x), y(y) {}
+ explicit vec2(const vec &v);
+ explicit vec2(const vec4 &v);
+
+ float &operator[](int i) { return v[i]; }
+ float operator[](int i) const { return v[i]; }
+
+ bool operator==(const vec2 &o) const { return x == o.x && y == o.y; }
+ bool operator!=(const vec2 &o) const { return x != o.x || y != o.y; }
+
+ bool iszero() const { return x==0 && y==0; }
+ float dot(const vec2 &o) const { return x*o.x + y*o.y; }
+ float squaredlen() const { return dot(*this); }
+ float magnitude() const { return sqrtf(squaredlen()); }
+ vec2 &normalize() { mul(1/magnitude()); return *this; }
+ vec2 &safenormalize() { float m = magnitude(); if(m) mul(1/m); return *this; }
+ float cross(const vec2 &o) const { return x*o.y - y*o.x; }
+
+ vec2 &mul(float f) { x *= f; y *= f; return *this; }
+ vec2 &mul(const vec2 &o) { x *= o.x; y *= o.y; return *this; }
+ vec2 &square() { mul(*this); return *this; }
+ vec2 &div(float f) { x /= f; y /= f; return *this; }
+ vec2 &div(const vec2 &o) { x /= o.x; y /= o.y; return *this; }
+ vec2 &recip() { x = 1/x; y = 1/y; return *this; }
+ vec2 &add(float f) { x += f; y += f; return *this; }
+ vec2 &add(const vec2 &o) { x += o.x; y += o.y; return *this; }
+ vec2 &sub(float f) { x -= f; y -= f; return *this; }
+ vec2 &sub(const vec2 &o) { x -= o.x; y -= o.y; return *this; }
+ vec2 &neg() { x = -x; y = -y; return *this; }
+ vec2 &min(const vec2 &o) { x = ::min(x, o.x); y = ::min(y, o.y); return *this; }
+ vec2 &max(const vec2 &o) { x = ::max(x, o.x); y = ::max(y, o.y); return *this; }
+ vec2 &min(float f) { x = ::min(x, f); y = ::min(y, f); return *this; }
+ vec2 &max(float f) { x = ::max(x, f); y = ::max(y, f); return *this; }
+ vec2 &abs() { x = fabs(x); y = fabs(y); return *this; }
+ vec2 &clamp(float l, float h) { x = ::clamp(x, l, h); y = ::clamp(y, l, h); return *this; }
+ vec2 &reflect(const vec2 &n) { float k = 2*dot(n); x -= k*n.x; y -= k*n.y; return *this; }
+ vec2 &lerp(const vec2 &b, float t) { x += (b.x-x)*t; y += (b.y-y)*t; return *this; }
+ vec2 &lerp(const vec2 &a, const vec2 &b, float t) { x = a.x + (b.x-a.x)*t; y = a.y + (b.y-a.y)*t; return *this; }
+ template<class B> vec2 &madd(const vec2 &a, const B &b) { return add(vec2(a).mul(b)); }
+ template<class B> vec2 &msub(const vec2 &a, const B &b) { return sub(vec2(a).mul(b)); }
+};
+
+static inline bool htcmp(const vec2 &x, const vec2 &y)
+{
+ return x == y;
+}
+
+static inline uint hthash(const vec2 &k)
+{
+ union { uint i; float f; } x, y;
+ x.f = k.x; y.f = k.y;
+ uint v = x.i^y.i;
+ return v + (v>>12);
+}
+
+struct ivec;
+
+struct vec
+{
+ union
+ {
+ struct { float x, y, z; };
+ struct { float r, g, b; };
+ float v[3];
+ };
+
+ vec() {}
+ explicit vec(int a) : x(a), y(a), z(a) {}
+ explicit vec(float a) : x(a), y(a), z(a) {}
+ vec(float a, float b, float c) : x(a), y(b), z(c) {}
+ explicit vec(int v[3]) : x(v[0]), y(v[1]), z(v[2]) {}
+ explicit vec(const float *v) : x(v[0]), y(v[1]), z(v[2]) {}
+ explicit vec(const vec2 &v, float z = 0) : x(v.x), y(v.y), z(z) {}
+ explicit vec(const vec4 &v);
+ explicit vec(const ivec &v);
+
+ vec(float yaw, float pitch) : x(-sinf(yaw)*cosf(pitch)), y(cosf(yaw)*cosf(pitch)), z(sinf(pitch)) {}
+
+ float &operator[](int i) { return v[i]; }
+ float operator[](int i) const { return v[i]; }
+
+ vec &set(int i, float f) { v[i] = f; return *this; }
+
+ bool operator==(const vec &o) const { return x == o.x && y == o.y && z == o.z; }
+ bool operator!=(const vec &o) const { return x != o.x || y != o.y || z != o.z; }
+
+ bool iszero() const { return x==0 && y==0 && z==0; }
+ float squaredlen() const { return x*x + y*y + z*z; }
+ template<class T> float dot2(const T &o) const { return x*o.x + y*o.y; }
+ float dot(const vec &o) const { return x*o.x + y*o.y + z*o.z; }
+ float absdot(const vec &o) const { return fabs(x*o.x) + fabs(y*o.y) + fabs(z*o.z); }
+ vec &pow(float f) { x = ::pow(x, f); y = ::pow(y, f); z = ::pow(z, f); return *this; }
+ vec &exp() { x = ::exp(x); y = ::exp(y); z = ::exp(z); return *this; }
+ vec &exp2() { x = ::exp2(x); y = ::exp2(y); z = ::exp2(z); return *this; }
+ vec &sqrt() { x = sqrtf(x); y = sqrtf(y); z = sqrtf(z); return *this; }
+ vec &mul(const vec &o) { x *= o.x; y *= o.y; z *= o.z; return *this; }
+ vec &mul(float f) { x *= f; y *= f; z *= f; return *this; }
+ vec &square() { mul(*this); return *this; }
+ vec &div(const vec &o) { x /= o.x; y /= o.y; z /= o.z; return *this; }
+ vec &div(float f) { x /= f; y /= f; z /= f; return *this; }
+ vec &recip() { x = 1/x; y = 1/y; z = 1/z; return *this; }
+ vec &add(const vec &o) { x += o.x; y += o.y; z += o.z; return *this; }
+ vec &add(float f) { x += f; y += f; z += f; return *this; }
+ vec &add2(float f) { x += f; y += f; return *this; }
+ vec &addz(float f) { z += f; return *this; }
+ vec &sub(const vec &o) { x -= o.x; y -= o.y; z -= o.z; return *this; }
+ vec &sub(float f) { x -= f; y -= f; z -= f; return *this; }
+ vec &sub2(float f) { x -= f; y -= f; return *this; }
+ vec &subz(float f) { z -= f; return *this; }
+ vec &neg2() { x = -x; y = -y; return *this; }
+ vec &neg() { x = -x; y = -y; z = -z; return *this; }
+ vec &min(const vec &o) { x = ::min(x, o.x); y = ::min(y, o.y); z = ::min(z, o.z); return *this; }
+ vec &max(const vec &o) { x = ::max(x, o.x); y = ::max(y, o.y); z = ::max(z, o.z); return *this; }
+ vec &min(float f) { x = ::min(x, f); y = ::min(y, f); z = ::min(z, f); return *this; }
+ vec &max(float f) { x = ::max(x, f); y = ::max(y, f); z = ::max(z, f); return *this; }
+ vec &clamp(float f, float h) { x = ::clamp(x, f, h); y = ::clamp(y, f, h); z = ::clamp(z, f, h); return *this; }
+ vec &abs() { x = fabs(x); y = fabs(y); z = fabs(z); return *this; }
+ float magnitude2() const { return sqrtf(dot2(*this)); }
+ float magnitude() const { return sqrtf(squaredlen()); }
+ vec &normalize() { div(magnitude()); return *this; }
+ vec &safenormalize() { float m = magnitude(); if(m) div(m); return *this; }
+ bool isnormalized() const { float m = squaredlen(); return (m>0.99f && m<1.01f); }
+ float squaredist(const vec &e) const { return vec(*this).sub(e).squaredlen(); }
+ float dist(const vec &e) const { vec t; return dist(e, t); }
+ float dist(const vec &e, vec &t) const { t = *this; t.sub(e); return t.magnitude(); }
+ float dist2(const vec &o) const { float dx = x-o.x, dy = y-o.y; return sqrtf(dx*dx + dy*dy); }
+ bool reject(const vec &o, float r) { return x>o.x+r || x<o.x-r || y>o.y+r || y<o.y-r; }
+ template<class A, class B>
+ vec &cross(const A &a, const B &b) { x = a.y*b.z-a.z*b.y; y = a.z*b.x-a.x*b.z; z = a.x*b.y-a.y*b.x; return *this; }
+ vec &cross(const vec &o, const vec &a, const vec &b) { return cross(vec(a).sub(o), vec(b).sub(o)); }
+ float scalartriple(const vec &a, const vec &b) const { return x*(a.y*b.z-a.z*b.y) + y*(a.z*b.x-a.x*b.z) + z*(a.x*b.y-a.y*b.x); }
+ vec &reflectz(float rz) { z = 2*rz - z; return *this; }
+ vec &reflect(const vec &n) { float k = 2*dot(n); x -= k*n.x; y -= k*n.y; z -= k*n.z; return *this; }
+ vec &project(const vec &n) { float k = dot(n); x -= k*n.x; y -= k*n.y; z -= k*n.z; return *this; }
+ vec &projectxydir(const vec &n) { if(n.z) z = -(x*n.x/n.z + y*n.y/n.z); return *this; }
+ vec &projectxy(const vec &n)
+ {
+ float m = squaredlen(), k = dot(n);
+ projectxydir(n);
+ rescale(sqrtf(::max(m - k*k, 0.0f)));
+ return *this;
+ }
+ vec &projectxy(const vec &n, float threshold)
+ {
+ float m = squaredlen(), k = ::min(dot(n), threshold);
+ projectxydir(n);
+ rescale(sqrtf(::max(m - k*k, 0.0f)));
+ return *this;
+ }
+ vec &lerp(const vec &b, float t) { x += (b.x-x)*t; y += (b.y-y)*t; z += (b.z-z)*t; return *this; }
+ vec &lerp(const vec &a, const vec &b, float t) { x = a.x + (b.x-a.x)*t; y = a.y + (b.y-a.y)*t; z = a.z + (b.z-a.z)*t; return *this; }
+ template<class B> vec &madd(const vec &a, const B &b) { return add(vec(a).mul(b)); }
+ template<class B> vec &msub(const vec &a, const B &b) { return sub(vec(a).mul(b)); }
+
+ vec &rescale(float k)
+ {
+ float mag = magnitude();
+ if(mag > 1e-6f) mul(k / mag);
+ return *this;
+ }
+
+ vec &rotate_around_z(float c, float s) { float rx = x, ry = y; x = c*rx-s*ry; y = c*ry+s*rx; return *this; }
+ vec &rotate_around_x(float c, float s) { float ry = y, rz = z; y = c*ry-s*rz; z = c*rz+s*ry; return *this; }
+ vec &rotate_around_y(float c, float s) { float rx = x, rz = z; x = c*rx+s*rz; z = c*rz-s*rx; return *this; }
+
+ vec &rotate_around_z(float angle) { return rotate_around_z(cosf(angle), sinf(angle)); }
+ vec &rotate_around_x(float angle) { return rotate_around_x(cosf(angle), sinf(angle)); }
+ vec &rotate_around_y(float angle) { return rotate_around_y(cosf(angle), sinf(angle)); }
+
+ vec &rotate_around_z(const vec2 &sc) { return rotate_around_z(sc.x, sc.y); }
+ vec &rotate_around_x(const vec2 &sc) { return rotate_around_x(sc.x, sc.y); }
+ vec &rotate_around_y(const vec2 &sc) { return rotate_around_y(sc.x, sc.y); }
+
+ vec &rotate(float c, float s, const vec &d)
+ {
+ *this = vec(x*(d.x*d.x*(1-c)+c) + y*(d.x*d.y*(1-c)-d.z*s) + z*(d.x*d.z*(1-c)+d.y*s),
+ x*(d.y*d.x*(1-c)+d.z*s) + y*(d.y*d.y*(1-c)+c) + z*(d.y*d.z*(1-c)-d.x*s),
+ x*(d.x*d.z*(1-c)-d.y*s) + y*(d.y*d.z*(1-c)+d.x*s) + z*(d.z*d.z*(1-c)+c));
+ return *this;
+ }
+ vec &rotate(float angle, const vec &d) { return rotate(cosf(angle), sinf(angle), d); }
+ vec &rotate(const vec2 &sc, const vec &d) { return rotate(sc.x, sc.y, d); }
+
+ void orthogonal(const vec &d)
+ {
+ *this = fabs(d.x) > fabs(d.z) ? vec(-d.y, d.x, 0) : vec(0, -d.z, d.y);
+ }
+
+ void orthonormalize(vec &s, vec &t) const
+ {
+ s.sub(vec(*this).mul(dot(s)));
+ t.sub(vec(*this).mul(dot(t)))
+ .sub(vec(s).mul(s.dot(t)));
+ }
+
+ template<class T>
+ bool insidebb(const T &bbmin, const T &bbmax) const
+ {
+ return x >= bbmin.x && x <= bbmax.x && y >= bbmin.y && y <= bbmax.y && z >= bbmin.z && z <= bbmax.z;
+ }
+
+ template<class T, class U>
+ bool insidebb(const T &o, U size) const
+ {
+ return x >= o.x && x <= o.x + size && y >= o.y && y <= o.y + size && z >= o.z && z <= o.z + size;
+ }
+
+ template<class T> float dist_to_bb(const T &min, const T &max) const
+ {
+ float sqrdist = 0;
+ loopi(3)
+ {
+ if (v[i] < min[i]) { float delta = v[i]-min[i]; sqrdist += delta*delta; }
+ else if(v[i] > max[i]) { float delta = max[i]-v[i]; sqrdist += delta*delta; }
+ }
+ return sqrtf(sqrdist);
+ }
+
+ template<class T, class S> float dist_to_bb(const T &o, S size) const
+ {
+ return dist_to_bb(o, T(o).add(size));
+ }
+
+ static vec hexcolor(int color)
+ {
+ return vec(((color>>16)&0xFF)*(1.0f/255.0f), ((color>>8)&0xFF)*(1.0f/255.0f), (color&0xFF)*(1.0f/255.0f));
+ }
+ int tohexcolor() const { return (int(::clamp(r, 0.0f, 1.0f)*255)<<16)|(int(::clamp(g, 0.0f, 1.0f)*255)<<8)|int(::clamp(b, 0.0f, 1.0f)*255); }
+};
+
+inline vec2::vec2(const vec &v) : x(v.x), y(v.y) {}
+
+static inline bool htcmp(const vec &x, const vec &y)
+{
+ return x == y;
+}
+
+static inline uint hthash(const vec &k)
+{
+ union { uint i; float f; } x, y, z;
+ x.f = k.x; y.f = k.y; z.f = k.z;
+ uint v = x.i^y.i^z.i;
+ return v + (v>>12);
+}
+
+struct vec4
+{
+ union
+ {
+ struct { float x, y, z, w; };
+ struct { float r, g, b, a; };
+ float v[4];
+ };
+
+ vec4() {}
+ explicit vec4(const vec &p, float w = 0) : x(p.x), y(p.y), z(p.z), w(w) {}
+ vec4(float x, float y, float z, float w) : x(x), y(y), z(z), w(w) {}
+ explicit vec4(const float *v) : x(v[0]), y(v[1]), z(v[2]), w(v[3]) {}
+
+ float &operator[](int i) { return v[i]; }
+ float operator[](int i) const { return v[i]; }
+
+ template<class T> float dot3(const T &o) const { return x*o.x + y*o.y + z*o.z; }
+ float dot(const vec4 &o) const { return dot3(o) + w*o.w; }
+ float dot(const vec &o) const { return x*o.x + y*o.y + z*o.z + w; }
+ float squaredlen() const { return dot(*this); }
+ float magnitude() const { return sqrtf(squaredlen()); }
+ float magnitude3() const { return sqrtf(dot3(*this)); }
+ vec4 &normalize() { mul(1/magnitude()); return *this; }
+ vec4 &safenormalize() { float m = magnitude(); if(m) mul(1/m); return *this; }
+
+ vec4 &lerp(const vec4 &b, float t)
+ {
+ x += (b.x-x)*t;
+ y += (b.y-y)*t;
+ z += (b.z-z)*t;
+ w += (b.w-w)*t;
+ return *this;
+ }
+ vec4 &lerp(const vec4 &a, const vec4 &b, float t)
+ {
+ x = a.x+(b.x-a.x)*t;
+ y = a.y+(b.y-a.y)*t;
+ z = a.z+(b.z-a.z)*t;
+ w = a.w+(b.w-a.w)*t;
+ return *this;
+ }
+
+ vec4 &mul3(float f) { x *= f; y *= f; z *= f; return *this; }
+ vec4 &mul(float f) { mul3(f); w *= f; return *this; }
+ vec4 &mul(const vec4 &o) { x *= o.x; y *= o.y; z *= o.z; w *= o.w; return *this; }
+ vec4 &square() { mul(*this); return *this; }
+ vec4 &div3(float f) { x /= f; y /= f; z /= f; return *this; }
+ vec4 &div(float f) { div3(f); w /= f; return *this; }
+ vec4 &div(const vec4 &o) { x /= o.x; y /= o.y; z /= o.z; w /= o.w; return *this; }
+ vec4 &recip() { x = 1/x; y = 1/y; z = 1/z; w = 1/w; return *this; }
+ vec4 &add(const vec4 &o) { x += o.x; y += o.y; z += o.z; w += o.w; return *this; }
+ vec4 &addw(float f) { w += f; return *this; }
+ vec4 &sub(const vec4 &o) { x -= o.x; y -= o.y; z -= o.z; w -= o.w; return *this; }
+ vec4 &subw(float f) { w -= f; return *this; }
+ vec4 &neg3() { x = -x; y = -y; z = -z; return *this; }
+ vec4 &neg() { neg3(); w = -w; return *this; }
+ template<class B> vec4 &madd(const vec4 &a, const B &b) { return add(vec4(a).mul(b)); }
+ template<class B> vec4 &msub(const vec4 &a, const B &b) { return sub(vec4(a).mul(b)); }
+
+ void setxyz(const vec &v) { x = v.x; y = v.y; z = v.z; }
+
+ vec4 &rotate_around_z(float c, float s) { float rx = x, ry = y; x = c*rx-s*ry; y = c*ry+s*rx; return *this; }
+ vec4 &rotate_around_x(float c, float s) { float ry = y, rz = z; y = c*ry-s*rz; z = c*rz+s*ry; return *this; }
+ vec4 &rotate_around_y(float c, float s) { float rx = x, rz = z; x = c*rx+s*rz; z = c*rz-s*rx; return *this; }
+
+ vec4 &rotate_around_z(float angle) { return rotate_around_z(cosf(angle), sinf(angle)); }
+ vec4 &rotate_around_x(float angle) { return rotate_around_x(cosf(angle), sinf(angle)); }
+ vec4 &rotate_around_y(float angle) { return rotate_around_y(cosf(angle), sinf(angle)); }
+};
+
+inline vec::vec(const vec4 &v) : x(v.x), y(v.y), z(v.z) {}
+
+struct matrix3;
+struct matrix4x3;
+struct matrix4;
+
+struct quat : vec4
+{
+ quat() {}
+ quat(float x, float y, float z, float w) : vec4(x, y, z, w) {}
+ quat(const vec &axis, float angle)
+ {
+ w = cosf(angle/2);
+ float s = sinf(angle/2);
+ x = s*axis.x;
+ y = s*axis.y;
+ z = s*axis.z;
+ }
+ explicit quat(const vec &v)
+ {
+ x = v.x;
+ y = v.y;
+ z = v.z;
+ restorew();
+ }
+ explicit quat(const matrix3 &m) { convertmatrix(m); }
+ explicit quat(const matrix4x3 &m) { convertmatrix(m); }
+ explicit quat(const matrix4 &m) { convertmatrix(m); }
+
+ void restorew() { w = 1.0f-x*x-y*y-z*z; w = w<0 ? 0 : -sqrtf(w); }
+
+ quat &add(const vec4 &o) { vec4::add(o); return *this; }
+ quat &sub(const vec4 &o) { vec4::sub(o); return *this; }
+ quat &mul(float k) { vec4::mul(k); return *this; }
+
+ quat &mul(const quat &p, const quat &o)
+ {
+ x = p.w*o.x + p.x*o.w + p.y*o.z - p.z*o.y;
+ y = p.w*o.y - p.x*o.z + p.y*o.w + p.z*o.x;
+ z = p.w*o.z + p.x*o.y - p.y*o.x + p.z*o.w;
+ w = p.w*o.w - p.x*o.x - p.y*o.y - p.z*o.z;
+ return *this;
+ }
+ quat &mul(const quat &o) { return mul(quat(*this), o); }
+
+ quat &invert() { neg3(); return *this; }
+
+ void calcangleaxis(float &angle, vec &axis)
+ {
+ float rr = dot3(*this);
+ if(rr>0)
+ {
+ angle = 2*acosf(w);
+ axis = vec(x, y, z).mul(1/rr);
+ }
+ else { angle = 0; axis = vec(0, 0, 1); }
+ }
+
+ vec rotate(const vec &v) const
+ {
+ return vec().cross(*this, vec().cross(*this, v).add(vec(v).mul(w))).mul(2).add(v);
+ }
+
+ vec invertedrotate(const vec &v) const
+ {
+ return vec().cross(*this, vec().cross(*this, v).sub(vec(v).mul(w))).mul(2).add(v);
+ }
+
+ template<class M>
+ void convertmatrix(const M &m)
+ {
+ float trace = m.a.x + m.b.y + m.c.z;
+ if(trace>0)
+ {
+ float r = sqrtf(1 + trace), inv = 0.5f/r;
+ w = 0.5f*r;
+ x = (m.b.z - m.c.y)*inv;
+ y = (m.c.x - m.a.z)*inv;
+ z = (m.a.y - m.b.x)*inv;
+ }
+ else if(m.a.x > m.b.y && m.a.x > m.c.z)
+ {
+ float r = sqrtf(1 + m.a.x - m.b.y - m.c.z), inv = 0.5f/r;
+ x = 0.5f*r;
+ y = (m.a.y + m.b.x)*inv;
+ z = (m.c.x + m.a.z)*inv;
+ w = (m.b.z - m.c.y)*inv;
+ }
+ else if(m.b.y > m.c.z)
+ {
+ float r = sqrtf(1 + m.b.y - m.a.x - m.c.z), inv = 0.5f/r;
+ x = (m.a.y + m.b.x)*inv;
+ y = 0.5f*r;
+ z = (m.b.z + m.c.y)*inv;
+ w = (m.c.x - m.a.z)*inv;
+ }
+ else
+ {
+ float r = sqrtf(1 + m.c.z - m.a.x - m.b.y), inv = 0.5f/r;
+ x = (m.c.x + m.a.z)*inv;
+ y = (m.b.z + m.c.y)*inv;
+ z = 0.5f*r;
+ w = (m.a.y - m.b.x)*inv;
+ }
+ }
+};
+
+struct dualquat
+{
+ quat real, dual;
+
+ dualquat() {}
+ dualquat(const quat &q, const vec &p)
+ : real(q),
+ dual(0.5f*( p.x*q.w + p.y*q.z - p.z*q.y),
+ 0.5f*(-p.x*q.z + p.y*q.w + p.z*q.x),
+ 0.5f*( p.x*q.y - p.y*q.x + p.z*q.w),
+ -0.5f*( p.x*q.x + p.y*q.y + p.z*q.z))
+ {
+ }
+ explicit dualquat(const quat &q) : real(q), dual(0, 0, 0, 0) {}
+ explicit dualquat(const matrix4x3 &m);
+
+ dualquat &mul(float k) { real.mul(k); dual.mul(k); return *this; }
+ dualquat &add(const dualquat &d) { real.add(d.real); dual.add(d.dual); return *this; }
+
+ dualquat &lerp(const dualquat &to, float t)
+ {
+ float k = real.dot(to.real) < 0 ? -t : t;
+ real.mul(1-t).add(vec4(to.real).mul(k));
+ dual.mul(1-t).add(vec4(to.dual).mul(k));
+ return *this;
+ }
+ dualquat &lerp(const dualquat &from, const dualquat &to, float t)
+ {
+ float k = from.real.dot(to.real) < 0 ? -t : t;
+ (real = from.real).mul(1-t).add(vec4(to.real).mul(k));
+ (dual = from.dual).mul(1-t).add(vec4(to.dual).mul(k));
+ return *this;
+ }
+
+ dualquat &invert()
+ {
+ real.invert();
+ dual.invert();
+ dual.sub(quat(real).mul(2*real.dot(dual)));
+ return *this;
+ }
+
+ void mul(const dualquat &p, const dualquat &o)
+ {
+ real.mul(p.real, o.real);
+ dual.mul(p.real, o.dual).add(quat().mul(p.dual, o.real));
+ }
+ void mul(const dualquat &o) { mul(dualquat(*this), o); }
+
+ void mulorient(const quat &q)
+ {
+ real.mul(q, quat(real));
+ dual.mul(quat(q).invert(), quat(dual));
+ }
+
+ void mulorient(const quat &q, const dualquat &base)
+ {
+ quat trans;
+ trans.mul(base.dual, quat(base.real).invert());
+ dual.mul(quat(q).invert(), quat(real).mul(trans).add(dual));
+
+ real.mul(q, quat(real));
+ dual.add(quat().mul(real, trans.invert())).sub(quat(real).mul(2*base.real.dot(base.dual)));
+ }
+
+ void normalize()
+ {
+ float invlen = 1/real.magnitude();
+ real.mul(invlen);
+ dual.mul(invlen);
+ }
+
+ void translate(const vec &p)
+ {
+ dual.x += 0.5f*( p.x*real.w + p.y*real.z - p.z*real.y);
+ dual.y += 0.5f*(-p.x*real.z + p.y*real.w + p.z*real.x);
+ dual.z += 0.5f*( p.x*real.y - p.y*real.x + p.z*real.w);
+ dual.w += -0.5f*( p.x*real.x + p.y*real.y + p.z*real.z);
+ }
+
+ void scale(float k)
+ {
+ dual.mul(k);
+ }
+
+ void fixantipodal(const dualquat &d)
+ {
+ if(real.dot(d.real) < 0)
+ {
+ real.neg();
+ dual.neg();
+ }
+ }
+
+ void accumulate(const dualquat &d, float k)
+ {
+ if(real.dot(d.real) < 0) k = -k;
+ real.add(vec4(d.real).mul(k));
+ dual.add(vec4(d.dual).mul(k));
+ }
+
+ vec transform(const vec &v) const
+ {
+ return vec().cross(real, vec().cross(real, v).add(vec(v).mul(real.w)).add(vec(dual))).add(vec(dual).mul(real.w)).sub(vec(real).mul(dual.w)).mul(2).add(v);
+ }
+
+ quat transform(const quat &q) const
+ {
+ return quat().mul(real, q);
+ }
+
+ vec transposedtransform(const vec &v) const
+ {
+ return dualquat(*this).invert().transform(v);
+ }
+
+ vec transformnormal(const vec &v) const
+ {
+ return real.rotate(v);
+ }
+
+ vec transposedtransformnormal(const vec &v) const
+ {
+ return real.invertedrotate(v);
+ }
+
+ vec gettranslation() const
+ {
+ return vec().cross(real, dual).add(vec(dual).mul(real.w)).sub(vec(real).mul(dual.w)).mul(2);
+ }
+};
+
+struct matrix3
+{
+ vec a, b, c;
+
+ matrix3() {}
+ matrix3(const vec &a, const vec &b, const vec &c) : a(a), b(b), c(c) {}
+ explicit matrix3(float angle, const vec &axis) { rotate(angle, axis); }
+ explicit matrix3(const quat &q)
+ {
+ float x = q.x, y = q.y, z = q.z, w = q.w,
+ tx = 2*x, ty = 2*y, tz = 2*z,
+ txx = tx*x, tyy = ty*y, tzz = tz*z,
+ txy = tx*y, txz = tx*z, tyz = ty*z,
+ twx = w*tx, twy = w*ty, twz = w*tz;
+ a = vec(1 - (tyy + tzz), txy + twz, txz - twy);
+ b = vec(txy - twz, 1 - (txx + tzz), tyz + twx);
+ c = vec(txz + twy, tyz - twx, 1 - (txx + tyy));
+ }
+ explicit matrix3(const matrix4x3 &m);
+ explicit matrix3(const matrix4 &m);
+
+ void mul(const matrix3 &m, const matrix3 &n)
+ {
+ a = vec(m.a).mul(n.a.x).madd(m.b, n.a.y).madd(m.c, n.a.z);
+ b = vec(m.a).mul(n.b.x).madd(m.b, n.b.y).madd(m.c, n.b.z);
+ c = vec(m.a).mul(n.c.x).madd(m.b, n.c.y).madd(m.c, n.c.z);
+ }
+ void mul(const matrix3 &n) { mul(matrix3(*this), n); }
+
+ void multranspose(const matrix3 &m, const matrix3 &n)
+ {
+ a = vec(m.a).mul(n.a.x).madd(m.b, n.b.x).madd(m.c, n.c.x);
+ b = vec(m.a).mul(n.a.y).madd(m.b, n.b.y).madd(m.c, n.c.y);
+ c = vec(m.a).mul(n.a.z).madd(m.b, n.b.z).madd(m.c, n.c.z);
+ }
+ void multranspose(const matrix3 &n) { multranspose(matrix3(*this), n); }
+
+ void transposemul(const matrix3 &m, const matrix3 &n)
+ {
+ a = vec(m.a.dot(n.a), m.b.dot(n.a), m.c.dot(n.a));
+ b = vec(m.a.dot(n.b), m.b.dot(n.b), m.c.dot(n.b));
+ c = vec(m.a.dot(n.c), m.b.dot(n.c), m.c.dot(n.c));
+ }
+ void transposemul(const matrix3 &n) { transposemul(matrix3(*this), n); }
+
+ void transpose()
+ {
+ swap(a.y, b.x); swap(a.z, c.x);
+ swap(b.z, c.y);
+ }
+
+ template<class M>
+ void transpose(const M &m)
+ {
+ a = vec(m.a.x, m.b.x, m.c.x);
+ b = vec(m.a.y, m.b.y, m.c.y);
+ c = vec(m.a.z, m.b.z, m.c.z);
+ }
+
+ void invert(const matrix3 &o)
+ {
+ vec unscale(1/o.a.squaredlen(), 1/o.b.squaredlen(), 1/o.c.squaredlen());
+ transpose(o);
+ a.mul(unscale);
+ b.mul(unscale);
+ c.mul(unscale);
+ }
+ void invert() { invert(matrix3(*this)); }
+
+ void normalize()
+ {
+ a.normalize();
+ b.normalize();
+ c.normalize();
+ }
+
+ void scale(float k)
+ {
+ a.mul(k);
+ b.mul(k);
+ c.mul(k);
+ }
+
+ void rotate(float angle, const vec &axis)
+ {
+ rotate(cosf(angle), sinf(angle), axis);
+ }
+
+ void rotate(float ck, float sk, const vec &axis)
+ {
+ a = vec(axis.x*axis.x*(1-ck)+ck, axis.x*axis.y*(1-ck)+axis.z*sk, axis.x*axis.z*(1-ck)-axis.y*sk);
+ b = vec(axis.x*axis.y*(1-ck)-axis.z*sk, axis.y*axis.y*(1-ck)+ck, axis.y*axis.z*(1-ck)+axis.x*sk);
+ c = vec(axis.x*axis.z*(1-ck)+axis.y*sk, axis.y*axis.z*(1-ck)-axis.x*sk, axis.z*axis.z*(1-ck)+ck);
+ }
+
+ void setyaw(float ck, float sk)
+ {
+ a = vec(ck, sk, 0);
+ b = vec(-sk, ck, 0);
+ c = vec(0, 0, 1);
+ }
+
+ void setyaw(float angle)
+ {
+ setyaw(cosf(angle), sinf(angle));
+ }
+
+ float trace() const { return a.x + b.y + c.z; }
+
+ bool calcangleaxis(float tr, float &angle, vec &axis, float threshold = 1e-16f) const
+ {
+ if(tr <= -1)
+ {
+ if(a.x >= b.y && a.x >= c.z)
+ {
+ float r = 1 + a.x - b.y - c.z;
+ if(r <= threshold) return false;
+ r = sqrtf(r);
+ axis.x = 0.5f*r;
+ axis.y = b.x/r;
+ axis.z = c.x/r;
+ }
+ else if(b.y >= c.z)
+ {
+ float r = 1 + b.y - a.x - c.z;
+ if(r <= threshold) return false;
+ r = sqrtf(r);
+ axis.y = 0.5f*r;
+ axis.x = b.x/r;
+ axis.z = c.y/r;
+ }
+ else
+ {
+ float r = 1 + b.y - a.x - c.z;
+ if(r <= threshold) return false;
+ r = sqrtf(r);
+ axis.z = 0.5f*r;
+ axis.x = c.x/r;
+ axis.y = c.y/r;
+ }
+ angle = M_PI;
+ }
+ else if(tr >= 3)
+ {
+ axis = vec(0, 0, 1);
+ angle = 0;
+ }
+ else
+ {
+ axis = vec(b.z - c.y, c.x - a.z, a.y - b.x);
+ float r = axis.squaredlen();
+ if(r <= threshold) return false;
+ axis.mul(1/sqrtf(r));
+ angle = acosf(0.5f*(tr - 1));
+ }
+ return true;
+ }
+
+ bool calcangleaxis(float &angle, vec &axis, float threshold = 1e-16f) const { return calcangleaxis(trace(), angle, axis, threshold); }
+
+ vec transform(const vec &o) const
+ {
+ return vec(a).mul(o.x).madd(b, o.y).madd(c, o.z);
+ }
+ vec transposedtransform(const vec &o) const { return vec(a.dot(o), b.dot(o), c.dot(o)); }
+ vec abstransform(const vec &o) const
+ {
+ return vec(a).mul(o.x).abs().add(vec(b).mul(o.y).abs()).add(vec(c).mul(o.z).abs());
+ }
+ vec abstransposedtransform(const vec &o) const
+ {
+ return vec(a.absdot(o), b.absdot(o), c.absdot(o));
+ }
+
+ void identity()
+ {
+ a = vec(1, 0, 0);
+ b = vec(0, 1, 0);
+ c = vec(0, 0, 1);
+ }
+
+ void rotate_around_x(float ck, float sk)
+ {
+ vec rb = vec(b).mul(ck).madd(c, sk),
+ rc = vec(c).mul(ck).msub(b, sk);
+ b = rb;
+ c = rc;
+ }
+ void rotate_around_x(float angle) { rotate_around_x(cosf(angle), sinf(angle)); }
+ void rotate_around_x(const vec2 &sc) { rotate_around_x(sc.x, sc.y); }
+
+ void rotate_around_y(float ck, float sk)
+ {
+ vec rc = vec(c).mul(ck).madd(a, sk),
+ ra = vec(a).mul(ck).msub(c, sk);
+ c = rc;
+ a = ra;
+ }
+ void rotate_around_y(float angle) { rotate_around_y(cosf(angle), sinf(angle)); }
+ void rotate_around_y(const vec2 &sc) { rotate_around_y(sc.x, sc.y); }
+
+ void rotate_around_z(float ck, float sk)
+ {
+ vec ra = vec(a).mul(ck).madd(b, sk),
+ rb = vec(b).mul(ck).msub(a, sk);
+ a = ra;
+ b = rb;
+ }
+ void rotate_around_z(float angle) { rotate_around_z(cosf(angle), sinf(angle)); }
+ void rotate_around_z(const vec2 &sc) { rotate_around_z(sc.x, sc.y); }
+
+ vec transform(const vec2 &o) { return vec(a).mul(o.x).madd(b, o.y); }
+ vec transposedtransform(const vec2 &o) const { return vec(a.dot2(o), b.dot2(o), c.dot2(o)); }
+
+ vec rowx() const { return vec(a.x, b.x, c.x); }
+ vec rowy() const { return vec(a.y, b.y, c.y); }
+ vec rowz() const { return vec(a.z, b.z, c.z); }
+};
+
+struct matrix4x3
+{
+ vec a, b, c, d;
+
+ matrix4x3() {}
+ matrix4x3(const vec &a, const vec &b, const vec &c, const vec &d) : a(a), b(b), c(c), d(d) {}
+ matrix4x3(const matrix3 &rot, const vec &trans) : a(rot.a), b(rot.b), c(rot.c), d(trans) {}
+ matrix4x3(const dualquat &dq)
+ {
+ vec4 r = vec4(dq.real).mul(1/dq.real.squaredlen()), rr = vec4(r).mul(dq.real);
+ r.mul(2);
+ float xy = r.x*dq.real.y, xz = r.x*dq.real.z, yz = r.y*dq.real.z,
+ wx = r.w*dq.real.x, wy = r.w*dq.real.y, wz = r.w*dq.real.z;
+ a = vec(rr.w + rr.x - rr.y - rr.z, xy + wz, xz - wy);
+ b = vec(xy - wz, rr.w + rr.y - rr.x - rr.z, yz + wx);
+ c = vec(xz + wy, yz - wx, rr.w + rr.z - rr.x - rr.y);
+ d = vec(-(dq.dual.w*r.x - dq.dual.x*r.w + dq.dual.y*r.z - dq.dual.z*r.y),
+ -(dq.dual.w*r.y - dq.dual.x*r.z - dq.dual.y*r.w + dq.dual.z*r.x),
+ -(dq.dual.w*r.z + dq.dual.x*r.y - dq.dual.y*r.x - dq.dual.z*r.w));
+
+ }
+ explicit matrix4x3(const matrix4 &m);
+
+ void mul(float k)
+ {
+ a.mul(k);
+ b.mul(k);
+ c.mul(k);
+ d.mul(k);
+ }
+
+ void setscale(float x, float y, float z) { a.x = x; b.y = y; c.z = z; }
+ void setscale(const vec &v) { setscale(v.x, v.y, v.z); }
+ void setscale(float n) { setscale(n, n, n); }
+
+ void scale(float x, float y, float z)
+ {
+ a.mul(x);
+ b.mul(y);
+ c.mul(z);
+ }
+ void scale(const vec &v) { scale(v.x, v.y, v.z); }
+ void scale(float n) { scale(n, n, n); }
+
+ void settranslation(const vec &p) { d = p; }
+ void settranslation(float x, float y, float z) { d = vec(x, y, z); }
+
+ void translate(const vec &p) { d.madd(a, p.x).madd(b, p.y).madd(c, p.z); }
+ void translate(float x, float y, float z) { translate(vec(x, y, z)); }
+ void translate(const vec &p, float scale) { translate(vec(p).mul(scale)); }
+
+ void posttranslate(const vec &p) { d.add(p); }
+ void posttranslate(float x, float y, float z) { posttranslate(vec(x, y, z)); }
+ void posttranslate(const vec &p, float scale) { d.madd(p, scale); }
+
+ void accumulate(const matrix4x3 &m, float k)
+ {
+ a.madd(m.a, k);
+ b.madd(m.b, k);
+ c.madd(m.c, k);
+ d.madd(m.d, k);
+ }
+
+ void normalize()
+ {
+ a.normalize();
+ b.normalize();
+ c.normalize();
+ }
+
+ void lerp(const matrix4x3 &to, float t)
+ {
+ a.lerp(to.a, t);
+ b.lerp(to.b, t);
+ c.lerp(to.c, t);
+ d.lerp(to.d, t);
+ }
+ void lerp(const matrix4x3 &from, const matrix4x3 &to, float t)
+ {
+ a.lerp(from.a, to.a, t);
+ b.lerp(from.b, to.b, t);
+ c.lerp(from.c, to.c, t);
+ d.lerp(from.d, to.d, t);
+ }
+
+ void identity()
+ {
+ a = vec(1, 0, 0);
+ b = vec(0, 1, 0);
+ c = vec(0, 0, 1);
+ d = vec(0, 0, 0);
+ }
+
+ void mul(const matrix4x3 &m, const matrix4x3 &n)
+ {
+ a = vec(m.a).mul(n.a.x).madd(m.b, n.a.y).madd(m.c, n.a.z);
+ b = vec(m.a).mul(n.b.x).madd(m.b, n.b.y).madd(m.c, n.b.z);
+ c = vec(m.a).mul(n.c.x).madd(m.b, n.c.y).madd(m.c, n.c.z);
+ d = vec(m.d).madd(m.a, n.d.x).madd(m.b, n.d.y).madd(m.c, n.d.z);
+ }
+ void mul(const matrix4x3 &n) { mul(matrix4x3(*this), n); }
+
+ void mul(const matrix3 &m, const matrix4x3 &n)
+ {
+ a = vec(m.a).mul(n.a.x).madd(m.b, n.a.y).madd(m.c, n.a.z);
+ b = vec(m.a).mul(n.b.x).madd(m.b, n.b.y).madd(m.c, n.b.z);
+ c = vec(m.a).mul(n.c.x).madd(m.b, n.c.y).madd(m.c, n.c.z);
+ d = vec(m.a).mul(n.d.x).madd(m.b, n.d.y).madd(m.c, n.d.z);
+ }
+
+ void mul(const matrix3 &rot, const vec &trans, const matrix4x3 &n)
+ {
+ mul(rot, n);
+ d.add(trans);
+ }
+
+ void transpose()
+ {
+ d = vec(a.dot(d), b.dot(d), c.dot(d)).neg();
+ swap(a.y, b.x); swap(a.z, c.x);
+ swap(b.z, c.y);
+ }
+
+ void transpose(const matrix4x3 &o)
+ {
+ a = vec(o.a.x, o.b.x, o.c.x);
+ b = vec(o.a.y, o.b.y, o.c.y);
+ c = vec(o.a.z, o.b.z, o.c.z);
+ d = vec(o.a.dot(o.d), o.b.dot(o.d), o.c.dot(o.d)).neg();
+ }
+
+ void transposemul(const matrix4x3 &m, const matrix4x3 &n)
+ {
+ vec t(m.a.dot(m.d), m.b.dot(m.d), m.c.dot(m.d));
+ a = vec(m.a.dot(n.a), m.b.dot(n.a), m.c.dot(n.a));
+ b = vec(m.a.dot(n.b), m.b.dot(n.b), m.c.dot(n.b));
+ c = vec(m.a.dot(n.c), m.b.dot(n.c), m.c.dot(n.c));
+ d = vec(m.a.dot(n.d), m.b.dot(n.d), m.c.dot(n.d)).sub(t);
+ }
+
+ void multranspose(const matrix4x3 &m, const matrix4x3 &n)
+ {
+ vec t(n.a.dot(n.d), n.b.dot(n.d), n.c.dot(n.d));
+ a = vec(m.a).mul(n.a.x).madd(m.b, n.b.x).madd(m.c, n.c.x);
+ b = vec(m.a).mul(n.a.y).madd(m.b, n.b.y).madd(m.c, n.c.y);
+ c = vec(m.a).mul(n.a.z).madd(m.b, n.b.z).madd(m.c, n.c.z);
+ d = vec(m.d).msub(m.a, t.x).msub(m.b, t.y).msub(m.c, t.z);
+ }
+
+ void invert(const matrix4x3 &o)
+ {
+ vec unscale(1/o.a.squaredlen(), 1/o.b.squaredlen(), 1/o.c.squaredlen());
+ transpose(o);
+ a.mul(unscale);
+ b.mul(unscale);
+ c.mul(unscale);
+ d.mul(unscale);
+ }
+ void invert() { invert(matrix4x3(*this)); }
+
+ void rotate(float angle, const vec &d)
+ {
+ rotate(cosf(angle), sinf(angle), d);
+ }
+
+ void rotate(float ck, float sk, const vec &axis)
+ {
+ matrix3 m;
+ m.rotate(ck, sk, axis);
+ *this = matrix4x3(m, vec(0, 0, 0));
+ }
+
+ void rotate_around_x(float ck, float sk)
+ {
+ vec rb = vec(b).mul(ck).madd(c, sk),
+ rc = vec(c).mul(ck).msub(b, sk);
+ b = rb;
+ c = rc;
+ }
+ void rotate_around_x(float angle) { rotate_around_x(cosf(angle), sinf(angle)); }
+ void rotate_around_x(const vec2 &sc) { rotate_around_x(sc.x, sc.y); }
+
+ void rotate_around_y(float ck, float sk)
+ {
+ vec rc = vec(c).mul(ck).madd(a, sk),
+ ra = vec(a).mul(ck).msub(c, sk);
+ c = rc;
+ a = ra;
+ }
+ void rotate_around_y(float angle) { rotate_around_y(cosf(angle), sinf(angle)); }
+ void rotate_around_y(const vec2 &sc) { rotate_around_y(sc.x, sc.y); }
+
+ void rotate_around_z(float ck, float sk)
+ {
+ vec ra = vec(a).mul(ck).madd(b, sk),
+ rb = vec(b).mul(ck).msub(a, sk);
+ a = ra;
+ b = rb;
+ }
+ void rotate_around_z(float angle) { rotate_around_z(cosf(angle), sinf(angle)); }
+ void rotate_around_z(const vec2 &sc) { rotate_around_z(sc.x, sc.y); }
+
+ vec transform(const vec &o) const { return vec(d).madd(a, o.x).madd(b, o.y).madd(c, o.z); }
+ vec transposedtransform(const vec &o) const { vec p = vec(o).sub(d); return vec(a.dot(p), b.dot(p), c.dot(p)); }
+ vec transformnormal(const vec &o) const { return vec(a).mul(o.x).madd(b, o.y).madd(c, o.z); }
+ vec transposedtransformnormal(const vec &o) const { return vec(a.dot(o), b.dot(o), c.dot(o)); }
+ vec transform(const vec2 &o) const { return vec(d).madd(a, o.x).madd(b, o.y); }
+
+ vec4 rowx() const { return vec4(a.x, b.x, c.x, d.x); }
+ vec4 rowy() const { return vec4(a.y, b.y, c.y, d.y); }
+ vec4 rowz() const { return vec4(a.z, b.z, c.z, d.z); }
+};
+
+inline dualquat::dualquat(const matrix4x3 &m) : real(m)
+{
+ dual.x = 0.5f*( m.d.x*real.w + m.d.y*real.z - m.d.z*real.y);
+ dual.y = 0.5f*(-m.d.x*real.z + m.d.y*real.w + m.d.z*real.x);
+ dual.z = 0.5f*( m.d.x*real.y - m.d.y*real.x + m.d.z*real.w);
+ dual.w = -0.5f*( m.d.x*real.x + m.d.y*real.y + m.d.z*real.z);
+}
+
+inline matrix3::matrix3(const matrix4x3 &m) : a(m.a), b(m.b), c(m.c) {}
+
+struct plane : vec
+{
+ float offset;
+
+ float dist(const vec &p) const { return dot(p)+offset; }
+ float dist(const vec4 &p) const { return p.dot3(*this) + p.w*offset; }
+ bool operator==(const plane &p) const { return x==p.x && y==p.y && z==p.z && offset==p.offset; }
+ bool operator!=(const plane &p) const { return x!=p.x || y!=p.y || z!=p.z || offset!=p.offset; }
+
+ plane() {}
+ plane(const vec &c, float off) : vec(c), offset(off) {}
+ plane(const vec4 &p) : vec(p), offset(p.w) {}
+ plane(int d, float off)
+ {
+ x = y = z = 0.0f;
+ v[d] = 1.0f;
+ offset = -off;
+ }
+ plane(float a, float b, float c, float d) : vec(a, b, c), offset(d) {}
+
+ void toplane(const vec &n, const vec &p)
+ {
+ x = n.x; y = n.y; z = n.z;
+ offset = -dot(p);
+ }
+
+ bool toplane(const vec &a, const vec &b, const vec &c)
+ {
+ cross(vec(b).sub(a), vec(c).sub(a));
+ float mag = magnitude();
+ if(!mag) return false;
+ div(mag);
+ offset = -dot(a);
+ return true;
+ }
+
+ bool rayintersect(const vec &o, const vec &ray, float &dist)
+ {
+ float cosalpha = dot(ray);
+ if(cosalpha==0) return false;
+ float deltac = offset+dot(o);
+ dist -= deltac/cosalpha;
+ return true;
+ }
+
+ plane &reflectz(float rz)
+ {
+ offset += 2*rz*z;
+ z = -z;
+ return *this;
+ }
+
+ plane &invert()
+ {
+ neg();
+ offset = -offset;
+ return *this;
+ }
+
+ plane &scale(float k)
+ {
+ mul(k);
+ return *this;
+ }
+
+ plane &translate(const vec &p)
+ {
+ offset += dot(p);
+ return *this;
+ }
+
+ plane &normalize()
+ {
+ float mag = magnitude();
+ div(mag);
+ offset /= mag;
+ return *this;
+ }
+
+ float zintersect(const vec &p) const { return -(x*p.x+y*p.y+offset)/z; }
+ float zdelta(const vec &p) const { return -(x*p.x+y*p.y)/z; }
+ float zdist(const vec &p) const { return p.z-zintersect(p); }
+};
+
+struct triangle
+{
+ vec a, b, c;
+
+ triangle(const vec &a, const vec &b, const vec &c) : a(a), b(b), c(c) {}
+ triangle() {}
+
+ triangle &add(const vec &o) { a.add(o); b.add(o); c.add(o); return *this; }
+ triangle &sub(const vec &o) { a.sub(o); b.sub(o); c.sub(o); return *this; }
+
+ bool operator==(const triangle &t) const { return a == t.a && b == t.b && c == t.c; }
+};
+
+/**
+
+Sauerbraten uses 3 different linear coordinate systems
+which are oriented around each of the axis dimensions.
+
+So any point within the game can be defined by four coordinates: (d, x, y, z)
+
+d is the reference axis dimension
+x is the coordinate of the ROW dimension
+y is the coordinate of the COL dimension
+z is the coordinate of the reference dimension (DEPTH)
+
+typically, if d is not used, then it is implicitly the Z dimension.
+ie: d=z => x=x, y=y, z=z
+
+**/
+
+// DIM: X=0 Y=1 Z=2.
+const int R[3] = {1, 2, 0}; // row
+const int C[3] = {2, 0, 1}; // col
+const int D[3] = {0, 1, 2}; // depth
+
+struct ivec4;
+struct ivec2;
+struct usvec;
+struct svec;
+
+struct ivec
+{
+ union
+ {
+ struct { int x, y, z; };
+ struct { int r, g, b; };
+ int v[3];
+ };
+
+ ivec() {}
+ explicit ivec(const vec &v) : x(int(v.x)), y(int(v.y)), z(int(v.z)) {}
+ ivec(int a, int b, int c) : x(a), y(b), z(c) {}
+ ivec(int d, int row, int col, int depth)
+ {
+ v[R[d]] = row;
+ v[C[d]] = col;
+ v[D[d]] = depth;
+ }
+ ivec(int i, const ivec &co, int size) : x(co.x+((i&1)>>0)*size), y(co.y+((i&2)>>1)*size), z(co.z +((i&4)>>2)*size) {}
+ explicit ivec(const ivec4 &v);
+ explicit ivec(const ivec2 &v, int z = 0);
+ explicit ivec(const usvec &v);
+ explicit ivec(const svec &v);
+
+ int &operator[](int i) { return v[i]; }
+ int operator[](int i) const { return v[i]; }
+
+ //int idx(int i) { return v[i]; }
+ bool operator==(const ivec &v) const { return x==v.x && y==v.y && z==v.z; }
+ bool operator!=(const ivec &v) const { return x!=v.x || y!=v.y || z!=v.z; }
+ bool iszero() const { return x==0 && y==0 && z==0; }
+ ivec &shl(int n) { x<<= n; y<<= n; z<<= n; return *this; }
+ ivec &shr(int n) { x>>= n; y>>= n; z>>= n; return *this; }
+ ivec &mul(int n) { x *= n; y *= n; z *= n; return *this; }
+ ivec &div(int n) { x /= n; y /= n; z /= n; return *this; }
+ ivec &add(int n) { x += n; y += n; z += n; return *this; }
+ ivec &sub(int n) { x -= n; y -= n; z -= n; return *this; }
+ ivec &mul(const ivec &v) { x *= v.x; y *= v.y; z *= v.z; return *this; }
+ ivec &div(const ivec &v) { x /= v.x; y /= v.y; z /= v.z; return *this; }
+ ivec &add(const ivec &v) { x += v.x; y += v.y; z += v.z; return *this; }
+ ivec &sub(const ivec &v) { x -= v.x; y -= v.y; z -= v.z; return *this; }
+ ivec &mask(int n) { x &= n; y &= n; z &= n; return *this; }
+ ivec &neg() { return mul(-1); }
+ ivec &min(const ivec &o) { x = ::min(x, o.x); y = ::min(y, o.y); z = ::min(z, o.z); return *this; }
+ ivec &max(const ivec &o) { x = ::max(x, o.x); y = ::max(y, o.y); z = ::max(z, o.z); return *this; }
+ ivec &min(int n) { x = ::min(x, n); y = ::min(y, n); z = ::min(z, n); return *this; }
+ ivec &max(int n) { x = ::max(x, n); y = ::max(y, n); z = ::max(z, n); return *this; }
+ ivec &abs() { x = ::abs(x); y = ::abs(y); z = ::abs(z); return *this; }
+ ivec &clamp(int l, int h) { x = ::clamp(x, l, h); y = ::clamp(y, l, h); z = ::clamp(z, l, h); return *this; }
+ ivec &cross(const ivec &a, const ivec &b) { x = a.y*b.z-a.z*b.y; y = a.z*b.x-a.x*b.z; z = a.x*b.y-a.y*b.x; return *this; }
+ int dot(const ivec &o) const { return x*o.x + y*o.y + z*o.z; }
+ float dist(const plane &p) const { return x*p.x + y*p.y + z*p.z + p.offset; }
+
+ static inline ivec floor(const vec &o) { return ivec(int(::floor(o.x)), int(::floor(o.y)), int(::floor(o.z))); }
+ static inline ivec ceil(const vec &o) { return ivec(int(::ceil(o.x)), int(::ceil(o.y)), int(::ceil(o.z))); }
+};
+
+inline vec::vec(const ivec &v) : x(v.x), y(v.y), z(v.z) {}
+
+static inline bool htcmp(const ivec &x, const ivec &y)
+{
+ return x == y;
+}
+
+static inline uint hthash(const ivec &k)
+{
+ return k.x^k.y^k.z;
+}
+
+struct ivec2
+{
+ union
+ {
+ struct { int x, y; };
+ int v[2];
+ };
+
+ ivec2() {}
+ ivec2(int x, int y) : x(x), y(y) {}
+ explicit ivec2(const vec2 &v) : x(int(v.x)), y(int(v.y)) {}
+ explicit ivec2(const ivec &v) : x(v.x), y(v.y) {}
+
+ int &operator[](int i) { return v[i]; }
+ int operator[](int i) const { return v[i]; }
+
+ bool operator==(const ivec2 &o) const { return x == o.x && y == o.y; }
+ bool operator!=(const ivec2 &o) const { return x != o.x || y != o.y; }
+
+ bool iszero() const { return x==0 && y==0; }
+ ivec2 &shl(int n) { x<<= n; y<<= n; return *this; }
+ ivec2 &shr(int n) { x>>= n; y>>= n; return *this; }
+ ivec2 &mul(int n) { x *= n; y *= n; return *this; }
+ ivec2 &div(int n) { x /= n; y /= n; return *this; }
+ ivec2 &add(int n) { x += n; y += n; return *this; }
+ ivec2 &sub(int n) { x -= n; y -= n; return *this; }
+ ivec2 &mul(const ivec2 &v) { x *= v.x; y *= v.y; return *this; }
+ ivec2 &div(const ivec2 &v) { x /= v.x; y /= v.y; return *this; }
+ ivec2 &add(const ivec2 &v) { x += v.x; y += v.y; return *this; }
+ ivec2 &sub(const ivec2 &v) { x -= v.x; y -= v.y; return *this; }
+ ivec2 &mask(int n) { x &= n; y &= n; return *this; }
+ ivec2 &neg() { x = -x; y = -y; return *this; }
+ ivec2 &min(const ivec2 &o) { x = ::min(x, o.x); y = ::min(y, o.y); return *this; }
+ ivec2 &max(const ivec2 &o) { x = ::max(x, o.x); y = ::max(y, o.y); return *this; }
+ ivec2 &min(int n) { x = ::min(x, n); y = ::min(y, n); return *this; }
+ ivec2 &max(int n) { x = ::max(x, n); y = ::max(y, n); return *this; }
+ ivec2 &abs() { x = ::abs(x); y = ::abs(y); return *this; }
+ int dot(const ivec2 &o) const { return x*o.x + y*o.y; }
+ int cross(const ivec2 &o) const { return x*o.y - y*o.x; }
+};
+
+inline ivec::ivec(const ivec2 &v, int z) : x(v.x), y(v.y), z(z) {}
+
+static inline bool htcmp(const ivec2 &x, const ivec2 &y)
+{
+ return x == y;
+}
+
+static inline uint hthash(const ivec2 &k)
+{
+ return k.x^k.y;
+}
+
+struct ivec4
+{
+ union
+ {
+ struct { int x, y, z, w; };
+ struct { int r, g, b, a; };
+ int v[4];
+ };
+
+ ivec4() {}
+ explicit ivec4(const ivec &p, int w = 0) : x(p.x), y(p.y), z(p.z), w(w) {}
+ ivec4(int x, int y, int z, int w) : x(x), y(y), z(z), w(w) {}
+ explicit ivec4(const vec4 &v) : x(int(v.x)), y(int(v.y)), z(int(v.z)), w(int(v.w)) {}
+
+ bool operator==(const ivec4 &o) const { return x == o.x && y == o.y && z == o.z && w == o.w; }
+ bool operator!=(const ivec4 &o) const { return x != o.x || y != o.y || z != o.z || w != o.w; }
+};
+
+inline ivec::ivec(const ivec4 &v) : x(v.x), y(v.y), z(v.z) {}
+
+static inline bool htcmp(const ivec4 &x, const ivec4 &y)
+{
+ return x == y;
+}
+
+static inline uint hthash(const ivec4 &k)
+{
+ return k.x^k.y^k.z^k.w;
+}
+
+struct bvec4;
+
+struct bvec
+{
+ union
+ {
+ struct { uchar x, y, z; };
+ struct { uchar r, g, b; };
+ uchar v[3];
+ };
+
+ bvec() {}
+ bvec(uchar x, uchar y, uchar z) : x(x), y(y), z(z) {}
+ explicit bvec(const vec &v) : x(uchar((v.x+1)*(255.0f/2.0f))), y(uchar((v.y+1)*(255.0f/2.0f))), z(uchar((v.z+1)*(255.0f/2.0f))) {}
+ explicit bvec(const bvec4 &v);
+
+ uchar &operator[](int i) { return v[i]; }
+ uchar operator[](int i) const { return v[i]; }
+
+ bool operator==(const bvec &v) const { return x==v.x && y==v.y && z==v.z; }
+ bool operator!=(const bvec &v) const { return x!=v.x || y!=v.y || z!=v.z; }
+
+ bool iszero() const { return x==0 && y==0 && z==0; }
+
+ vec tonormal() const { return vec(x*(2.0f/255.0f)-1.0f, y*(2.0f/255.0f)-1.0f, z*(2.0f/255.0f)-1.0f); }
+
+ bvec &normalize()
+ {
+ vec n(x-127.5f, y-127.5f, z-127.5f);
+ float mag = 127.5f/n.magnitude();
+ x = uchar(n.x*mag+127.5f);
+ y = uchar(n.y*mag+127.5f);
+ z = uchar(n.z*mag+127.5f);
+ return *this;
+ }
+
+ void lerp(const bvec &a, const bvec &b, float t) { x = uchar(a.x + (b.x-a.x)*t); y = uchar(a.y + (b.y-a.y)*t); z = uchar(a.z + (b.z-a.z)*t); }
+
+ void lerp(const bvec &a, const bvec &b, int ka, int kb, int d)
+ {
+ x = uchar((a.x*ka + b.x*kb)/d);
+ y = uchar((a.y*ka + b.y*kb)/d);
+ z = uchar((a.z*ka + b.z*kb)/d);
+ }
+
+ void flip() { x ^= 0x80; y ^= 0x80; z ^= 0x80; }
+
+ void scale(int k, int d) { x = uchar((x*k)/d); y = uchar((y*k)/d); z = uchar((z*k)/d); }
+
+ bvec &shl(int n) { x<<= n; y<<= n; z<<= n; return *this; }
+ bvec &shr(int n) { x>>= n; y>>= n; z>>= n; return *this; }
+
+ static bvec fromcolor(const vec &v) { return bvec(uchar(v.x*255.0f), uchar(v.y*255.0f), uchar(v.z*255.0f)); }
+ vec tocolor() const { return vec(x*(1.0f/255.0f), y*(1.0f/255.0f), z*(1.0f/255.0f)); }
+
+ static bvec from565(ushort c) { return bvec((((c>>11)&0x1F)*527 + 15) >> 6, (((c>>5)&0x3F)*259 + 35) >> 6, ((c&0x1F)*527 + 15) >> 6); }
+
+ static bvec hexcolor(int color)
+ {
+ return bvec((color>>16)&0xFF, (color>>8)&0xFF, color&0xFF);
+ }
+ int tohexcolor() const { return (int(r)<<16)|(int(g)<<8)|int(b); }
+};
+
+struct bvec4
+{
+ union
+ {
+ struct { uchar x, y, z, w; };
+ struct { uchar r, g, b, a; };
+ uchar v[4];
+ uint mask;
+ };
+
+ bvec4() {}
+ bvec4(uchar x, uchar y, uchar z, uchar w = 0) : x(x), y(y), z(z), w(w) {}
+ bvec4(const bvec &v, uchar w = 0) : x(v.x), y(v.y), z(v.z), w(w) {}
+
+ uchar &operator[](int i) { return v[i]; }
+ uchar operator[](int i) const { return v[i]; }
+
+ bool operator==(const bvec4 &v) const { return mask==v.mask; }
+ bool operator!=(const bvec4 &v) const { return mask!=v.mask; }
+
+ bool iszero() const { return mask==0; }
+
+ vec tonormal() const { return vec(x*(2.0f/255.0f)-1.0f, y*(2.0f/255.0f)-1.0f, z*(2.0f/255.0f)-1.0f); }
+
+ void lerp(const bvec4 &a, const bvec4 &b, float t)
+ {
+ x = uchar(a.x + (b.x-a.x)*t);
+ y = uchar(a.y + (b.y-a.y)*t);
+ z = uchar(a.z + (b.z-a.z)*t);
+ w = a.w;
+ }
+
+ void lerp(const bvec4 &a, const bvec4 &b, int ka, int kb, int d)
+ {
+ x = uchar((a.x*ka + b.x*kb)/d);
+ y = uchar((a.y*ka + b.y*kb)/d);
+ z = uchar((a.z*ka + b.z*kb)/d);
+ w = a.w;
+ }
+
+ void flip() { mask ^= 0x80808080; }
+};
+
+inline bvec::bvec(const bvec4 &v) : x(v.x), y(v.y), z(v.z) {}
+
+struct usvec
+{
+ union
+ {
+ struct { ushort x, y, z; };
+ ushort v[3];
+ };
+
+ ushort &operator[](int i) { return v[i]; }
+ ushort operator[](int i) const { return v[i]; }
+};
+
+inline ivec::ivec(const usvec &v) : x(v.x), y(v.y), z(v.z) {}
+
+struct svec
+{
+ union
+ {
+ struct { short x, y, z; };
+ short v[3];
+ };
+
+ svec() {}
+ svec(short x, short y, short z) : x(x), y(y), z(z) {}
+ explicit svec(const ivec &v) : x(v.x), y(v.y), z(v.z) {}
+
+ short &operator[](int i) { return v[i]; }
+ short operator[](int i) const { return v[i]; }
+};
+
+inline ivec::ivec(const svec &v) : x(v.x), y(v.y), z(v.z) {}
+
+struct svec2
+{
+ union
+ {
+ struct { short x, y; };
+ short v[2];
+ };
+
+ svec2() {}
+ svec2(short x, short y) : x(x), y(y) {}
+
+ short &operator[](int i) { return v[i]; }
+ short operator[](int i) const { return v[i]; }
+
+ bool operator==(const svec2 &o) const { return x == o.x && y == o.y; }
+ bool operator!=(const svec2 &o) const { return x != o.x || y != o.y; }
+
+ bool iszero() const { return x==0 && y==0; }
+};
+
+struct dvec4
+{
+ double x, y, z, w;
+
+ dvec4() {}
+ dvec4(double x, double y, double z, double w) : x(x), y(y), z(z), w(w) {}
+ dvec4(const vec4 &v) : x(v.x), y(v.y), z(v.z), w(v.w) {}
+
+ template<class B> dvec4 &madd(const dvec4 &a, const B &b) { return add(dvec4(a).mul(b)); }
+ dvec4 &mul(double f) { x *= f; y *= f; z *= f; w *= f; return *this; }
+ dvec4 &mul(const dvec4 &o) { x *= o.x; y *= o.y; z *= o.z; w *= o.w; return *this; }
+ dvec4 &add(double f) { x += f; y += f; z += f; w += f; return *this; }
+ dvec4 &add(const dvec4 &o) { x += o.x; y += o.y; z += o.z; w += o.w; return *this; }
+
+ operator vec4() const { return vec4(x, y, z, w); }
+};
+
+struct matrix4
+{
+ vec4 a, b, c, d;
+
+ matrix4() {}
+ matrix4(const float *m) : a(m), b(m+4), c(m+8), d(m+12) {}
+ matrix4(const vec &a, const vec &b, const vec &c = vec(0, 0, 1))
+ : a(a.x, b.x, c.x, 0), b(a.y, b.y, c.y, 0), c(a.z, b.z, c.z, 0), d(0, 0, 0, 1)
+ {}
+ matrix4(const vec4 &a, const vec4 &b, const vec4 &c, const vec4 &d = vec4(0, 0, 0, 1))
+ : a(a), b(b), c(c), d(d)
+ {}
+ matrix4(const matrix4x3 &m)
+ : a(m.a, 0), b(m.b, 0), c(m.c, 0), d(m.d, 1)
+ {}
+ matrix4(const matrix3 &rot, const vec &trans)
+ : a(rot.a, 0), b(rot.b, 0), c(rot.c, 0), d(trans, 1)
+ {}
+
+ void mul(const matrix4 &x, const matrix3 &y)
+ {
+ a = vec4(x.a).mul(y.a.x).madd(x.b, y.a.y).madd(x.c, y.a.z);
+ b = vec4(x.a).mul(y.b.x).madd(x.b, y.b.y).madd(x.c, y.b.z);
+ c = vec4(x.a).mul(y.c.x).madd(x.b, y.c.y).madd(x.c, y.c.z);
+ d = x.d;
+ }
+ void mul(const matrix3 &y) { mul(matrix4(*this), y); }
+
+ template<class T> void mult(const matrix4 &x, const matrix4 &y)
+ {
+ a = T(x.a).mul(y.a.x).madd(x.b, y.a.y).madd(x.c, y.a.z).madd(x.d, y.a.w);
+ b = T(x.a).mul(y.b.x).madd(x.b, y.b.y).madd(x.c, y.b.z).madd(x.d, y.b.w);
+ c = T(x.a).mul(y.c.x).madd(x.b, y.c.y).madd(x.c, y.c.z).madd(x.d, y.c.w);
+ d = T(x.a).mul(y.d.x).madd(x.b, y.d.y).madd(x.c, y.d.z).madd(x.d, y.d.w);
+ }
+
+ void mul(const matrix4 &x, const matrix4 &y) { mult<vec4>(x, y); }
+ void mul(const matrix4 &y) { mult<vec4>(matrix4(*this), y); }
+
+ void muld(const matrix4 &x, const matrix4 &y) { mult<dvec4>(x, y); }
+ void muld(const matrix4 &y) { mult<dvec4>(matrix4(*this), y); }
+
+ void rotate_around_x(float ck, float sk)
+ {
+ vec4 rb = vec4(b).mul(ck).madd(c, sk),
+ rc = vec4(c).mul(ck).msub(b, sk);
+ b = rb;
+ c = rc;
+ }
+ void rotate_around_x(float angle) { rotate_around_x(cosf(angle), sinf(angle)); }
+ void rotate_around_x(const vec2 &sc) { rotate_around_x(sc.x, sc.y); }
+
+ void rotate_around_y(float ck, float sk)
+ {
+ vec4 rc = vec4(c).mul(ck).madd(a, sk),
+ ra = vec4(a).mul(ck).msub(c, sk);
+ c = rc;
+ a = ra;
+ }
+ void rotate_around_y(float angle) { rotate_around_y(cosf(angle), sinf(angle)); }
+ void rotate_around_y(const vec2 &sc) { rotate_around_y(sc.x, sc.y); }
+
+ void rotate_around_z(float ck, float sk)
+ {
+ vec4 ra = vec4(a).mul(ck).madd(b, sk),
+ rb = vec4(b).mul(ck).msub(a, sk);
+ a = ra;
+ b = rb;
+ }
+ void rotate_around_z(float angle) { rotate_around_z(cosf(angle), sinf(angle)); }
+ void rotate_around_z(const vec2 &sc) { rotate_around_z(sc.x, sc.y); }
+
+ void rotate(float ck, float sk, const vec &axis)
+ {
+ matrix3 m;
+ m.rotate(ck, sk, axis);
+ mul(m);
+ }
+ void rotate(float angle, const vec &dir) { rotate(cosf(angle), sinf(angle), dir); }
+ void rotate(const vec2 &sc, const vec &dir) { rotate(sc.x, sc.y, dir); }
+
+ void identity()
+ {
+ a = vec4(1, 0, 0, 0);
+ b = vec4(0, 1, 0, 0);
+ c = vec4(0, 0, 1, 0);
+ d = vec4(0, 0, 0, 1);
+ }
+
+ void settranslation(const vec &v) { d.setxyz(v); }
+ void settranslation(float x, float y, float z) { d.x = x; d.y = y; d.z = z; }
+
+ void translate(const vec &p) { d.madd(a, p.x).madd(b, p.y).madd(c, p.z); }
+ void translate(float x, float y, float z) { translate(vec(x, y, z)); }
+ void translate(const vec &p, float scale) { translate(vec(p).mul(scale)); }
+
+ void setscale(float x, float y, float z) { a.x = x; b.y = y; c.z = z; }
+ void setscale(const vec &v) { setscale(v.x, v.y, v.z); }
+ void setscale(float n) { setscale(n, n, n); }
+
+ void scale(float x, float y, float z)
+ {
+ a.mul(x);
+ b.mul(y);
+ c.mul(z);
+ }
+ void scale(const vec &v) { scale(v.x, v.y, v.z); }
+ void scale(float n) { scale(n, n, n); }
+
+ void scalexy(float x, float y)
+ {
+ a.x *= x; a.y *= y;
+ b.x *= x; b.y *= y;
+ c.x *= x; c.y *= y;
+ d.x *= x; d.y *= y;
+ }
+
+ void scalez(float k)
+ {
+ a.z *= k;
+ b.z *= k;
+ c.z *= k;
+ d.z *= k;
+ }
+
+ void reflectz(float z)
+ {
+ d.add(vec4(c).mul(2*z));
+ c.neg();
+ }
+
+ void projective(float zscale = 0.5f, float zoffset = 0.5f)
+ {
+ a.x = 0.5f*(a.x + a.w);
+ a.y = 0.5f*(a.y + a.w);
+ b.x = 0.5f*(b.x + b.w);
+ b.y = 0.5f*(b.y + b.w);
+ c.x = 0.5f*(c.x + c.w);
+ c.y = 0.5f*(c.y + c.w);
+ d.x = 0.5f*(d.x + d.w);
+ d.y = 0.5f*(d.y + d.w);
+ a.z = zscale*a.z + zoffset*a.w;
+ b.z = zscale*b.z + zoffset*b.w;
+ c.z = zscale*c.z + zoffset*c.w;
+ d.z = zscale*d.z + zoffset*d.w;
+ }
+
+ void jitter(float x, float y)
+ {
+ a.x += x * a.w;
+ a.y += y * a.w;
+ b.x += x * b.w;
+ b.y += y * b.w;
+ c.x += x * c.w;
+ c.y += y * c.w;
+ d.x += x * d.w;
+ d.y += y * d.w;
+ }
+
+ void transpose()
+ {
+ swap(a.y, b.x); swap(a.z, c.x); swap(a.w, d.x);
+ swap(b.z, c.y); swap(b.w, d.y);
+ swap(c.w, d.z);
+ }
+
+ void transpose(const matrix4 &m)
+ {
+ a = vec4(m.a.x, m.b.x, m.c.x, m.d.x);
+ b = vec4(m.a.y, m.b.y, m.c.y, m.d.y);
+ c = vec4(m.a.z, m.b.z, m.c.z, m.d.z);
+ d = vec4(m.a.w, m.b.w, m.c.w, m.d.w);
+ }
+
+ void frustum(float left, float right, float bottom, float top, float znear, float zfar)
+ {
+ float width = right - left, height = top - bottom, zrange = znear - zfar;
+ a = vec4(2*znear/width, 0, 0, 0);
+ b = vec4(0, 2*znear/height, 0, 0);
+ c = vec4((right + left)/width, (top + bottom)/height, (zfar + znear)/zrange, -1);
+ d = vec4(0, 0, 2*znear*zfar/zrange, 0);
+ }
+
+ void perspective(float fovy, float aspect, float znear, float zfar)
+ {
+ float ydist = znear * tan(fovy/2*RAD), xdist = ydist * aspect;
+ frustum(-xdist, xdist, -ydist, ydist, znear, zfar);
+ }
+
+ void ortho(float left, float right, float bottom, float top, float znear, float zfar)
+ {
+ float width = right - left, height = top - bottom, zrange = znear - zfar;
+ a = vec4(2/width, 0, 0, 0);
+ b = vec4(0, 2/height, 0, 0);
+ c = vec4(0, 0, 2/zrange, 0);
+ d = vec4(-(right+left)/width, -(top+bottom)/height, (zfar+znear)/zrange, 1);
+ }
+
+ void clip(const plane &p, const matrix4 &m)
+ {
+ float x = ((p.x<0 ? -1 : (p.x>0 ? 1 : 0)) + m.c.x) / m.a.x,
+ y = ((p.y<0 ? -1 : (p.y>0 ? 1 : 0)) + m.c.y) / m.b.y,
+ w = (1 + m.c.z) / m.d.z,
+ scale = 2 / (x*p.x + y*p.y - p.z + w*p.offset);
+ a = vec4(m.a.x, m.a.y, p.x*scale, m.a.w);
+ b = vec4(m.b.x, m.b.y, p.y*scale, m.b.w);
+ c = vec4(m.c.x, m.c.y, p.z*scale + 1.0f, m.c.w);
+ d = vec4(m.d.x, m.d.y, p.offset*scale, m.d.w);
+ }
+
+ void transform(const vec &in, vec &out) const
+ {
+ out = vec(a).mul(in.x).add(vec(b).mul(in.y)).add(vec(c).mul(in.z)).add(vec(d));
+ }
+
+ void transform(const vec4 &in, vec &out) const
+ {
+ out = vec(a).mul(in.x).add(vec(b).mul(in.y)).add(vec(c).mul(in.z)).add(vec(d).mul(in.w));
+ }
+
+ void transform(const vec &in, vec4 &out) const
+ {
+ out = vec4(a).mul(in.x).madd(b, in.y).madd(c, in.z).add(d);
+ }
+
+ void transform(const vec4 &in, vec4 &out) const
+ {
+ out = vec4(a).mul(in.x).madd(b, in.y).madd(c, in.z).madd(d, in.w);
+ }
+
+ template<class T, class U> T transform(const U &in) const
+ {
+ T v;
+ transform(in, v);
+ return v;
+ }
+
+ template<class T> vec perspectivetransform(const T &in) const
+ {
+ vec4 v;
+ transform(in, v);
+ return vec(v).div(v.w);
+ }
+
+ void transformnormal(const vec &in, vec &out) const
+ {
+ out = vec(a).mul(in.x).add(vec(b).mul(in.y)).add(vec(c).mul(in.z));
+ }
+
+ void transformnormal(const vec &in, vec4 &out) const
+ {
+ out = vec4(a).mul(in.x).madd(b, in.y).madd(c, in.z);
+ }
+
+ template<class T, class U> T transformnormal(const U &in) const
+ {
+ T v;
+ transformnormal(in, v);
+ return v;
+ }
+
+ void transposedtransform(const vec &in, vec &out) const
+ {
+ vec p = vec(in).sub(vec(d));
+ out.x = a.dot3(p);
+ out.y = b.dot3(p);
+ out.z = c.dot3(p);
+ }
+
+ void transposedtransformnormal(const vec &in, vec &out) const
+ {
+ out.x = a.dot3(in);
+ out.y = b.dot3(in);
+ out.z = c.dot3(in);
+ }
+
+ void transposedtransform(const plane &in, plane &out) const
+ {
+ out.x = in.dist(a);
+ out.y = in.dist(b);
+ out.z = in.dist(c);
+ out.offset = in.dist(d);
+ }
+
+ float getscale() const
+ {
+ return sqrtf(a.x*a.y + b.x*b.x + c.x*c.x);
+ }
+
+ vec gettranslation() const
+ {
+ return vec(d);
+ }
+
+ vec4 rowx() const { return vec4(a.x, b.x, c.x, d.x); }
+ vec4 rowy() const { return vec4(a.y, b.y, c.y, d.y); }
+ vec4 rowz() const { return vec4(a.z, b.z, c.z, d.z); }
+ vec4 roww() const { return vec4(a.w, b.w, c.w, d.w); }
+
+ bool invert(const matrix4 &m, double mindet = 1.0e-12);
+
+ vec2 lineardepthscale() const
+ {
+ return vec2(d.w, -d.z).div(c.z*d.w - d.z*c.w);
+ }
+};
+
+inline matrix3::matrix3(const matrix4 &m)
+ : a(m.a), b(m.b), c(m.c)
+{}
+
+inline matrix4x3::matrix4x3(const matrix4 &m)
+ : a(m.a), b(m.b), c(m.c), d(m.d)
+{}
+
+struct matrix2
+{
+ vec2 a, b;
+
+ matrix2() {}
+ matrix2(const vec2 &a, const vec2 &b) : a(a), b(b) {}
+ explicit matrix2(const matrix4 &m) : a(m.a), b(m.b) {}
+ explicit matrix2(const matrix3 &m) : a(m.a), b(m.b) {}
+};
+
+struct squat
+{
+ short x, y, z, w;
+
+ squat() {}
+ squat(const vec4 &q) { convert(q); }
+
+ void convert(const vec4 &q)
+ {
+ x = short(q.x*32767.5f-0.5f);
+ y = short(q.y*32767.5f-0.5f);
+ z = short(q.z*32767.5f-0.5f);
+ w = short(q.w*32767.5f-0.5f);
+ }
+
+ void lerp(const vec4 &a, const vec4 &b, float t)
+ {
+ vec4 q;
+ q.lerp(a, b, t);
+ convert(q);
+ }
+};
+
+extern bool raysphereintersect(const vec &center, float radius, const vec &o, const vec &ray, float &dist);
+extern bool rayboxintersect(const vec &b, const vec &s, const vec &o, const vec &ray, float &dist, int &orient);
+extern bool linecylinderintersect(const vec &from, const vec &to, const vec &start, const vec &end, float radius, float &dist);
+
+extern const vec2 sincos360[];
+static inline int mod360(int angle)
+{
+ if(angle < 0) angle = 360 + (angle <= -360 ? angle%360 : angle);
+ else if(angle >= 360) angle %= 360;
+ return angle;
+}
+static inline const vec2 &sincosmod360(int angle) { return sincos360[mod360(angle)]; }
+static inline float cos360(int angle) { return sincos360[angle].x; }
+static inline float sin360(int angle) { return sincos360[angle].y; }
+static inline float tan360(int angle) { const vec2 &sc = sincos360[angle]; return sc.y/sc.x; }
+static inline float cotan360(int angle) { const vec2 &sc = sincos360[angle]; return sc.x/sc.y; }
+
diff --git a/src/shared/glemu.cpp b/src/shared/glemu.cpp
new file mode 100644
index 0000000..5658eb8
--- /dev/null
+++ b/src/shared/glemu.cpp
@@ -0,0 +1,355 @@
+#include "cube.h"
+
+extern int glversion;
+extern int intel_mapbufferrange_bug;
+
+namespace gle
+{
+ struct attribinfo
+ {
+ int type, size, formatsize, offset;
+ GLenum format;
+
+ attribinfo() : type(0), size(0), formatsize(0), offset(0), format(GL_FALSE) {}
+
+ bool operator==(const attribinfo &a) const
+ {
+ return type == a.type && size == a.size && format == a.format && offset == a.offset;
+ }
+ bool operator!=(const attribinfo &a) const
+ {
+ return type != a.type || size != a.size || format != a.format || offset != a.offset;
+ }
+ };
+
+ extern const char * const attribnames[MAXATTRIBS] = { "vvertex", "vcolor", "vtexcoord0", "vtexcoord1", "vnormal", "vtangent", "vboneweight", "vboneindex" };
+ ucharbuf attribbuf;
+ static uchar *attribdata;
+ static attribinfo attribdefs[MAXATTRIBS], lastattribs[MAXATTRIBS];
+ int enabled = 0;
+ static int numattribs = 0, attribmask = 0, numlastattribs = 0, lastattribmask = 0, vertexsize = 0, lastvertexsize = 0;
+ static GLenum primtype = GL_TRIANGLES;
+ static uchar *lastbuf = NULL;
+ static bool changedattribs = false;
+ static vector<GLint> multidrawstart;
+ static vector<GLsizei> multidrawcount;
+
+ #define MAXQUADS (0x10000/4)
+ static GLuint quadindexes = 0;
+ static bool quadsenabled = false;
+
+ #define MAXVBOSIZE (4*1024*1024)
+ static GLuint vbo = 0;
+ static int vbooffset = MAXVBOSIZE;
+
+ static GLuint defaultvao = 0;
+
+ void enablequads()
+ {
+ quadsenabled = true;
+
+ if(glversion < 300) return;
+
+ if(quadindexes)
+ {
+ glBindBuffer_(GL_ELEMENT_ARRAY_BUFFER, quadindexes);
+ return;
+ }
+
+ glGenBuffers_(1, &quadindexes);
+ ushort *data = new ushort[MAXQUADS*6], *dst = data;
+ for(int idx = 0; idx < MAXQUADS*4; idx += 4, dst += 6)
+ {
+ dst[0] = idx;
+ dst[1] = idx + 1;
+ dst[2] = idx + 2;
+ dst[3] = idx + 0;
+ dst[4] = idx + 2;
+ dst[5] = idx + 3;
+ }
+ glBindBuffer_(GL_ELEMENT_ARRAY_BUFFER, quadindexes);
+ glBufferData_(GL_ELEMENT_ARRAY_BUFFER, MAXQUADS*6*sizeof(ushort), data, GL_STATIC_DRAW);
+ delete[] data;
+ }
+
+ void disablequads()
+ {
+ quadsenabled = false;
+
+ if(glversion < 300) return;
+
+ glBindBuffer_(GL_ELEMENT_ARRAY_BUFFER, 0);
+ }
+
+ void drawquads(int offset, int count)
+ {
+ if(count <= 0) return;
+ if(glversion < 300)
+ {
+ glDrawArrays(GL_QUADS, offset*4, count*4);
+ return;
+ }
+ if(offset + count > MAXQUADS)
+ {
+ if(offset >= MAXQUADS) return;
+ count = MAXQUADS - offset;
+ }
+ glDrawRangeElements_(GL_TRIANGLES, offset*4, (offset + count)*4-1, count*6, GL_UNSIGNED_SHORT, (ushort *)0 + offset*6);
+ }
+
+ void defattrib(int type, int size, int format)
+ {
+ if(type == ATTRIB_VERTEX)
+ {
+ numattribs = attribmask = 0;
+ vertexsize = 0;
+ }
+ changedattribs = true;
+ attribmask |= 1<<type;
+ attribinfo &a = attribdefs[numattribs++];
+ a.type = type;
+ a.size = size;
+ a.format = format;
+ switch(format)
+ {
+ case 'B': case GL_UNSIGNED_BYTE: a.formatsize = 1; a.format = GL_UNSIGNED_BYTE; break;
+ case 'b': case GL_BYTE: a.formatsize = 1; a.format = GL_BYTE; break;
+ case 'S': case GL_UNSIGNED_SHORT: a.formatsize = 2; a.format = GL_UNSIGNED_SHORT; break;
+ case 's': case GL_SHORT: a.formatsize = 2; a.format = GL_SHORT; break;
+ case 'I': case GL_UNSIGNED_INT: a.formatsize = 4; a.format = GL_UNSIGNED_INT; break;
+ case 'i': case GL_INT: a.formatsize = 4; a.format = GL_INT; break;
+ case 'f': case GL_FLOAT: a.formatsize = 4; a.format = GL_FLOAT; break;
+ case 'd': case GL_DOUBLE: a.formatsize = 8; a.format = GL_DOUBLE; break;
+ default: a.formatsize = 0; a.format = GL_FALSE; break;
+ }
+ a.formatsize *= size;
+ a.offset = vertexsize;
+ vertexsize += a.formatsize;
+ }
+
+ void defattribs(const char *fmt)
+ {
+ for(;; fmt += 3)
+ {
+ GLenum format;
+ switch(fmt[0])
+ {
+ case 'v': format = ATTRIB_VERTEX; break;
+ case 'c': format = ATTRIB_COLOR; break;
+ case 't': format = ATTRIB_TEXCOORD0; break;
+ case 'T': format = ATTRIB_TEXCOORD1; break;
+ case 'n': format = ATTRIB_NORMAL; break;
+ case 'x': format = ATTRIB_TANGENT; break;
+ case 'w': format = ATTRIB_BONEWEIGHT; break;
+ case 'i': format = ATTRIB_BONEINDEX; break;
+ default: return;
+ }
+ defattrib(format, fmt[1]-'0', fmt[2]);
+ }
+ }
+
+ static inline void setattrib(const attribinfo &a, uchar *buf)
+ {
+ switch(a.type)
+ {
+ case ATTRIB_VERTEX:
+ case ATTRIB_TEXCOORD0:
+ case ATTRIB_TEXCOORD1:
+ case ATTRIB_BONEINDEX:
+ glVertexAttribPointer_(a.type, a.size, a.format, GL_FALSE, vertexsize, buf);
+ break;
+ case ATTRIB_COLOR:
+ case ATTRIB_NORMAL:
+ case ATTRIB_TANGENT:
+ case ATTRIB_BONEWEIGHT:
+ glVertexAttribPointer_(a.type, a.size, a.format, GL_TRUE, vertexsize, buf);
+ break;
+ }
+ if(!(enabled&(1<<a.type)))
+ {
+ glEnableVertexAttribArray_(a.type);
+ enabled |= 1<<a.type;
+ }
+ }
+
+ static inline void unsetattrib(const attribinfo &a)
+ {
+ glDisableVertexAttribArray_(a.type);
+ enabled &= ~(1<<a.type);
+ }
+
+ static inline void setattribs(uchar *buf)
+ {
+ bool forceattribs = numattribs != numlastattribs || vertexsize != lastvertexsize || buf != lastbuf;
+ if(forceattribs || changedattribs)
+ {
+ int diffmask = enabled & lastattribmask & ~attribmask;
+ if(diffmask) loopi(numlastattribs)
+ {
+ const attribinfo &a = lastattribs[i];
+ if(diffmask & (1<<a.type)) unsetattrib(a);
+ }
+ uchar *src = buf;
+ loopi(numattribs)
+ {
+ const attribinfo &a = attribdefs[i];
+ if(forceattribs || a != lastattribs[i])
+ {
+ setattrib(a, src);
+ lastattribs[i] = a;
+ }
+ src += a.formatsize;
+ }
+ lastbuf = buf;
+ numlastattribs = numattribs;
+ lastattribmask = attribmask;
+ lastvertexsize = vertexsize;
+ changedattribs = false;
+ }
+ }
+
+ void begin(GLenum mode)
+ {
+ primtype = mode;
+ }
+
+ void begin(GLenum mode, int numverts)
+ {
+ primtype = mode;
+ if(glversion >= 300 && !intel_mapbufferrange_bug)
+ {
+ int len = numverts * vertexsize;
+ if(vbooffset + len >= MAXVBOSIZE)
+ {
+ len = min(len, MAXVBOSIZE);
+ if(!vbo) glGenBuffers_(1, &vbo);
+ glBindBuffer_(GL_ARRAY_BUFFER, vbo);
+ glBufferData_(GL_ARRAY_BUFFER, MAXVBOSIZE, NULL, GL_STREAM_DRAW);
+ vbooffset = 0;
+ }
+ else if(!lastvertexsize) glBindBuffer_(GL_ARRAY_BUFFER, vbo);
+ void *buf = glMapBufferRange_(GL_ARRAY_BUFFER, vbooffset, len, GL_MAP_WRITE_BIT|GL_MAP_INVALIDATE_RANGE_BIT|GL_MAP_UNSYNCHRONIZED_BIT);
+ if(buf) attribbuf.reset((uchar *)buf, len);
+ }
+ }
+
+ void multidraw()
+ {
+ int start = multidrawstart.length() ? multidrawstart.last() + multidrawcount.last() : 0,
+ count = attribbuf.length()/vertexsize - start;
+ if(count > 0)
+ {
+ multidrawstart.add(start);
+ multidrawcount.add(count);
+ }
+ }
+
+ int end()
+ {
+ uchar *buf = attribbuf.getbuf();
+ if(attribbuf.empty())
+ {
+ if(buf != attribdata)
+ {
+ glUnmapBuffer_(GL_ARRAY_BUFFER);
+ attribbuf.reset(attribdata, MAXVBOSIZE);
+ }
+ return 0;
+ }
+ int start = 0;
+ if(glversion >= 300)
+ {
+ if(buf == attribdata)
+ {
+ if(vbooffset + attribbuf.length() >= MAXVBOSIZE)
+ {
+ if(!vbo) glGenBuffers_(1, &vbo);
+ glBindBuffer_(GL_ARRAY_BUFFER, vbo);
+ glBufferData_(GL_ARRAY_BUFFER, MAXVBOSIZE, NULL, GL_STREAM_DRAW);
+ vbooffset = 0;
+ }
+ else if(!lastvertexsize) glBindBuffer_(GL_ARRAY_BUFFER, vbo);
+ void *dst = intel_mapbufferrange_bug ? NULL :
+ glMapBufferRange_(GL_ARRAY_BUFFER, vbooffset, attribbuf.length(), GL_MAP_WRITE_BIT|GL_MAP_INVALIDATE_RANGE_BIT|GL_MAP_UNSYNCHRONIZED_BIT);
+ if(dst)
+ {
+ memcpy(dst, attribbuf.getbuf(), attribbuf.length());
+ glUnmapBuffer_(GL_ARRAY_BUFFER);
+ }
+ else glBufferSubData_(GL_ARRAY_BUFFER, vbooffset, attribbuf.length(), attribbuf.getbuf());
+ }
+ else glUnmapBuffer_(GL_ARRAY_BUFFER);
+ buf = (uchar *)0 + vbooffset;
+ if(vertexsize == lastvertexsize && buf >= lastbuf)
+ {
+ start = int(buf - lastbuf)/vertexsize;
+ if(primtype == GL_QUADS && (start%4 || start + attribbuf.length()/vertexsize >= 4*MAXQUADS))
+ start = 0;
+ else buf = lastbuf;
+ }
+ vbooffset += attribbuf.length();
+ }
+ setattribs(buf);
+ int numvertexes = attribbuf.length()/vertexsize;
+ if(primtype == GL_QUADS)
+ {
+ if(!quadsenabled) enablequads();
+ for(int quads = numvertexes/4;;)
+ {
+ int count = min(quads, MAXQUADS);
+ drawquads(start/4, count);
+ quads -= count;
+ if(quads <= 0) break;
+ setattribs(buf + 4*count*vertexsize);
+ start = 0;
+ }
+ }
+ else
+ {
+ if(multidrawstart.length())
+ {
+ multidraw();
+ if(start) loopv(multidrawstart) multidrawstart[i] += start;
+ glMultiDrawArrays_(primtype, multidrawstart.getbuf(), multidrawcount.getbuf(), multidrawstart.length());
+ multidrawstart.setsize(0);
+ multidrawcount.setsize(0);
+ }
+ else glDrawArrays(primtype, start, numvertexes);
+ }
+ attribbuf.reset(attribdata, MAXVBOSIZE);
+ return numvertexes;
+ }
+
+ void forcedisable()
+ {
+ for(int i = 0; enabled; i++) if(enabled&(1<<i)) { glDisableVertexAttribArray_(i); enabled &= ~(1<<i); }
+ numlastattribs = lastattribmask = lastvertexsize = 0;
+ lastbuf = NULL;
+ if(quadsenabled) disablequads();
+ if(glversion >= 300) glBindBuffer_(GL_ARRAY_BUFFER, 0);
+ }
+
+ void setup()
+ {
+ if(glversion >= 300)
+ {
+ if(!defaultvao) glGenVertexArrays_(1, &defaultvao);
+ glBindVertexArray_(defaultvao);
+ }
+ attribdata = new uchar[MAXVBOSIZE];
+ attribbuf.reset(attribdata, MAXVBOSIZE);
+ }
+
+ void cleanup()
+ {
+ disable();
+
+ if(quadindexes) { glDeleteBuffers_(1, &quadindexes); quadindexes = 0; }
+
+ if(vbo) { glDeleteBuffers_(1, &vbo); vbo = 0; }
+ vbooffset = MAXVBOSIZE;
+
+ if(defaultvao) { glDeleteVertexArrays_(1, &defaultvao); defaultvao = 0; }
+ }
+}
+
diff --git a/src/shared/glemu.h b/src/shared/glemu.h
new file mode 100644
index 0000000..94af8f9
--- /dev/null
+++ b/src/shared/glemu.h
@@ -0,0 +1,180 @@
+namespace gle
+{
+ enum
+ {
+ ATTRIB_VERTEX = 0,
+ ATTRIB_COLOR = 1,
+ ATTRIB_TEXCOORD0 = 2,
+ ATTRIB_TEXCOORD1 = 3,
+ ATTRIB_NORMAL = 4,
+ ATTRIB_TANGENT = 5,
+ ATTRIB_BONEWEIGHT = 6,
+ ATTRIB_BONEINDEX = 7,
+ MAXATTRIBS = 8
+ };
+
+ extern const char * const attribnames[MAXATTRIBS];
+ extern ucharbuf attribbuf;
+
+ extern int enabled;
+ extern void forcedisable();
+ static inline void disable() { if(enabled) forcedisable(); }
+
+ extern void begin(GLenum mode);
+ extern void begin(GLenum mode, int numverts);
+ extern void defattribs(const char *fmt);
+ extern void defattrib(int type, int size, int format);
+
+ #define GLE_DEFATTRIB(name, type, defaultsize, defaultformat) \
+ static inline void def##name(int size = defaultsize, int format = defaultformat) { defattrib(type, size, format); }
+
+ GLE_DEFATTRIB(vertex, ATTRIB_VERTEX, 3, GL_FLOAT)
+ GLE_DEFATTRIB(color, ATTRIB_COLOR, 3, GL_FLOAT)
+ GLE_DEFATTRIB(texcoord0, ATTRIB_TEXCOORD0, 2, GL_FLOAT)
+ GLE_DEFATTRIB(texcoord1, ATTRIB_TEXCOORD1, 2, GL_FLOAT)
+ GLE_DEFATTRIB(normal, ATTRIB_NORMAL, 3, GL_FLOAT)
+ GLE_DEFATTRIB(tangent, ATTRIB_TANGENT, 4, GL_FLOAT)
+ GLE_DEFATTRIB(boneweight, ATTRIB_BONEWEIGHT, 4, GL_UNSIGNED_BYTE)
+ GLE_DEFATTRIB(boneindex, ATTRIB_BONEINDEX, 4, GL_UNSIGNED_BYTE)
+
+ #define GLE_INITATTRIB(name, index, suffix, type) \
+ static inline void name##suffix(type x) { glVertexAttrib1##suffix##_(index, x); } \
+ static inline void name##suffix(type x, type y) { glVertexAttrib2##suffix##_(index, x, y); } \
+ static inline void name##suffix(type x, type y, type z) { glVertexAttrib3##suffix##_(index, x, y, z); } \
+ static inline void name##suffix(type x, type y, type z, type w) { glVertexAttrib4##suffix##_(index, x, y, z, w); }
+ #define GLE_INITATTRIBF(name, index) \
+ GLE_INITATTRIB(name, index, f, float) \
+ static inline void name(const vec &v) { glVertexAttrib3fv_(index, v.v); } \
+ static inline void name(const vec &v, float w) { glVertexAttrib4f_(index, v.x, v.y, v.z, w); } \
+ static inline void name(const vec2 &v) { glVertexAttrib2fv_(index, v.v); } \
+ static inline void name(const vec4 &v) { glVertexAttrib4fv_(index, v.v); }
+ #define GLE_INITATTRIBN(name, index, suffix, type, defaultw) \
+ static inline void name##suffix(type x, type y, type z, type w = defaultw) { glVertexAttrib4N##suffix##_(index, x, y, z, w); }
+
+ GLE_INITATTRIBF(vertex, ATTRIB_VERTEX)
+ GLE_INITATTRIBF(color, ATTRIB_COLOR)
+ static inline void color(const bvec4 &v) { glVertexAttrib4Nubv_(ATTRIB_COLOR, v.v); }
+ static inline void color(const bvec &v, uchar alpha = 255) { color(bvec4(v, alpha)); }
+ static inline void colorub(uchar x, uchar y, uchar z, uchar w = 255) { color(bvec4(x, y, z, w)); }
+ GLE_INITATTRIBF(texcoord0, ATTRIB_TEXCOORD0)
+ GLE_INITATTRIBF(texcoord1, ATTRIB_TEXCOORD1)
+ static inline void normal(float x, float y, float z) { glVertexAttrib4f_(ATTRIB_NORMAL, x, y, z, 0.0f); }
+ static inline void normal(const vec &v) { glVertexAttrib4f_(ATTRIB_NORMAL, v.x, v.y, v.z, 0.0f); }
+ static inline void tangent(float x, float y, float z, float w = 1.0f) { glVertexAttrib4f_(ATTRIB_TANGENT, x, y, z, w); }
+ static inline void tangent(const vec &v, float w = 1.0f) { glVertexAttrib4f_(ATTRIB_TANGENT, v.x, v.y, v.z, w); }
+ static inline void tangent(const vec4 &v) { glVertexAttrib4fv_(ATTRIB_TANGENT, v.v); }
+
+ #define GLE_ATTRIBPOINTER(name, index, defaultnormalized, defaultsize, defaulttype, prepare) \
+ static inline void enable##name() { prepare; glEnableVertexAttribArray_(index); } \
+ static inline void disable##name() { glDisableVertexAttribArray_(index); } \
+ static inline void name##pointer(int stride, const void *data, GLenum type = defaulttype, int size = defaultsize, GLenum normalized = defaultnormalized) { \
+ prepare; \
+ glVertexAttribPointer_(index, size, type, normalized, stride, data); \
+ }
+
+ static inline void enableattrib(int index) { disable(); glEnableVertexAttribArray_(index); }
+ static inline void disableattrib(int index) { glDisableVertexAttribArray_(index); }
+ GLE_ATTRIBPOINTER(vertex, ATTRIB_VERTEX, GL_FALSE, 3, GL_FLOAT, disable())
+ GLE_ATTRIBPOINTER(color, ATTRIB_COLOR, GL_TRUE, 4, GL_UNSIGNED_BYTE, )
+ GLE_ATTRIBPOINTER(texcoord0, ATTRIB_TEXCOORD0, GL_FALSE, 2, GL_FLOAT, )
+ GLE_ATTRIBPOINTER(texcoord1, ATTRIB_TEXCOORD1, GL_FALSE, 2, GL_FLOAT, )
+ GLE_ATTRIBPOINTER(normal, ATTRIB_NORMAL, GL_TRUE, 3, GL_FLOAT, )
+ GLE_ATTRIBPOINTER(tangent, ATTRIB_TANGENT, GL_TRUE, 4, GL_FLOAT, )
+ GLE_ATTRIBPOINTER(boneweight, ATTRIB_BONEWEIGHT, GL_TRUE, 4, GL_UNSIGNED_BYTE, )
+ GLE_ATTRIBPOINTER(boneindex, ATTRIB_BONEINDEX, GL_FALSE, 4, GL_UNSIGNED_BYTE, )
+
+ static inline void bindebo(GLuint ebo) { disable(); glBindBuffer_(GL_ELEMENT_ARRAY_BUFFER, ebo); }
+ static inline void clearebo() { glBindBuffer_(GL_ELEMENT_ARRAY_BUFFER, 0); }
+ static inline void bindvbo(GLuint vbo) { disable(); glBindBuffer_(GL_ARRAY_BUFFER, vbo); }
+ static inline void clearvbo() { glBindBuffer_(GL_ARRAY_BUFFER, 0); }
+
+ template<class T>
+ static inline void attrib(T x)
+ {
+ if(attribbuf.check(sizeof(T)))
+ {
+ T *buf = (T *)attribbuf.pad(sizeof(T));
+ buf[0] = x;
+ }
+ }
+
+ template<class T>
+ static inline void attrib(T x, T y)
+ {
+ if(attribbuf.check(2*sizeof(T)))
+ {
+ T *buf = (T *)attribbuf.pad(2*sizeof(T));
+ buf[0] = x;
+ buf[1] = y;
+ }
+ }
+
+ template<class T>
+ static inline void attrib(T x, T y, T z)
+ {
+ if(attribbuf.check(3*sizeof(T)))
+ {
+ T *buf = (T *)attribbuf.pad(3*sizeof(T));
+ buf[0] = x;
+ buf[1] = y;
+ buf[2] = z;
+ }
+ }
+
+ template<class T>
+ static inline void attrib(T x, T y, T z, T w)
+ {
+ if(attribbuf.check(4*sizeof(T)))
+ {
+ T *buf = (T *)attribbuf.pad(4*sizeof(T));
+ buf[0] = x;
+ buf[1] = y;
+ buf[2] = z;
+ buf[3] = w;
+ }
+ }
+
+ template<size_t N, class T>
+ static inline void attribv(const T *v)
+ {
+ attribbuf.put((const uchar *)v, N*sizeof(T));
+ }
+
+ #define GLE_ATTRIB(suffix, type) \
+ static inline void attrib##suffix(type x) { attrib<type>(x); } \
+ static inline void attrib##suffix(type x, type y) { attrib<type>(x, y); } \
+ static inline void attrib##suffix(type x, type y, type z) { attrib<type>(x, y, z); } \
+ static inline void attrib##suffix(type x, type y, type z, type w) { attrib<type>(x, y, z, w); }
+
+ GLE_ATTRIB(f, float)
+ GLE_ATTRIB(d, double)
+ GLE_ATTRIB(b, char)
+ GLE_ATTRIB(ub, uchar)
+ GLE_ATTRIB(s, short)
+ GLE_ATTRIB(us, ushort)
+ GLE_ATTRIB(i, int)
+ GLE_ATTRIB(ui, uint)
+
+ static inline void attrib(const vec &v) { attribf(v.x, v.y, v.z); }
+ static inline void attrib(const vec &v, float w) { attribf(v.x, v.y, v.z, w); }
+ static inline void attrib(const vec2 &v) { attribf(v.x, v.y); }
+ static inline void attrib(const vec4 &v) { attribf(v.x, v.y, v.z, v.w); }
+ static inline void attrib(const ivec &v) { attribi(v.x, v.y, v.z); }
+ static inline void attrib(const ivec &v, int w) { attribi(v.x, v.y, v.z, w); }
+ static inline void attrib(const ivec2 &v) { attribi(v.x, v.y); }
+ static inline void attrib(const ivec4 &v) { attribi(v.x, v.y, v.z, v.w); }
+ static inline void attrib(const bvec &b) { attribub(b.x, b.y, b.z); }
+ static inline void attrib(const bvec &b, uchar w) { attribub(b.x, b.y, b.z, w); }
+ static inline void attrib(const bvec4 &b) { attribub(b.x, b.y, b.z, b.w); }
+
+ extern void multidraw();
+ extern int end();
+
+ extern void enablequads();
+ extern void disablequads();
+ extern void drawquads(int offset, int count);
+
+ extern void setup();
+ extern void cleanup();
+}
+
diff --git a/src/shared/glexts.h b/src/shared/glexts.h
new file mode 100644
index 0000000..59509c1
--- /dev/null
+++ b/src/shared/glexts.h
@@ -0,0 +1,488 @@
+#ifndef APIENTRY
+#define APIENTRY
+#endif
+#ifndef APIENTRYP
+#define APIENTRYP APIENTRY *
+#endif
+
+// OpenGL deprecated functionality
+#ifndef GL_QUADS
+#define GL_QUADS 0x0007
+#endif
+
+#ifndef GL_ALPHA
+#define GL_ALPHA 0x1906
+#endif
+#ifndef GL_ALPHA8
+#define GL_ALPHA8 0x803C
+#endif
+#ifndef GL_ALPHA16
+#define GL_ALPHA16 0x803E
+#endif
+#ifndef GL_COMPRESSED_ALPHA
+#define GL_COMPRESSED_ALPHA 0x84E9
+#endif
+
+#ifndef GL_LUMINANCE
+#define GL_LUMINANCE 0x1909
+#endif
+#ifndef GL_LUMINANCE8
+#define GL_LUMINANCE8 0x8040
+#endif
+#ifndef GL_LUMINANCE16
+#define GL_LUMINANCE16 0x8042
+#endif
+#ifndef GL_COMPRESSED_LUMINANCE
+#define GL_COMPRESSED_LUMINANCE 0x84EA
+#endif
+
+#ifndef GL_LUMINANCE_ALPHA
+#define GL_LUMINANCE_ALPHA 0x190A
+#endif
+#ifndef GL_LUMINANCE8_ALPHA8
+#define GL_LUMINANCE8_ALPHA8 0x8045
+#endif
+#ifndef GL_LUMINANCE16_ALPHA16
+#define GL_LUMINANCE16_ALPHA16 0x8048
+#endif
+#ifndef GL_COMPRESSED_LUMINANCE_ALPHA
+#define GL_COMPRESSED_LUMINANCE_ALPHA 0x84EB
+#endif
+
+// OpenGL 1.3
+#ifndef WIN32
+#define glActiveTexture_ glActiveTexture
+
+#define glBlendEquation_ glBlendEquation
+#define glBlendColor_ glBlendColor
+
+#define glTexImage3D_ glTexImage3D
+#define glTexSubImage3D_ glTexSubImage3D
+#define glCopyTexSubImage3D_ glCopyTexSubImage3D
+
+#define glCompressedTexImage3D_ glCompressedTexImage3D
+#define glCompressedTexImage2D_ glCompressedTexImage2D
+#define glCompressedTexSubImage3D_ glCompressedTexSubImage3D
+#define glCompressedTexSubImage2D_ glCompressedTexSubImage2D
+#define glGetCompressedTexImage_ glGetCompressedTexImage
+
+#define glDrawRangeElements_ glDrawRangeElements
+#else
+extern PFNGLACTIVETEXTUREPROC glActiveTexture_;
+
+extern PFNGLBLENDEQUATIONPROC glBlendEquation_;
+extern PFNGLBLENDCOLORPROC glBlendColor_;
+
+extern PFNGLTEXIMAGE3DPROC glTexImage3D_;
+extern PFNGLTEXSUBIMAGE3DPROC glTexSubImage3D_;
+extern PFNGLCOPYTEXSUBIMAGE3DPROC glCopyTexSubImage3D_;
+
+extern PFNGLCOMPRESSEDTEXIMAGE3DPROC glCompressedTexImage3D_;
+extern PFNGLCOMPRESSEDTEXIMAGE2DPROC glCompressedTexImage2D_;
+extern PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glCompressedTexSubImage3D_;
+extern PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glCompressedTexSubImage2D_;
+extern PFNGLGETCOMPRESSEDTEXIMAGEPROC glGetCompressedTexImage_;
+
+extern PFNGLDRAWRANGEELEMENTSPROC glDrawRangeElements_;
+#endif
+
+// OpenGL 2.0
+#ifdef __APPLE__
+#define glMultiDrawArrays_ glMultiDrawArrays
+#define glMultiDrawElements_ glMultiDrawElements
+
+#define glBlendFuncSeparate_ glBlendFuncSeparate
+#define glBlendEquationSeparate_ glBlendEquationSeparate
+#define glStencilOpSeparate_ glStencilOpSeparate
+#define glStencilFuncSeparate_ glStencilFuncSeparate
+#define glStencilMaskSeparate_ glStencilMaskSeparate
+
+#define glGenBuffers_ glGenBuffers
+#define glBindBuffer_ glBindBuffer
+#define glMapBuffer_ glMapBuffer
+#define glUnmapBuffer_ glUnmapBuffer
+#define glBufferData_ glBufferData
+#define glBufferSubData_ glBufferSubData
+#define glDeleteBuffers_ glDeleteBuffers
+#define glGetBufferSubData_ glGetBufferSubData
+
+#define glGenQueries_ glGenQueries
+#define glDeleteQueries_ glDeleteQueries
+#define glBeginQuery_ glBeginQuery
+#define glEndQuery_ glEndQuery
+#define glGetQueryiv_ glGetQueryiv
+#define glGetQueryObjectiv_ glGetQueryObjectiv
+#define glGetQueryObjectuiv_ glGetQueryObjectuiv
+
+#define glCreateProgram_ glCreateProgram
+#define glDeleteProgram_ glDeleteProgram
+#define glUseProgram_ glUseProgram
+#define glCreateShader_ glCreateShader
+#define glDeleteShader_ glDeleteShader
+#define glShaderSource_ glShaderSource
+#define glCompileShader_ glCompileShader
+#define glGetShaderiv_ glGetShaderiv
+#define glGetProgramiv_ glGetProgramiv
+#define glAttachShader_ glAttachShader
+#define glGetProgramInfoLog_ glGetProgramInfoLog
+#define glGetShaderInfoLog_ glGetShaderInfoLog
+#define glLinkProgram_ glLinkProgram
+#define glGetUniformLocation_ glGetUniformLocation
+#define glUniform1f_ glUniform1f
+#define glUniform2f_ glUniform2f
+#define glUniform3f_ glUniform3f
+#define glUniform4f_ glUniform4f
+#define glUniform1fv_ glUniform1fv
+#define glUniform2fv_ glUniform2fv
+#define glUniform3fv_ glUniform3fv
+#define glUniform4fv_ glUniform4fv
+#define glUniform1i_ glUniform1i
+#define glUniform2i_ glUniform2i
+#define glUniform3i_ glUniform3i
+#define glUniform4i_ glUniform4i
+#define glUniform1iv_ glUniform1iv
+#define glUniform2iv_ glUniform2iv
+#define glUniform3iv_ glUniform3iv
+#define glUniform4iv_ glUniform4iv
+#define glUniformMatrix2fv_ glUniformMatrix2fv
+#define glUniformMatrix3fv_ glUniformMatrix3fv
+#define glUniformMatrix4fv_ glUniformMatrix4fv
+#define glBindAttribLocation_ glBindAttribLocation
+#define glGetActiveUniform_ glGetActiveUniform
+#define glEnableVertexAttribArray_ glEnableVertexAttribArray
+#define glDisableVertexAttribArray_ glDisableVertexAttribArray
+
+#define glVertexAttrib1f_ glVertexAttrib1f
+#define glVertexAttrib1fv_ glVertexAttrib1fv
+#define glVertexAttrib1s_ glVertexAttrib1s
+#define glVertexAttrib1sv_ glVertexAttrib1sv
+#define glVertexAttrib2f_ glVertexAttrib2f
+#define glVertexAttrib2fv_ glVertexAttrib2fv
+#define glVertexAttrib2s_ glVertexAttrib2s
+#define glVertexAttrib2sv_ glVertexAttrib2sv
+#define glVertexAttrib3f_ glVertexAttrib3f
+#define glVertexAttrib3fv_ glVertexAttrib3fv
+#define glVertexAttrib3s_ glVertexAttrib3s
+#define glVertexAttrib3sv_ glVertexAttrib3sv
+#define glVertexAttrib4f_ glVertexAttrib4f
+#define glVertexAttrib4fv_ glVertexAttrib4fv
+#define glVertexAttrib4s_ glVertexAttrib4s
+#define glVertexAttrib4sv_ glVertexAttrib4sv
+#define glVertexAttrib4bv_ glVertexAttrib4bv
+#define glVertexAttrib4iv_ glVertexAttrib4iv
+#define glVertexAttrib4ubv_ glVertexAttrib4ubv
+#define glVertexAttrib4uiv_ glVertexAttrib4uiv
+#define glVertexAttrib4usv_ glVertexAttrib4usv
+#define glVertexAttrib4Nbv_ glVertexAttrib4Nbv
+#define glVertexAttrib4Niv_ glVertexAttrib4Niv
+#define glVertexAttrib4Nub_ glVertexAttrib4Nub
+#define glVertexAttrib4Nubv_ glVertexAttrib4Nubv
+#define glVertexAttrib4Nuiv_ glVertexAttrib4Nuiv
+#define glVertexAttrib4Nusv_ glVertexAttrib4Nusv
+#define glVertexAttribPointer_ glVertexAttribPointer
+
+#define glDrawBuffers_ glDrawBuffers
+#else
+extern PFNGLMULTIDRAWARRAYSPROC glMultiDrawArrays_;
+extern PFNGLMULTIDRAWELEMENTSPROC glMultiDrawElements_;
+
+extern PFNGLBLENDFUNCSEPARATEPROC glBlendFuncSeparate_;
+extern PFNGLBLENDEQUATIONSEPARATEPROC glBlendEquationSeparate_;
+extern PFNGLSTENCILOPSEPARATEPROC glStencilOpSeparate_;
+extern PFNGLSTENCILFUNCSEPARATEPROC glStencilFuncSeparate_;
+extern PFNGLSTENCILMASKSEPARATEPROC glStencilMaskSeparate_;
+
+extern PFNGLGENBUFFERSPROC glGenBuffers_;
+extern PFNGLBINDBUFFERPROC glBindBuffer_;
+extern PFNGLMAPBUFFERPROC glMapBuffer_;
+extern PFNGLUNMAPBUFFERPROC glUnmapBuffer_;
+extern PFNGLBUFFERDATAPROC glBufferData_;
+extern PFNGLBUFFERSUBDATAPROC glBufferSubData_;
+extern PFNGLDELETEBUFFERSPROC glDeleteBuffers_;
+extern PFNGLGETBUFFERSUBDATAPROC glGetBufferSubData_;
+
+extern PFNGLGENQUERIESPROC glGenQueries_;
+extern PFNGLDELETEQUERIESPROC glDeleteQueries_;
+extern PFNGLBEGINQUERYPROC glBeginQuery_;
+extern PFNGLENDQUERYPROC glEndQuery_;
+extern PFNGLGETQUERYIVPROC glGetQueryiv_;
+extern PFNGLGETQUERYOBJECTIVPROC glGetQueryObjectiv_;
+extern PFNGLGETQUERYOBJECTUIVPROC glGetQueryObjectuiv_;
+
+extern PFNGLCREATEPROGRAMPROC glCreateProgram_;
+extern PFNGLDELETEPROGRAMPROC glDeleteProgram_;
+extern PFNGLUSEPROGRAMPROC glUseProgram_;
+extern PFNGLCREATESHADERPROC glCreateShader_;
+extern PFNGLDELETESHADERPROC glDeleteShader_;
+extern PFNGLSHADERSOURCEPROC glShaderSource_;
+extern PFNGLCOMPILESHADERPROC glCompileShader_;
+extern PFNGLGETSHADERIVPROC glGetShaderiv_;
+extern PFNGLGETPROGRAMIVPROC glGetProgramiv_;
+extern PFNGLATTACHSHADERPROC glAttachShader_;
+extern PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog_;
+extern PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog_;
+extern PFNGLLINKPROGRAMPROC glLinkProgram_;
+extern PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation_;
+extern PFNGLUNIFORM1FPROC glUniform1f_;
+extern PFNGLUNIFORM2FPROC glUniform2f_;
+extern PFNGLUNIFORM3FPROC glUniform3f_;
+extern PFNGLUNIFORM4FPROC glUniform4f_;
+extern PFNGLUNIFORM1FVPROC glUniform1fv_;
+extern PFNGLUNIFORM2FVPROC glUniform2fv_;
+extern PFNGLUNIFORM3FVPROC glUniform3fv_;
+extern PFNGLUNIFORM4FVPROC glUniform4fv_;
+extern PFNGLUNIFORM1IPROC glUniform1i_;
+extern PFNGLUNIFORM2IPROC glUniform2i_;
+extern PFNGLUNIFORM3IPROC glUniform3i_;
+extern PFNGLUNIFORM4IPROC glUniform4i_;
+extern PFNGLUNIFORM1IVPROC glUniform1iv_;
+extern PFNGLUNIFORM2IVPROC glUniform2iv_;
+extern PFNGLUNIFORM3IVPROC glUniform3iv_;
+extern PFNGLUNIFORM4IVPROC glUniform4iv_;
+extern PFNGLUNIFORMMATRIX2FVPROC glUniformMatrix2fv_;
+extern PFNGLUNIFORMMATRIX3FVPROC glUniformMatrix3fv_;
+extern PFNGLUNIFORMMATRIX4FVPROC glUniformMatrix4fv_;
+extern PFNGLBINDATTRIBLOCATIONPROC glBindAttribLocation_;
+extern PFNGLGETACTIVEUNIFORMPROC glGetActiveUniform_;
+extern PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray_;
+extern PFNGLDISABLEVERTEXATTRIBARRAYPROC glDisableVertexAttribArray_;
+
+extern PFNGLVERTEXATTRIB1FPROC glVertexAttrib1f_;
+extern PFNGLVERTEXATTRIB1FVPROC glVertexAttrib1fv_;
+extern PFNGLVERTEXATTRIB1SPROC glVertexAttrib1s_;
+extern PFNGLVERTEXATTRIB1SVPROC glVertexAttrib1sv_;
+extern PFNGLVERTEXATTRIB2FPROC glVertexAttrib2f_;
+extern PFNGLVERTEXATTRIB2FVPROC glVertexAttrib2fv_;
+extern PFNGLVERTEXATTRIB2SPROC glVertexAttrib2s_;
+extern PFNGLVERTEXATTRIB2SVPROC glVertexAttrib2sv_;
+extern PFNGLVERTEXATTRIB3FPROC glVertexAttrib3f_;
+extern PFNGLVERTEXATTRIB3FVPROC glVertexAttrib3fv_;
+extern PFNGLVERTEXATTRIB3SPROC glVertexAttrib3s_;
+extern PFNGLVERTEXATTRIB3SVPROC glVertexAttrib3sv_;
+extern PFNGLVERTEXATTRIB4FPROC glVertexAttrib4f_;
+extern PFNGLVERTEXATTRIB4FVPROC glVertexAttrib4fv_;
+extern PFNGLVERTEXATTRIB4SPROC glVertexAttrib4s_;
+extern PFNGLVERTEXATTRIB4SVPROC glVertexAttrib4sv_;
+extern PFNGLVERTEXATTRIB4BVPROC glVertexAttrib4bv_;
+extern PFNGLVERTEXATTRIB4IVPROC glVertexAttrib4iv_;
+extern PFNGLVERTEXATTRIB4UBVPROC glVertexAttrib4ubv_;
+extern PFNGLVERTEXATTRIB4UIVPROC glVertexAttrib4uiv_;
+extern PFNGLVERTEXATTRIB4USVPROC glVertexAttrib4usv_;
+extern PFNGLVERTEXATTRIB4NBVPROC glVertexAttrib4Nbv_;
+extern PFNGLVERTEXATTRIB4NIVPROC glVertexAttrib4Niv_;
+extern PFNGLVERTEXATTRIB4NUBPROC glVertexAttrib4Nub_;
+extern PFNGLVERTEXATTRIB4NUBVPROC glVertexAttrib4Nubv_;
+extern PFNGLVERTEXATTRIB4NUIVPROC glVertexAttrib4Nuiv_;
+extern PFNGLVERTEXATTRIB4NUSVPROC glVertexAttrib4Nusv_;
+extern PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer_;
+
+extern PFNGLDRAWBUFFERSPROC glDrawBuffers_;
+#endif
+
+#ifndef GL_VERSION_2_1
+#define GL_VERSION_2_1 1
+#define GL_PIXEL_PACK_BUFFER 0x88EB
+#define GL_PIXEL_UNPACK_BUFFER 0x88EC
+#endif
+
+#ifndef GL_EXT_texture_filter_anisotropic
+#define GL_EXT_texture_filter_anisotropic 1
+#define GL_TEXTURE_MAX_ANISOTROPY_EXT 0x84FE
+#define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF
+#endif
+
+#ifndef GL_EXT_texture_compression_s3tc
+#define GL_EXT_texture_compression_s3tc 1
+#define GL_COMPRESSED_RGB_S3TC_DXT1_EXT 0x83F0
+#define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT 0x83F1
+#define GL_COMPRESSED_RGBA_S3TC_DXT3_EXT 0x83F2
+#define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT 0x83F3
+#endif
+
+#ifndef GL_ARB_framebuffer_object
+#define GL_ARB_framebuffer_object 1
+#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A
+#define GL_DEPTH_STENCIL 0x84F9
+#define GL_UNSIGNED_INT_24_8 0x84FA
+#define GL_DEPTH24_STENCIL8 0x88F0
+#define GL_FRAMEBUFFER_BINDING 0x8CA6
+#define GL_READ_FRAMEBUFFER 0x8CA8
+#define GL_DRAW_FRAMEBUFFER 0x8CA9
+#define GL_FRAMEBUFFER_COMPLETE 0x8CD5
+#define GL_COLOR_ATTACHMENT0 0x8CE0
+#define GL_COLOR_ATTACHMENT1 0x8CE1
+#define GL_DEPTH_ATTACHMENT 0x8D00
+#define GL_STENCIL_ATTACHMENT 0x8D20
+#define GL_FRAMEBUFFER 0x8D40
+#define GL_RENDERBUFFER 0x8D41
+typedef void (APIENTRYP PFNGLBINDRENDERBUFFERPROC) (GLenum target, GLuint renderbuffer);
+typedef void (APIENTRYP PFNGLDELETERENDERBUFFERSPROC) (GLsizei n, const GLuint *renderbuffers);
+typedef void (APIENTRYP PFNGLGENRENDERBUFFERSPROC) (GLsizei n, GLuint *renderbuffers);
+typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
+typedef void (APIENTRYP PFNGLBINDFRAMEBUFFERPROC) (GLenum target, GLuint framebuffer);
+typedef void (APIENTRYP PFNGLDELETEFRAMEBUFFERSPROC) (GLsizei n, const GLuint *framebuffers);
+typedef void (APIENTRYP PFNGLGENFRAMEBUFFERSPROC) (GLsizei n, GLuint *framebuffers);
+typedef GLenum (APIENTRYP PFNGLCHECKFRAMEBUFFERSTATUSPROC) (GLenum target);
+typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE2DPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+typedef void (APIENTRYP PFNGLFRAMEBUFFERRENDERBUFFERPROC) (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
+typedef void (APIENTRYP PFNGLGENERATEMIPMAPPROC) (GLenum target);
+typedef void (APIENTRYP PFNGLBLITFRAMEBUFFERPROC) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+#endif
+
+// GL_EXT_framebuffer_object
+extern PFNGLBINDRENDERBUFFERPROC glBindRenderbuffer_;
+extern PFNGLDELETERENDERBUFFERSPROC glDeleteRenderbuffers_;
+extern PFNGLGENFRAMEBUFFERSPROC glGenRenderbuffers_;
+extern PFNGLRENDERBUFFERSTORAGEPROC glRenderbufferStorage_;
+extern PFNGLCHECKFRAMEBUFFERSTATUSPROC glCheckFramebufferStatus_;
+extern PFNGLBINDFRAMEBUFFERPROC glBindFramebuffer_;
+extern PFNGLDELETEFRAMEBUFFERSPROC glDeleteFramebuffers_;
+extern PFNGLGENFRAMEBUFFERSPROC glGenFramebuffers_;
+extern PFNGLFRAMEBUFFERTEXTURE2DPROC glFramebufferTexture2D_;
+extern PFNGLFRAMEBUFFERRENDERBUFFERPROC glFramebufferRenderbuffer_;
+extern PFNGLGENERATEMIPMAPPROC glGenerateMipmap_;
+
+// GL_EXT_framebuffer_blit
+extern PFNGLBLITFRAMEBUFFERPROC glBlitFramebuffer_;
+
+#ifndef GL_ARB_texture_rg
+#define GL_ARB_texture_rg 1
+#define GL_RG 0x8227
+#define GL_R8 0x8229
+#define GL_R16 0x822A
+#define GL_RG8 0x822B
+#define GL_RG16 0x822C
+#define GL_R16F 0x822D
+#define GL_R32F 0x822E
+#define GL_RG16F 0x822F
+#define GL_RG32F 0x8230
+#endif
+
+#ifndef GL_EXT_texture_compression_latc
+#define GL_EXT_texture_compression_latc 1
+#define GL_COMPRESSED_LUMINANCE_LATC1_EXT 0x8C70
+#define GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT 0x8C72
+#endif
+
+#ifndef GL_ARB_texture_compression_rgtc
+#define GL_ARB_texture_compression_rgtc 1
+#define GL_COMPRESSED_RED_RGTC1 0x8DBB
+#define GL_COMPRESSED_RG_RGTC2 0x8DBD
+#endif
+
+#ifndef GL_ARB_map_buffer_range
+#define GL_ARB_map_buffer_range 1
+#define GL_MAP_READ_BIT 0x0001
+#define GL_MAP_WRITE_BIT 0x0002
+#define GL_MAP_INVALIDATE_RANGE_BIT 0x0004
+#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008
+#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010
+#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020
+typedef GLvoid* (APIENTRYP PFNGLMAPBUFFERRANGEPROC) (GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
+typedef void (APIENTRYP PFNGLFLUSHMAPPEDBUFFERRANGEPROC) (GLenum target, GLintptr offset, GLsizeiptr length);
+#endif
+extern PFNGLMAPBUFFERRANGEPROC glMapBufferRange_;
+extern PFNGLFLUSHMAPPEDBUFFERRANGEPROC glFlushMappedBufferRange_;
+
+#ifndef GL_ARB_uniform_buffer_object
+#define GL_ARB_uniform_buffer_object 1
+#define GL_UNIFORM_BUFFER 0x8A11
+#define GL_UNIFORM_BUFFER_BINDING 0x8A28
+#define GL_UNIFORM_BUFFER_START 0x8A29
+#define GL_UNIFORM_BUFFER_SIZE 0x8A2A
+#define GL_MAX_VERTEX_UNIFORM_BLOCKS 0x8A2B
+#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS 0x8A2C
+#define GL_MAX_FRAGMENT_UNIFORM_BLOCKS 0x8A2D
+#define GL_MAX_COMBINED_UNIFORM_BLOCKS 0x8A2E
+#define GL_MAX_UNIFORM_BUFFER_BINDINGS 0x8A2F
+#define GL_MAX_UNIFORM_BLOCK_SIZE 0x8A30
+#define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31
+#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS 0x8A32
+#define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33
+#define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34
+#define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35
+#define GL_ACTIVE_UNIFORM_BLOCKS 0x8A36
+#define GL_UNIFORM_TYPE 0x8A37
+#define GL_UNIFORM_SIZE 0x8A38
+#define GL_UNIFORM_NAME_LENGTH 0x8A39
+#define GL_UNIFORM_BLOCK_INDEX 0x8A3A
+#define GL_UNIFORM_OFFSET 0x8A3B
+#define GL_UNIFORM_ARRAY_STRIDE 0x8A3C
+#define GL_UNIFORM_MATRIX_STRIDE 0x8A3D
+#define GL_UNIFORM_IS_ROW_MAJOR 0x8A3E
+#define GL_UNIFORM_BLOCK_BINDING 0x8A3F
+#define GL_UNIFORM_BLOCK_DATA_SIZE 0x8A40
+#define GL_UNIFORM_BLOCK_NAME_LENGTH 0x8A41
+#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS 0x8A42
+#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER 0x8A45
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46
+#define GL_INVALID_INDEX 0xFFFFFFFFu
+typedef void (APIENTRYP PFNGLGETUNIFORMINDICESPROC) (GLuint program, GLsizei uniformCount, const GLchar* *uniformNames, GLuint *uniformIndices);
+typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMSIVPROC) (GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);
+typedef GLuint (APIENTRYP PFNGLGETUNIFORMBLOCKINDEXPROC) (GLuint program, const GLchar *uniformBlockName);
+typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKIVPROC) (GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLUNIFORMBLOCKBINDINGPROC) (GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
+#endif
+#ifndef GL_INVALID_INDEX
+#define GL_INVALID_INDEX 0xFFFFFFFFu
+#endif
+extern PFNGLGETUNIFORMINDICESPROC glGetUniformIndices_;
+extern PFNGLGETACTIVEUNIFORMSIVPROC glGetActiveUniformsiv_;
+extern PFNGLGETUNIFORMBLOCKINDEXPROC glGetUniformBlockIndex_;
+extern PFNGLGETACTIVEUNIFORMBLOCKIVPROC glGetActiveUniformBlockiv_;
+extern PFNGLUNIFORMBLOCKBINDINGPROC glUniformBlockBinding_;
+
+#ifndef GL_VERSION_3_0
+#define GL_VERSION_3_0 1
+#define GL_NUM_EXTENSIONS 0x821D
+#define GL_COMPARE_REF_TO_TEXTURE 0x884E
+#define GL_MAX_VARYING_COMPONENTS 0x8B4B
+#define GL_RGBA32F 0x8814
+#define GL_RGB32F 0x8815
+#define GL_RGBA16F 0x881A
+#define GL_RGB16F 0x881B
+#define GL_COMPRESSED_RED 0x8225
+#define GL_COMPRESSED_RG 0x8226
+typedef void (APIENTRYP PFNGLBINDBUFFERRANGEPROC) (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
+typedef void (APIENTRYP PFNGLBINDBUFFERBASEPROC) (GLenum target, GLuint index, GLuint buffer);
+typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONPROC) (GLuint program, GLuint color, const GLchar *name);
+typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGIPROC) (GLenum name, GLuint index);
+#elif GL_GLEXT_VERSION < 43
+typedef void (APIENTRYP PFNGLBINDBUFFERRANGEPROC) (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
+typedef void (APIENTRYP PFNGLBINDBUFFERBASEPROC) (GLenum target, GLuint index, GLuint buffer);
+#endif
+
+extern PFNGLGETSTRINGIPROC glGetStringi_;
+extern PFNGLBINDFRAGDATALOCATIONPROC glBindFragDataLocation_;
+extern PFNGLBINDBUFFERBASEPROC glBindBufferBase_;
+extern PFNGLBINDBUFFERRANGEPROC glBindBufferRange_;
+
+#ifndef GL_VERSION_3_1
+#define GL_VERSION_3_1 1
+#define GL_TEXTURE_RECTANGLE 0x84F5
+#endif
+
+#ifndef GL_ARB_vertex_array_object
+#define GL_ARB_vertex_array_object 1
+#define GL_VERTEX_ARRAY_BINDING 0x85B5
+typedef void (APIENTRYP PFNGLBINDVERTEXARRAYPROC) (GLuint array);
+typedef void (APIENTRYP PFNGLDELETEVERTEXARRAYSPROC) (GLsizei n, const GLuint *arrays);
+typedef void (APIENTRYP PFNGLGENVERTEXARRAYSPROC) (GLsizei n, GLuint *arrays);
+typedef GLboolean (APIENTRYP PFNGLISVERTEXARRAYPROC) (GLuint array);
+#endif
+extern PFNGLBINDVERTEXARRAYPROC glBindVertexArray_;
+extern PFNGLDELETEVERTEXARRAYSPROC glDeleteVertexArrays_;
+extern PFNGLGENVERTEXARRAYSPROC glGenVertexArrays_;
+extern PFNGLISVERTEXARRAYPROC glIsVertexArray_;
+
+#ifndef GL_ARB_texture_swizzle
+#define GL_ARB_texture_swizzle 1
+#define GL_TEXTURE_SWIZZLE_R 0x8E42
+#define GL_TEXTURE_SWIZZLE_G 0x8E43
+#define GL_TEXTURE_SWIZZLE_B 0x8E44
+#define GL_TEXTURE_SWIZZLE_A 0x8E45
+#define GL_TEXTURE_SWIZZLE_RGBA 0x8E46
+#endif
+
diff --git a/src/shared/iengine.h b/src/shared/iengine.h
new file mode 100644
index 0000000..32b1957
--- /dev/null
+++ b/src/shared/iengine.h
@@ -0,0 +1,583 @@
+// the interface the game uses to access the engine
+
+extern int curtime; // current frame time
+extern int lastmillis; // last time
+extern int elapsedtime; // elapsed frame time
+extern int totalmillis; // total elapsed time
+extern uint totalsecs;
+extern int gamespeed, paused;
+
+enum
+{
+ MATF_INDEX_SHIFT = 0,
+ MATF_VOLUME_SHIFT = 2,
+ MATF_CLIP_SHIFT = 5,
+ MATF_FLAG_SHIFT = 8,
+
+ MATF_INDEX = 3 << MATF_INDEX_SHIFT,
+ MATF_VOLUME = 7 << MATF_VOLUME_SHIFT,
+ MATF_CLIP = 7 << MATF_CLIP_SHIFT,
+ MATF_FLAGS = 0xFF << MATF_FLAG_SHIFT
+};
+
+enum // cube empty-space materials
+{
+ MAT_AIR = 0, // the default, fill the empty space with air
+ MAT_WATER = 1 << MATF_VOLUME_SHIFT, // fill with water, showing waves at the surface
+ MAT_LAVA = 2 << MATF_VOLUME_SHIFT, // fill with lava
+ MAT_GLASS = 3 << MATF_VOLUME_SHIFT, // behaves like clip but is blended blueish
+
+ MAT_NOCLIP = 1 << MATF_CLIP_SHIFT, // collisions always treat cube as empty
+ MAT_CLIP = 2 << MATF_CLIP_SHIFT, // collisions always treat cube as solid
+ MAT_GAMECLIP = 3 << MATF_CLIP_SHIFT, // game specific clip material
+
+ MAT_DEATH = 1 << MATF_FLAG_SHIFT, // force player suicide
+ MAT_ALPHA = 4 << MATF_FLAG_SHIFT // alpha blended
+};
+
+#define isliquid(mat) ((mat)==MAT_WATER || (mat)==MAT_LAVA)
+#define isclipped(mat) ((mat)==MAT_GLASS)
+#define isdeadly(mat) ((mat)==MAT_LAVA)
+
+extern void lightent(extentity &e, float height = 8.0f);
+extern void lightreaching(const vec &target, vec &color, vec &dir, bool fast = false, extentity *e = 0, float ambient = 0.4f);
+extern entity *brightestlight(const vec &target, const vec &dir);
+
+enum { RAY_BB = 1, RAY_POLY = 3, RAY_ALPHAPOLY = 7, RAY_ENTS = 9, RAY_CLIPMAT = 16, RAY_SKIPFIRST = 32, RAY_EDITMAT = 64, RAY_SHADOW = 128, RAY_PASS = 256, RAY_SKIPSKY = 512, RAY_SKYTEX = 1024 };
+
+extern float raycube (const vec &o, const vec &ray, float radius = 0, int mode = RAY_CLIPMAT, int size = 0, extentity *t = 0);
+extern float raycubepos(const vec &o, const vec &ray, vec &hit, float radius = 0, int mode = RAY_CLIPMAT, int size = 0);
+extern float rayfloor (const vec &o, vec &floor, int mode = 0, float radius = 0);
+extern bool raycubelos(const vec &o, const vec &dest, vec &hitpos);
+
+extern int thirdperson;
+extern bool isthirdperson();
+
+extern bool settexture(const char *name, int clamp = 0);
+
+// octaedit
+
+enum { EDIT_FACE = 0, EDIT_TEX, EDIT_MAT, EDIT_FLIP, EDIT_COPY, EDIT_PASTE, EDIT_ROTATE, EDIT_REPLACE, EDIT_DELCUBE, EDIT_REMIP, EDIT_VSLOT, EDIT_UNDO, EDIT_REDO };
+
+struct selinfo
+{
+ int corner;
+ int cx, cxs, cy, cys;
+ ivec o, s;
+ int grid, orient;
+ selinfo() : corner(0), cx(0), cxs(0), cy(0), cys(0), o(0, 0, 0), s(0, 0, 0), grid(8), orient(0) {}
+ int size() const { return s.x*s.y*s.z; }
+ int us(int d) const { return s[d]*grid; }
+ bool operator==(const selinfo &sel) const { return o==sel.o && s==sel.s && grid==sel.grid && orient==sel.orient; }
+ bool validate()
+ {
+ extern int worldsize;
+ if(grid <= 0 || grid >= worldsize) return false;
+ if(o.x >= worldsize || o.y >= worldsize || o.z >= worldsize) return false;
+ if(o.x < 0) { s.x -= (grid - 1 - o.x)/grid; o.x = 0; }
+ if(o.y < 0) { s.y -= (grid - 1 - o.y)/grid; o.y = 0; }
+ if(o.z < 0) { s.z -= (grid - 1 - o.z)/grid; o.z = 0; }
+ s.x = clamp(s.x, 0, (worldsize - o.x)/grid);
+ s.y = clamp(s.y, 0, (worldsize - o.y)/grid);
+ s.z = clamp(s.z, 0, (worldsize - o.z)/grid);
+ return s.x > 0 && s.y > 0 && s.z > 0;
+ }
+};
+
+struct editinfo;
+extern editinfo *localedit;
+
+extern bool editmode;
+
+extern int shouldpacktex(int index);
+extern bool packeditinfo(editinfo *e, int &inlen, uchar *&outbuf, int &outlen);
+extern bool unpackeditinfo(editinfo *&e, const uchar *inbuf, int inlen, int outlen);
+extern void freeeditinfo(editinfo *&e);
+extern void pruneundos(int maxremain = 0);
+extern bool packundo(int op, int &inlen, uchar *&outbuf, int &outlen);
+extern bool unpackundo(const uchar *inbuf, int inlen, int outlen);
+extern bool noedit(bool view = false, bool msg = true);
+extern void toggleedit(bool force = true);
+extern void mpeditface(int dir, int mode, selinfo &sel, bool local);
+extern void mpedittex(int tex, int allfaces, selinfo &sel, bool local);
+extern bool mpedittex(int tex, int allfaces, selinfo &sel, ucharbuf &buf);
+extern void mpeditmat(int matid, int filter, selinfo &sel, bool local);
+extern void mpflip(selinfo &sel, bool local);
+extern void mpcopy(editinfo *&e, selinfo &sel, bool local);
+extern void mppaste(editinfo *&e, selinfo &sel, bool local);
+extern void mprotate(int cw, selinfo &sel, bool local);
+extern void mpreplacetex(int oldtex, int newtex, bool insel, selinfo &sel, bool local);
+extern bool mpreplacetex(int oldtex, int newtex, bool insel, selinfo &sel, ucharbuf &buf);
+extern void mpdelcube(selinfo &sel, bool local);
+extern bool mpeditvslot(int delta, int allfaces, selinfo &sel, ucharbuf &buf);
+extern void mpremip(bool local);
+
+// texture
+
+struct VSlot;
+
+extern void packvslot(vector<uchar> &buf, int index);
+extern void packvslot(vector<uchar> &buf, const VSlot *vs);
+
+// command
+extern int variable(const char *name, int min, int cur, int max, int *storage, identfun fun, int flags);
+extern float fvariable(const char *name, float min, float cur, float max, float *storage, identfun fun, int flags);
+extern char *svariable(const char *name, const char *cur, char **storage, identfun fun, int flags);
+extern void setvar(const char *name, int i, bool dofunc = true, bool doclamp = true);
+extern void setfvar(const char *name, float f, bool dofunc = true, bool doclamp = true);
+extern void setsvar(const char *name, const char *str, bool dofunc = true);
+extern void setvarchecked(ident *id, int val);
+extern void setfvarchecked(ident *id, float val);
+extern void setsvarchecked(ident *id, const char *val);
+extern void touchvar(const char *name);
+extern int getvar(const char *name);
+extern int getvarmin(const char *name);
+extern int getvarmax(const char *name);
+extern bool identexists(const char *name);
+extern ident *getident(const char *name);
+extern ident *newident(const char *name, int flags = 0);
+extern ident *readident(const char *name);
+extern ident *writeident(const char *name, int flags = 0);
+extern bool addcommand(const char *name, identfun fun, const char *narg);
+extern bool addkeyword(int type, const char *name);
+extern uint *compilecode(const char *p);
+extern void keepcode(uint *p);
+extern void freecode(uint *p);
+extern void executeret(const uint *code, tagval &result = *commandret);
+extern void executeret(const char *p, tagval &result = *commandret);
+extern void executeret(ident *id, tagval *args, int numargs, bool lookup = false, tagval &result = *commandret);
+extern char *executestr(const uint *code);
+extern char *executestr(const char *p);
+extern char *executestr(ident *id, tagval *args, int numargs, bool lookup = false);
+extern char *execidentstr(const char *name, bool lookup = false);
+extern int execute(const uint *code);
+extern int execute(const char *p);
+extern int execute(ident *id, tagval *args, int numargs, bool lookup = false);
+extern int execident(const char *name, int noid = 0, bool lookup = false);
+extern bool executebool(const uint *code);
+extern bool executebool(const char *p);
+extern bool executebool(ident *id, tagval *args, int numargs, bool lookup = false);
+extern bool execidentbool(const char *name, bool noid = false, bool lookup = false);
+extern bool execfile(const char *cfgfile, bool msg = true);
+extern void alias(const char *name, const char *action);
+extern void alias(const char *name, tagval &v);
+extern const char *getalias(const char *name);
+extern const char *escapestring(const char *s);
+extern const char *escapeid(const char *s);
+static inline const char *escapeid(ident &id) { return escapeid(id.name); }
+extern bool validateblock(const char *s);
+extern void explodelist(const char *s, vector<char *> &elems, int limit = -1);
+extern char *indexlist(const char *s, int pos);
+extern int listlen(const char *s);
+extern void printvar(ident *id);
+extern void printvar(ident *id, int i);
+extern void printfvar(ident *id, float f);
+extern void printsvar(ident *id, const char *s);
+extern int clampvar(ident *id, int i, int minval, int maxval);
+extern float clampfvar(ident *id, float f, float minval, float maxval);
+extern void loopiter(ident *id, identstack &stack, const tagval &v);
+extern void loopend(ident *id, identstack &stack);
+
+#define loopstart(id, stack) if((id)->type != ID_ALIAS) return; identstack stack;
+static inline void loopiter(ident *id, identstack &stack, int i) { tagval v; v.setint(i); loopiter(id, stack, v); }
+static inline void loopiter(ident *id, identstack &stack, float f) { tagval v; v.setfloat(f); loopiter(id, stack, v); }
+static inline void loopiter(ident *id, identstack &stack, const char *s) { tagval v; v.setstr(newstring(s)); loopiter(id, stack, v); }
+
+// console
+
+enum
+{
+ CON_INFO = 1<<0,
+ CON_WARN = 1<<1,
+ CON_ERROR = 1<<2,
+ CON_DEBUG = 1<<3,
+ CON_INIT = 1<<4,
+ CON_ECHO = 1<<5,
+
+ CON_FLAGS = 0xFFFF,
+ CON_TAG_SHIFT = 16,
+ CON_TAG_MASK = (0x7FFF << CON_TAG_SHIFT)
+};
+
+extern void conoutf(const char *s, ...) PRINTFARGS(1, 2);
+extern void conoutf(int type, const char *s, ...) PRINTFARGS(2, 3);
+extern void conoutf(int type, int tag, const char *s, ...) PRINTFARGS(3, 4);
+extern void conoutfv(int type, const char *fmt, va_list args);
+
+extern FILE *getlogfile();
+extern void setlogfile(const char *fname);
+extern void closelogfile();
+extern void logoutfv(const char *fmt, va_list args);
+extern void logoutf(const char *fmt, ...) PRINTFARGS(1, 2);
+
+// menus
+extern vec menuinfrontofplayer();
+extern void newgui(char *name, char *contents, char *header = NULL, char *init = NULL);
+extern void showgui(const char *name);
+extern int cleargui(int n = 0);
+
+// octa
+extern int lookupmaterial(const vec &o);
+
+static inline bool insideworld(const vec &o)
+{
+ extern int worldsize;
+ return o.x>=0 && o.x<worldsize && o.y>=0 && o.y<worldsize && o.z>=0 && o.z<worldsize;
+}
+
+static inline bool insideworld(const ivec &o)
+{
+ extern int worldsize;
+ return uint(o.x)<uint(worldsize) && uint(o.y)<uint(worldsize) && uint(o.z)<uint(worldsize);
+}
+
+// world
+extern bool emptymap(int factor, bool force, const char *mname = "", bool usecfg = true);
+extern bool enlargemap(bool force);
+extern int findentity(int type, int index = 0, int attr1 = -1, int attr2 = -1);
+extern void findents(int low, int high, bool notspawned, const vec &pos, const vec &radius, vector<int> &found);
+extern void mpeditent(int i, const vec &o, int type, int attr1, int attr2, int attr3, int attr4, int attr5, bool local);
+extern vec getselpos();
+extern int getworldsize();
+extern int getmapversion();
+extern void renderentcone(const extentity &e, const vec &dir, float radius, float angle);
+extern void renderentarrow(const extentity &e, const vec &dir, float radius);
+extern void renderentattachment(const extentity &e);
+extern void renderentsphere(const extentity &e, float radius);
+extern void renderentring(const extentity &e, float radius, int axis = 0);
+
+// main
+extern void fatal(const char *s, ...) PRINTFARGS(1, 2);
+
+// rendertext
+extern bool setfont(const char *name);
+extern void pushfont();
+extern bool popfont();
+extern void gettextres(int &w, int &h);
+extern void draw_text(const char *str, int left, int top, int r = 255, int g = 255, int b = 255, int a = 255, int cursor = -1, int maxwidth = -1);
+extern void draw_textf(const char *fstr, int left, int top, ...) PRINTFARGS(1, 4);
+extern float text_widthf(const char *str);
+extern void text_boundsf(const char *str, float &width, float &height, int maxwidth = -1);
+extern int text_visible(const char *str, float hitx, float hity, int maxwidth);
+extern void text_posf(const char *str, int cursor, float &cx, float &cy, int maxwidth);
+
+static inline int text_width(const char *str)
+{
+ return int(ceil(text_widthf(str)));
+}
+
+static inline void text_bounds(const char *str, int &width, int &height, int maxwidth = -1)
+{
+ float widthf, heightf;
+ text_boundsf(str, widthf, heightf, maxwidth);
+ width = int(ceil(widthf));
+ height = int(ceil(heightf));
+}
+
+static inline void text_pos(const char *str, int cursor, int &cx, int &cy, int maxwidth)
+{
+ float cxf, cyf;
+ text_posf(str, cursor, cxf, cyf, maxwidth);
+ cx = int(cxf);
+ cy = int(cyf);
+}
+
+// renderva
+enum
+{
+ DL_SHRINK = 1<<0,
+ DL_EXPAND = 1<<1,
+ DL_FLASH = 1<<2
+};
+
+extern void adddynlight(const vec &o, float radius, const vec &color, int fade = 0, int peak = 0, int flags = 0, float initradius = 0, const vec &initcolor = vec(0, 0, 0), physent *owner = NULL);
+extern void dynlightreaching(const vec &target, vec &color, vec &dir, bool hud = false);
+extern void removetrackeddynlights(physent *owner = NULL);
+
+// rendergl
+extern physent *camera1;
+extern vec worldpos, camdir, camright, camup;
+
+extern void disablezoom();
+
+extern vec calcavatarpos(const vec &pos, float dist);
+extern vec calcmodelpreviewpos(const vec &radius, float &yaw);
+
+extern void damageblend(int n);
+extern void damagecompass(int n, const vec &loc);
+extern void cleardamagescreen();
+
+extern vec minimapcenter, minimapradius, minimapscale;
+extern void bindminimap();
+
+extern matrix4 hudmatrix;
+extern void resethudmatrix();
+extern void pushhudmatrix();
+extern void flushhudmatrix(bool flushparams = true);
+extern void pophudmatrix(bool flush = true, bool flushparams = true);
+extern void pushhudscale(float sx, float sy = 0);
+extern void pushhudtranslate(float tx, float ty, float sx = 0, float sy = 0);
+
+// renderparticles
+enum
+{
+ PART_BLOOD = 0,
+ PART_WATER,
+ PART_SMOKE,
+ PART_STEAM,
+ PART_FLAME,
+ PART_FIREBALL1, PART_FIREBALL2, PART_FIREBALL3,
+ PART_STREAK, PART_LIGHTNING,
+ PART_EXPLOSION, PART_EXPLOSION_BLUE,
+ PART_SPARK, PART_EDIT,
+ PART_SNOW,
+ PART_MUZZLE_FLASH1, PART_MUZZLE_FLASH2, PART_MUZZLE_FLASH3,
+ PART_HUD_ICON,
+ PART_HUD_ICON_GREY,
+ PART_TEXT,
+ PART_TEXT_ICON,
+ PART_METER, PART_METER_VS,
+ PART_LENS_FLARE
+};
+
+extern bool canaddparticles();
+extern void regular_particle_splash(int type, int num, int fade, const vec &p, int color = 0xFFFFFF, float size = 1.0f, int radius = 150, int gravity = 2, int delay = 0);
+extern void regular_particle_flame(int type, const vec &p, float radius, float height, int color, int density = 3, float scale = 2.0f, float speed = 200.0f, float fade = 600.0f, int gravity = -15);
+extern void particle_splash(int type, int num, int fade, const vec &p, int color = 0xFFFFFF, float size = 1.0f, int radius = 150, int gravity = 2);
+extern void particle_trail(int type, int fade, const vec &from, const vec &to, int color = 0xFFFFFF, float size = 1.0f, int gravity = 20);
+extern void particle_text(const vec &s, const char *t, int type, int fade = 2000, int color = 0xFFFFFF, float size = 2.0f, int gravity = 0, int offset = 0);
+extern void particle_textcopy(const vec &s, const char *t, int type, int fade = 2000, int color = 0xFFFFFF, float size = 2.0f, int gravity = 0);
+extern void particle_texticon(const vec &s, int ix, int iy, float offset, int type, int fade = 2000, int color = 0xFFFFFF, float size = 2.0f, int gravity = 0);
+extern void particle_icon(const vec &s, int ix, int iy, int type, int fade = 2000, int color = 0xFFFFFF, float size = 2.0f, int gravity = 0);
+extern void particle_meter(const vec &s, float val, int type, int fade = 1, int color = 0xFFFFFF, int color2 = 0xFFFFF, float size = 2.0f);
+extern void particle_flare(const vec &p, const vec &dest, int fade, int type, int color = 0xFFFFFF, float size = 0.28f, physent *owner = NULL);
+extern void particle_fireball(const vec &dest, float max, int type, int fade = -1, int color = 0xFFFFFF, float size = 4.0f);
+extern void removetrackedparticles(physent *owner = NULL);
+
+// decal
+enum
+{
+ DECAL_SCORCH = 0,
+ DECAL_BLOOD,
+ DECAL_BULLET
+};
+
+extern void adddecal(int type, const vec &center, const vec &surface, float radius, const bvec &color = bvec(0xFF, 0xFF, 0xFF), int info = 0);
+
+// worldio
+extern bool load_world(const char *mname, const char *cname = NULL);
+extern bool save_world(const char *mname, bool nolms = false);
+extern void fixmapname(char *name);
+extern void getmapfilenames(const char *fname, const char *cname, char *pakname, char *mapname, char *cfgname);
+extern uint getmapcrc();
+extern void clearmapcrc();
+extern bool loadents(const char *fname, vector<entity> &ents, uint *crc = NULL);
+
+// physics
+extern vec collidewall;
+extern int collideinside;
+extern physent *collideplayer;
+
+extern void moveplayer(physent *pl, int moveres, bool local);
+extern bool moveplayer(physent *pl, int moveres, bool local, int curtime);
+extern bool collide(physent *d, const vec &dir = vec(0, 0, 0), float cutoff = 0.0f, bool playercol = true, bool insideplayercol = false);
+extern bool bounce(physent *d, float secs, float elasticity, float waterfric, float grav);
+extern bool bounce(physent *d, float elasticity, float waterfric, float grav);
+extern void avoidcollision(physent *d, const vec &dir, physent *obstacle, float space);
+extern bool overlapsdynent(const vec &o, float radius);
+extern bool movecamera(physent *pl, const vec &dir, float dist, float stepdist);
+extern void physicsframe();
+extern void dropenttofloor(entity *e);
+extern bool droptofloor(vec &o, float radius, float height);
+
+extern void vecfromyawpitch(float yaw, float pitch, int move, int strafe, vec &m);
+extern void vectoyawpitch(const vec &v, float &yaw, float &pitch);
+extern bool moveplatform(physent *p, const vec &dir);
+extern void updatephysstate(physent *d);
+extern void cleardynentcache();
+extern void updatedynentcache(physent *d);
+extern bool entinmap(dynent *d, bool avoidplayers = false);
+extern void findplayerspawn(dynent *d, int forceent = -1, int tag = 0);
+
+// sound
+enum
+{
+ SND_MAP = 1<<0,
+ SND_NO_ALT = 1<<1,
+ SND_USE_ALT = 1<<2
+};
+
+extern int playsound(int n, const vec *loc = NULL, extentity *ent = NULL, int flags = 0, int loops = 0, int fade = 0, int chanid = -1, int radius = 0, int expire = -1);
+extern int playsoundname(const char *s, const vec *loc = NULL, int vol = 0, int flags = 0, int loops = 0, int fade = 0, int chanid = -1, int radius = 0, int expire = -1);
+extern void preloadsound(int n);
+extern void preloadmapsound(int n);
+extern bool stopsound(int n, int chanid, int fade = 0);
+extern void stopsounds();
+extern void initsound();
+
+// rendermodel
+enum { MDL_CULL_VFC = 1<<0, MDL_CULL_DIST = 1<<1, MDL_CULL_OCCLUDED = 1<<2, MDL_CULL_QUERY = 1<<3, MDL_SHADOW = 1<<4, MDL_DYNSHADOW = 1<<5, MDL_LIGHT = 1<<6, MDL_DYNLIGHT = 1<<7, MDL_FULLBRIGHT = 1<<8, MDL_NORENDER = 1<<9, MDL_LIGHT_FAST = 1<<10, MDL_HUD = 1<<11, MDL_GHOST = 1<<12 };
+
+struct model;
+struct modelattach
+{
+ const char *tag, *name;
+ int anim, basetime;
+ vec *pos;
+ model *m;
+
+ modelattach() : tag(NULL), name(NULL), anim(-1), basetime(0), pos(NULL), m(NULL) {}
+ modelattach(const char *tag, const char *name, int anim = -1, int basetime = 0) : tag(tag), name(name), anim(anim), basetime(basetime), pos(NULL), m(NULL) {}
+ modelattach(const char *tag, vec *pos) : tag(tag), name(NULL), anim(-1), basetime(0), pos(pos), m(NULL) {}
+};
+
+extern void startmodelbatches();
+extern void endmodelbatches();
+extern void rendermodel(entitylight *light, const char *mdl, int anim, const vec &o, float yaw = 0, float pitch = 0, int cull = MDL_CULL_VFC | MDL_CULL_DIST | MDL_CULL_OCCLUDED | MDL_LIGHT, dynent *d = NULL, modelattach *a = NULL, int basetime = 0, int basetime2 = 0, float trans = 1);
+extern void abovemodel(vec &o, const char *mdl);
+extern void rendershadow(dynent *d);
+extern void renderclient(dynent *d, const char *mdlname, modelattach *attachments, int hold, int attack, int attackdelay, int lastaction, int lastpain, float fade = 1, bool ragdoll = false);
+extern void interpolateorientation(dynent *d, float &interpyaw, float &interppitch);
+extern void setbbfrommodel(dynent *d, const char *mdl);
+extern const char *mapmodelname(int i);
+extern model *loadmodel(const char *name, int i = -1, bool msg = false);
+extern void preloadmodel(const char *name);
+extern void flushpreloadedmodels(bool msg = true);
+
+// ragdoll
+
+extern void moveragdoll(dynent *d);
+extern void cleanragdoll(dynent *d);
+
+// server
+#define MAXCLIENTS 128 // DO NOT set this any higher
+#define MAXTRANS 5000 // max amount of data to swallow in 1 go
+
+extern int maxclients;
+
+enum { DISC_NONE = 0, DISC_EOP, DISC_LOCAL, DISC_KICK, DISC_MSGERR, DISC_IPBAN, DISC_PRIVATE, DISC_MAXCLIENTS, DISC_TIMEOUT, DISC_OVERFLOW, DISC_PASSWORD, DISC_NUM };
+
+extern void *getclientinfo(int i);
+extern ENetPeer *getclientpeer(int i);
+extern ENetPacket *sendf(int cn, int chan, const char *format, ...);
+extern ENetPacket *sendfile(int cn, int chan, stream *file, const char *format = "", ...);
+extern void sendpacket(int cn, int chan, ENetPacket *packet, int exclude = -1);
+extern void flushserver(bool force);
+extern int getservermtu();
+extern int getnumclients();
+extern uint getclientip(int n);
+extern void localconnect();
+extern const char *disconnectreason(int reason);
+extern void disconnect_client(int n, int reason);
+extern void kicknonlocalclients(int reason = DISC_NONE);
+extern bool hasnonlocalclients();
+extern bool haslocalclients();
+extern void sendserverinforeply(ucharbuf &p);
+extern bool requestmaster(const char *req);
+extern bool requestmasterf(const char *fmt, ...) PRINTFARGS(1, 2);
+extern bool isdedicatedserver();
+
+// client
+extern void sendclientpacket(ENetPacket *packet, int chan);
+extern void flushclient();
+extern void disconnect(bool async = false, bool cleanup = true);
+extern bool isconnected(bool attempt = false, bool local = true);
+extern const ENetAddress *connectedpeer();
+extern bool multiplayer(bool msg = true);
+extern void neterr(const char *s, bool disc = true);
+extern void gets2c();
+extern void notifywelcome();
+
+// crypto
+extern void genprivkey(const char *seed, vector<char> &privstr, vector<char> &pubstr);
+extern bool calcpubkey(const char *privstr, vector<char> &pubstr);
+extern bool hashstring(const char *str, char *result, int maxlen);
+extern void answerchallenge(const char *privstr, const char *challenge, vector<char> &answerstr);
+extern void *parsepubkey(const char *pubstr);
+extern void freepubkey(void *pubkey);
+extern void *genchallenge(void *pubkey, const void *seed, int seedlen, vector<char> &challengestr);
+extern void freechallenge(void *answer);
+extern bool checkchallenge(const char *answerstr, void *correct);
+
+// 3dgui
+struct Texture;
+struct VSlot;
+
+enum { G3D_DOWN = 1, G3D_UP = 2, G3D_PRESSED = 4, G3D_ROLLOVER = 8, G3D_DRAGGED = 16 };
+
+enum { EDITORFOCUSED = 1, EDITORUSED, EDITORFOREVER };
+
+struct g3d_gui
+{
+ virtual ~g3d_gui() {}
+
+ virtual void start(int starttime, float basescale, int *tab = NULL, bool allowinput = true) = 0;
+ virtual void end() = 0;
+
+ virtual int text(const char *text, int color, const char *icon = NULL) = 0;
+ int textf(const char *fmt, int color, const char *icon = NULL, ...) PRINTFARGS(2, 5)
+ {
+ defvformatstring(str, icon, fmt);
+ return text(str, color, icon);
+ }
+ virtual int button(const char *text, int color, const char *icon = NULL) = 0;
+ int buttonf(const char *fmt, int color, const char *icon = NULL, ...) PRINTFARGS(2, 5)
+ {
+ defvformatstring(str, icon, fmt);
+ return button(str, color, icon);
+ }
+ virtual int title(const char *text, int color, const char *icon = NULL) = 0;
+ int titlef(const char *fmt, int color, const char *icon = NULL, ...) PRINTFARGS(2, 5)
+ {
+ defvformatstring(str, icon, fmt);
+ return title(str, color, icon);
+ }
+ virtual void background(int color, int parentw = 0, int parenth = 0) = 0;
+
+ virtual void pushlist() {}
+ virtual void poplist() {}
+
+ virtual bool allowautotab(bool on) = 0;
+ virtual bool shouldtab() { return false; }
+ virtual void tab(const char *name = NULL, int color = 0) = 0;
+ virtual int image(Texture *t, float scale, const char *overlaid = NULL) = 0;
+ virtual int texture(VSlot &vslot, float scale, bool overlaid = true) = 0;
+ virtual int playerpreview(int model, int team, int weap, float scale, const char *overlaid = NULL) { return 0; }
+ virtual int modelpreview(const char *name, int anim, float scale, const char *overlaid = NULL, bool throttle = false) { return 0; }
+ virtual int prefabpreview(const char *prefab, const vec &color, float scale, const char *overlaid = NULL, bool throttle = false) { return 0; }
+ virtual void slider(int &val, int vmin, int vmax, int color, const char *label = NULL) = 0;
+ virtual void separator() = 0;
+ virtual void progress(float percent) = 0;
+ virtual void strut(float size) = 0;
+ virtual void space(float size) = 0;
+ virtual void spring(int weight = 1) = 0;
+ virtual void column(int col) = 0;
+ virtual char *keyfield(const char *name, int color, int length, int height = 0, const char *initval = NULL, int initmode = EDITORFOCUSED) = 0;
+ virtual char *field(const char *name, int color, int length, int height = 0, const char *initval = NULL, int initmode = EDITORFOCUSED) = 0;
+ virtual void textbox(const char *text, int width, int height, int color = 0xFFFFFF) = 0;
+ virtual bool mergehits(bool on) = 0;
+};
+
+struct g3d_callback
+{
+ virtual ~g3d_callback() {}
+
+ int starttime() { return totalmillis; }
+
+ virtual void gui(g3d_gui &g, bool firstpass) = 0;
+};
+
+enum
+{
+ GUI_2D = 1<<0,
+ GUI_FOLLOW = 1<<1,
+ GUI_FORCE_2D = 1<<2,
+ GUI_BOTTOM = 1<<3
+};
+
+extern void g3d_addgui(g3d_callback *cb, vec &origin, int flags = 0);
+extern bool g3d_movecursor(int dx, int dy);
+extern void g3d_cursorpos(float &x, float &y);
+extern void g3d_resetcursor();
+extern void g3d_limitscale(float scale);
+
diff --git a/src/shared/igame.h b/src/shared/igame.h
new file mode 100644
index 0000000..113ca17
--- /dev/null
+++ b/src/shared/igame.h
@@ -0,0 +1,130 @@
+// the interface the engine uses to run the gameplay module
+
+namespace entities
+{
+ extern void editent(int i, bool local);
+ extern const char *entnameinfo(entity &e);
+ extern const char *entname(int i);
+ extern int extraentinfosize();
+ extern void writeent(entity &e, char *buf);
+ extern void readent(entity &e, char *buf, int ver);
+ extern float dropheight(entity &e);
+ extern void fixentity(extentity &e);
+ extern void entradius(extentity &e, bool color);
+ extern bool mayattach(extentity &e);
+ extern bool attachent(extentity &e, extentity &a);
+ extern bool printent(extentity &e, char *buf, int len);
+ extern extentity *newentity();
+ extern void deleteentity(extentity *e);
+ extern void clearents();
+ extern vector<extentity *> &getents();
+ extern const char *entmodel(const entity &e);
+ extern void animatemapmodel(const extentity &e, int &anim, int &basetime);
+}
+
+namespace game
+{
+ extern void parseoptions(vector<const char *> &args);
+
+ extern void gamedisconnect(bool cleanup);
+ extern void parsepacketclient(int chan, packetbuf &p);
+ extern void connectattempt(const char *name, const char *password, const ENetAddress &address);
+ extern void connectfail();
+ extern void gameconnect(bool _remote);
+ extern bool allowedittoggle();
+ extern void edittoggled(bool on);
+ extern void writeclientinfo(stream *f);
+ extern void toserver(char *text);
+ extern void changemap(const char *name);
+ extern void forceedit(const char *name);
+ extern bool ispaused();
+ extern int scaletime(int t);
+ extern bool allowmouselook();
+
+ extern const char *gameident();
+ extern const char *savedconfig();
+ extern const char *restoreconfig();
+ extern const char *defaultconfig();
+ extern const char *autoexec();
+ extern const char *savedservers();
+ extern void loadconfigs();
+
+ extern void updateworld();
+ extern void initclient();
+ extern void physicstrigger(physent *d, bool local, int floorlevel, int waterlevel, int material = 0);
+ extern void bounced(physent *d, const vec &surface);
+ extern void edittrigger(const selinfo &sel, int op, int arg1 = 0, int arg2 = 0, int arg3 = 0, const VSlot *vs = NULL);
+ extern void vartrigger(ident *id);
+ extern void dynentcollide(physent *d, physent *o, const vec &dir);
+ extern const char *getclientmap();
+ extern const char *getmapinfo();
+ extern const char *getscreenshotinfo();
+ extern void resetgamestate();
+ extern void suicide(physent *d);
+ extern float ratespawn(dynent *d, const extentity &e);
+ extern void newmap(int size);
+ extern void loadingmap(const char *name);
+ extern void startmap(const char *name);
+ extern void preload();
+ extern float abovegameplayhud(int w, int h);
+ extern void gameplayhud(int w, int h);
+ extern bool canjump();
+ extern bool allowmove(physent *d);
+ extern void doattack(bool on);
+ extern dynent *iterdynents(int i);
+ extern int numdynents();
+ extern void rendergame(bool mainpass);
+ extern void renderavatar();
+ extern void renderplayerpreview(int model, int team, int weap);
+ extern void writegamedata(vector<char> &extras);
+ extern void readgamedata(vector<char> &extras);
+ extern int clipconsole(int w, int h);
+ extern void g3d_gamemenus();
+ extern const char *defaultcrosshair(int index);
+ extern int selectcrosshair(vec &color);
+ extern void lighteffects(dynent *d, vec &color, vec &dir);
+ extern void setupcamera();
+ extern bool allowthirdperson(bool msg = false);
+ extern bool detachcamera();
+ extern bool collidecamera();
+ extern void adddynlights();
+ extern void particletrack(physent *owner, vec &o, vec &d);
+ extern void dynlighttrack(physent *owner, vec &o, vec &hud);
+ extern int maxsoundradius(int n);
+ extern bool serverinfostartcolumn(g3d_gui *g, int i);
+ extern void serverinfoendcolumn(g3d_gui *g, int i);
+ extern bool serverinfoentry(g3d_gui *g, int i, const char *name, int port, const char *desc, const char *map, int ping, const vector<int> &attr, int np);
+ extern bool needminimap();
+}
+
+namespace server
+{
+ extern void *newclientinfo();
+ extern void deleteclientinfo(void *ci);
+ extern void serverinit();
+ extern int reserveclients();
+ extern int numchannels();
+ extern void clientdisconnect(int n);
+ extern int clientconnect(int n, uint ip);
+ extern void localdisconnect(int n);
+ extern void localconnect(int n);
+ extern bool allowbroadcast(int n);
+ extern void recordpacket(int chan, void *data, int len);
+ extern void parsepacket(int sender, int chan, packetbuf &p);
+ extern void sendservmsg(const char *s);
+ extern bool sendpackets(bool force = false);
+ extern void serverinforeply(ucharbuf &req, ucharbuf &p);
+ extern void serverupdate();
+ extern bool servercompatible(char *name, char *sdec, char *map, int ping, const vector<int> &attr, int np);
+ extern int laninfoport();
+ extern int serverinfoport(int servport = -1);
+ extern int serverport(int infoport = -1);
+ extern const char *defaultmaster();
+ extern int masterport();
+ extern void processmasterinput(const char *cmd, int cmdlen, const char *args);
+ extern void masterconnected();
+ extern void masterdisconnected();
+ extern bool ispaused();
+ extern int scaletime(int t);
+}
+
diff --git a/src/shared/stream.cpp b/src/shared/stream.cpp
new file mode 100644
index 0000000..f2b586e
--- /dev/null
+++ b/src/shared/stream.cpp
@@ -0,0 +1,1264 @@
+#include "cube.h"
+
+///////////////////////////// console ////////////////////////
+
+void conoutf(const char *fmt, ...)
+{
+ va_list args;
+ va_start(args, fmt);
+ conoutfv(CON_INFO, fmt, args);
+ va_end(args);
+}
+
+void conoutf(int type, const char *fmt, ...)
+{
+ va_list args;
+ va_start(args, fmt);
+ conoutfv(type, fmt, args);
+ va_end(args);
+}
+
+void conoutf(int type, int tag, const char *fmt, ...)
+{
+ va_list args;
+ va_start(args, fmt);
+ conoutfv(type | ((tag << CON_TAG_SHIFT) & CON_TAG_MASK), fmt, args);
+ va_end(args);
+}
+
+///////////////////////// character conversion ///////////////
+
+#define CUBECTYPE(s, p, d, a, A, u, U) \
+ 0, U, U, U, U, U, U, U, U, s, s, s, s, s, U, U, \
+ U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, \
+ s, p, p, p, p, p, p, p, p, p, p, p, p, p, p, p, \
+ d, d, d, d, d, d, d, d, d, d, p, p, p, p, p, p, \
+ p, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, \
+ A, A, A, A, A, A, A, A, A, A, A, p, p, p, p, p, \
+ p, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, \
+ a, a, a, a, a, a, a, a, a, a, a, p, p, p, p, U, \
+ U, u, u, u, u, u, u, u, u, u, u, u, u, u, u, u, \
+ u, u, u, u, u, u, u, u, u, u, u, u, u, u, u, U, \
+ u, U, u, U, u, U, u, U, u, U, u, U, u, U, u, U, \
+ u, U, u, U, u, U, u, U, u, U, u, U, u, U, u, U, \
+ u, U, u, U, u, U, u, U, U, u, U, u, U, u, U, U, \
+ U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, \
+ U, U, U, U, u, u, u, u, u, u, u, u, u, u, u, u, \
+ u, u, u, u, u, u, u, u, u, u, u, u, u, u, U, u
+
+extern const uchar cubectype[256] =
+{
+ CUBECTYPE(CT_SPACE,
+ CT_PRINT,
+ CT_PRINT|CT_DIGIT,
+ CT_PRINT|CT_ALPHA|CT_LOWER,
+ CT_PRINT|CT_ALPHA|CT_UPPER,
+ CT_PRINT|CT_UNICODE|CT_ALPHA|CT_LOWER,
+ CT_PRINT|CT_UNICODE|CT_ALPHA|CT_UPPER)
+};
+extern const int cube2unichars[256] =
+{
+ 0, 192, 193, 194, 195, 196, 197, 198, 199, 9, 10, 11, 12, 13, 200, 201,
+ 202, 203, 204, 205, 206, 207, 209, 210, 211, 212, 213, 214, 216, 217, 218, 219,
+ 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
+ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
+ 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
+ 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
+ 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
+ 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 220,
+ 221, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237,
+ 238, 239, 241, 242, 243, 244, 245, 246, 248, 249, 250, 251, 252, 253, 255, 0x104,
+ 0x105, 0x106, 0x107, 0x10C, 0x10D, 0x10E, 0x10F, 0x118, 0x119, 0x11A, 0x11B, 0x11E, 0x11F, 0x130, 0x131, 0x141,
+ 0x142, 0x143, 0x144, 0x147, 0x148, 0x150, 0x151, 0x152, 0x153, 0x158, 0x159, 0x15A, 0x15B, 0x15E, 0x15F, 0x160,
+ 0x161, 0x164, 0x165, 0x16E, 0x16F, 0x170, 0x171, 0x178, 0x179, 0x17A, 0x17B, 0x17C, 0x17D, 0x17E, 0x404, 0x411,
+ 0x413, 0x414, 0x416, 0x417, 0x418, 0x419, 0x41B, 0x41F, 0x423, 0x424, 0x426, 0x427, 0x428, 0x429, 0x42A, 0x42B,
+ 0x42C, 0x42D, 0x42E, 0x42F, 0x431, 0x432, 0x433, 0x434, 0x436, 0x437, 0x438, 0x439, 0x43A, 0x43B, 0x43C, 0x43D,
+ 0x43F, 0x442, 0x444, 0x446, 0x447, 0x448, 0x449, 0x44A, 0x44B, 0x44C, 0x44D, 0x44E, 0x44F, 0x454, 0x490, 0x491
+};
+extern const int uni2cubeoffsets[8] =
+{
+ 0, 256, 658, 658, 512, 658, 658, 658
+};
+extern const uchar uni2cubechars[878] =
+{
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 10, 11, 12, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
+ 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
+ 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 2, 3, 4, 5, 6, 7, 8, 14, 15, 16, 17, 18, 19, 20, 21, 0, 22, 23, 24, 25, 26, 27, 0, 28, 29, 30, 31, 127, 128, 0, 129,
+ 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 0, 146, 147, 148, 149, 150, 151, 0, 152, 153, 154, 155, 156, 157, 0, 158,
+ 0, 0, 0, 0, 159, 160, 161, 162, 0, 0, 0, 0, 163, 164, 165, 166, 0, 0, 0, 0, 0, 0, 0, 0, 167, 168, 169, 170, 0, 0, 171, 172,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 173, 174, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 175, 176, 177, 178, 0, 0, 179, 180, 0, 0, 0, 0, 0, 0, 0, 181, 182, 183, 184, 0, 0, 0, 0, 185, 186, 187, 188, 0, 0, 189, 190,
+ 191, 192, 0, 0, 193, 194, 0, 0, 0, 0, 0, 0, 0, 0, 195, 196, 197, 198, 0, 0, 0, 0, 0, 0, 199, 200, 201, 202, 203, 204, 205, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 17, 0, 0, 206, 83, 73, 21, 74, 0, 0, 0, 0, 0, 0, 0, 65, 207, 66, 208, 209, 69, 210, 211, 212, 213, 75, 214, 77, 72, 79, 215,
+ 80, 67, 84, 216, 217, 88, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 97, 228, 229, 230, 231, 101, 232, 233, 234, 235, 236, 237, 238, 239, 111, 240,
+ 112, 99, 241, 121, 242, 120, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 0, 141, 0, 0, 253, 115, 105, 145, 106, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 254, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+};
+extern const uchar cubelowerchars[256] =
+{
+ 0, 130, 131, 132, 133, 134, 135, 136, 137, 9, 10, 11, 12, 13, 138, 139,
+ 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155,
+ 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
+ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
+ 64, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
+ 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 91, 92, 93, 94, 95,
+ 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
+ 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 156,
+ 157, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
+ 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 160,
+ 160, 162, 162, 164, 164, 166, 166, 168, 168, 170, 170, 172, 172, 105, 174, 176,
+ 176, 178, 178, 180, 180, 182, 182, 184, 184, 186, 186, 188, 188, 190, 190, 192,
+ 192, 194, 194, 196, 196, 198, 198, 158, 201, 201, 203, 203, 205, 205, 206, 207,
+ 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223,
+ 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239,
+ 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255
+};
+extern const uchar cubeupperchars[256] =
+{
+ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+ 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+ 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
+ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
+ 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
+ 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
+ 96, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
+ 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 123, 124, 125, 126, 127,
+ 128, 129, 1, 2, 3, 4, 5, 6, 7, 8, 14, 15, 16, 17, 18, 19,
+ 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 127, 128, 199, 159,
+ 159, 161, 161, 163, 163, 165, 165, 167, 167, 169, 169, 171, 171, 173, 73, 175,
+ 175, 177, 177, 179, 179, 181, 181, 183, 183, 185, 185, 187, 187, 189, 189, 191,
+ 191, 193, 193, 195, 195, 197, 197, 199, 200, 200, 202, 202, 204, 204, 206, 207,
+ 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223,
+ 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239,
+ 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255
+};
+
+size_t decodeutf8(uchar *dstbuf, size_t dstlen, const uchar *srcbuf, size_t srclen, size_t *carry)
+{
+ uchar *dst = dstbuf, *dstend = &dstbuf[dstlen];
+ const uchar *src = srcbuf, *srcend = &srcbuf[srclen];
+ if(dstbuf == srcbuf)
+ {
+ int len = min(dstlen, srclen);
+ for(const uchar *end4 = &srcbuf[len&~3]; src < end4; src += 4) if(*(const int *)src & 0x80808080) goto decode;
+ for(const uchar *end = &srcbuf[len]; src < end; src++) if(*src & 0x80) goto decode;
+ if(carry) *carry += len;
+ return len;
+ }
+
+decode:
+ dst += src - srcbuf;
+ while(src < srcend && dst < dstend)
+ {
+ int c = *src++;
+ if(c < 0x80) *dst++ = c;
+ else if(c >= 0xC0)
+ {
+ int uni;
+ if(c >= 0xE0)
+ {
+ if(c >= 0xF0)
+ {
+ if(c >= 0xF8)
+ {
+ if(c >= 0xFC)
+ {
+ if(c >= 0xFE) continue;
+ uni = c&1; if(srcend - src < 5) break;
+ c = *src; if((c&0xC0) != 0x80) continue; src++; uni = (uni<<6) | (c&0x3F);
+ }
+ else { uni = c&3; if(srcend - src < 4) break; }
+ c = *src; if((c&0xC0) != 0x80) continue; src++; uni = (uni<<6) | (c&0x3F);
+ }
+ else { uni = c&7; if(srcend - src < 3) break; }
+ c = *src; if((c&0xC0) != 0x80) continue; src++; uni = (uni<<6) | (c&0x3F);
+ }
+ else { uni = c&0xF; if(srcend - src < 2) break; }
+ c = *src; if((c&0xC0) != 0x80) continue; src++; uni = (uni<<6) | (c&0x3F);
+ }
+ else { uni = c&0x1F; if(srcend - src < 1) break; }
+ c = *src; if((c&0xC0) != 0x80) continue; src++; uni = (uni<<6) | (c&0x3F);
+ c = uni2cube(uni);
+ if(!c) continue;
+ *dst++ = c;
+ }
+ }
+ if(carry) *carry += src - srcbuf;
+ return dst - dstbuf;
+}
+
+size_t encodeutf8(uchar *dstbuf, size_t dstlen, const uchar *srcbuf, size_t srclen, size_t *carry)
+{
+ uchar *dst = dstbuf, *dstend = &dstbuf[dstlen];
+ const uchar *src = srcbuf, *srcend = &srcbuf[srclen];
+ if(src < srcend && dst < dstend) do
+ {
+ int uni = cube2uni(*src);
+ if(uni <= 0x7F)
+ {
+ if(dst >= dstend) goto done;
+ const uchar *end = min(srcend, &src[dstend-dst]);
+ do
+ {
+ if(uni == '\f')
+ {
+ if(++src >= srcend) goto done;
+ goto uni1;
+ }
+ *dst++ = uni;
+ if(++src >= end) goto done;
+ uni = cube2uni(*src);
+ }
+ while(uni <= 0x7F);
+ }
+ if(uni <= 0x7FF) { if(dst + 2 > dstend) goto done; *dst++ = 0xC0 | (uni>>6); goto uni2; }
+ else if(uni <= 0xFFFF) { if(dst + 3 > dstend) goto done; *dst++ = 0xE0 | (uni>>12); goto uni3; }
+ else if(uni <= 0x1FFFFF) { if(dst + 4 > dstend) goto done; *dst++ = 0xF0 | (uni>>18); goto uni4; }
+ else if(uni <= 0x3FFFFFF) { if(dst + 5 > dstend) goto done; *dst++ = 0xF8 | (uni>>24); goto uni5; }
+ else if(uni <= 0x7FFFFFFF) { if(dst + 6 > dstend) goto done; *dst++ = 0xFC | (uni>>30); goto uni6; }
+ else goto uni1;
+ uni6: *dst++ = 0x80 | ((uni>>24)&0x3F);
+ uni5: *dst++ = 0x80 | ((uni>>18)&0x3F);
+ uni4: *dst++ = 0x80 | ((uni>>12)&0x3F);
+ uni3: *dst++ = 0x80 | ((uni>>6)&0x3F);
+ uni2: *dst++ = 0x80 | (uni&0x3F);
+ uni1:;
+ }
+ while(++src < srcend);
+
+done:
+ if(carry) *carry += src - srcbuf;
+ return dst - dstbuf;
+}
+
+///////////////////////// file system ///////////////////////
+
+#ifdef WIN32
+#include <shlobj.h>
+#else
+#include <unistd.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <dirent.h>
+#endif
+
+string homedir = "";
+struct packagedir
+{
+ char *dir, *filter;
+ size_t dirlen, filterlen;
+};
+vector<packagedir> packagedirs;
+
+char *makerelpath(const char *dir, const char *file, const char *prefix, const char *cmd)
+{
+ static string tmp;
+ if(prefix) copystring(tmp, prefix);
+ else tmp[0] = '\0';
+ if(file[0]=='<')
+ {
+ const char *end = strrchr(file, '>');
+ if(end)
+ {
+ size_t len = strlen(tmp);
+ copystring(&tmp[len], file, min(sizeof(tmp)-len, size_t(end+2-file)));
+ file = end+1;
+ }
+ }
+ if(cmd) concatstring(tmp, cmd);
+ if(dir)
+ {
+ defformatstring(pname, "%s/%s", dir, file);
+ concatstring(tmp, pname);
+ }
+ else concatstring(tmp, file);
+ return tmp;
+}
+
+
+char *path(char *s)
+{
+ for(char *curpart = s;;)
+ {
+ char *endpart = strchr(curpart, '&');
+ if(endpart) *endpart = '\0';
+ if(curpart[0]=='<')
+ {
+ char *file = strrchr(curpart, '>');
+ if(!file) return s;
+ curpart = file+1;
+ }
+ for(char *t = curpart; (t = strpbrk(t, "/\\")); *t++ = PATHDIV);
+ for(char *prevdir = NULL, *curdir = curpart;;)
+ {
+ prevdir = curdir[0]==PATHDIV ? curdir+1 : curdir;
+ curdir = strchr(prevdir, PATHDIV);
+ if(!curdir) break;
+ if(prevdir+1==curdir && prevdir[0]=='.')
+ {
+ memmove(prevdir, curdir+1, strlen(curdir+1)+1);
+ curdir = prevdir;
+ }
+ else if(curdir[1]=='.' && curdir[2]=='.' && curdir[3]==PATHDIV)
+ {
+ if(prevdir+2==curdir && prevdir[0]=='.' && prevdir[1]=='.') continue;
+ memmove(prevdir, curdir+4, strlen(curdir+4)+1);
+ if(prevdir-2 >= curpart && prevdir[-1]==PATHDIV)
+ {
+ prevdir -= 2;
+ while(prevdir-1 >= curpart && prevdir[-1] != PATHDIV) --prevdir;
+ }
+ curdir = prevdir;
+ }
+ }
+ if(endpart)
+ {
+ *endpart = '&';
+ curpart = endpart+1;
+ }
+ else break;
+ }
+ return s;
+}
+
+char *path(const char *s, bool copy)
+{
+ static string tmp;
+ copystring(tmp, s);
+ path(tmp);
+ return tmp;
+}
+
+const char *parentdir(const char *directory)
+{
+ const char *p = directory + strlen(directory);
+ while(p > directory && *p != '/' && *p != '\\') p--;
+ static string parent;
+ size_t len = p-directory+1;
+ copystring(parent, directory, len);
+ return parent;
+}
+
+bool fileexists(const char *path, const char *mode)
+{
+ bool exists = true;
+ if(mode[0]=='w' || mode[0]=='a') path = parentdir(path);
+#ifdef WIN32
+ if(GetFileAttributes(path[0] ? path : ".\\") == INVALID_FILE_ATTRIBUTES) exists = false;
+#else
+ if(access(path[0] ? path : ".", mode[0]=='w' || mode[0]=='a' ? W_OK : (mode[0]=='d' ? X_OK : R_OK)) == -1) exists = false;
+#endif
+ return exists;
+}
+
+bool createdir(const char *path)
+{
+ size_t len = strlen(path);
+ if(path[len-1]==PATHDIV)
+ {
+ static string strip;
+ path = copystring(strip, path, len);
+ }
+#ifdef WIN32
+ return CreateDirectory(path, NULL)!=0;
+#else
+ return mkdir(path, 0777)==0;
+#endif
+}
+
+size_t fixpackagedir(char *dir)
+{
+ path(dir);
+ size_t len = strlen(dir);
+ if(len > 0 && dir[len-1] != PATHDIV)
+ {
+ dir[len] = PATHDIV;
+ dir[len+1] = '\0';
+ }
+ return len;
+}
+
+bool subhomedir(char *dst, int len, const char *src)
+{
+ const char *sub = strstr(src, "$HOME");
+ if(!sub) sub = strchr(src, '~');
+ if(sub && sub-src < len)
+ {
+#ifdef WIN32
+ char home[MAX_PATH+1];
+ home[0] = '\0';
+ if(SHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, home) != S_OK || !home[0]) return false;
+#else
+ const char *home = getenv("HOME");
+ if(!home || !home[0]) return false;
+#endif
+ dst[sub-src] = '\0';
+ concatstring(dst, home, len);
+ concatstring(dst, sub+(*sub == '~' ? 1 : strlen("$HOME")), len);
+ }
+ return true;
+}
+
+const char *sethomedir(const char *dir)
+{
+ string pdir;
+ copystring(pdir, dir);
+ if(!subhomedir(pdir, sizeof(pdir), dir) || !fixpackagedir(pdir)) return NULL;
+ copystring(homedir, pdir);
+ return homedir;
+}
+
+const char *addpackagedir(const char *dir)
+{
+ string pdir;
+ copystring(pdir, dir);
+ if(!subhomedir(pdir, sizeof(pdir), dir) || !fixpackagedir(pdir)) return NULL;
+ char *filter = pdir;
+ for(;;)
+ {
+ static int len = strlen("packages");
+ filter = strstr(filter, "packages");
+ if(!filter) break;
+ if(filter > pdir && filter[-1] == PATHDIV && filter[len] == PATHDIV) break;
+ filter += len;
+ }
+ packagedir &pf = packagedirs.add();
+ pf.dir = filter ? newstring(pdir, filter-pdir) : newstring(pdir);
+ pf.dirlen = filter ? filter-pdir : strlen(pdir);
+ pf.filter = filter ? newstring(filter) : NULL;
+ pf.filterlen = filter ? strlen(filter) : 0;
+ return pf.dir;
+}
+
+const char *findfile(const char *filename, const char *mode)
+{
+ static string s;
+ if(homedir[0])
+ {
+ formatstring(s, "%s%s", homedir, filename);
+ if(fileexists(s, mode)) return s;
+ if(mode[0]=='w' || mode[0]=='a')
+ {
+ string dirs;
+ copystring(dirs, s);
+ char *dir = strchr(dirs[0]==PATHDIV ? dirs+1 : dirs, PATHDIV);
+ while(dir)
+ {
+ *dir = '\0';
+ if(!fileexists(dirs, "d") && !createdir(dirs)) return s;
+ *dir = PATHDIV;
+ dir = strchr(dir+1, PATHDIV);
+ }
+ return s;
+ }
+ }
+ if(mode[0]=='w' || mode[0]=='a') return filename;
+ loopv(packagedirs)
+ {
+ packagedir &pf = packagedirs[i];
+ if(pf.filter && strncmp(filename, pf.filter, pf.filterlen)) continue;
+ formatstring(s, "%s%s", pf.dir, filename);
+ if(fileexists(s, mode)) return s;
+ }
+ if(mode[0]=='e') return NULL;
+ return filename;
+}
+
+bool listdir(const char *dirname, bool rel, const char *ext, vector<char *> &files)
+{
+ size_t extsize = ext ? strlen(ext)+1 : 0;
+#ifdef WIN32
+ defformatstring(pathname, rel ? ".\\%s\\*.%s" : "%s\\*.%s", dirname, ext ? ext : "*");
+ WIN32_FIND_DATA FindFileData;
+ HANDLE Find = FindFirstFile(pathname, &FindFileData);
+ if(Find != INVALID_HANDLE_VALUE)
+ {
+ do {
+ if(!ext) files.add(newstring(FindFileData.cFileName));
+ else
+ {
+ size_t namelen = strlen(FindFileData.cFileName);
+ if(namelen > extsize)
+ {
+ namelen -= extsize;
+ if(FindFileData.cFileName[namelen] == '.' && strncmp(FindFileData.cFileName+namelen+1, ext, extsize-1)==0)
+ files.add(newstring(FindFileData.cFileName, namelen));
+ }
+ }
+ } while(FindNextFile(Find, &FindFileData));
+ FindClose(Find);
+ return true;
+ }
+#else
+ defformatstring(pathname, rel ? "./%s" : "%s", dirname);
+ DIR *d = opendir(pathname);
+ if(d)
+ {
+ struct dirent *de;
+ while((de = readdir(d)) != NULL)
+ {
+ if(!ext) files.add(newstring(de->d_name));
+ else
+ {
+ size_t namelen = strlen(de->d_name);
+ if(namelen > extsize)
+ {
+ namelen -= extsize;
+ if(de->d_name[namelen] == '.' && strncmp(de->d_name+namelen+1, ext, extsize-1)==0)
+ files.add(newstring(de->d_name, namelen));
+ }
+ }
+ }
+ closedir(d);
+ return true;
+ }
+#endif
+ else return false;
+}
+
+int listfiles(const char *dir, const char *ext, vector<char *> &files)
+{
+ string dirname;
+ copystring(dirname, dir);
+ path(dirname);
+ size_t dirlen = strlen(dirname);
+ while(dirlen > 1 && dirname[dirlen-1] == PATHDIV) dirname[--dirlen] = '\0';
+ int dirs = 0;
+ if(listdir(dirname, true, ext, files)) dirs++;
+ string s;
+ if(homedir[0])
+ {
+ formatstring(s, "%s%s", homedir, dirname);
+ if(listdir(s, false, ext, files)) dirs++;
+ }
+ loopv(packagedirs)
+ {
+ packagedir &pf = packagedirs[i];
+ if(pf.filter && strncmp(dirname, pf.filter, dirlen == pf.filterlen-1 ? dirlen : pf.filterlen))
+ continue;
+ formatstring(s, "%s%s", pf.dir, dirname);
+ if(listdir(s, false, ext, files)) dirs++;
+ }
+#ifndef STANDALONE
+ dirs += listzipfiles(dirname, ext, files);
+#endif
+ return dirs;
+}
+
+#ifndef STANDALONE
+static Sint64 rwopsseek(SDL_RWops *rw, Sint64 pos, int whence)
+{
+ stream *f = (stream *)rw->hidden.unknown.data1;
+ if((!pos && whence==SEEK_CUR) || f->seek(pos, whence)) return (int)f->tell();
+ return -1;
+}
+
+static size_t rwopsread(SDL_RWops *rw, void *buf, size_t size, size_t nmemb)
+{
+ stream *f = (stream *)rw->hidden.unknown.data1;
+ return f->read(buf, size*nmemb)/size;
+}
+
+static size_t rwopswrite(SDL_RWops *rw, const void *buf, size_t size, size_t nmemb)
+{
+ stream *f = (stream *)rw->hidden.unknown.data1;
+ return f->write(buf, size*nmemb)/size;
+}
+
+static int rwopsclose(SDL_RWops *rw)
+{
+ return 0;
+}
+
+SDL_RWops *stream::rwops()
+{
+ SDL_RWops *rw = SDL_AllocRW();
+ if(!rw) return NULL;
+ rw->hidden.unknown.data1 = this;
+ rw->seek = rwopsseek;
+ rw->read = rwopsread;
+ rw->write = rwopswrite;
+ rw->close = rwopsclose;
+ return rw;
+}
+#endif
+
+stream::offset stream::size()
+{
+ offset pos = tell(), endpos;
+ if(pos < 0 || !seek(0, SEEK_END)) return -1;
+ endpos = tell();
+ return pos == endpos || seek(pos, SEEK_SET) ? endpos : -1;
+}
+
+bool stream::getline(char *str, size_t len)
+{
+ loopi(len-1)
+ {
+ if(read(&str[i], 1) != 1) { str[i] = '\0'; return i > 0; }
+ else if(str[i] == '\n') { str[i+1] = '\0'; return true; }
+ }
+ if(len > 0) str[len-1] = '\0';
+ return true;
+}
+
+size_t stream::printf(const char *fmt, ...)
+{
+ char buf[512];
+ char *str = buf;
+ va_list args;
+#if defined(WIN32) && !defined(__GNUC__)
+ va_start(args, fmt);
+ int len = _vscprintf(fmt, args);
+ if(len <= 0) { va_end(args); return 0; }
+ if(len >= (int)sizeof(buf)) str = new char[len+1];
+ _vsnprintf(str, len+1, fmt, args);
+ va_end(args);
+#else
+ va_start(args, fmt);
+ int len = vsnprintf(buf, sizeof(buf), fmt, args);
+ va_end(args);
+ if(len <= 0) return 0;
+ if(len >= (int)sizeof(buf))
+ {
+ str = new char[len+1];
+ va_start(args, fmt);
+ vsnprintf(str, len+1, fmt, args);
+ va_end(args);
+ }
+#endif
+ size_t n = write(str, len);
+ if(str != buf) delete[] str;
+ return n;
+}
+
+struct filestream : stream
+{
+ FILE *file;
+
+ filestream() : file(NULL) {}
+ ~filestream() { close(); }
+
+ bool open(const char *name, const char *mode)
+ {
+ if(file) return false;
+ file = fopen(name, mode);
+ return file!=NULL;
+ }
+
+ bool opentemp(const char *name, const char *mode)
+ {
+ if(file) return false;
+#ifdef WIN32
+ file = fopen(name, mode);
+#else
+ file = tmpfile();
+#endif
+ return file!=NULL;
+ }
+
+ void close()
+ {
+ if(file) { fclose(file); file = NULL; }
+ }
+
+ bool end() { return feof(file)!=0; }
+ offset tell()
+ {
+#ifdef WIN32
+#if defined(__GNUC__) && !defined(__MINGW32__)
+ offset off = ftello64(file);
+#else
+ offset off = _ftelli64(file);
+#endif
+#else
+ offset off = ftello(file);
+#endif
+ // ftello returns LONG_MAX for directories on some platforms
+ return off + 1 >= 0 ? off : -1;
+ }
+ bool seek(offset pos, int whence)
+ {
+#ifdef WIN32
+#if defined(__GNUC__) && !defined(__MINGW32__)
+ return fseeko64(file, pos, whence) >= 0;
+#else
+ return _fseeki64(file, pos, whence) >= 0;
+#endif
+#else
+ return fseeko(file, pos, whence) >= 0;
+#endif
+ }
+
+ size_t read(void *buf, size_t len) { return fread(buf, 1, len, file); }
+ size_t write(const void *buf, size_t len) { return fwrite(buf, 1, len, file); }
+ bool flush() { return !fflush(file); }
+ int getchar() { return fgetc(file); }
+ bool putchar(int c) { return fputc(c, file)!=EOF; }
+ bool getline(char *str, size_t len) { return fgets(str, len, file)!=NULL; }
+ bool putstring(const char *str) { return fputs(str, file)!=EOF; }
+
+ size_t printf(const char *fmt, ...)
+ {
+ va_list v;
+ va_start(v, fmt);
+ int result = vfprintf(file, fmt, v);
+ va_end(v);
+ return max(result, 0);
+ }
+};
+
+#ifndef STANDALONE
+VAR(dbggz, 0, 0, 1);
+#endif
+
+struct gzstream : stream
+{
+ enum
+ {
+ MAGIC1 = 0x1F,
+ MAGIC2 = 0x8B,
+ BUFSIZE = 16384,
+ OS_UNIX = 0x03
+ };
+
+ enum
+ {
+ F_ASCII = 0x01,
+ F_CRC = 0x02,
+ F_EXTRA = 0x04,
+ F_NAME = 0x08,
+ F_COMMENT = 0x10,
+ F_RESERVED = 0xE0
+ };
+
+ stream *file;
+ z_stream zfile;
+ uchar *buf;
+ bool reading, writing, autoclose;
+ uint crc;
+ size_t headersize;
+
+ gzstream() : file(NULL), buf(NULL), reading(false), writing(false), autoclose(false), crc(0), headersize(0)
+ {
+ zfile.zalloc = NULL;
+ zfile.zfree = NULL;
+ zfile.opaque = NULL;
+ zfile.next_in = zfile.next_out = NULL;
+ zfile.avail_in = zfile.avail_out = 0;
+ }
+
+ ~gzstream()
+ {
+ close();
+ }
+
+ void writeheader()
+ {
+ uchar header[] = { MAGIC1, MAGIC2, Z_DEFLATED, 0, 0, 0, 0, 0, 0, OS_UNIX };
+ file->write(header, sizeof(header));
+ }
+
+ void readbuf(size_t size = BUFSIZE)
+ {
+ if(!zfile.avail_in) zfile.next_in = (Bytef *)buf;
+ size = min(size, size_t(&buf[BUFSIZE] - &zfile.next_in[zfile.avail_in]));
+ size_t n = file->read(zfile.next_in + zfile.avail_in, size);
+ if(n > 0) zfile.avail_in += n;
+ }
+
+ uchar readbyte(size_t size = BUFSIZE)
+ {
+ if(!zfile.avail_in) readbuf(size);
+ if(!zfile.avail_in) return 0;
+ zfile.avail_in--;
+ return *(uchar *)zfile.next_in++;
+ }
+
+ void skipbytes(size_t n)
+ {
+ while(n > 0 && zfile.avail_in > 0)
+ {
+ size_t skipped = min(n, size_t(zfile.avail_in));
+ zfile.avail_in -= skipped;
+ zfile.next_in += skipped;
+ n -= skipped;
+ }
+ if(n <= 0) return;
+ file->seek(n, SEEK_CUR);
+ }
+
+ bool checkheader()
+ {
+ readbuf(10);
+ if(readbyte() != MAGIC1 || readbyte() != MAGIC2 || readbyte() != Z_DEFLATED) return false;
+ uchar flags = readbyte();
+ if(flags & F_RESERVED) return false;
+ skipbytes(6);
+ if(flags & F_EXTRA)
+ {
+ size_t len = readbyte(512);
+ len |= size_t(readbyte(512))<<8;
+ skipbytes(len);
+ }
+ if(flags & F_NAME) while(readbyte(512));
+ if(flags & F_COMMENT) while(readbyte(512));
+ if(flags & F_CRC) skipbytes(2);
+ headersize = size_t(file->tell() - zfile.avail_in);
+ return zfile.avail_in > 0 || !file->end();
+ }
+
+ bool open(stream *f, const char *mode, bool needclose, int level)
+ {
+ if(file) return false;
+ for(; *mode; mode++)
+ {
+ if(*mode=='r') { reading = true; break; }
+ else if(*mode=='w') { writing = true; break; }
+ }
+ if(reading)
+ {
+ if(inflateInit2(&zfile, -MAX_WBITS) != Z_OK) reading = false;
+ }
+ else if(writing && deflateInit2(&zfile, level, Z_DEFLATED, -MAX_WBITS, min(MAX_MEM_LEVEL, 8), Z_DEFAULT_STRATEGY) != Z_OK) writing = false;
+ if(!reading && !writing) return false;
+
+ file = f;
+ crc = crc32(0, NULL, 0);
+ buf = new uchar[BUFSIZE];
+
+ if(reading)
+ {
+ if(!checkheader()) { stopreading(); return false; }
+ }
+ else if(writing) writeheader();
+
+ autoclose = needclose;
+ return true;
+ }
+
+ uint getcrc() { return crc; }
+
+ void finishreading()
+ {
+ if(!reading) return;
+#ifndef STANDALONE
+ if(dbggz)
+ {
+ uint checkcrc = 0, checksize = 0;
+ loopi(4) checkcrc |= uint(readbyte()) << (i*8);
+ loopi(4) checksize |= uint(readbyte()) << (i*8);
+ if(checkcrc != crc)
+ conoutf(CON_DEBUG, "gzip crc check failed: read %X, calculated %X", checkcrc, crc);
+ if(checksize != zfile.total_out)
+ conoutf(CON_DEBUG, "gzip size check failed: read %u, calculated %u", checksize, uint(zfile.total_out));
+ }
+#endif
+ }
+
+ void stopreading()
+ {
+ if(!reading) return;
+ inflateEnd(&zfile);
+ reading = false;
+ }
+
+ void finishwriting()
+ {
+ if(!writing) return;
+ for(;;)
+ {
+ int err = zfile.avail_out > 0 ? deflate(&zfile, Z_FINISH) : Z_OK;
+ if(err != Z_OK && err != Z_STREAM_END) break;
+ flushbuf();
+ if(err == Z_STREAM_END) break;
+ }
+ uchar trailer[8] =
+ {
+ uchar(crc&0xFF), uchar((crc>>8)&0xFF), uchar((crc>>16)&0xFF), uchar((crc>>24)&0xFF),
+ uchar(zfile.total_in&0xFF), uchar((zfile.total_in>>8)&0xFF), uchar((zfile.total_in>>16)&0xFF), uchar((zfile.total_in>>24)&0xFF)
+ };
+ file->write(trailer, sizeof(trailer));
+ }
+
+ void stopwriting()
+ {
+ if(!writing) return;
+ deflateEnd(&zfile);
+ writing = false;
+ }
+
+ void close()
+ {
+ if(reading) finishreading();
+ stopreading();
+ if(writing) finishwriting();
+ stopwriting();
+ DELETEA(buf);
+ if(autoclose) DELETEP(file);
+ }
+
+ bool end() { return !reading && !writing; }
+ offset tell() { return reading ? zfile.total_out : (writing ? zfile.total_in : offset(-1)); }
+ offset rawtell() { return file ? file->tell() : offset(-1); }
+
+ offset size()
+ {
+ if(!file) return -1;
+ offset pos = tell();
+ if(!file->seek(-4, SEEK_END)) return -1;
+ uint isize = file->getlil<uint>();
+ return file->seek(pos, SEEK_SET) ? isize : offset(-1);
+ }
+
+ offset rawsize() { return file ? file->size() : offset(-1); }
+
+ bool seek(offset pos, int whence)
+ {
+ if(writing || !reading) return false;
+
+ if(whence == SEEK_END)
+ {
+ uchar skip[512];
+ while(read(skip, sizeof(skip)) == sizeof(skip));
+ return !pos;
+ }
+ else if(whence == SEEK_CUR) pos += zfile.total_out;
+
+ if(pos >= (offset)zfile.total_out) pos -= zfile.total_out;
+ else if(pos < 0 || !file->seek(headersize, SEEK_SET)) return false;
+ else
+ {
+ if(zfile.next_in && zfile.total_in <= uint(zfile.next_in - buf))
+ {
+ zfile.avail_in += zfile.total_in;
+ zfile.next_in -= zfile.total_in;
+ }
+ else
+ {
+ zfile.avail_in = 0;
+ zfile.next_in = NULL;
+ }
+ inflateReset(&zfile);
+ crc = crc32(0, NULL, 0);
+ }
+
+ uchar skip[512];
+ while(pos > 0)
+ {
+ size_t skipped = (size_t)min(pos, (offset)sizeof(skip));
+ if(read(skip, skipped) != skipped) { stopreading(); return false; }
+ pos -= skipped;
+ }
+
+ return true;
+ }
+
+ size_t read(void *buf, size_t len)
+ {
+ if(!reading || !buf || !len) return 0;
+ zfile.next_out = (Bytef *)buf;
+ zfile.avail_out = len;
+ while(zfile.avail_out > 0)
+ {
+ if(!zfile.avail_in)
+ {
+ readbuf(BUFSIZE);
+ if(!zfile.avail_in) { stopreading(); break; }
+ }
+ int err = inflate(&zfile, Z_NO_FLUSH);
+ if(err == Z_STREAM_END) { crc = crc32(crc, (Bytef *)buf, len - zfile.avail_out); finishreading(); stopreading(); return len - zfile.avail_out; }
+ else if(err != Z_OK) { stopreading(); break; }
+ }
+ crc = crc32(crc, (Bytef *)buf, len - zfile.avail_out);
+ return len - zfile.avail_out;
+ }
+
+ bool flushbuf(bool full = false)
+ {
+ if(full) deflate(&zfile, Z_SYNC_FLUSH);
+ if(zfile.next_out && zfile.avail_out < BUFSIZE)
+ {
+ if(file->write(buf, BUFSIZE - zfile.avail_out) != BUFSIZE - zfile.avail_out || (full && !file->flush()))
+ return false;
+ }
+ zfile.next_out = buf;
+ zfile.avail_out = BUFSIZE;
+ return true;
+ }
+
+ bool flush() { return flushbuf(true); }
+
+ size_t write(const void *buf, size_t len)
+ {
+ if(!writing || !buf || !len) return 0;
+ zfile.next_in = (Bytef *)buf;
+ zfile.avail_in = len;
+ while(zfile.avail_in > 0)
+ {
+ if(!zfile.avail_out && !flushbuf()) { stopwriting(); break; }
+ int err = deflate(&zfile, Z_NO_FLUSH);
+ if(err != Z_OK) { stopwriting(); break; }
+ }
+ crc = crc32(crc, (Bytef *)buf, len - zfile.avail_in);
+ return len - zfile.avail_in;
+ }
+};
+
+struct utf8stream : stream
+{
+ enum
+ {
+ BUFSIZE = 4096
+ };
+ stream *file;
+ offset pos;
+ size_t bufread, bufcarry, buflen;
+ bool reading, writing, autoclose;
+ uchar buf[BUFSIZE];
+
+ utf8stream() : file(NULL), pos(0), bufread(0), bufcarry(0), buflen(0), reading(false), writing(false), autoclose(false)
+ {
+ }
+
+ ~utf8stream()
+ {
+ close();
+ }
+
+ bool readbuf(size_t size = BUFSIZE)
+ {
+ if(bufread >= bufcarry) { if(bufcarry > 0 && bufcarry < buflen) memmove(buf, &buf[bufcarry], buflen - bufcarry); buflen -= bufcarry; bufread = bufcarry = 0; }
+ size_t n = file->read(&buf[buflen], min(size, BUFSIZE - buflen));
+ if(n <= 0) return false;
+ buflen += n;
+ size_t carry = bufcarry;
+ bufcarry += decodeutf8(&buf[bufcarry], BUFSIZE-bufcarry, &buf[bufcarry], buflen-bufcarry, &carry);
+ if(carry > bufcarry && carry < buflen) { memmove(&buf[bufcarry], &buf[carry], buflen - carry); buflen -= carry - bufcarry; }
+ return true;
+ }
+
+ bool checkheader()
+ {
+ size_t n = file->read(buf, 3);
+ if(n == 3 && buf[0] == 0xEF && buf[1] == 0xBB && buf[2] == 0xBF) return true;
+ buflen = n;
+ return false;
+ }
+
+ bool open(stream *f, const char *mode, bool needclose)
+ {
+ if(file) return false;
+ for(; *mode; mode++)
+ {
+ if(*mode=='r') { reading = true; break; }
+ else if(*mode=='w') { writing = true; break; }
+ }
+ if(!reading && !writing) return false;
+
+ file = f;
+
+ if(reading) checkheader();
+
+ autoclose = needclose;
+ return true;
+ }
+
+ void finishreading()
+ {
+ if(!reading) return;
+ }
+
+ void stopreading()
+ {
+ if(!reading) return;
+ reading = false;
+ }
+
+ void stopwriting()
+ {
+ if(!writing) return;
+ writing = false;
+ }
+
+ void close()
+ {
+ stopreading();
+ stopwriting();
+ if(autoclose) DELETEP(file);
+ }
+
+ bool end() { return !reading && !writing; }
+ offset tell() { return reading || writing ? pos : offset(-1); }
+
+ bool seek(offset off, int whence)
+ {
+ if(writing || !reading) return false;
+
+ if(whence == SEEK_END)
+ {
+ uchar skip[512];
+ while(read(skip, sizeof(skip)) == sizeof(skip));
+ return !off;
+ }
+ else if(whence == SEEK_CUR) off += pos;
+
+ if(off >= pos) off -= pos;
+ else if(off < 0 || !file->seek(0, SEEK_SET)) return false;
+ else
+ {
+ bufread = bufcarry = buflen = 0;
+ pos = 0;
+ checkheader();
+ }
+
+ uchar skip[512];
+ while(off > 0)
+ {
+ size_t skipped = (size_t)min(off, (offset)sizeof(skip));
+ if(read(skip, skipped) != skipped) { stopreading(); return false; }
+ off -= skipped;
+ }
+
+ return true;
+ }
+
+ size_t read(void *dst, size_t len)
+ {
+ if(!reading || !dst || !len) return 0;
+ size_t next = 0;
+ while(next < len)
+ {
+ if(bufread >= bufcarry) { if(readbuf(BUFSIZE)) continue; stopreading(); break; }
+ size_t n = min(len - next, bufcarry - bufread);
+ memcpy(&((uchar *)dst)[next], &buf[bufread], n);
+ next += n;
+ bufread += n;
+ }
+ pos += next;
+ return next;
+ }
+
+ bool getline(char *dst, size_t len)
+ {
+ if(!reading || !dst || !len) return false;
+ --len;
+ size_t next = 0;
+ while(next < len)
+ {
+ if(bufread >= bufcarry) { if(readbuf(BUFSIZE)) continue; stopreading(); if(!next) return false; break; }
+ size_t n = min(len - next, bufcarry - bufread);
+ uchar *endline = (uchar *)memchr(&buf[bufread], '\n', n);
+ if(endline) { n = endline+1 - &buf[bufread]; len = next + n; }
+ memcpy(&((uchar *)dst)[next], &buf[bufread], n);
+ next += n;
+ bufread += n;
+ }
+ dst[next] = '\0';
+ pos += next;
+ return true;
+ }
+
+ size_t write(const void *src, size_t len)
+ {
+ if(!writing || !src || !len) return 0;
+ uchar dst[512];
+ size_t next = 0;
+ while(next < len)
+ {
+ size_t carry = 0, n = encodeutf8(dst, sizeof(dst), &((uchar *)src)[next], len - next, &carry);
+ if(n > 0 && file->write(dst, n) != n) { stopwriting(); break; }
+ next += carry;
+ }
+ pos += next;
+ return next;
+ }
+
+ bool flush() { return file->flush(); }
+};
+
+stream *openrawfile(const char *filename, const char *mode)
+{
+ const char *found = findfile(filename, mode);
+ if(!found) return NULL;
+ filestream *file = new filestream;
+ if(!file->open(found, mode)) { delete file; return NULL; }
+ return file;
+}
+
+stream *openfile(const char *filename, const char *mode)
+{
+#ifndef STANDALONE
+ stream *s = openzipfile(filename, mode);
+ if(s) return s;
+#endif
+ return openrawfile(filename, mode);
+}
+
+stream *opentempfile(const char *name, const char *mode)
+{
+ const char *found = findfile(name, mode);
+ filestream *file = new filestream;
+ if(!file->opentemp(found ? found : name, mode)) { delete file; return NULL; }
+ return file;
+}
+
+stream *opengzfile(const char *filename, const char *mode, stream *file, int level)
+{
+ stream *source = file ? file : openfile(filename, mode);
+ if(!source) return NULL;
+ gzstream *gz = new gzstream;
+ if(!gz->open(source, mode, !file, level)) { if(!file) delete source; delete gz; return NULL; }
+ return gz;
+}
+
+stream *openutf8file(const char *filename, const char *mode, stream *file)
+{
+ stream *source = file ? file : openfile(filename, mode);
+ if(!source) return NULL;
+ utf8stream *utf8 = new utf8stream;
+ if(!utf8->open(source, mode, !file)) { if(!file) delete source; delete utf8; return NULL; }
+ return utf8;
+}
+
+char *loadfile(const char *fn, size_t *size, bool utf8)
+{
+ stream *f = openfile(fn, "rb");
+ if(!f) return NULL;
+ stream::offset fsize = f->size();
+ if(fsize <= 0) { delete f; return NULL; }
+ size_t len = fsize;
+ char *buf = new (false) char[len+1];
+ if(!buf) { delete f; return NULL; }
+ size_t offset = 0;
+ if(utf8 && len >= 3)
+ {
+ if(f->read(buf, 3) != 3) { delete f; delete[] buf; return NULL; }
+ if(((uchar *)buf)[0] == 0xEF && ((uchar *)buf)[1] == 0xBB && ((uchar *)buf)[2] == 0xBF) len -= 3;
+ else offset += 3;
+ }
+ size_t rlen = f->read(&buf[offset], len-offset);
+ delete f;
+ if(rlen != len-offset) { delete[] buf; return NULL; }
+ if(utf8) len = decodeutf8((uchar *)buf, len, (uchar *)buf, len);
+ buf[len] = '\0';
+ if(size!=NULL) *size = len;
+ return buf;
+}
+
diff --git a/src/shared/tools.cpp b/src/shared/tools.cpp
new file mode 100644
index 0000000..ca82e8f
--- /dev/null
+++ b/src/shared/tools.cpp
@@ -0,0 +1,244 @@
+// implementation of generic tools
+
+#include "cube.h"
+
+void *operator new(size_t size)
+{
+ void *p = malloc(size);
+ if(!p) abort();
+ return p;
+}
+
+void *operator new[](size_t size)
+{
+ void *p = malloc(size);
+ if(!p) abort();
+ return p;
+}
+
+void operator delete(void *p) { if(p) free(p); }
+
+void operator delete[](void *p) { if(p) free(p); }
+
+void *operator new(size_t size, bool err)
+{
+ void *p = malloc(size);
+ if(!p && err) abort();
+ return p;
+}
+
+void *operator new[](size_t size, bool err)
+{
+ void *p = malloc(size);
+ if(!p && err) abort();
+ return p;
+}
+
+////////////////////////// rnd numbers ////////////////////////////////////////
+
+#define N (624)
+#define M (397)
+#define K (0x9908B0DFU)
+
+static uint state[N];
+static int next = N;
+
+void seedMT(uint seed)
+{
+ state[0] = seed;
+ for(uint i = 1; i < N; i++)
+ state[i] = seed = 1812433253U * (seed ^ (seed >> 30)) + i;
+ next = 0;
+}
+
+uint randomMT()
+{
+ int cur = next;
+ if(++next >= N)
+ {
+ if(next > N) { seedMT(5489U + time(NULL)); cur = next++; }
+ else next = 0;
+ }
+ uint y = (state[cur] & 0x80000000U) | (state[next] & 0x7FFFFFFFU);
+ state[cur] = y = state[cur < N-M ? cur + M : cur + M-N] ^ (y >> 1) ^ (-int(y & 1U) & K);
+ y ^= (y >> 11);
+ y ^= (y << 7) & 0x9D2C5680U;
+ y ^= (y << 15) & 0xEFC60000U;
+ y ^= (y >> 18);
+ return y;
+}
+
+///////////////////////// network ///////////////////////
+
+// all network traffic is in 32bit ints, which are then compressed using the following simple scheme (assumes that most values are small).
+
+template<class T>
+static inline void putint_(T &p, int n)
+{
+ if(n<128 && n>-127) p.put(n);
+ else if(n<0x8000 && n>=-0x8000) { p.put(0x80); p.put(n); p.put(n>>8); }
+ else { p.put(0x81); p.put(n); p.put(n>>8); p.put(n>>16); p.put(n>>24); }
+}
+void putint(ucharbuf &p, int n) { putint_(p, n); }
+void putint(packetbuf &p, int n) { putint_(p, n); }
+void putint(vector<uchar> &p, int n) { putint_(p, n); }
+
+int getint(ucharbuf &p)
+{
+ int c = (schar)p.get();
+ if(c==-128) { int n = p.get(); n |= ((schar)p.get())<<8; return n; }
+ else if(c==-127) { int n = p.get(); n |= p.get()<<8; n |= p.get()<<16; return n|(p.get()<<24); }
+ else return c;
+}
+
+// much smaller encoding for unsigned integers up to 28 bits, but can handle signed
+template<class T>
+static inline void putuint_(T &p, int n)
+{
+ if(n < 0 || n >= (1<<21))
+ {
+ p.put(0x80 | (n & 0x7F));
+ p.put(0x80 | ((n >> 7) & 0x7F));
+ p.put(0x80 | ((n >> 14) & 0x7F));
+ p.put(n >> 21);
+ }
+ else if(n < (1<<7)) p.put(n);
+ else if(n < (1<<14))
+ {
+ p.put(0x80 | (n & 0x7F));
+ p.put(n >> 7);
+ }
+ else
+ {
+ p.put(0x80 | (n & 0x7F));
+ p.put(0x80 | ((n >> 7) & 0x7F));
+ p.put(n >> 14);
+ }
+}
+void putuint(ucharbuf &p, int n) { putuint_(p, n); }
+void putuint(packetbuf &p, int n) { putuint_(p, n); }
+void putuint(vector<uchar> &p, int n) { putuint_(p, n); }
+
+int getuint(ucharbuf &p)
+{
+ int n = p.get();
+ if(n & 0x80)
+ {
+ n += (p.get() << 7) - 0x80;
+ if(n & (1<<14)) n += (p.get() << 14) - (1<<14);
+ if(n & (1<<21)) n += (p.get() << 21) - (1<<21);
+ if(n & (1<<28)) n |= ~0U<<28;
+ }
+ return n;
+}
+
+template<class T>
+static inline void putfloat_(T &p, float f)
+{
+ lilswap(&f, 1);
+ p.put((uchar *)&f, sizeof(float));
+}
+void putfloat(ucharbuf &p, float f) { putfloat_(p, f); }
+void putfloat(packetbuf &p, float f) { putfloat_(p, f); }
+void putfloat(vector<uchar> &p, float f) { putfloat_(p, f); }
+
+float getfloat(ucharbuf &p)
+{
+ float f;
+ p.get((uchar *)&f, sizeof(float));
+ return lilswap(f);
+}
+
+template<class T>
+static inline void sendstring_(const char *t, T &p)
+{
+ while(*t) putint(p, *t++);
+ putint(p, 0);
+}
+void sendstring(const char *t, ucharbuf &p) { sendstring_(t, p); }
+void sendstring(const char *t, packetbuf &p) { sendstring_(t, p); }
+void sendstring(const char *t, vector<uchar> &p) { sendstring_(t, p); }
+
+void getstring(char *text, ucharbuf &p, size_t len)
+{
+ char *t = text;
+ do
+ {
+ if(t>=&text[len]) { text[len-1] = 0; return; }
+ if(!p.remaining()) { *t = 0; return; }
+ *t = getint(p);
+ }
+ while(*t++);
+}
+
+void filtertext(char *dst, const char *src, bool whitespace, bool forcespace, size_t len)
+{
+ for(int c = uchar(*src); c; c = uchar(*++src))
+ {
+ if(c == '\f')
+ {
+ if(!*++src) break;
+ continue;
+ }
+ if(!iscubeprint(c))
+ {
+ if(!iscubespace(c) || !whitespace) continue;
+ if(forcespace) c = ' ';
+ }
+ *dst++ = c;
+ if(!--len) break;
+ }
+ *dst = '\0';
+}
+
+void ipmask::parse(const char *name)
+{
+ union { uchar b[sizeof(enet_uint32)]; enet_uint32 i; } ipconv, maskconv;
+ ipconv.i = 0;
+ maskconv.i = 0;
+ loopi(4)
+ {
+ char *end = NULL;
+ int n = strtol(name, &end, 10);
+ if(!end) break;
+ if(end > name) { ipconv.b[i] = n; maskconv.b[i] = 0xFF; }
+ name = end;
+ while(int c = *name)
+ {
+ ++name;
+ if(c == '.') break;
+ if(c == '/')
+ {
+ int range = clamp(int(strtol(name, NULL, 10)), 0, 32);
+ mask = range ? ENET_HOST_TO_NET_32(0xFFffFFff << (32 - range)) : maskconv.i;
+ ip = ipconv.i & mask;
+ return;
+ }
+ }
+ }
+ ip = ipconv.i;
+ mask = maskconv.i;
+}
+
+int ipmask::print(char *buf) const
+{
+ char *start = buf;
+ union { uchar b[sizeof(enet_uint32)]; enet_uint32 i; } ipconv, maskconv;
+ ipconv.i = ip;
+ maskconv.i = mask;
+ int lastdigit = -1;
+ loopi(4) if(maskconv.b[i])
+ {
+ if(lastdigit >= 0) *buf++ = '.';
+ loopj(i - lastdigit - 1) { *buf++ = '*'; *buf++ = '.'; }
+ buf += sprintf(buf, "%d", ipconv.b[i]);
+ lastdigit = i;
+ }
+ enet_uint32 bits = ~ENET_NET_TO_HOST_32(mask);
+ int range = 32;
+ for(; (bits&0xFF) == 0xFF; bits >>= 8) range -= 8;
+ for(; bits&1; bits >>= 1) --range;
+ if(!bits && range%8) buf += sprintf(buf, "/%d", range);
+ return int(buf-start);
+}
+
diff --git a/src/shared/tools.h b/src/shared/tools.h
new file mode 100644
index 0000000..c66f5bd
--- /dev/null
+++ b/src/shared/tools.h
@@ -0,0 +1,1408 @@
+// generic useful stuff for any C++ program
+
+#ifndef _TOOLS_H
+#define _TOOLS_H
+
+#ifdef NULL
+#undef NULL
+#endif
+#define NULL 0
+
+typedef signed char schar;
+typedef unsigned char uchar;
+typedef unsigned short ushort;
+typedef unsigned int uint;
+typedef unsigned long ulong;
+typedef signed long long int llong;
+typedef unsigned long long int ullong;
+
+#ifdef _DEBUG
+#define ASSERT(c) assert(c)
+#else
+#define ASSERT(c) if(c) {}
+#endif
+
+#if defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1400)
+#define RESTRICT __restrict
+#else
+#define RESTRICT
+#endif
+
+#ifdef __GNUC__
+#define UNUSED __attribute__((unused))
+#else
+#define UNUSED
+#endif
+
+void *operator new(size_t, bool);
+void *operator new[](size_t, bool);
+inline void *operator new(size_t, void *p) { return p; }
+inline void *operator new[](size_t, void *p) { return p; }
+inline void operator delete(void *, void *) {}
+inline void operator delete[](void *, void *) {}
+
+#ifdef swap
+#undef swap
+#endif
+template<class T>
+static inline void swap(T &a, T &b)
+{
+ T t = a;
+ a = b;
+ b = t;
+}
+#ifdef max
+#undef max
+#endif
+#ifdef min
+#undef min
+#endif
+template<class T>
+static inline T max(T a, T b)
+{
+ return a > b ? a : b;
+}
+template<class T>
+static inline T min(T a, T b)
+{
+ return a < b ? a : b;
+}
+template<class T, class U>
+static inline T clamp(T a, U b, U c)
+{
+ return max(T(b), min(a, T(c)));
+}
+
+#ifdef __GNUC__
+#define bitscan(mask) (__builtin_ffs(mask)-1)
+#else
+#ifdef WIN32
+#pragma intrinsic(_BitScanForward)
+static inline int bitscan(uint mask)
+{
+ ulong i;
+ return _BitScanForward(&i, mask) ? i : -1;
+}
+#else
+static inline int bitscan(uint mask)
+{
+ if(!mask) return -1;
+ int i = 1;
+ if(!(mask&0xFFFF)) { i += 16; mask >>= 16; }
+ if(!(mask&0xFF)) { i += 8; mask >>= 8; }
+ if(!(mask&0xF)) { i += 4; mask >>= 4; }
+ if(!(mask&3)) { i += 2; mask >>= 2; }
+ return i - (mask&1);
+}
+#endif
+#endif
+
+#define rnd(x) ((int)(randomMT()&0x7FFFFFFF)%(x))
+#define rndscale(x) (float((randomMT()&0x7FFFFFFF)*double(x)/double(0x7FFFFFFF)))
+#define detrnd(s, x) ((int)(((((uint)(s))*1103515245+12345)>>16)%(x)))
+
+#define loop(v,m) for(int v = 0; v < int(m); ++v)
+#define loopi(m) loop(i,m)
+#define loopj(m) loop(j,m)
+#define loopk(m) loop(k,m)
+#define loopl(m) loop(l,m)
+#define looprev(v,m) for(int v = int(m); --v >= 0;)
+#define loopirev(m) looprev(i,m)
+#define loopjrev(m) looprev(j,m)
+#define loopkrev(m) looprev(k,m)
+#define looplrev(m) looprev(l,m)
+
+#define DELETEP(p) if(p) { delete p; p = 0; }
+#define DELETEA(p) if(p) { delete[] p; p = 0; }
+
+#define PI (3.1415927f)
+#define PI2 (2*PI)
+#define SQRT2 (1.4142136f)
+#define SQRT3 (1.7320508f)
+#define RAD (PI / 180.0f)
+
+#ifdef WIN32
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+#ifndef M_LN2
+#define M_LN2 0.693147180559945309417
+#endif
+
+#ifndef __GNUC__
+#pragma warning (3: 4189) // local variable is initialized but not referenced
+#pragma warning (disable: 4244) // conversion from 'int' to 'float', possible loss of data
+#pragma warning (disable: 4267) // conversion from 'size_t' to 'int', possible loss of data
+#pragma warning (disable: 4355) // 'this' : used in base member initializer list
+#pragma warning (disable: 4996) // 'strncpy' was declared deprecated
+#endif
+
+#define strcasecmp _stricmp
+#define strncasecmp _strnicmp
+#define PATHDIV '\\'
+
+#else
+#define __cdecl
+#define _vsnprintf vsnprintf
+#define PATHDIV '/'
+#endif
+
+#ifdef __GNUC__
+#define PRINTFARGS(fmt, args) __attribute__((format(printf, fmt, args)))
+#else
+#define PRINTFARGS(fmt, args)
+#endif
+
+// easy safe strings
+
+#define MAXSTRLEN 260
+typedef char string[MAXSTRLEN];
+
+inline void vformatstring(char *d, const char *fmt, va_list v, int len) { _vsnprintf(d, len, fmt, v); d[len-1] = 0; }
+template<size_t N> inline void vformatstring(char (&d)[N], const char *fmt, va_list v) { vformatstring(d, fmt, v, N); }
+
+inline char *copystring(char *d, const char *s, size_t len)
+{
+ size_t slen = min(strlen(s), len-1);
+ memcpy(d, s, slen);
+ d[slen] = 0;
+ return d;
+}
+template<size_t N> inline char *copystring(char (&d)[N], const char *s) { return copystring(d, s, N); }
+
+inline char *concatstring(char *d, const char *s, size_t len) { size_t used = strlen(d); return used < len ? copystring(d+used, s, len-used) : d; }
+template<size_t N> inline char *concatstring(char (&d)[N], const char *s) { return concatstring(d, s, N); }
+
+inline char *prependstring(char *d, const char *s, size_t len)
+{
+ size_t slen = min(strlen(s), len);
+ memmove(&d[slen], d, min(len - slen, strlen(d) + 1));
+ memcpy(d, s, slen);
+ d[len-1] = 0;
+ return d;
+}
+template<size_t N> inline char *prependstring(char (&d)[N], const char *s) { return prependstring(d, s, N); }
+
+inline void nformatstring(char *d, int len, const char *fmt, ...) PRINTFARGS(3, 4);
+inline void nformatstring(char *d, int len, const char *fmt, ...)
+{
+ va_list v;
+ va_start(v, fmt);
+ vformatstring(d, fmt, v, len);
+ va_end(v);
+}
+
+template<size_t N> inline void formatstring(char (&d)[N], const char *fmt, ...) PRINTFARGS(2, 3);
+template<size_t N> inline void formatstring(char (&d)[N], const char *fmt, ...)
+{
+ va_list v;
+ va_start(v, fmt);
+ vformatstring(d, fmt, v, int(N));
+ va_end(v);
+}
+
+template<size_t N> inline void concformatstring(char (&d)[N], const char *fmt, ...) PRINTFARGS(2, 3);
+template<size_t N> inline void concformatstring(char (&d)[N], const char *fmt, ...)
+{
+ va_list v;
+ va_start(v, fmt);
+ int len = strlen(d);
+ vformatstring(d + len, fmt, v, int(N) - len);
+ va_end(v);
+}
+
+#define defformatstring(d,...) string d; formatstring(d, __VA_ARGS__)
+#define defvformatstring(d,last,fmt) string d; { va_list ap; va_start(ap, last); vformatstring(d, fmt, ap); va_end(ap); }
+
+template<size_t N> inline bool matchstring(const char *s, size_t len, const char (&d)[N])
+{
+ return len == N-1 && !memcmp(s, d, N-1);
+}
+
+inline char *newstring(size_t l) { return new char[l+1]; }
+inline char *newstring(const char *s, size_t l) { return copystring(newstring(l), s, l+1); }
+inline char *newstring(const char *s) { size_t l = strlen(s); char *d = newstring(l); memcpy(d, s, l+1); return d; }
+
+#define loopv(v) for(int i = 0; i<(v).length(); i++)
+#define loopvj(v) for(int j = 0; j<(v).length(); j++)
+#define loopvk(v) for(int k = 0; k<(v).length(); k++)
+#define loopvrev(v) for(int i = (v).length()-1; i>=0; i--)
+
+template<class T> inline void memclear(T *p, size_t n) { memset((void *)p, 0, n * sizeof(T)); }
+template<class T> inline void memclear(T &p) { memset((void *)&p, 0, sizeof(T)); }
+template<class T, size_t N> inline void memclear(T (&p)[N]) { memset((void *)p, 0, N * sizeof(T)); }
+
+template <class T>
+struct databuf
+{
+ enum
+ {
+ OVERREAD = 1<<0,
+ OVERWROTE = 1<<1
+ };
+
+ T *buf;
+ int len, maxlen;
+ uchar flags;
+
+ databuf() : buf(NULL), len(0), maxlen(0), flags(0) {}
+
+ template<class U>
+ databuf(T *buf, U maxlen) : buf(buf), len(0), maxlen((int)maxlen), flags(0) {}
+
+ void reset()
+ {
+ len = 0;
+ flags = 0;
+ }
+
+ void reset(T *buf_, int maxlen_)
+ {
+ reset();
+ buf = buf_;
+ maxlen = maxlen_;
+ }
+
+ const T &get()
+ {
+ static T overreadval = 0;
+ if(len<maxlen) return buf[len++];
+ flags |= OVERREAD;
+ return overreadval;
+ }
+
+ databuf subbuf(int sz)
+ {
+ sz = clamp(sz, 0, maxlen-len);
+ len += sz;
+ return databuf(&buf[len-sz], sz);
+ }
+
+ T *pad(int numvals)
+ {
+ T *vals = &buf[len];
+ len += min(numvals, maxlen-len);
+ return vals;
+ }
+
+ void put(const T &val)
+ {
+ if(len<maxlen) buf[len++] = val;
+ else flags |= OVERWROTE;
+ }
+
+ void put(const T *vals, int numvals)
+ {
+ if(maxlen-len<numvals) flags |= OVERWROTE;
+ memcpy(&buf[len], (const void *)vals, min(maxlen-len, numvals)*sizeof(T));
+ len += min(maxlen-len, numvals);
+ }
+
+ int get(T *vals, int numvals)
+ {
+ int read = min(maxlen-len, numvals);
+ if(read<numvals) flags |= OVERREAD;
+ memcpy(vals, (void *)&buf[len], read*sizeof(T));
+ len += read;
+ return read;
+ }
+
+ void offset(int n)
+ {
+ n = min(n, maxlen);
+ buf += n;
+ maxlen -= n;
+ len = max(len-n, 0);
+ }
+
+ T *getbuf() const { return buf; }
+ bool empty() const { return len==0; }
+ int length() const { return len; }
+ int remaining() const { return maxlen-len; }
+ bool overread() const { return (flags&OVERREAD)!=0; }
+ bool overwrote() const { return (flags&OVERWROTE)!=0; }
+
+ bool check(int n) { return remaining() >= n; }
+
+ void forceoverread()
+ {
+ len = maxlen;
+ flags |= OVERREAD;
+ }
+};
+
+typedef databuf<char> charbuf;
+typedef databuf<uchar> ucharbuf;
+
+struct packetbuf : ucharbuf
+{
+ ENetPacket *packet;
+ int growth;
+
+ packetbuf(ENetPacket *packet) : ucharbuf(packet->data, packet->dataLength), packet(packet), growth(0) {}
+ packetbuf(int growth, int pflags = 0) : growth(growth)
+ {
+ packet = enet_packet_create(NULL, growth, pflags);
+ buf = (uchar *)packet->data;
+ maxlen = packet->dataLength;
+ }
+ ~packetbuf() { cleanup(); }
+
+ void reliable() { packet->flags |= ENET_PACKET_FLAG_RELIABLE; }
+
+ void resize(int n)
+ {
+ enet_packet_resize(packet, n);
+ buf = (uchar *)packet->data;
+ maxlen = packet->dataLength;
+ }
+
+ void checkspace(int n)
+ {
+ if(len + n > maxlen && packet && growth > 0) resize(max(len + n, maxlen + growth));
+ }
+
+ ucharbuf subbuf(int sz)
+ {
+ checkspace(sz);
+ return ucharbuf::subbuf(sz);
+ }
+
+ void put(const uchar &val)
+ {
+ checkspace(1);
+ ucharbuf::put(val);
+ }
+
+ void put(const uchar *vals, int numvals)
+ {
+ checkspace(numvals);
+ ucharbuf::put(vals, numvals);
+ }
+
+ ENetPacket *finalize()
+ {
+ resize(len);
+ return packet;
+ }
+
+ void cleanup()
+ {
+ if(growth > 0 && packet && !packet->referenceCount) { enet_packet_destroy(packet); packet = NULL; buf = NULL; len = maxlen = 0; }
+ }
+};
+
+template<class T>
+static inline float heapscore(const T &n) { return n; }
+
+struct sortless
+{
+ template<class T> bool operator()(const T &x, const T &y) const { return x < y; }
+ bool operator()(char *x, char *y) const { return strcmp(x, y) < 0; }
+ bool operator()(const char *x, const char *y) const { return strcmp(x, y) < 0; }
+};
+
+struct sortnameless
+{
+ template<class T> bool operator()(const T &x, const T &y) const { return sortless()(x.name, y.name); }
+ template<class T> bool operator()(T *x, T *y) const { return sortless()(x->name, y->name); }
+ template<class T> bool operator()(const T *x, const T *y) const { return sortless()(x->name, y->name); }
+};
+
+template<class T, class F>
+static inline void insertionsort(T *start, T *end, F fun)
+{
+ for(T *i = start+1; i < end; i++)
+ {
+ if(fun(*i, i[-1]))
+ {
+ T tmp = *i;
+ *i = i[-1];
+ T *j = i-1;
+ for(; j > start && fun(tmp, j[-1]); --j)
+ *j = j[-1];
+ *j = tmp;
+ }
+ }
+
+}
+
+template<class T, class F>
+static inline void insertionsort(T *buf, int n, F fun)
+{
+ insertionsort(buf, buf+n, fun);
+}
+
+template<class T>
+static inline void insertionsort(T *buf, int n)
+{
+ insertionsort(buf, buf+n, sortless());
+}
+
+template<class T, class F>
+static inline void quicksort(T *start, T *end, F fun)
+{
+ while(end-start > 10)
+ {
+ T *mid = &start[(end-start)/2], *i = start+1, *j = end-2, pivot;
+ if(fun(*start, *mid)) /* start < mid */
+ {
+ if(fun(end[-1], *start)) { pivot = *start; *start = end[-1]; end[-1] = *mid; } /* end < start < mid */
+ else if(fun(end[-1], *mid)) { pivot = end[-1]; end[-1] = *mid; } /* start <= end < mid */
+ else { pivot = *mid; } /* start < mid <= end */
+ }
+ else if(fun(*start, end[-1])) { pivot = *start; *start = *mid; } /*mid <= start < end */
+ else if(fun(*mid, end[-1])) { pivot = end[-1]; end[-1] = *start; *start = *mid; } /* mid < end <= start */
+ else { pivot = *mid; swap(*start, end[-1]); } /* end <= mid <= start */
+ *mid = end[-2];
+ do
+ {
+ while(fun(*i, pivot)) if(++i >= j) goto partitioned;
+ while(fun(pivot, *--j)) if(i >= j) goto partitioned;
+ swap(*i, *j);
+ }
+ while(++i < j);
+ partitioned:
+ end[-2] = *i;
+ *i = pivot;
+
+ if(i-start < end-(i+1))
+ {
+ quicksort(start, i, fun);
+ start = i+1;
+ }
+ else
+ {
+ quicksort(i+1, end, fun);
+ end = i;
+ }
+ }
+
+ insertionsort(start, end, fun);
+}
+
+template<class T, class F>
+static inline void quicksort(T *buf, int n, F fun)
+{
+ quicksort(buf, buf+n, fun);
+}
+
+template<class T>
+static inline void quicksort(T *buf, int n)
+{
+ quicksort(buf, buf+n, sortless());
+}
+
+template<class T> struct isclass
+{
+ template<class C> static char test(void (C::*)(void));
+ template<class C> static int test(...);
+ enum { yes = sizeof(test<T>(0)) == 1 ? 1 : 0, no = yes^1 };
+};
+
+static inline uint hthash(const char *key)
+{
+ uint h = 5381;
+ for(int i = 0, k; (k = key[i]); i++) h = ((h<<5)+h)^k; // bernstein k=33 xor
+ return h;
+}
+
+static inline bool htcmp(const char *x, const char *y)
+{
+ return !strcmp(x, y);
+}
+
+struct stringslice
+{
+ const char *str;
+ int len;
+ stringslice() {}
+ stringslice(const char *str, int len) : str(str), len(len) {}
+ stringslice(const char *str, const char *end) : str(str), len(int(end-str)) {}
+
+ const char *end() const { return &str[len]; }
+};
+
+inline char *newstring(const stringslice &s) { return newstring(s.str, s.len); }
+inline const char *stringptr(const char *s) { return s; }
+inline const char *stringptr(const stringslice &s) { return s.str; }
+inline int stringlen(const char *s) { return int(strlen(s)); }
+inline int stringlen(const stringslice &s) { return s.len; }
+
+inline char *copystring(char *d, const stringslice &s, size_t len)
+{
+ size_t slen = min(size_t(s.len), len-1);
+ memcpy(d, s.str, slen);
+ d[slen] = 0;
+ return d;
+}
+template<size_t N> inline char *copystring(char (&d)[N], const stringslice &s) { return copystring(d, s, N); }
+
+static inline uint memhash(const void *ptr, int len)
+{
+ const uchar *data = (const uchar *)ptr;
+ uint h = 5381;
+ loopi(len) h = ((h<<5)+h)^data[i];
+ return h;
+}
+
+static inline uint hthash(const stringslice &s) { return memhash(s.str, s.len); }
+
+static inline bool htcmp(const stringslice &x, const char *y)
+{
+ return x.len == (int)strlen(y) && !memcmp(x.str, y, x.len);
+}
+
+static inline uint hthash(int key)
+{
+ return key;
+}
+
+static inline bool htcmp(int x, int y)
+{
+ return x==y;
+}
+
+#ifndef STANDALONE
+static inline uint hthash(GLuint key)
+{
+ return key;
+}
+
+static inline bool htcmp(GLuint x, GLuint y)
+{
+ return x==y;
+}
+#endif
+
+template <class T> struct vector
+{
+ static const int MINSIZE = 8;
+
+ T *buf;
+ int alen, ulen;
+
+ vector() : buf(NULL), alen(0), ulen(0)
+ {
+ }
+
+ vector(const vector &v) : buf(NULL), alen(0), ulen(0)
+ {
+ *this = v;
+ }
+
+ ~vector() { shrink(0); if(buf) delete[] (uchar *)buf; }
+
+ vector<T> &operator=(const vector<T> &v)
+ {
+ shrink(0);
+ if(v.length() > alen) growbuf(v.length());
+ loopv(v) add(v[i]);
+ return *this;
+ }
+
+ T &add(const T &x)
+ {
+ if(ulen==alen) growbuf(ulen+1);
+ new (&buf[ulen]) T(x);
+ return buf[ulen++];
+ }
+
+ T &add()
+ {
+ if(ulen==alen) growbuf(ulen+1);
+ new (&buf[ulen]) T;
+ return buf[ulen++];
+ }
+
+ T &dup()
+ {
+ if(ulen==alen) growbuf(ulen+1);
+ new (&buf[ulen]) T(buf[ulen-1]);
+ return buf[ulen++];
+ }
+
+ void move(vector<T> &v)
+ {
+ if(!ulen)
+ {
+ swap(buf, v.buf);
+ swap(ulen, v.ulen);
+ swap(alen, v.alen);
+ }
+ else
+ {
+ growbuf(ulen+v.ulen);
+ if(v.ulen) memcpy(&buf[ulen], (void *)v.buf, v.ulen*sizeof(T));
+ ulen += v.ulen;
+ v.ulen = 0;
+ }
+ }
+
+ bool inrange(size_t i) const { return i<size_t(ulen); }
+ bool inrange(int i) const { return i>=0 && i<ulen; }
+
+ T &pop() { return buf[--ulen]; }
+ T &last() { return buf[ulen-1]; }
+ void drop() { ulen--; buf[ulen].~T(); }
+ bool empty() const { return ulen==0; }
+
+ int capacity() const { return alen; }
+ int length() const { return ulen; }
+ T &operator[](int i) { ASSERT(i>=0 && i<ulen); return buf[i]; }
+ const T &operator[](int i) const { ASSERT(i >= 0 && i<ulen); return buf[i]; }
+
+ void disown() { buf = NULL; alen = ulen = 0; }
+
+ void shrink(int i) { ASSERT(i<=ulen); if(isclass<T>::no) ulen = i; else while(ulen>i) drop(); }
+ void setsize(int i) { ASSERT(i<=ulen); ulen = i; }
+
+ void deletecontents() { while(!empty()) delete pop(); }
+ void deletearrays() { while(!empty()) delete[] pop(); }
+
+ T *getbuf() { return buf; }
+ const T *getbuf() const { return buf; }
+ bool inbuf(const T *e) const { return e >= buf && e < &buf[ulen]; }
+
+ template<class F>
+ void sort(F fun, int i = 0, int n = -1)
+ {
+ quicksort(&buf[i], n < 0 ? ulen-i : n, fun);
+ }
+
+ void sort() { sort(sortless()); }
+ void sortname() { sort(sortnameless()); }
+
+ void growbuf(int sz)
+ {
+ int olen = alen;
+ if(alen <= 0) alen = max(MINSIZE, sz);
+ else while(alen < sz) alen += alen/2;
+ if(alen <= olen) return;
+ uchar *newbuf = new uchar[alen*sizeof(T)];
+ if(olen > 0)
+ {
+ if(ulen > 0) memcpy(newbuf, (void *)buf, ulen*sizeof(T));
+ delete[] (uchar *)buf;
+ }
+ buf = (T *)newbuf;
+ }
+
+ databuf<T> reserve(int sz)
+ {
+ if(alen-ulen < sz) growbuf(ulen+sz);
+ return databuf<T>(&buf[ulen], sz);
+ }
+
+ void advance(int sz)
+ {
+ ulen += sz;
+ }
+
+ void addbuf(const databuf<T> &p)
+ {
+ advance(p.length());
+ }
+
+ T *pad(int n)
+ {
+ T *buf = reserve(n).buf;
+ advance(n);
+ return buf;
+ }
+
+ void put(const T &v) { add(v); }
+
+ void put(const T *v, int n)
+ {
+ databuf<T> buf = reserve(n);
+ buf.put(v, n);
+ addbuf(buf);
+ }
+
+ void remove(int i, int n)
+ {
+ for(int p = i+n; p<ulen; p++) buf[p-n] = buf[p];
+ ulen -= n;
+ }
+
+ T remove(int i)
+ {
+ T e = buf[i];
+ for(int p = i+1; p<ulen; p++) buf[p-1] = buf[p];
+ ulen--;
+ return e;
+ }
+
+ T removeunordered(int i)
+ {
+ T e = buf[i];
+ ulen--;
+ if(ulen>0) buf[i] = buf[ulen];
+ return e;
+ }
+
+ template<class U>
+ int find(const U &o)
+ {
+ loopi(ulen) if(buf[i]==o) return i;
+ return -1;
+ }
+
+ void addunique(const T &o)
+ {
+ if(find(o) < 0) add(o);
+ }
+
+ void removeobj(const T &o)
+ {
+ loopi(ulen) if(buf[i] == o)
+ {
+ int dst = i;
+ for(int j = i+1; j < ulen; j++) if(!(buf[j] == o)) buf[dst++] = buf[j];
+ setsize(dst);
+ break;
+ }
+ }
+
+ void replacewithlast(const T &o)
+ {
+ if(!ulen) return;
+ loopi(ulen-1) if(buf[i]==o)
+ {
+ buf[i] = buf[ulen-1];
+ break;
+ }
+ ulen--;
+ }
+
+ T &insert(int i, const T &e)
+ {
+ add(T());
+ for(int p = ulen-1; p>i; p--) buf[p] = buf[p-1];
+ buf[i] = e;
+ return buf[i];
+ }
+
+ T *insert(int i, const T *e, int n)
+ {
+ if(alen-ulen < n) growbuf(ulen+n);
+ loopj(n) add(T());
+ for(int p = ulen-1; p>=i+n; p--) buf[p] = buf[p-n];
+ loopj(n) buf[i+j] = e[j];
+ return &buf[i];
+ }
+
+ void reverse()
+ {
+ loopi(ulen/2) swap(buf[i], buf[ulen-1-i]);
+ }
+
+ static int heapparent(int i) { return (i - 1) >> 1; }
+ static int heapchild(int i) { return (i << 1) + 1; }
+
+ void buildheap()
+ {
+ for(int i = ulen/2; i >= 0; i--) downheap(i);
+ }
+
+ int upheap(int i)
+ {
+ float score = heapscore(buf[i]);
+ while(i > 0)
+ {
+ int pi = heapparent(i);
+ if(score >= heapscore(buf[pi])) break;
+ swap(buf[i], buf[pi]);
+ i = pi;
+ }
+ return i;
+ }
+
+ T &addheap(const T &x)
+ {
+ add(x);
+ return buf[upheap(ulen-1)];
+ }
+
+ int downheap(int i)
+ {
+ float score = heapscore(buf[i]);
+ for(;;)
+ {
+ int ci = heapchild(i);
+ if(ci >= ulen) break;
+ float cscore = heapscore(buf[ci]);
+ if(score > cscore)
+ {
+ if(ci+1 < ulen && heapscore(buf[ci+1]) < cscore) { swap(buf[ci+1], buf[i]); i = ci+1; }
+ else { swap(buf[ci], buf[i]); i = ci; }
+ }
+ else if(ci+1 < ulen && heapscore(buf[ci+1]) < score) { swap(buf[ci+1], buf[i]); i = ci+1; }
+ else break;
+ }
+ return i;
+ }
+
+ T removeheap()
+ {
+ T e = removeunordered(0);
+ if(ulen) downheap(0);
+ return e;
+ }
+
+ template<class K>
+ int htfind(const K &key)
+ {
+ loopi(ulen) if(htcmp(key, buf[i])) return i;
+ return -1;
+ }
+};
+
+template<class H, class E, class K, class T> struct hashbase
+{
+ typedef E elemtype;
+ typedef K keytype;
+ typedef T datatype;
+
+ enum { CHUNKSIZE = 64 };
+
+ struct chain { E elem; chain *next; };
+ struct chainchunk { chain chains[CHUNKSIZE]; chainchunk *next; };
+
+ int size;
+ int numelems;
+ chain **chains;
+
+ chainchunk *chunks;
+ chain *unused;
+
+ enum { DEFAULTSIZE = 1<<10 };
+
+ hashbase(int size = DEFAULTSIZE)
+ : size(size)
+ {
+ numelems = 0;
+ chunks = NULL;
+ unused = NULL;
+ chains = new chain *[size];
+ memset(chains, 0, size*sizeof(chain *));
+ }
+
+ ~hashbase()
+ {
+ DELETEA(chains);
+ deletechunks();
+ }
+
+ chain *insert(uint h)
+ {
+ if(!unused)
+ {
+ chainchunk *chunk = new chainchunk;
+ chunk->next = chunks;
+ chunks = chunk;
+ loopi(CHUNKSIZE-1) chunk->chains[i].next = &chunk->chains[i+1];
+ chunk->chains[CHUNKSIZE-1].next = unused;
+ unused = chunk->chains;
+ }
+ chain *c = unused;
+ unused = unused->next;
+ c->next = chains[h];
+ chains[h] = c;
+ numelems++;
+ return c;
+ }
+
+ template<class U>
+ T &insert(uint h, const U &key)
+ {
+ chain *c = insert(h);
+ H::setkey(c->elem, key);
+ return H::getdata(c->elem);
+ }
+
+ #define HTFIND(success, fail) \
+ uint h = hthash(key)&(this->size-1); \
+ for(chain *c = this->chains[h]; c; c = c->next) \
+ { \
+ if(htcmp(key, H::getkey(c->elem))) return success H::getdata(c->elem); \
+ } \
+ return (fail);
+
+ template<class U>
+ T *access(const U &key)
+ {
+ HTFIND(&, NULL);
+ }
+
+ template<class U, class V>
+ T &access(const U &key, const V &elem)
+ {
+ HTFIND( , insert(h, key) = elem);
+ }
+
+ template<class U>
+ T &operator[](const U &key)
+ {
+ HTFIND( , insert(h, key));
+ }
+
+ template<class U>
+ T &find(const U &key, T &notfound)
+ {
+ HTFIND( , notfound);
+ }
+
+ template<class U>
+ const T &find(const U &key, const T &notfound)
+ {
+ HTFIND( , notfound);
+ }
+
+ template<class U>
+ bool remove(const U &key)
+ {
+ uint h = hthash(key)&(size-1);
+ for(chain **p = &chains[h], *c = chains[h]; c; p = &c->next, c = c->next)
+ {
+ if(htcmp(key, H::getkey(c->elem)))
+ {
+ *p = c->next;
+ c->elem.~E();
+ new (&c->elem) E;
+ c->next = unused;
+ unused = c;
+ numelems--;
+ return true;
+ }
+ }
+ return false;
+ }
+
+ void deletechunks()
+ {
+ for(chainchunk *nextchunk; chunks; chunks = nextchunk)
+ {
+ nextchunk = chunks->next;
+ delete chunks;
+ }
+ }
+
+ void clear()
+ {
+ if(!numelems) return;
+ memset(chains, 0, size*sizeof(chain *));
+ numelems = 0;
+ unused = NULL;
+ deletechunks();
+ }
+
+ static inline chain *enumnext(void *i) { return ((chain *)i)->next; }
+ static inline K &enumkey(void *i) { return H::getkey(((chain *)i)->elem); }
+ static inline T &enumdata(void *i) { return H::getdata(((chain *)i)->elem); }
+};
+
+template<class T> struct hashset : hashbase<hashset<T>, T, T, T>
+{
+ typedef hashbase<hashset<T>, T, T, T> basetype;
+
+ hashset(int size = basetype::DEFAULTSIZE) : basetype(size) {}
+
+ static inline const T &getkey(const T &elem) { return elem; }
+ static inline T &getdata(T &elem) { return elem; }
+ template<class K> static inline void setkey(T &elem, const K &key) {}
+
+ template<class V>
+ T &add(const V &elem)
+ {
+ return basetype::access(elem, elem);
+ }
+};
+
+template<class T> struct hashnameset : hashbase<hashnameset<T>, T, const char *, T>
+{
+ typedef hashbase<hashnameset<T>, T, const char *, T> basetype;
+
+ hashnameset(int size = basetype::DEFAULTSIZE) : basetype(size) {}
+
+ template<class U> static inline const char *getkey(const U &elem) { return elem.name; }
+ template<class U> static inline const char *getkey(U *elem) { return elem->name; }
+ static inline T &getdata(T &elem) { return elem; }
+ template<class K> static inline void setkey(T &elem, const K &key) {}
+
+ template<class V>
+ T &add(const V &elem)
+ {
+ return basetype::access(getkey(elem), elem);
+ }
+};
+
+template<class K, class T> struct hashtableentry
+{
+ K key;
+ T data;
+};
+
+template<class K, class T> struct hashtable : hashbase<hashtable<K, T>, hashtableentry<K, T>, K, T>
+{
+ typedef hashbase<hashtable<K, T>, hashtableentry<K, T>, K, T> basetype;
+ typedef typename basetype::elemtype elemtype;
+
+ hashtable(int size = basetype::DEFAULTSIZE) : basetype(size) {}
+
+ static inline K &getkey(elemtype &elem) { return elem.key; }
+ static inline T &getdata(elemtype &elem) { return elem.data; }
+ template<class U> static inline void setkey(elemtype &elem, const U &key) { elem.key = key; }
+};
+
+#define enumeratekt(ht,k,e,t,f,b) loopi((ht).size) for(void *ec = (ht).chains[i]; ec;) { k &e = (ht).enumkey(ec); t &f = (ht).enumdata(ec); ec = (ht).enumnext(ec); b; }
+#define enumerate(ht,t,e,b) loopi((ht).size) for(void *ec = (ht).chains[i]; ec;) { t &e = (ht).enumdata(ec); ec = (ht).enumnext(ec); b; }
+
+struct unionfind
+{
+ struct ufval
+ {
+ int rank, next;
+
+ ufval() : rank(0), next(-1) {}
+ };
+
+ vector<ufval> ufvals;
+
+ int find(int k)
+ {
+ if(k>=ufvals.length()) return k;
+ while(ufvals[k].next>=0) k = ufvals[k].next;
+ return k;
+ }
+
+ int compressfind(int k)
+ {
+ if(ufvals[k].next<0) return k;
+ return ufvals[k].next = compressfind(ufvals[k].next);
+ }
+
+ void unite (int x, int y)
+ {
+ while(ufvals.length() <= max(x, y)) ufvals.add();
+ x = compressfind(x);
+ y = compressfind(y);
+ if(x==y) return;
+ ufval &xval = ufvals[x], &yval = ufvals[y];
+ if(xval.rank < yval.rank) xval.next = y;
+ else
+ {
+ yval.next = x;
+ if(xval.rank==yval.rank) yval.rank++;
+ }
+ }
+};
+
+template <class T, int SIZE> struct queue
+{
+ int head, tail, len;
+ T data[SIZE];
+
+ queue() { clear(); }
+
+ void clear() { head = tail = len = 0; }
+
+ int capacity() const { return SIZE; }
+ int length() const { return len; }
+ bool empty() const { return !len; }
+ bool full() const { return len == SIZE; }
+
+ bool inrange(size_t i) const { return i<size_t(len); }
+ bool inrange(int i) const { return i>=0 && i<len; }
+
+ T &added() { return data[tail > 0 ? tail-1 : SIZE-1]; }
+ T &added(int offset) { return data[tail-offset > 0 ? tail-offset-1 : tail-offset-1 + SIZE]; }
+ T &adding() { return data[tail]; }
+ T &adding(int offset) { return data[tail+offset >= SIZE ? tail+offset - SIZE : tail+offset]; }
+ T &add()
+ {
+ T &t = data[tail];
+ tail++;
+ if(tail >= SIZE) tail -= SIZE;
+ if(len < SIZE) len++;
+ return t;
+ }
+ T &add(const T &e) { return add() = e; }
+
+ databuf<T> reserve(int sz)
+ {
+ if(!len) head = tail = 0;
+ return databuf<T>(&data[tail], min(sz, SIZE-tail));
+ }
+
+ void advance(int sz)
+ {
+ if(len + sz > SIZE) sz = SIZE - len;
+ tail += sz;
+ if(tail >= SIZE) tail -= SIZE;
+ len += sz;
+ }
+
+ void addbuf(const databuf<T> &p)
+ {
+ advance(p.length());
+ }
+
+ T &pop()
+ {
+ tail--;
+ if(tail < 0) tail += SIZE;
+ len--;
+ return data[tail];
+ }
+
+ T &removing() { return data[head]; }
+ T &removing(int offset) { return data[head+offset >= SIZE ? head+offset - SIZE : head+offset]; }
+ T &remove()
+ {
+ T &t = data[head];
+ head++;
+ if(head >= SIZE) head -= SIZE;
+ len--;
+ return t;
+ }
+
+ T remove(int offset)
+ {
+ T val = removing(offset);
+ if(head+offset >= SIZE) for(int i = head+offset - SIZE + 1; i < tail; i++) data[i-1] = data[i];
+ else if(head < tail) for(int i = head+offset + 1; i < tail; i++) data[i-1] = data[i];
+ else
+ {
+ for(int i = head+offset + 1; i < SIZE; i++) data[i-1] = data[i];
+ data[SIZE-1] = data[0];
+ for(int i = 1; i < tail; i++) data[i-1] = data[i];
+ }
+ tail--;
+ if(tail < 0) tail += SIZE;
+ len--;
+ return val;
+ }
+
+ T &operator[](int offset) { return removing(offset); }
+ const T &operator[](int offset) const { return removing(offset); }
+};
+
+template <class T, int SIZE> struct reversequeue : queue<T, SIZE>
+{
+ T &operator[](int offset) { return queue<T, SIZE>::added(offset); }
+ const T &operator[](int offset) const { return queue<T, SIZE>::added(offset); }
+};
+
+const int islittleendian = 1;
+#ifdef SDL_BYTEORDER
+#define endianswap16 SDL_Swap16
+#define endianswap32 SDL_Swap32
+#define endianswap64 SDL_Swap64
+#else
+inline ushort endianswap16(ushort n) { return (n<<8) | (n>>8); }
+inline uint endianswap32(uint n) { return (n<<24) | (n>>24) | ((n>>8)&0xFF00) | ((n<<8)&0xFF0000); }
+inline ullong endianswap64(ullong n) { return endianswap32(uint(n >> 32)) | ((ullong)endianswap32(uint(n)) << 32); }
+#endif
+template<class T> inline T endianswap(T n) { union { T t; uint i; } conv; conv.t = n; conv.i = endianswap32(conv.i); return conv.t; }
+template<> inline ushort endianswap<ushort>(ushort n) { return endianswap16(n); }
+template<> inline short endianswap<short>(short n) { return endianswap16(n); }
+template<> inline uint endianswap<uint>(uint n) { return endianswap32(n); }
+template<> inline int endianswap<int>(int n) { return endianswap32(n); }
+template<> inline ullong endianswap<ullong>(ullong n) { return endianswap64(n); }
+template<> inline llong endianswap<llong>(llong n) { return endianswap64(n); }
+template<> inline double endianswap<double>(double n) { union { double t; uint i; } conv; conv.t = n; conv.i = endianswap64(conv.i); return conv.t; }
+template<class T> inline void endianswap(T *buf, size_t len) { for(T *end = &buf[len]; buf < end; buf++) *buf = endianswap(*buf); }
+template<class T> inline T endiansame(T n) { return n; }
+template<class T> inline void endiansame(T *buf, size_t len) {}
+#ifdef SDL_BYTEORDER
+#if SDL_BYTEORDER == SDL_LIL_ENDIAN
+#define lilswap endiansame
+#define bigswap endianswap
+#else
+#define lilswap endianswap
+#define bigswap endiansame
+#endif
+#elif defined(__BYTE_ORDER__)
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#define lilswap endiansame
+#define bigswap endianswap
+#else
+#define lilswap endianswap
+#define bigswap endiansame
+#endif
+#else
+template<class T> inline T lilswap(T n) { return *(const uchar *)&islittleendian ? n : endianswap(n); }
+template<class T> inline void lilswap(T *buf, size_t len) { if(!*(const uchar *)&islittleendian) endianswap(buf, len); }
+template<class T> inline T bigswap(T n) { return *(const uchar *)&islittleendian ? endianswap(n) : n; }
+template<class T> inline void bigswap(T *buf, size_t len) { if(*(const uchar *)&islittleendian) endianswap(buf, len); }
+#endif
+
+/* workaround for some C platforms that have these two functions as macros - not used anywhere */
+#ifdef getchar
+#undef getchar
+#endif
+#ifdef putchar
+#undef putchar
+#endif
+
+struct stream
+{
+#ifdef WIN32
+#if defined(__GNUC__) && !defined(__MINGW32__)
+ typedef off64_t offset;
+#else
+ typedef __int64 offset;
+#endif
+#else
+ typedef off_t offset;
+#endif
+
+ virtual ~stream() {}
+ virtual void close() = 0;
+ virtual bool end() = 0;
+ virtual offset tell() { return -1; }
+ virtual offset rawtell() { return tell(); }
+ virtual bool seek(offset pos, int whence = SEEK_SET) { return false; }
+ virtual offset size();
+ virtual offset rawsize() { return size(); }
+ virtual size_t read(void *buf, size_t len) { return 0; }
+ virtual size_t write(const void *buf, size_t len) { return 0; }
+ virtual bool flush() { return true; }
+ virtual int getchar() { uchar c; return read(&c, 1) == 1 ? c : -1; }
+ virtual bool putchar(int n) { uchar c = n; return write(&c, 1) == 1; }
+ virtual bool getline(char *str, size_t len);
+ virtual bool putstring(const char *str) { size_t len = strlen(str); return write(str, len) == len; }
+ virtual bool putline(const char *str) { return putstring(str) && putchar('\n'); }
+ virtual size_t printf(const char *fmt, ...) PRINTFARGS(2, 3);
+ virtual uint getcrc() { return 0; }
+
+ template<class T> size_t put(const T *v, size_t n) { return write(v, n*sizeof(T))/sizeof(T); }
+ template<class T> bool put(T n) { return write(&n, sizeof(n)) == sizeof(n); }
+ template<class T> bool putlil(T n) { return put<T>(lilswap(n)); }
+ template<class T> bool putbig(T n) { return put<T>(bigswap(n)); }
+
+ template<class T> size_t get(T *v, size_t n) { return read(v, n*sizeof(T))/sizeof(T); }
+ template<class T> T get() { T n; return read(&n, sizeof(n)) == sizeof(n) ? n : 0; }
+ template<class T> T getlil() { return lilswap(get<T>()); }
+ template<class T> T getbig() { return bigswap(get<T>()); }
+
+#ifndef STANDALONE
+ SDL_RWops *rwops();
+#endif
+};
+
+template<class T>
+struct streambuf
+{
+ stream *s;
+
+ streambuf(stream *s) : s(s) {}
+
+ T get() { return s->get<T>(); }
+ size_t get(T *vals, size_t numvals) { return s->get(vals, numvals); }
+ void put(const T &val) { s->put(&val, 1); }
+ void put(const T *vals, size_t numvals) { s->put(vals, numvals); }
+ size_t length() { return s->size(); }
+};
+
+enum
+{
+ CT_PRINT = 1<<0,
+ CT_SPACE = 1<<1,
+ CT_DIGIT = 1<<2,
+ CT_ALPHA = 1<<3,
+ CT_LOWER = 1<<4,
+ CT_UPPER = 1<<5,
+ CT_UNICODE = 1<<6
+};
+extern const uchar cubectype[256];
+static inline int iscubeprint(uchar c) { return cubectype[c]&CT_PRINT; }
+static inline int iscubespace(uchar c) { return cubectype[c]&CT_SPACE; }
+static inline int iscubealpha(uchar c) { return cubectype[c]&CT_ALPHA; }
+static inline int iscubealnum(uchar c) { return cubectype[c]&(CT_ALPHA|CT_DIGIT); }
+static inline int iscubelower(uchar c) { return cubectype[c]&CT_LOWER; }
+static inline int iscubeupper(uchar c) { return cubectype[c]&CT_UPPER; }
+static inline int iscubepunct(uchar c) { return cubectype[c] == CT_PRINT; }
+static inline int cube2uni(uchar c)
+{
+ extern const int cube2unichars[256];
+ return cube2unichars[c];
+}
+static inline uchar uni2cube(int c)
+{
+ extern const int uni2cubeoffsets[8];
+ extern const uchar uni2cubechars[];
+ return uint(c) <= 0x7FF ? uni2cubechars[uni2cubeoffsets[c>>8] + (c&0xFF)] : 0;
+}
+static inline uchar cubelower(uchar c)
+{
+ extern const uchar cubelowerchars[256];
+ return cubelowerchars[c];
+}
+static inline uchar cubeupper(uchar c)
+{
+ extern const uchar cubeupperchars[256];
+ return cubeupperchars[c];
+}
+extern size_t decodeutf8(uchar *dst, size_t dstlen, const uchar *src, size_t srclen, size_t *carry = NULL);
+extern size_t encodeutf8(uchar *dstbuf, size_t dstlen, const uchar *srcbuf, size_t srclen, size_t *carry = NULL);
+
+extern string homedir;
+
+extern char *makerelpath(const char *dir, const char *file, const char *prefix = NULL, const char *cmd = NULL);
+extern char *path(char *s);
+extern char *path(const char *s, bool copy);
+extern const char *parentdir(const char *directory);
+extern bool fileexists(const char *path, const char *mode);
+extern bool createdir(const char *path);
+extern size_t fixpackagedir(char *dir);
+extern const char *sethomedir(const char *dir);
+extern const char *addpackagedir(const char *dir);
+extern const char *findfile(const char *filename, const char *mode);
+extern bool findzipfile(const char *filename);
+extern stream *openrawfile(const char *filename, const char *mode);
+extern stream *openzipfile(const char *filename, const char *mode);
+extern stream *openfile(const char *filename, const char *mode);
+extern stream *opentempfile(const char *filename, const char *mode);
+extern stream *opengzfile(const char *filename, const char *mode, stream *file = NULL, int level = Z_BEST_COMPRESSION);
+extern stream *openutf8file(const char *filename, const char *mode, stream *file = NULL);
+extern char *loadfile(const char *fn, size_t *size, bool utf8 = true);
+extern bool listdir(const char *dir, bool rel, const char *ext, vector<char *> &files);
+extern int listfiles(const char *dir, const char *ext, vector<char *> &files);
+extern int listzipfiles(const char *dir, const char *ext, vector<char *> &files);
+extern void seedMT(uint seed);
+extern uint randomMT();
+
+extern void putint(ucharbuf &p, int n);
+extern void putint(packetbuf &p, int n);
+extern void putint(vector<uchar> &p, int n);
+extern int getint(ucharbuf &p);
+extern void putuint(ucharbuf &p, int n);
+extern void putuint(packetbuf &p, int n);
+extern void putuint(vector<uchar> &p, int n);
+extern int getuint(ucharbuf &p);
+extern void putfloat(ucharbuf &p, float f);
+extern void putfloat(packetbuf &p, float f);
+extern void putfloat(vector<uchar> &p, float f);
+extern float getfloat(ucharbuf &p);
+extern void sendstring(const char *t, ucharbuf &p);
+extern void sendstring(const char *t, packetbuf &p);
+extern void sendstring(const char *t, vector<uchar> &p);
+extern void getstring(char *t, ucharbuf &p, size_t len);
+template<size_t N> static inline void getstring(char (&t)[N], ucharbuf &p) { getstring(t, p, N); }
+extern void filtertext(char *dst, const char *src, bool whitespace, bool forcespace, size_t len);
+template<size_t N> static inline void filtertext(char (&dst)[N], const char *src, bool whitespace = true, bool forcespace = false) { filtertext(dst, src, whitespace, forcespace, N-1); }
+
+struct ipmask
+{
+ enet_uint32 ip, mask;
+
+ void parse(const char *name);
+ int print(char *buf) const;
+ bool check(enet_uint32 host) const { return (host & mask) == ip; }
+};
+
+#endif
+
diff --git a/src/shared/zip.cpp b/src/shared/zip.cpp
new file mode 100644
index 0000000..c35fa87
--- /dev/null
+++ b/src/shared/zip.cpp
@@ -0,0 +1,588 @@
+#include "cube.h"
+
+enum
+{
+ ZIP_LOCAL_FILE_SIGNATURE = 0x04034B50,
+ ZIP_LOCAL_FILE_SIZE = 30,
+ ZIP_FILE_SIGNATURE = 0x02014B50,
+ ZIP_FILE_SIZE = 46,
+ ZIP_DIRECTORY_SIGNATURE = 0x06054B50,
+ ZIP_DIRECTORY_SIZE = 22
+};
+
+struct ziplocalfileheader
+{
+ uint signature;
+ ushort version, flags, compression, modtime, moddate;
+ uint crc32, compressedsize, uncompressedsize;
+ ushort namelength, extralength;
+};
+
+struct zipfileheader
+{
+ uint signature;
+ ushort version, needversion, flags, compression, modtime, moddate;
+ uint crc32, compressedsize, uncompressedsize;
+ ushort namelength, extralength, commentlength, disknumber, internalattribs;
+ uint externalattribs, offset;
+};
+
+struct zipdirectoryheader
+{
+ uint signature;
+ ushort disknumber, directorydisk, diskentries, entries;
+ uint size, offset;
+ ushort commentlength;
+};
+
+struct zipfile
+{
+ char *name;
+ uint header, offset, size, compressedsize;
+
+ zipfile() : name(NULL), header(0), offset(~0U), size(0), compressedsize(0)
+ {
+ }
+ ~zipfile()
+ {
+ DELETEA(name);
+ }
+};
+
+struct zipstream;
+
+struct ziparchive
+{
+ char *name;
+ FILE *data;
+ hashnameset<zipfile> files;
+ int openfiles;
+ zipstream *owner;
+
+ ziparchive() : name(NULL), data(NULL), files(512), openfiles(0), owner(NULL)
+ {
+ }
+ ~ziparchive()
+ {
+ DELETEA(name);
+ if(data) { fclose(data); data = NULL; }
+ }
+};
+
+static bool findzipdirectory(FILE *f, zipdirectoryheader &hdr)
+{
+ if(fseek(f, 0, SEEK_END) < 0) return false;
+
+ long offset = ftell(f);
+ if(offset < 0) return false;
+
+ uchar buf[1024], *src = NULL;
+ long end = max(offset - 0xFFFFL - ZIP_DIRECTORY_SIZE, 0L);
+ size_t len = 0;
+ const uint signature = lilswap<uint>(ZIP_DIRECTORY_SIGNATURE);
+
+ while(offset > end)
+ {
+ size_t carry = min(len, size_t(ZIP_DIRECTORY_SIZE-1)), next = min(sizeof(buf) - carry, size_t(offset - end));
+ offset -= next;
+ memmove(&buf[next], buf, carry);
+ if(next + carry < ZIP_DIRECTORY_SIZE || fseek(f, offset, SEEK_SET) < 0 || fread(buf, 1, next, f) != next) return false;
+ len = next + carry;
+ uchar *search = &buf[next-1];
+ for(; search >= buf; search--) if(*(uint *)search == signature) break;
+ if(search >= buf) { src = search; break; }
+ }
+
+ if(!src || &buf[len] - src < ZIP_DIRECTORY_SIZE) return false;
+
+ hdr.signature = lilswap(*(uint *)src); src += 4;
+ hdr.disknumber = lilswap(*(ushort *)src); src += 2;
+ hdr.directorydisk = lilswap(*(ushort *)src); src += 2;
+ hdr.diskentries = lilswap(*(ushort *)src); src += 2;
+ hdr.entries = lilswap(*(ushort *)src); src += 2;
+ hdr.size = lilswap(*(uint *)src); src += 4;
+ hdr.offset = lilswap(*(uint *)src); src += 4;
+ hdr.commentlength = lilswap(*(ushort *)src); src += 2;
+
+ if(hdr.signature != ZIP_DIRECTORY_SIGNATURE || hdr.disknumber != hdr.directorydisk || hdr.diskentries != hdr.entries) return false;
+
+ return true;
+}
+
+#ifndef STANDALONE
+VAR(dbgzip, 0, 0, 1);
+#endif
+
+static bool readzipdirectory(const char *archname, FILE *f, int entries, int offset, uint size, vector<zipfile> &files)
+{
+ uchar *buf = new (false) uchar[size], *src = buf;
+ if(!buf || fseek(f, offset, SEEK_SET) < 0 || fread(buf, 1, size, f) != size) { delete[] buf; return false; }
+ loopi(entries)
+ {
+ if(src + ZIP_FILE_SIZE > &buf[size]) break;
+
+ zipfileheader hdr;
+ hdr.signature = lilswap(*(uint *)src); src += 4;
+ hdr.version = lilswap(*(ushort *)src); src += 2;
+ hdr.needversion = lilswap(*(ushort *)src); src += 2;
+ hdr.flags = lilswap(*(ushort *)src); src += 2;
+ hdr.compression = lilswap(*(ushort *)src); src += 2;
+ hdr.modtime = lilswap(*(ushort *)src); src += 2;
+ hdr.moddate = lilswap(*(ushort *)src); src += 2;
+ hdr.crc32 = lilswap(*(uint *)src); src += 4;
+ hdr.compressedsize = lilswap(*(uint *)src); src += 4;
+ hdr.uncompressedsize = lilswap(*(uint *)src); src += 4;
+ hdr.namelength = lilswap(*(ushort *)src); src += 2;
+ hdr.extralength = lilswap(*(ushort *)src); src += 2;
+ hdr.commentlength = lilswap(*(ushort *)src); src += 2;
+ hdr.disknumber = lilswap(*(ushort *)src); src += 2;
+ hdr.internalattribs = lilswap(*(ushort *)src); src += 2;
+ hdr.externalattribs = lilswap(*(uint *)src); src += 4;
+ hdr.offset = lilswap(*(uint *)src); src += 4;
+ if(hdr.signature != ZIP_FILE_SIGNATURE) break;
+ if(!hdr.namelength || !hdr.uncompressedsize || (hdr.compression && (hdr.compression != Z_DEFLATED || !hdr.compressedsize)))
+ {
+ src += hdr.namelength + hdr.extralength + hdr.commentlength;
+ continue;
+ }
+ if(src + hdr.namelength > &buf[size]) break;
+
+ string pname;
+ int namelen = min((int)hdr.namelength, (int)sizeof(pname)-1);
+ memcpy(pname, src, namelen);
+ pname[namelen] = '\0';
+ path(pname);
+ char *name = newstring(pname);
+
+ zipfile &f = files.add();
+ f.name = name;
+ f.header = hdr.offset;
+ f.size = hdr.uncompressedsize;
+ f.compressedsize = hdr.compression ? hdr.compressedsize : 0;
+#ifndef STANDALONE
+ if(dbgzip) conoutf(CON_DEBUG, "%s: file %s, size %d, compress %d, flags %x", archname, name, hdr.uncompressedsize, hdr.compression, hdr.flags);
+#endif
+
+ src += hdr.namelength + hdr.extralength + hdr.commentlength;
+ }
+ delete[] buf;
+
+ return files.length() > 0;
+}
+
+static bool readlocalfileheader(FILE *f, ziplocalfileheader &h, uint offset)
+{
+ uchar buf[ZIP_LOCAL_FILE_SIZE];
+ if(fseek(f, offset, SEEK_SET) < 0 || fread(buf, 1, ZIP_LOCAL_FILE_SIZE, f) != ZIP_LOCAL_FILE_SIZE)
+ return false;
+ uchar *src = buf;
+ h.signature = lilswap(*(uint *)src); src += 4;
+ h.version = lilswap(*(ushort *)src); src += 2;
+ h.flags = lilswap(*(ushort *)src); src += 2;
+ h.compression = lilswap(*(ushort *)src); src += 2;
+ h.modtime = lilswap(*(ushort *)src); src += 2;
+ h.moddate = lilswap(*(ushort *)src); src += 2;
+ h.crc32 = lilswap(*(uint *)src); src += 4;
+ h.compressedsize = lilswap(*(uint *)src); src += 4;
+ h.uncompressedsize = lilswap(*(uint *)src); src += 4;
+ h.namelength = lilswap(*(ushort *)src); src += 2;
+ h.extralength = lilswap(*(ushort *)src); src += 2;
+ if(h.signature != ZIP_LOCAL_FILE_SIGNATURE) return false;
+ // h.uncompressedsize or h.compressedsize may be zero - so don't validate
+ return true;
+}
+
+static vector<ziparchive *> archives;
+
+ziparchive *findzip(const char *name)
+{
+ loopv(archives) if(!strcmp(name, archives[i]->name)) return archives[i];
+ return NULL;
+}
+
+static bool checkprefix(vector<zipfile> &files, const char *prefix, int prefixlen)
+{
+ loopv(files)
+ {
+ if(!strncmp(files[i].name, prefix, prefixlen)) return false;
+ }
+ return true;
+}
+
+static void mountzip(ziparchive &arch, vector<zipfile> &files, const char *mountdir, const char *stripdir)
+{
+ string packagesdir = "packages/";
+ path(packagesdir);
+ size_t striplen = stripdir ? strlen(stripdir) : 0;
+ if(!mountdir && !stripdir) loopv(files)
+ {
+ zipfile &f = files[i];
+ const char *foundpackages = strstr(f.name, packagesdir);
+ if(foundpackages)
+ {
+ if(foundpackages > f.name)
+ {
+ stripdir = f.name;
+ striplen = foundpackages - f.name;
+ }
+ break;
+ }
+ const char *foundogz = strstr(f.name, ".ogz");
+ if(foundogz)
+ {
+ const char *ogzdir = foundogz;
+ while(--ogzdir >= f.name && *ogzdir != PATHDIV);
+ if(ogzdir < f.name || checkprefix(files, f.name, ogzdir + 1 - f.name))
+ {
+ if(ogzdir >= f.name)
+ {
+ stripdir = f.name;
+ striplen = ogzdir + 1 - f.name;
+ }
+ if(!mountdir) mountdir = "packages/base/";
+ break;
+ }
+ }
+ }
+ string mdir = "", fname;
+ if(mountdir)
+ {
+ copystring(mdir, mountdir);
+ if(fixpackagedir(mdir) <= 1) mdir[0] = '\0';
+ }
+ loopv(files)
+ {
+ zipfile &f = files[i];
+ formatstring(fname, "%s%s", mdir, striplen && !strncmp(f.name, stripdir, striplen) ? &f.name[striplen] : f.name);
+ if(arch.files.access(fname)) continue;
+ char *mname = newstring(fname);
+ zipfile &mf = arch.files[mname];
+ mf = f;
+ mf.name = mname;
+ }
+}
+
+bool addzip(const char *name, const char *mount = NULL, const char *strip = NULL)
+{
+ string pname;
+ copystring(pname, name);
+ path(pname);
+ size_t plen = strlen(pname);
+ if(plen < 4 || !strchr(&pname[plen-4], '.')) concatstring(pname, ".zip");
+
+ ziparchive *exists = findzip(pname);
+ if(exists)
+ {
+ conoutf(CON_ERROR, "already added zip %s", pname);
+ return true;
+ }
+
+ FILE *f = fopen(findfile(pname, "rb"), "rb");
+ if(!f)
+ {
+ conoutf(CON_ERROR, "could not open file %s", pname);
+ return false;
+ }
+ zipdirectoryheader h;
+ vector<zipfile> files;
+ if(!findzipdirectory(f, h) || !readzipdirectory(pname, f, h.entries, h.offset, h.size, files))
+ {
+ conoutf(CON_ERROR, "could not read directory in zip %s", pname);
+ fclose(f);
+ return false;
+ }
+
+ ziparchive *arch = new ziparchive;
+ arch->name = newstring(pname);
+ arch->data = f;
+ mountzip(*arch, files, mount, strip);
+ archives.add(arch);
+
+ conoutf("added zip %s", pname);
+ return true;
+}
+
+bool removezip(const char *name)
+{
+ string pname;
+ copystring(pname, name);
+ path(pname);
+ int plen = (int)strlen(pname);
+ if(plen < 4 || !strchr(&pname[plen-4], '.')) concatstring(pname, ".zip");
+ ziparchive *exists = findzip(pname);
+ if(!exists)
+ {
+ conoutf(CON_ERROR, "zip %s is not loaded", pname);
+ return false;
+ }
+ if(exists->openfiles)
+ {
+ conoutf(CON_ERROR, "zip %s has open files", pname);
+ return false;
+ }
+ conoutf("removed zip %s", exists->name);
+ archives.removeobj(exists);
+ delete exists;
+ return true;
+}
+
+struct zipstream : stream
+{
+ enum
+ {
+ BUFSIZE = 16384
+ };
+
+ ziparchive *arch;
+ zipfile *info;
+ z_stream zfile;
+ uchar *buf;
+ uint reading;
+ bool ended;
+
+ zipstream() : arch(NULL), info(NULL), buf(NULL), reading(~0U), ended(false)
+ {
+ zfile.zalloc = NULL;
+ zfile.zfree = NULL;
+ zfile.opaque = NULL;
+ zfile.next_in = zfile.next_out = NULL;
+ zfile.avail_in = zfile.avail_out = 0;
+ }
+
+ ~zipstream()
+ {
+ close();
+ }
+
+ void readbuf(uint size = BUFSIZE)
+ {
+ if(!zfile.avail_in) zfile.next_in = (Bytef *)buf;
+ size = min(size, uint(&buf[BUFSIZE] - &zfile.next_in[zfile.avail_in]));
+ if(arch->owner != this)
+ {
+ arch->owner = NULL;
+ if(fseek(arch->data, reading, SEEK_SET) >= 0) arch->owner = this;
+ else return;
+ }
+ uint remaining = info->offset + info->compressedsize - reading,
+ n = arch->owner == this ? fread(zfile.next_in + zfile.avail_in, 1, min(size, remaining), arch->data) : 0U;
+ zfile.avail_in += n;
+ reading += n;
+ }
+
+ bool open(ziparchive *a, zipfile *f)
+ {
+ if(f->offset == ~0U)
+ {
+ ziplocalfileheader h;
+ a->owner = NULL;
+ if(!readlocalfileheader(a->data, h, f->header)) return false;
+ f->offset = f->header + ZIP_LOCAL_FILE_SIZE + h.namelength + h.extralength;
+ }
+
+ if(f->compressedsize && inflateInit2(&zfile, -MAX_WBITS) != Z_OK) return false;
+
+ a->openfiles++;
+ arch = a;
+ info = f;
+ reading = f->offset;
+ ended = false;
+ if(f->compressedsize) buf = new uchar[BUFSIZE];
+ return true;
+ }
+
+ void stopreading()
+ {
+ if(reading == ~0U) return;
+#ifndef STANDALONE
+ if(dbgzip) conoutf(CON_DEBUG, info->compressedsize ? "%s: zfile.total_out %u, info->size %u" : "%s: reading %u, info->size %u", info->name, info->compressedsize ? uint(zfile.total_out) : reading - info->offset, info->size);
+#endif
+ if(info->compressedsize) inflateEnd(&zfile);
+ reading = ~0U;
+ }
+
+ void close()
+ {
+ stopreading();
+ DELETEA(buf);
+ if(arch) { arch->owner = NULL; arch->openfiles--; arch = NULL; }
+ }
+
+ offset size() { return info->size; }
+ bool end() { return reading == ~0U || ended; }
+ offset tell() { return reading != ~0U ? (info->compressedsize ? zfile.total_out : reading - info->offset) : offset(-1); }
+
+ bool seek(offset pos, int whence)
+ {
+ if(reading == ~0U) return false;
+ if(!info->compressedsize)
+ {
+ switch(whence)
+ {
+ case SEEK_END: pos += info->offset + info->size; break;
+ case SEEK_CUR: pos += reading; break;
+ case SEEK_SET: pos += info->offset; break;
+ default: return false;
+ }
+ pos = clamp(pos, offset(info->offset), offset(info->offset + info->size));
+ arch->owner = NULL;
+ if(fseek(arch->data, int(pos), SEEK_SET) < 0) return false;
+ arch->owner = this;
+ reading = pos;
+ ended = false;
+ return true;
+ }
+
+ switch(whence)
+ {
+ case SEEK_END: pos += info->size; break;
+ case SEEK_CUR: pos += zfile.total_out; break;
+ case SEEK_SET: break;
+ default: return false;
+ }
+
+ if(pos >= (offset)info->size)
+ {
+ reading = info->offset + info->compressedsize;
+ zfile.next_in += zfile.avail_in;
+ zfile.avail_in = 0;
+ zfile.total_in = info->compressedsize;
+ zfile.total_out = info->size;
+ arch->owner = NULL;
+ ended = false;
+ return true;
+ }
+
+ if(pos < 0) return false;
+ if(pos >= (offset)zfile.total_out) pos -= zfile.total_out;
+ else
+ {
+ if(zfile.next_in && zfile.total_in <= uint(zfile.next_in - buf))
+ {
+ zfile.avail_in += zfile.total_in;
+ zfile.next_in -= zfile.total_in;
+ }
+ else
+ {
+ arch->owner = NULL;
+ zfile.avail_in = 0;
+ zfile.next_in = NULL;
+ reading = info->offset;
+ }
+ inflateReset(&zfile);
+ }
+
+ uchar skip[512];
+ while(pos > 0)
+ {
+ size_t skipped = (size_t)min(pos, (offset)sizeof(skip));
+ if(read(skip, skipped) != skipped) return false;
+ pos -= skipped;
+ }
+
+ ended = false;
+ return true;
+ }
+
+ size_t read(void *buf, size_t len)
+ {
+ if(reading == ~0U || !buf || !len) return 0;
+ if(!info->compressedsize)
+ {
+ if(arch->owner != this)
+ {
+ arch->owner = NULL;
+ if(fseek(arch->data, reading, SEEK_SET) < 0) { stopreading(); return 0; }
+ arch->owner = this;
+ }
+
+ size_t n = fread(buf, 1, min(len, size_t(info->size + info->offset - reading)), arch->data);
+ reading += n;
+ if(n < len) ended = true;
+ return n;
+ }
+
+ zfile.next_out = (Bytef *)buf;
+ zfile.avail_out = len;
+ while(zfile.avail_out > 0)
+ {
+ if(!zfile.avail_in) readbuf(BUFSIZE);
+ int err = inflate(&zfile, Z_NO_FLUSH);
+ if(err != Z_OK)
+ {
+ if(err == Z_STREAM_END) ended = true;
+ else
+ {
+#ifndef STANDALONE
+ if(dbgzip) conoutf(CON_DEBUG, "inflate error: %s", zError(err));
+#endif
+ stopreading();
+ }
+ break;
+ }
+ }
+ return len - zfile.avail_out;
+ }
+};
+
+stream *openzipfile(const char *name, const char *mode)
+{
+ for(; *mode; mode++) if(*mode=='w' || *mode=='a') return NULL;
+ loopvrev(archives)
+ {
+ ziparchive *arch = archives[i];
+ zipfile *f = arch->files.access(name);
+ if(!f) continue;
+ zipstream *s = new zipstream;
+ if(s->open(arch, f)) return s;
+ delete s;
+ }
+ return NULL;
+}
+
+bool findzipfile(const char *name)
+{
+ loopvrev(archives)
+ {
+ ziparchive *arch = archives[i];
+ if(arch->files.access(name)) return true;
+ }
+ return false;
+}
+
+int listzipfiles(const char *dir, const char *ext, vector<char *> &files)
+{
+ size_t extsize = ext ? strlen(ext)+1 : 0, dirsize = strlen(dir);
+ int dirs = 0;
+ loopvrev(archives)
+ {
+ ziparchive *arch = archives[i];
+ int oldsize = files.length();
+ enumerate(arch->files, zipfile, f,
+ {
+ if(strncmp(f.name, dir, dirsize)) continue;
+ const char *name = f.name + dirsize;
+ if(name[0] == PATHDIV) name++;
+ if(strchr(name, PATHDIV)) continue;
+ if(!ext) files.add(newstring(name));
+ else
+ {
+ size_t namelen = strlen(name);
+ if(namelen > extsize)
+ {
+ namelen -= extsize;
+ if(name[namelen] == '.' && strncmp(name+namelen+1, ext, extsize-1)==0)
+ files.add(newstring(name, namelen));
+ }
+ }
+ });
+ if(files.length() > oldsize) dirs++;
+ }
+ return dirs;
+}
+
+#ifndef STANDALONE
+ICOMMAND(addzip, "sss", (const char *name, const char *mount, const char *strip), addzip(name, mount[0] ? mount : NULL, strip[0] ? strip : NULL));
+ICOMMAND(removezip, "s", (const char *name), removezip(name));
+#endif
+
generated by cgit v1.2.3 (git 2.46.0) at 2026-02-21 10:46:33 +0000