2023-01-10 07:13:00 -06:00
|
|
|
#include "ffi.h"
|
|
|
|
|
|
|
|
#include "script.h"
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
#include "anim.h"
|
2023-03-24 14:01:01 -05:00
|
|
|
#include "debug.h"
|
2023-05-12 13:22:05 -05:00
|
|
|
#include "debugdraw.h"
|
2023-01-10 15:41:43 -06:00
|
|
|
#include "font.h"
|
2023-05-12 13:22:05 -05:00
|
|
|
#include "gameobject.h"
|
|
|
|
#include "input.h"
|
2023-01-16 13:20:07 -06:00
|
|
|
#include "level.h"
|
2023-05-12 13:22:05 -05:00
|
|
|
#include "log.h"
|
2023-02-02 17:52:15 -06:00
|
|
|
#include "mix.h"
|
2023-05-12 13:22:05 -05:00
|
|
|
#include "music.h"
|
2023-09-15 03:37:07 -05:00
|
|
|
#include "2dphysics.h"
|
2023-09-12 23:32:14 -05:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
#include "sound.h"
|
|
|
|
#include "sprite.h"
|
2023-02-05 17:42:36 -06:00
|
|
|
#include "stb_ds.h"
|
2023-05-12 13:22:05 -05:00
|
|
|
#include "string.h"
|
|
|
|
#include "tinyspline.h"
|
|
|
|
#include "window.h"
|
|
|
|
#include "yugine.h"
|
2023-04-21 16:57:30 -05:00
|
|
|
#include <assert.h>
|
2023-09-04 09:48:44 -05:00
|
|
|
#include "resources.h"
|
2023-09-11 02:46:12 -05:00
|
|
|
#include <sokol/sokol_time.h>
|
|
|
|
|
2023-05-24 20:45:50 -05:00
|
|
|
#include "render.h"
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
#include "model.h"
|
2023-02-02 17:52:15 -06:00
|
|
|
|
2023-05-24 20:45:50 -05:00
|
|
|
#include "HandmadeMath.h"
|
|
|
|
|
|
|
|
static JSValue globalThis;
|
|
|
|
|
2023-02-02 17:52:15 -06:00
|
|
|
#define BYTE_TO_BINARY_PATTERN "%c%c%c%c%c%c%c%c"
|
2023-05-12 13:22:05 -05:00
|
|
|
#define BYTE_TO_BINARY(byte) \
|
|
|
|
(byte & 0x80 ? '1' : '0'), \
|
|
|
|
(byte & 0x40 ? '1' : '0'), \
|
|
|
|
(byte & 0x20 ? '1' : '0'), \
|
|
|
|
(byte & 0x10 ? '1' : '0'), \
|
|
|
|
(byte & 0x08 ? '1' : '0'), \
|
|
|
|
(byte & 0x04 ? '1' : '0'), \
|
|
|
|
(byte & 0x02 ? '1' : '0'), \
|
|
|
|
(byte & 0x01 ? '1' : '0')
|
|
|
|
|
2023-05-24 20:45:50 -05:00
|
|
|
JSValue js_getpropstr(JSValue v, const char *str)
|
|
|
|
{
|
|
|
|
JSValue p = JS_GetPropertyStr(js,v,str);
|
|
|
|
JS_FreeValue(js,p);
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
|
|
|
JSValue js_getpropidx(JSValue v, uint32_t i)
|
|
|
|
{
|
|
|
|
JSValue p = JS_GetPropertyUint32(js,v,i);
|
|
|
|
JS_FreeValue(js,p);
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
2023-09-11 02:46:12 -05:00
|
|
|
uint64_t js2uint64(JSValue v)
|
|
|
|
{
|
|
|
|
int64_t i;
|
|
|
|
JS_ToInt64(js, &i, v);
|
|
|
|
uint64_t n = i;
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
int js2int(JSValue v) {
|
2023-04-19 15:16:35 -05:00
|
|
|
int32_t i;
|
2023-05-12 13:22:05 -05:00
|
|
|
JS_ToInt32(js, &i, v);
|
2023-04-18 14:49:17 -05:00
|
|
|
return i;
|
2023-02-06 16:41:47 -06:00
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue int2js(int i) {
|
2023-04-18 17:58:44 -05:00
|
|
|
return JS_NewInt64(js, i);
|
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue str2js(const char *c) {
|
2023-04-25 16:59:12 -05:00
|
|
|
return JS_NewString(js, c);
|
|
|
|
}
|
|
|
|
|
2023-09-13 01:08:32 -05:00
|
|
|
JSValue strarr2js(const char **c)
|
2023-09-11 02:46:12 -05:00
|
|
|
{
|
|
|
|
JSValue arr = JS_NewArray(js);
|
2023-09-13 01:08:32 -05:00
|
|
|
for (int i = 0; i < arrlen(c); i++)
|
2023-09-11 02:46:12 -05:00
|
|
|
JS_SetPropertyUint32(js, arr, i, JS_NewString(js, c[i]));
|
|
|
|
|
|
|
|
return arr;
|
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
double js2number(JSValue v) {
|
2023-04-18 17:58:44 -05:00
|
|
|
double g;
|
2023-05-12 13:22:05 -05:00
|
|
|
JS_ToFloat64(js, &g, v);
|
2023-04-18 17:58:44 -05:00
|
|
|
return g;
|
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
int js2bool(JSValue v) {
|
|
|
|
return JS_ToBool(js, v);
|
2023-05-01 20:58:10 -05:00
|
|
|
}
|
|
|
|
|
2023-05-27 07:01:17 -05:00
|
|
|
JSValue bool2js(int b)
|
|
|
|
{
|
|
|
|
return JS_NewBool(js,b);
|
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue float2js(double g) {
|
|
|
|
return JS_NewFloat64(js, g);
|
2023-04-18 17:58:44 -05:00
|
|
|
}
|
2023-04-19 15:16:35 -05:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue num2js(double g) {
|
2023-04-18 17:58:44 -05:00
|
|
|
return float2js(g);
|
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
struct gameobject *js2go(JSValue v) {
|
2023-04-18 14:49:17 -05:00
|
|
|
return id2go(js2int(v));
|
2023-03-05 22:05:22 -06:00
|
|
|
}
|
|
|
|
|
2023-09-12 17:19:46 -05:00
|
|
|
struct sprite *js2sprite(JSValue v) { return id2sprite(js2int(v)); }
|
2023-05-27 07:01:17 -05:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
void *js2ptr(JSValue v) {
|
2023-04-18 17:58:44 -05:00
|
|
|
void *p;
|
|
|
|
JS_ToInt64(js, &p, v);
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue ptr2js(void *ptr) {
|
|
|
|
return JS_NewInt64(js, (long)ptr);
|
2023-04-18 17:58:44 -05:00
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
struct timer *js2timer(JSValue v) {
|
2023-04-18 14:49:17 -05:00
|
|
|
return id2timer(js2int(v));
|
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
double js_get_prop_number(JSValue v, const char *p) {
|
2023-04-19 15:16:35 -05:00
|
|
|
double num;
|
2023-05-24 20:45:50 -05:00
|
|
|
JS_ToFloat64(js, &num, js_getpropstr(v,p));
|
2023-04-18 14:49:17 -05:00
|
|
|
return num;
|
2023-03-05 22:05:22 -06:00
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
struct glrect js2glrect(JSValue v) {
|
2023-03-05 22:05:22 -06:00
|
|
|
struct glrect rect;
|
2023-05-12 13:22:05 -05:00
|
|
|
rect.s0 = js_get_prop_number(v, "s0");
|
|
|
|
rect.s1 = js_get_prop_number(v, "s1");
|
|
|
|
rect.t0 = js_get_prop_number(v, "t0");
|
|
|
|
rect.t1 = js_get_prop_number(v, "t1");
|
2023-03-05 22:05:22 -06:00
|
|
|
return rect;
|
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue js_arridx(JSValue v, int idx) {
|
2023-05-24 20:45:50 -05:00
|
|
|
return js_getpropidx( v, idx);
|
2023-04-19 15:16:35 -05:00
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
int js_arrlen(JSValue v) {
|
2023-04-18 14:49:17 -05:00
|
|
|
int len;
|
2023-05-24 20:45:50 -05:00
|
|
|
JS_ToInt32(js, &len, js_getpropstr( v, "length"));
|
2023-04-18 14:49:17 -05:00
|
|
|
return len;
|
|
|
|
}
|
2023-05-16 01:31:13 -05:00
|
|
|
|
|
|
|
struct rgba js2color(JSValue v) {
|
2023-05-24 20:45:50 -05:00
|
|
|
JSValue c[4];
|
|
|
|
for (int i = 0; i < 4; i++)
|
|
|
|
c[i] = js_arridx(v,i);
|
2023-09-23 12:35:02 -05:00
|
|
|
float a = JS_IsUndefined(c[3]) ? 1.0 : js2number(c[3]);
|
2023-05-16 01:31:13 -05:00
|
|
|
struct rgba color = {
|
2023-09-23 12:35:02 -05:00
|
|
|
.r = js2number(c[0])*RGBA_MAX,
|
|
|
|
.g = js2number(c[1])*RGBA_MAX,
|
|
|
|
.b = js2number(c[2])*RGBA_MAX,
|
|
|
|
.a = a*RGBA_MAX,
|
2023-05-16 01:31:13 -05:00
|
|
|
};
|
2023-05-24 20:45:50 -05:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
return color;
|
2023-04-19 15:16:35 -05:00
|
|
|
}
|
2023-01-27 12:06:16 -06:00
|
|
|
|
2023-05-24 20:45:50 -05:00
|
|
|
HMM_Vec2 js2hmmv2(JSValue v)
|
|
|
|
{
|
|
|
|
HMM_Vec2 v2;
|
|
|
|
v2.X = js2number(js_getpropidx(v,0));
|
|
|
|
v2.Y = js2number(js_getpropidx(v,1));
|
|
|
|
return v2;
|
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
cpVect js2vec2(JSValue v) {
|
2023-04-18 14:49:17 -05:00
|
|
|
cpVect vect;
|
2023-05-24 20:45:50 -05:00
|
|
|
vect.x = js2number(js_getpropidx(v,0));
|
|
|
|
vect.y = js2number(js_getpropidx(v,1));
|
2023-04-18 14:49:17 -05:00
|
|
|
return vect;
|
2023-01-10 07:13:00 -06:00
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
cpBitmask js2bitmask(JSValue v) {
|
|
|
|
cpBitmask mask = 0;
|
|
|
|
int len = js_arrlen(v);
|
2023-02-02 17:52:15 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
for (int i = 0; i < len; i++) {
|
2023-05-24 20:45:50 -05:00
|
|
|
int val = JS_ToBool(js, js_getpropidx( v, i));
|
2023-05-12 13:22:05 -05:00
|
|
|
if (!val) continue;
|
2023-02-02 17:52:15 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
mask |= 1 << i;
|
|
|
|
}
|
2023-02-02 17:52:15 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
return mask;
|
2023-02-02 17:52:15 -06:00
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
cpVect *js2cpvec2arr(JSValue v) {
|
2023-04-18 14:49:17 -05:00
|
|
|
int n = js_arrlen(v);
|
2023-02-08 15:30:12 -06:00
|
|
|
cpVect *points = NULL;
|
|
|
|
|
2023-04-18 14:49:17 -05:00
|
|
|
for (int i = 0; i < n; i++)
|
2023-05-24 20:45:50 -05:00
|
|
|
arrput(points, js2vec2(js_getpropidx( v, i)));
|
2023-02-08 15:30:12 -06:00
|
|
|
|
|
|
|
return points;
|
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue bitmask2js(cpBitmask mask) {
|
2023-04-19 16:58:17 -05:00
|
|
|
JSValue arr = JS_NewArray(js);
|
2023-02-02 17:52:15 -06:00
|
|
|
for (int i = 0; i < 11; i++) {
|
2023-05-12 13:22:05 -05:00
|
|
|
int on = mask & 1 << i;
|
2023-04-18 14:49:17 -05:00
|
|
|
JS_SetPropertyUint32(js, arr, i, JS_NewBool(js, on));
|
2023-02-02 17:52:15 -06:00
|
|
|
}
|
2023-04-18 14:49:17 -05:00
|
|
|
|
|
|
|
return arr;
|
2023-02-02 17:52:15 -06:00
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
void vec2float(cpVect v, float *f) {
|
|
|
|
f[0] = v.x;
|
|
|
|
f[1] = v.y;
|
2023-01-19 18:30:23 -06:00
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue vec2js(cpVect v) {
|
2023-04-19 15:16:35 -05:00
|
|
|
JSValue array = JS_NewArray(js);
|
2023-05-12 13:22:05 -05:00
|
|
|
JS_SetPropertyInt64(js, array, 0, JS_NewFloat64(js, v.x));
|
|
|
|
JS_SetPropertyInt64(js, array, 1, JS_NewFloat64(js, v.y));
|
2023-04-18 14:49:17 -05:00
|
|
|
return array;
|
2023-03-19 20:33:05 -05:00
|
|
|
}
|
|
|
|
|
2023-05-27 07:01:17 -05:00
|
|
|
JSValue v22js(HMM_Vec2 v)
|
|
|
|
{
|
|
|
|
cpVect c = { v.X, v.Y };
|
|
|
|
return vec2js(c);
|
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue vecarr2js(cpVect *points, int n) {
|
2023-04-19 16:58:17 -05:00
|
|
|
JSValue array = JS_NewArray(js);
|
2023-05-12 13:22:05 -05:00
|
|
|
for (int i = 0; i < n; i++)
|
2023-04-18 14:49:17 -05:00
|
|
|
JS_SetPropertyInt64(js, array, i, vec2js(points[i]));
|
|
|
|
return array;
|
2023-02-02 17:52:15 -06:00
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue duk_gui_text(JSContext *js, JSValueConst this, int argc, JSValueConst *argv) {
|
|
|
|
const char *s = JS_ToCString(js, argv[0]);
|
2023-05-24 20:45:50 -05:00
|
|
|
HMM_Vec2 pos = js2hmmv2(argv[1]);
|
2023-01-10 07:13:00 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
float size = js2number(argv[2]);
|
2023-05-30 15:41:02 -05:00
|
|
|
renderText(s, pos, size, color_white, 500, -1, 1.0);
|
2023-05-12 13:22:05 -05:00
|
|
|
JS_FreeCString(js, s);
|
|
|
|
return JS_NULL;
|
2023-01-10 07:13:00 -06:00
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue duk_ui_text(JSContext *js, JSValueConst this, int argc, JSValueConst *argv) {
|
|
|
|
const char *s = JS_ToCString(js, argv[0]);
|
2023-05-24 20:45:50 -05:00
|
|
|
HMM_Vec2 pos = js2hmmv2(argv[1]);
|
2023-05-12 13:22:05 -05:00
|
|
|
|
|
|
|
float size = js2number(argv[2]);
|
2023-05-16 01:31:13 -05:00
|
|
|
struct rgba c = js2color(argv[3]);
|
2023-05-12 13:22:05 -05:00
|
|
|
int wrap = js2int(argv[4]);
|
2023-05-30 15:41:02 -05:00
|
|
|
JSValue ret = JS_NewInt64(js, renderText(s, pos, size, c, wrap, -1, 1.0));
|
2023-05-12 13:22:05 -05:00
|
|
|
JS_FreeCString(js, s);
|
|
|
|
return ret;
|
2023-03-10 13:13:48 -06:00
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue duk_cursor_text(JSContext *js, JSValueConst this, int argc, JSValueConst *argv) {
|
|
|
|
const char *s = JS_ToCString(js, argv[0]);
|
2023-05-24 20:45:50 -05:00
|
|
|
HMM_Vec2 pos = js2hmmv2(argv[1]);
|
2023-05-12 13:22:05 -05:00
|
|
|
|
|
|
|
float size = js2number(argv[2]);
|
2023-05-16 01:31:13 -05:00
|
|
|
struct rgba c = js2color(argv[3]);
|
2023-05-12 13:22:05 -05:00
|
|
|
int wrap = js2int(argv[5]);
|
|
|
|
int cursor = js2int(argv[4]);
|
2023-05-30 15:41:02 -05:00
|
|
|
renderText(s, pos, size, c, wrap, cursor, 1.0);
|
2023-05-12 13:22:05 -05:00
|
|
|
JS_FreeCString(js, s);
|
|
|
|
return JS_NULL;
|
2023-03-03 13:07:59 -06:00
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue duk_gui_img(JSContext *js, JSValueConst this, int argc, JSValueConst *argv) {
|
|
|
|
const char *img = JS_ToCString(js, argv[0]);
|
2023-06-06 15:49:55 -05:00
|
|
|
gui_draw_img(img, js2hmmv2(argv[1]), js2hmmv2(argv[2]), js2number(argv[3]), js2bool(argv[4]), js2hmmv2(argv[5]), 1.0, js2color(argv[6]));
|
2023-05-12 13:22:05 -05:00
|
|
|
JS_FreeCString(js, img);
|
|
|
|
return JS_NULL;
|
2023-01-10 17:23:11 -06:00
|
|
|
}
|
|
|
|
|
2023-09-05 09:38:52 -05:00
|
|
|
struct rect js2rect(JSValue v) {
|
|
|
|
struct rect rect;
|
2023-05-24 20:45:50 -05:00
|
|
|
rect.x = js2number(js_getpropstr(v, "x"));
|
|
|
|
rect.y = js2number(js_getpropstr(v, "y"));
|
|
|
|
rect.w = js2number(js_getpropstr(v, "w"));
|
|
|
|
rect.h = js2number(js_getpropstr(v, "h"));
|
2023-04-18 17:58:44 -05:00
|
|
|
return rect;
|
|
|
|
}
|
|
|
|
|
2023-09-05 09:38:52 -05:00
|
|
|
JSValue rect2js(struct rect rect) {
|
2023-04-18 17:58:44 -05:00
|
|
|
JSValue obj = JS_NewObject(js);
|
|
|
|
JS_SetPropertyStr(js, obj, "x", JS_NewFloat64(js, rect.x));
|
2023-05-12 13:22:05 -05:00
|
|
|
JS_SetPropertyStr(js, obj, "y", JS_NewFloat64(js, rect.y));
|
2023-04-18 17:58:44 -05:00
|
|
|
JS_SetPropertyStr(js, obj, "w", JS_NewFloat64(js, rect.w));
|
|
|
|
JS_SetPropertyStr(js, obj, "h", JS_NewFloat64(js, rect.h));
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
2023-05-30 13:07:18 -05:00
|
|
|
JSValue bb2js(struct boundingbox bb)
|
|
|
|
{
|
|
|
|
JSValue obj = JS_NewObject(js);
|
|
|
|
JS_SetPropertyStr(js,obj,"t", JS_NewFloat64(js,bb.t));
|
|
|
|
JS_SetPropertyStr(js,obj,"b", JS_NewFloat64(js,bb.b));
|
|
|
|
JS_SetPropertyStr(js,obj,"r", JS_NewFloat64(js,bb.r));
|
|
|
|
JS_SetPropertyStr(js,obj,"l", JS_NewFloat64(js,bb.l));
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
2023-09-12 23:32:14 -05:00
|
|
|
|
|
|
|
#ifndef NO_EDITOR
|
|
|
|
|
|
|
|
#include "nuke.h"
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue duk_nuke(JSContext *js, JSValueConst this, int argc, JSValueConst *argv) {
|
|
|
|
int cmd = js2int(argv[0]);
|
|
|
|
float editnum;
|
|
|
|
int editint;
|
|
|
|
char textbox[130];
|
|
|
|
const char *str = NULL;
|
2023-01-19 13:06:32 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
if (JS_IsString(argv[1]))
|
|
|
|
str = JS_ToCString(js, argv[1]);
|
|
|
|
else {
|
|
|
|
JSValue tostr = JS_ToString(js, argv[1]);
|
|
|
|
str = JS_ToCString(js, argv[1]);
|
|
|
|
JS_FreeValue(js, tostr);
|
|
|
|
}
|
2023-04-19 16:58:17 -05:00
|
|
|
|
2023-09-05 09:38:52 -05:00
|
|
|
struct rect rect = (struct rect){0, 0, 0, 0};
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue ret = JS_NULL;
|
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case 0:
|
2023-09-05 09:38:52 -05:00
|
|
|
rect = js2rect(argv[2]);
|
|
|
|
nuke_begin(str, rect);
|
2023-05-12 13:22:05 -05:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 1:
|
|
|
|
nuke_stop();
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 2:
|
|
|
|
editnum = js2number(argv[2]);
|
|
|
|
nuke_property_float(str, js2number(argv[3]), &editnum, js2number(argv[4]), js2number(argv[5]), js2number(argv[5]));
|
|
|
|
ret = JS_NewFloat64(js, editnum);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 3:
|
|
|
|
nuke_nel(js2number(argv[1]));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 4:
|
|
|
|
editint = JS_ToBool(js, argv[2]);
|
|
|
|
nuke_checkbox(str, &editint);
|
|
|
|
ret = JS_NewBool(js, editint);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 5:
|
|
|
|
nuke_label(str);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 6:
|
|
|
|
ret = JS_NewBool(js, nuke_btn(str));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 7:
|
|
|
|
strncpy(textbox, str, 130);
|
|
|
|
nuke_edit_str(textbox);
|
|
|
|
ret = JS_NewString(js, textbox);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 8:
|
|
|
|
nuke_img(str);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 9:
|
|
|
|
editint = js2int(argv[2]);
|
|
|
|
nuke_radio_btn(str, &editint, js2int(argv[3]));
|
|
|
|
ret = JS_NewInt64(js, editint);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 10:
|
|
|
|
rect = nuke_win_get_bounds();
|
2023-09-05 09:38:52 -05:00
|
|
|
ret = rect2js(rect);
|
2023-05-12 13:22:05 -05:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 11:
|
|
|
|
ret = JS_NewBool(js, nuke_push_tree_id(str, js2int(argv[2])));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 12:
|
|
|
|
nuke_tree_pop();
|
|
|
|
return JS_NULL;
|
|
|
|
|
|
|
|
case 13:
|
|
|
|
nuke_row(js2int(argv[1]));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 14:
|
|
|
|
nuke_scrolltext(str);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 15:
|
|
|
|
nuke_nel_h(js2int(argv[1]), js2int(argv[2]));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (str)
|
|
|
|
JS_FreeCString(js, str);
|
|
|
|
|
|
|
|
return ret;
|
2023-01-19 13:06:32 -06:00
|
|
|
}
|
|
|
|
|
2023-09-12 23:32:14 -05:00
|
|
|
#endif
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue duk_spline_cmd(JSContext *js, JSValueConst this, int argc, JSValueConst *argv) {
|
2023-09-04 09:48:44 -05:00
|
|
|
static_assert(sizeof(tsReal) * 2 == sizeof(cpVect));
|
2023-05-12 13:22:05 -05:00
|
|
|
|
|
|
|
tsBSpline spline;
|
2023-01-27 12:06:16 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
int d = js2int(argv[2]); /* dimensions */
|
|
|
|
int degrees = js2int(argv[1]);
|
|
|
|
int type = js2int(argv[3]);
|
|
|
|
JSValue ctrl_pts = argv[4];
|
|
|
|
int n = js_arrlen(ctrl_pts);
|
|
|
|
size_t nsamples = js2int(argv[5]);
|
2023-04-21 16:57:30 -05:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
cpVect points[n];
|
2023-01-27 12:06:16 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
tsStatus status;
|
|
|
|
ts_bspline_new(n, d, degrees, type, &spline, &status);
|
2023-02-10 14:31:59 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
if (status.code)
|
|
|
|
YughCritical("Spline creation error %d: %s", status.code, status.message);
|
2023-01-27 12:06:16 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
for (int i = 0; i < n; i++)
|
2023-05-24 20:45:50 -05:00
|
|
|
points[i] = js2vec2(js_getpropidx( ctrl_pts, i));
|
2023-01-27 12:06:16 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
ts_bspline_set_control_points(&spline, (tsReal *)points, &status);
|
2023-01-27 12:06:16 -06:00
|
|
|
|
2023-04-21 16:57:30 -05:00
|
|
|
if (status.code)
|
|
|
|
YughCritical("Spline creation error %d: %s", status.code, status.message);
|
2023-05-12 13:22:05 -05:00
|
|
|
|
2023-01-27 12:06:16 -06:00
|
|
|
cpVect samples[nsamples];
|
2023-05-12 13:22:05 -05:00
|
|
|
|
2023-03-24 14:01:01 -05:00
|
|
|
size_t rsamples;
|
2023-04-21 16:57:30 -05:00
|
|
|
/* TODO: This does not work with Clang/GCC due to UB */
|
2023-05-12 13:22:05 -05:00
|
|
|
ts_bspline_sample(&spline, nsamples, (tsReal **)&samples, &rsamples, &status);
|
2023-04-21 16:57:30 -05:00
|
|
|
|
|
|
|
if (status.code)
|
|
|
|
YughCritical("Spline creation error %d: %s", status.code, status.message);
|
2023-01-27 12:06:16 -06:00
|
|
|
|
2023-04-19 16:58:17 -05:00
|
|
|
JSValue arr = JS_NewArray(js);
|
2023-01-27 12:06:16 -06:00
|
|
|
|
2023-03-24 14:01:01 -05:00
|
|
|
for (int i = 0; i < nsamples; i++) {
|
2023-04-21 16:57:30 -05:00
|
|
|
JSValue psample = JS_NewArray(js);
|
2023-04-18 17:58:44 -05:00
|
|
|
JS_SetPropertyUint32(js, psample, 0, float2js(samples[i].x));
|
|
|
|
JS_SetPropertyUint32(js, psample, 1, float2js(samples[i].y));
|
|
|
|
JS_SetPropertyUint32(js, arr, i, psample);
|
2023-03-24 14:01:01 -05:00
|
|
|
}
|
2023-01-27 12:06:16 -06:00
|
|
|
|
2023-03-24 14:01:01 -05:00
|
|
|
ts_bspline_free(&spline);
|
2023-01-27 12:06:16 -06:00
|
|
|
|
2023-04-18 17:58:44 -05:00
|
|
|
return arr;
|
2023-01-27 12:06:16 -06:00
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue ints2js(int *ints) {
|
2023-04-19 16:58:17 -05:00
|
|
|
JSValue arr = JS_NewArray(js);
|
2023-04-18 17:58:44 -05:00
|
|
|
for (int i = 0; i < arrlen(ints); i++)
|
|
|
|
JS_SetPropertyUint32(js, arr, i, int2js(ints[i]));
|
|
|
|
|
|
|
|
return arr;
|
2023-02-05 17:42:36 -06:00
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
int vec_between(cpVect p, cpVect a, cpVect b) {
|
2023-02-10 14:31:58 -06:00
|
|
|
cpVect n;
|
|
|
|
n.x = b.x - a.x;
|
|
|
|
n.y = b.y - a.y;
|
|
|
|
n = cpvnormalize(n);
|
|
|
|
|
|
|
|
return (cpvdot(n, cpvsub(p, a)) > 0 && cpvdot(cpvneg(n), cpvsub(p, b)) > 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Determines between which two points in 'segs' point 'p' falls.
|
|
|
|
0 indicates 'p' comes before the first point.
|
|
|
|
arrlen(segs) indicates it comes after the last point.
|
|
|
|
*/
|
2023-05-12 13:22:05 -05:00
|
|
|
int point2segindex(cpVect p, cpVect *segs, double slop) {
|
2023-02-10 14:31:58 -06:00
|
|
|
float shortest = slop < 0 ? INFINITY : slop;
|
2023-02-08 15:30:12 -06:00
|
|
|
int best = -1;
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
for (int i = 0; i < arrlen(segs) - 1; i++) {
|
|
|
|
float a = (segs[i + 1].y - segs[i].y) / (segs[i + 1].x - segs[i].x);
|
2023-02-08 15:30:12 -06:00
|
|
|
float c = segs[i].y - (a * segs[i].x);
|
|
|
|
float b = -1;
|
|
|
|
|
2023-09-04 01:20:55 -05:00
|
|
|
float dist = fabsf(a * p.x + b * p.y + c) / sqrt(pow(a, 2) + 1);
|
2023-02-08 15:30:12 -06:00
|
|
|
|
2023-02-10 14:31:58 -06:00
|
|
|
if (dist > shortest) continue;
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
int between = vec_between(p, segs[i], segs[i + 1]);
|
2023-02-10 14:31:58 -06:00
|
|
|
|
|
|
|
if (between) {
|
2023-02-08 15:30:12 -06:00
|
|
|
shortest = dist;
|
2023-05-12 13:22:05 -05:00
|
|
|
best = i + 1;
|
2023-02-10 14:31:58 -06:00
|
|
|
} else {
|
|
|
|
if (i == 0 && cpvdist(p, segs[0]) < slop) {
|
|
|
|
shortest = dist;
|
2023-05-12 13:22:05 -05:00
|
|
|
best = i;
|
|
|
|
} else if (i == arrlen(segs) - 2 && cpvdist(p, arrlast(segs)) < slop) {
|
2023-02-10 14:31:58 -06:00
|
|
|
shortest = dist;
|
2023-05-12 13:22:05 -05:00
|
|
|
best = arrlen(segs);
|
2023-02-10 14:31:58 -06:00
|
|
|
}
|
2023-02-08 15:30:12 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-02-10 14:31:58 -06:00
|
|
|
if (best == 1) {
|
2023-02-08 15:30:12 -06:00
|
|
|
cpVect n;
|
2023-05-12 13:22:05 -05:00
|
|
|
n.x = segs[1].x - segs[0].x;
|
|
|
|
n.y = segs[1].y - segs[0].y;
|
2023-02-08 15:30:12 -06:00
|
|
|
n = cpvnormalize(n);
|
2023-09-04 01:20:55 -05:00
|
|
|
if (cpvdot(n, cpvsub(p, segs[0])) < 0) {
|
2023-02-10 14:31:58 -06:00
|
|
|
if (cpvdist(p, segs[0]) >= slop)
|
|
|
|
best = -1;
|
|
|
|
else
|
|
|
|
best = 0;
|
2023-09-04 01:20:55 -05:00
|
|
|
}
|
2023-02-08 15:30:12 -06:00
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
if (best == arrlen(segs) - 1) {
|
2023-02-08 15:30:12 -06:00
|
|
|
cpVect n;
|
2023-05-12 13:22:05 -05:00
|
|
|
n.x = segs[best - 1].x - segs[best].x;
|
|
|
|
n.y = segs[best - 1].y - segs[best - 1].y;
|
2023-02-08 15:30:12 -06:00
|
|
|
n = cpvnormalize(n);
|
|
|
|
|
2023-09-04 01:20:55 -05:00
|
|
|
if (cpvdot(n, cpvsub(p, segs[best])) < 0) {
|
2023-02-10 14:31:58 -06:00
|
|
|
if (cpvdist(p, segs[best]) >= slop)
|
|
|
|
best = -1;
|
|
|
|
else
|
|
|
|
best = arrlen(segs);
|
2023-09-04 01:20:55 -05:00
|
|
|
}
|
2023-02-08 15:30:12 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return best;
|
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue duk_cmd(JSContext *js, JSValueConst this, int argc, JSValueConst *argv) {
|
2023-04-18 17:58:44 -05:00
|
|
|
int cmd = js2int(argv[0]);
|
2023-04-22 16:44:26 -05:00
|
|
|
const char *str = NULL;
|
|
|
|
const char *str2 = NULL;
|
2023-04-19 16:58:17 -05:00
|
|
|
JSValue ret = JS_NULL;
|
2023-01-10 14:02:24 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
switch (cmd) {
|
|
|
|
case 0:
|
|
|
|
str = JS_ToCString(js, argv[1]);
|
|
|
|
ret = JS_NewInt64(js, script_dofile(str));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 1:
|
|
|
|
YughWarn("Do not set pawns here anymore; Do it entirely in script.");
|
|
|
|
// set_pawn(js2ptrduk_get_heapptr(duk, 1));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 2:
|
|
|
|
gameobject_delete(js2int(argv[1]));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 3:
|
|
|
|
set_timescale(js2number(argv[1]));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 4:
|
|
|
|
debug_draw_phys(JS_ToBool(js, argv[1]));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 5:
|
2023-09-06 17:48:08 -05:00
|
|
|
// renderMS = js2number(argv[1]);
|
2023-05-12 13:22:05 -05:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 6:
|
2023-09-06 17:48:08 -05:00
|
|
|
// updateMS = js2number(argv[1]);
|
2023-05-12 13:22:05 -05:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 7:
|
|
|
|
physMS = js2number(argv[1]);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 8:
|
|
|
|
phys2d_set_gravity(js2vec2(argv[1]));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 9:
|
|
|
|
sprite_delete(js2int(argv[1]));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 10:
|
|
|
|
YughWarn("Pawns are handled in script only now.");
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 11:
|
|
|
|
str = JS_ToCString(js, argv[1]);
|
|
|
|
ret = JS_NewInt64(js, file_mod_secs(str));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 12:
|
|
|
|
str = JS_ToCString(js, argv[2]);
|
|
|
|
sprite_loadtex(id2sprite(js2int(argv[1])), str, js2glrect(argv[3]));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 13:
|
|
|
|
str = JS_ToCString(js, argv[1]);
|
|
|
|
str2 = JS_ToCString(js, argv[2]);
|
|
|
|
play_song(str, str2);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 14:
|
|
|
|
str = JS_ToCString(js, argv[1]);
|
2023-08-30 18:22:32 -05:00
|
|
|
play_oneshot(make_sound(str));
|
2023-05-12 13:22:05 -05:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 15:
|
|
|
|
music_stop();
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 16:
|
2023-05-24 20:45:50 -05:00
|
|
|
// dbg_color = js2color(argv[1]);
|
2023-05-12 13:22:05 -05:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 17:
|
2023-05-24 20:45:50 -05:00
|
|
|
// trigger_color = js2color(argv[1]);
|
2023-05-12 13:22:05 -05:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 18:
|
|
|
|
shape_set_sensor(js2ptr(argv[1]), JS_ToBool(js, argv[2]));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 19:
|
2023-08-30 18:22:32 -05:00
|
|
|
// mini_master(js2number(argv[1]));
|
2023-05-12 13:22:05 -05:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 20:
|
|
|
|
sprite_enabled(js2int(argv[1]), JS_ToBool(js, argv[2]));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 21:
|
|
|
|
return JS_NewBool(js, shape_get_sensor(js2ptr(argv[1])));
|
|
|
|
|
|
|
|
case 22:
|
|
|
|
shape_enabled(js2ptr(argv[1]), JS_ToBool(js, argv[2]));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 23:
|
|
|
|
return JS_NewBool(js, shape_is_enabled(js2ptr(argv[1])));
|
|
|
|
|
|
|
|
case 24:
|
|
|
|
timer_pause(js2timer(argv[1]));
|
|
|
|
break;
|
2023-01-10 14:02:24 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 25:
|
|
|
|
timer_stop(js2timer(argv[1]));
|
|
|
|
break;
|
2023-01-10 17:23:11 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 26:
|
|
|
|
timer_start(js2timer(argv[1]));
|
|
|
|
break;
|
2023-01-11 16:57:34 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 27:
|
|
|
|
timer_remove(js2int(argv[1]));
|
|
|
|
break;
|
2023-01-11 16:57:34 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 28:
|
|
|
|
timerr_settime(js2timer(argv[1]), js2number(argv[2]));
|
|
|
|
break;
|
2023-01-11 16:57:34 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 29:
|
|
|
|
return JS_NewFloat64(js, js2timer(argv[1])->interval);
|
2023-01-13 22:08:39 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 30:
|
|
|
|
sprite_setanim(id2sprite(js2int(argv[1])), js2ptr(argv[2]), js2int(argv[3]));
|
|
|
|
return JS_NULL;
|
|
|
|
|
|
|
|
case 31:
|
|
|
|
free(js2ptr(argv[1]));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 32:
|
|
|
|
return JS_NewFloat64(js, js2timer(argv[1])->remain_time);
|
|
|
|
|
|
|
|
case 33:
|
|
|
|
return JS_NewBool(js, js2timer(argv[1])->on);
|
|
|
|
|
|
|
|
case 34:
|
|
|
|
return JS_NewBool(js, js2timer(argv[1])->repeat);
|
|
|
|
|
|
|
|
case 35:
|
|
|
|
js2timer(argv[1])->repeat = JS_ToBool(js, argv[2]);
|
|
|
|
return JS_NULL;
|
|
|
|
|
|
|
|
case 36:
|
|
|
|
id2go(js2int(argv[1]))->scale = js2number(argv[2]);
|
2023-09-26 17:07:51 -05:00
|
|
|
gameobject_apply(id2go(js2int(argv[1])));
|
2023-05-12 13:22:05 -05:00
|
|
|
cpSpaceReindexShapesForBody(space, id2go(js2int(argv[1]))->body);
|
|
|
|
return JS_NULL;
|
|
|
|
|
|
|
|
case 37:
|
|
|
|
if (!id2sprite(js2int(argv[1]))) return JS_NULL;
|
2023-05-24 20:45:50 -05:00
|
|
|
id2sprite(js2int(argv[1]))->pos = js2hmmv2(argv[2]);
|
2023-05-12 13:22:05 -05:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 38:
|
|
|
|
str = JS_ToCString(js, argv[1]);
|
2023-09-07 16:46:35 -05:00
|
|
|
ret = JS_NewString(js, slurp_text(str, NULL));
|
2023-05-12 13:22:05 -05:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 39:
|
|
|
|
str = JS_ToCString(js, argv[1]);
|
|
|
|
str2 = JS_ToCString(js, argv[2]);
|
|
|
|
ret = JS_NewInt64(js, slurp_write(str, str2));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 40:
|
|
|
|
id2go(js2int(argv[1]))->filter.categories = js2bitmask(argv[2]);
|
|
|
|
gameobject_apply(id2go(js2int(argv[1])));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 41:
|
|
|
|
id2go(js2int(argv[1]))->filter.mask = js2bitmask(argv[2]);
|
|
|
|
gameobject_apply(id2go(js2int(argv[1])));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 42:
|
|
|
|
return bitmask2js(id2go(js2int(argv[1]))->filter.categories);
|
|
|
|
|
|
|
|
case 43:
|
|
|
|
return bitmask2js(id2go(js2int(argv[1]))->filter.mask);
|
|
|
|
|
|
|
|
case 44:
|
|
|
|
return JS_NewInt64(js, pos2gameobject(js2vec2(argv[1])));
|
|
|
|
|
|
|
|
case 45:
|
|
|
|
return vec2js(mouse_pos);
|
|
|
|
|
|
|
|
case 46:
|
|
|
|
set_mouse_mode(js2int(argv[1]));
|
|
|
|
return JS_NULL;
|
|
|
|
|
|
|
|
case 47:
|
2023-09-06 17:48:08 -05:00
|
|
|
draw_grid(js2number(argv[1]), js2number(argv[2]), js2color(argv[3]));
|
2023-05-12 13:22:05 -05:00
|
|
|
return JS_NULL;
|
|
|
|
|
|
|
|
case 48:
|
2023-08-31 02:05:06 -05:00
|
|
|
return JS_NewInt64(js, mainwin.width);
|
2023-05-12 13:22:05 -05:00
|
|
|
|
|
|
|
case 49:
|
2023-08-31 02:05:06 -05:00
|
|
|
return JS_NewInt64(js, mainwin.height);
|
2023-05-12 13:22:05 -05:00
|
|
|
|
|
|
|
case 50:
|
|
|
|
return JS_NewBool(js, action_down(js2int(argv[1])));
|
|
|
|
|
|
|
|
case 51:
|
|
|
|
draw_cppoint(js2vec2(argv[1]), js2number(argv[2]), js2color(argv[3]));
|
|
|
|
return JS_NULL;
|
|
|
|
|
|
|
|
case 52:
|
|
|
|
return ints2js(phys2d_query_box(js2vec2(argv[1]), js2vec2(argv[2])));
|
|
|
|
|
|
|
|
case 53:
|
|
|
|
draw_box(js2vec2(argv[1]), js2vec2(argv[2]), js2color(argv[3]));
|
|
|
|
return JS_NULL;
|
|
|
|
|
|
|
|
case 54:
|
|
|
|
gameobject_apply(js2go(argv[1]));
|
|
|
|
return JS_NULL;
|
|
|
|
|
|
|
|
case 55:
|
|
|
|
js2go(argv[1])->flipx = JS_ToBool(js, argv[2]) ? -1 : 1;
|
|
|
|
return JS_NULL;
|
|
|
|
|
|
|
|
case 56:
|
|
|
|
js2go(argv[1])->flipy = JS_ToBool(js, argv[2]) ? -1 : 1;
|
|
|
|
return JS_NULL;
|
|
|
|
|
|
|
|
case 57:
|
|
|
|
return JS_NewBool(js, js2go(argv[1])->flipx == -1 ? 1 : 0);
|
2023-01-10 14:02:24 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 58:
|
|
|
|
return JS_NewBool(js, js2go(argv[1])->flipy == -1 ? 1 : 0);
|
2023-04-22 16:44:26 -05:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 59:
|
|
|
|
return JS_NewInt64(js, point2segindex(js2vec2(argv[1]), js2cpvec2arr(argv[2]), js2number(argv[3])));
|
2023-04-22 16:44:26 -05:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 60:
|
|
|
|
if (!id2sprite(js2int(argv[1]))) return JS_NULL;
|
|
|
|
id2sprite(js2int(argv[1]))->layer = js2int(argv[2]);
|
|
|
|
break;
|
2023-04-22 16:44:26 -05:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 61:
|
|
|
|
set_cam_body(id2body(js2int(argv[1])));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 62:
|
|
|
|
add_zoom(js2number(argv[1]));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 63:
|
|
|
|
return JS_NewFloat64(js, deltaT);
|
|
|
|
|
|
|
|
case 64:
|
|
|
|
str = JS_ToCString(js, argv[1]);
|
|
|
|
ret = vec2js(tex_get_dimensions(texture_pullfromfile(str)));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 65:
|
|
|
|
str = JS_ToCString(js, argv[1]);
|
2023-09-18 10:45:51 -05:00
|
|
|
ret = JS_NewBool(js, fexists(str));
|
2023-05-12 13:22:05 -05:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 66:
|
2023-09-13 01:08:32 -05:00
|
|
|
ret = strarr2js(ls(","));
|
2023-05-12 13:22:05 -05:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 67:
|
|
|
|
opengl_rendermode(LIT);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 68:
|
|
|
|
opengl_rendermode(WIREFRAME);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 69:
|
|
|
|
gameobject_set_sensor(js2int(argv[1]), JS_ToBool(js, argv[2]));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 70:
|
|
|
|
return vec2js(world2go(js2go(argv[1]), js2vec2(argv[2])));
|
|
|
|
|
|
|
|
case 71:
|
|
|
|
return vec2js(go2world(js2go(argv[1]), js2vec2(argv[2])));
|
|
|
|
|
|
|
|
case 72:
|
|
|
|
return vec2js(cpSpaceGetGravity(space));
|
|
|
|
|
|
|
|
case 73:
|
|
|
|
cpSpaceSetDamping(space, js2number(argv[1]));
|
|
|
|
return JS_NULL;
|
|
|
|
|
|
|
|
case 74:
|
|
|
|
return JS_NewFloat64(js, cpSpaceGetDamping(space));
|
|
|
|
|
|
|
|
case 75:
|
|
|
|
js2go(argv[1])->layer = js2int(argv[2]);
|
|
|
|
return JS_NULL;
|
|
|
|
|
|
|
|
case 76:
|
|
|
|
set_cat_mask(js2int(argv[1]), js2bitmask(argv[2]));
|
|
|
|
return JS_NULL;
|
|
|
|
|
|
|
|
case 77:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 78:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 79:
|
|
|
|
return JS_NewBool(js, phys_stepping());
|
|
|
|
|
|
|
|
case 80:
|
|
|
|
return ints2js(phys2d_query_shape(js2ptr(argv[1])));
|
|
|
|
|
|
|
|
case 81:
|
|
|
|
draw_arrow(js2vec2(argv[1]), js2vec2(argv[2]), js2color(argv[3]), js2int(argv[4]));
|
|
|
|
return JS_NULL;
|
|
|
|
|
|
|
|
case 82:
|
|
|
|
gameobject_draw_debug(js2int(argv[1]));
|
2023-04-18 17:58:44 -05:00
|
|
|
return JS_NULL;
|
2023-05-12 13:22:05 -05:00
|
|
|
|
|
|
|
case 83:
|
2023-05-29 10:47:30 -05:00
|
|
|
draw_edge(js2cpvec2arr(argv[1]), js_arrlen(argv[1]), js2color(argv[2]), js2number(argv[3]), 0, 0, js2color(argv[2]), 10);
|
2023-05-12 13:22:05 -05:00
|
|
|
return JS_NULL;
|
|
|
|
|
|
|
|
case 84:
|
|
|
|
return JS_NewString(js, consolelog);
|
|
|
|
|
|
|
|
case 85:
|
|
|
|
return vec2js(cpvproject(js2vec2(argv[1]), js2vec2(argv[2])));
|
|
|
|
|
|
|
|
case 86:
|
|
|
|
return ints2js(phys2d_query_box_points(js2vec2(argv[1]), js2vec2(argv[2]), js2cpvec2arr(argv[3]), js2int(argv[4])));
|
|
|
|
|
|
|
|
case 87:
|
|
|
|
str = JS_ToCString(js, argv[1]);
|
2023-08-30 18:22:32 -05:00
|
|
|
// mini_music_play(str);
|
2023-05-12 13:22:05 -05:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 88:
|
2023-08-30 18:22:32 -05:00
|
|
|
// mini_music_pause();
|
2023-05-12 13:22:05 -05:00
|
|
|
return JS_NULL;
|
|
|
|
|
|
|
|
case 89:
|
2023-08-30 18:22:32 -05:00
|
|
|
// mini_music_stop();
|
2023-05-12 13:22:05 -05:00
|
|
|
return JS_NULL;
|
|
|
|
|
|
|
|
case 90:
|
|
|
|
str = JS_ToCString(js, argv[1]);
|
|
|
|
window_set_icon(str);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 91:
|
|
|
|
str = JS_ToCString(js, argv[1]);
|
|
|
|
log_print(str);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 92:
|
|
|
|
logLevel = js2int(argv[1]);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 93:
|
|
|
|
ret = int2js(logLevel);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 94:
|
|
|
|
str = JS_ToCString(js, argv[1]);
|
|
|
|
texture_pullfromfile(str)->opts.mips = js2bool(argv[2]);
|
|
|
|
texture_sync(str);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 95:
|
|
|
|
str = JS_ToCString(js, argv[1]);
|
|
|
|
texture_pullfromfile(str)->opts.sprite = js2bool(argv[2]);
|
|
|
|
texture_sync(str);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 96:
|
2023-05-24 20:45:50 -05:00
|
|
|
id2sprite(js2int(argv[1]))->color = js2color(argv[2]);
|
2023-05-12 13:22:05 -05:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 97:
|
|
|
|
eye = HMM_AddV3(eye, (HMM_Vec3){0, 0.01, 0});
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 98:
|
|
|
|
eye = HMM_AddV3(eye, (HMM_Vec3){0, -0.01, 0});
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 99:
|
|
|
|
eye = HMM_AddV3(eye, (HMM_Vec3){-0.01, 0, 0});
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 100:
|
|
|
|
eye = HMM_AddV3(eye, (HMM_Vec3){0.01, 0,0});
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 101:
|
|
|
|
eye = HMM_AddV3(eye, (HMM_Vec3){0,0,-0.01});
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 102:
|
|
|
|
eye = HMM_AddV3(eye,(HMM_Vec3){0,0,0.01});
|
|
|
|
break;
|
2023-05-25 21:55:55 -05:00
|
|
|
case 103:
|
|
|
|
return num2js(js2go(argv[1])->scale);
|
|
|
|
|
|
|
|
case 104:
|
2023-09-14 17:37:04 -05:00
|
|
|
return bool2js(js2go(argv[1])->flipx == -1 ? 1 : 0);
|
2023-05-25 21:55:55 -05:00
|
|
|
|
|
|
|
case 105:
|
2023-09-14 17:37:04 -05:00
|
|
|
return bool2js(js2go(argv[1])->flipy == -1 ? 1 : 0);
|
2023-05-25 21:55:55 -05:00
|
|
|
|
|
|
|
case 106:
|
2023-05-27 07:01:17 -05:00
|
|
|
js2go(argv[1])->e = js2number(argv[2]);
|
2023-05-25 21:55:55 -05:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 107:
|
|
|
|
return num2js(js2go(argv[1])->e);
|
|
|
|
|
|
|
|
case 108:
|
2023-05-27 07:01:17 -05:00
|
|
|
js2go(argv[1])->f = js2number(argv[2]);
|
2023-05-25 21:55:55 -05:00
|
|
|
break;
|
|
|
|
case 109:
|
|
|
|
return num2js(js2go(argv[1])->f);
|
|
|
|
case 110:
|
2023-05-27 07:01:17 -05:00
|
|
|
return num2js(js2go(argv[1])->e);
|
|
|
|
|
|
|
|
case 111:
|
|
|
|
return v22js(js2sprite(argv[1])->pos);
|
|
|
|
|
|
|
|
case 112:
|
|
|
|
return num2js(((struct phys2d_edge*)js2ptr(argv[1]))->thickness);
|
|
|
|
|
|
|
|
case 113:
|
|
|
|
js2go(argv[1])->ref = JS_DupValue(js,argv[2]);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 114:
|
|
|
|
return bool2js(js2sprite(argv[1])->enabled);
|
2023-05-27 10:13:20 -05:00
|
|
|
|
|
|
|
case 115:
|
|
|
|
draw_circle(js2vec2(argv[1]), js2number(argv[2]), js2number(argv[2]), js2color(argv[3]), -1);
|
|
|
|
break;
|
2023-05-29 10:47:30 -05:00
|
|
|
|
|
|
|
case 116:
|
|
|
|
return str2js(tex_get_path(js2sprite(argv[1])->tex));
|
2023-08-16 20:17:18 -05:00
|
|
|
|
2023-05-29 10:47:30 -05:00
|
|
|
case 117:
|
|
|
|
str = JS_ToCString(js, argv[1]);
|
2023-06-08 17:27:37 -05:00
|
|
|
ret = script_runfile(str);
|
2023-05-29 10:47:30 -05:00
|
|
|
break;
|
2023-05-30 13:07:18 -05:00
|
|
|
|
|
|
|
case 118:
|
|
|
|
str = JS_ToCString(js,argv[1]);
|
2023-08-28 17:00:53 -05:00
|
|
|
ret = bb2js(text_bb(str, js2number(argv[2]), js2number(argv[3]), 1.0));
|
2023-05-30 13:07:18 -05:00
|
|
|
break;
|
2023-06-08 17:27:37 -05:00
|
|
|
|
|
|
|
case 119:
|
|
|
|
str = JS_ToCString(js, argv[1]);
|
|
|
|
ret = JS_NewInt64(js, file_mod_secs(str));
|
|
|
|
break;
|
2023-06-28 11:35:41 -05:00
|
|
|
|
|
|
|
case 120:
|
|
|
|
ret = str2js(engine_info());
|
|
|
|
break;
|
2023-08-28 17:00:53 -05:00
|
|
|
case 121:
|
|
|
|
return num2js(get_timescale());
|
|
|
|
break;
|
2023-08-29 09:41:40 -05:00
|
|
|
case 122:
|
2023-09-07 16:46:35 -05:00
|
|
|
break;
|
2023-08-29 09:41:40 -05:00
|
|
|
|
|
|
|
case 123:
|
|
|
|
str = JS_ToCString(js, argv[1]);
|
2023-09-07 16:46:35 -05:00
|
|
|
str2 = JS_ToCString(js, argv[3]);
|
|
|
|
script_eval_w_env(str, argv[2], str2);
|
2023-08-29 09:41:40 -05:00
|
|
|
break;
|
2023-09-04 09:48:44 -05:00
|
|
|
|
|
|
|
case 124:
|
2023-09-05 17:09:25 -05:00
|
|
|
str = JS_ToCString(js, argv[1]);
|
|
|
|
pack_engine(str);
|
2023-09-04 09:48:44 -05:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 125:
|
|
|
|
mainwin.width = js2int(argv[1]);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 126:
|
2023-09-12 17:19:46 -05:00
|
|
|
mainwin.height = js2int(argv[1]);
|
2023-09-04 09:48:44 -05:00
|
|
|
break;
|
2023-09-11 02:46:12 -05:00
|
|
|
|
|
|
|
case 127:
|
|
|
|
ret = JS_NewInt64(js, stm_now());
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 128:
|
|
|
|
YughWarn("%g",stm_ms(9737310));
|
|
|
|
ret = JS_NewFloat64(js, stm_ns(js2uint64(argv[1])));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 129:
|
|
|
|
ret = JS_NewFloat64(js, stm_us(js2uint64(argv[1])));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 130:
|
|
|
|
ret = JS_NewFloat64(js, stm_ms(js2uint64(argv[1])));
|
|
|
|
break;
|
2023-09-11 15:07:36 -05:00
|
|
|
|
|
|
|
case 131:
|
2023-09-12 07:56:40 -05:00
|
|
|
gif_rec_start(js2int(argv[1]), js2int(argv[2]), js2int(argv[3]), js2int(argv[4]));
|
2023-09-11 15:07:36 -05:00
|
|
|
break;
|
|
|
|
case 132:
|
|
|
|
str = JS_ToCString(js, argv[1]);
|
|
|
|
gif_rec_end(str);
|
|
|
|
break;
|
2023-09-12 12:45:54 -05:00
|
|
|
case 133:
|
|
|
|
ret = JS_NewFloat64(js, appTime);
|
|
|
|
break;
|
2023-09-13 01:08:32 -05:00
|
|
|
|
|
|
|
case 134:
|
|
|
|
str = JS_ToCString(js,argv[1]);
|
|
|
|
app_name(str);
|
|
|
|
break;
|
2023-09-15 22:40:19 -05:00
|
|
|
|
|
|
|
case 135:
|
|
|
|
ret = float2js(cam_zoom());
|
|
|
|
break;
|
2023-09-18 07:36:07 -05:00
|
|
|
|
|
|
|
case 136:
|
|
|
|
ret = v22js(world2screen(js2hmmv2(argv[1])));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 137:
|
|
|
|
ret = v22js(screen2world(js2hmmv2(argv[1])));
|
|
|
|
break;
|
2023-09-18 10:45:51 -05:00
|
|
|
|
|
|
|
case 138:
|
|
|
|
str = JS_ToCString(js, argv[1]);
|
|
|
|
ret = JS_NewInt64(js, jso_file(str));
|
|
|
|
break;
|
|
|
|
|
2023-09-24 11:26:44 -05:00
|
|
|
case 139:
|
|
|
|
str = JS_ToCString(js,argv[1]);
|
|
|
|
ret = JS_NewInt64(js, gif_nframes(str));
|
|
|
|
break;
|
2023-05-12 13:22:05 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
if (str)
|
|
|
|
JS_FreeCString(js, str);
|
|
|
|
|
|
|
|
if (str2)
|
|
|
|
JS_FreeCString(js, str2);
|
|
|
|
|
|
|
|
if (!JS_IsNull(ret))
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return JS_NULL;
|
2023-01-10 14:02:24 -06:00
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue duk_register(JSContext *js, JSValueConst this, int argc, JSValueConst *argv) {
|
|
|
|
int cmd = js2int(argv[0]);
|
|
|
|
|
|
|
|
struct callee c;
|
|
|
|
c.fn = argv[1];
|
|
|
|
c.obj = argv[2];
|
2023-04-19 15:16:35 -05:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
switch (cmd) {
|
|
|
|
case 0:
|
|
|
|
register_update(c);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 1:
|
|
|
|
register_physics(c);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 2:
|
|
|
|
register_gui(c);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 3:
|
|
|
|
register_nk_gui(c);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 4:
|
|
|
|
// unregister_obj(obj);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 5:
|
|
|
|
// unregister_gui(c);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 6:
|
|
|
|
register_debug(c);
|
|
|
|
break;
|
|
|
|
case 7:
|
|
|
|
register_pawn(c);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 8:
|
|
|
|
register_gamepad(c);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 9:
|
|
|
|
stacktrace_callee = c;
|
|
|
|
break;
|
2023-05-24 20:45:50 -05:00
|
|
|
|
|
|
|
case 10:
|
|
|
|
register_draw(c);
|
|
|
|
break;
|
2023-05-12 13:22:05 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
return JS_NULL;
|
2023-01-11 16:57:34 -06:00
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
void gameobject_add_shape_collider(int go, struct callee c, struct phys2d_shape *shape) {
|
2023-02-17 01:16:52 -06:00
|
|
|
struct shape_cb shapecb;
|
2023-03-10 13:13:48 -06:00
|
|
|
shapecb.shape = shape;
|
2023-02-17 01:16:52 -06:00
|
|
|
shapecb.cbs.begin = c;
|
|
|
|
arrpush(id2go(go)->shape_cbs, shapecb);
|
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue duk_register_collide(JSContext *js, JSValueConst this, int argc, JSValueConst *argv) {
|
|
|
|
int cmd = js2int(argv[0]);
|
|
|
|
int go = js2int(argv[3]);
|
|
|
|
struct callee c;
|
|
|
|
c.fn = argv[1];
|
|
|
|
c.obj = argv[2];
|
2023-01-11 16:57:34 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
switch (cmd) {
|
|
|
|
case 0:
|
|
|
|
id2go(go)->cbs.begin = c;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 1:
|
|
|
|
gameobject_add_shape_collider(go, c, js2ptr(argv[4]));
|
|
|
|
break;
|
2023-01-11 16:57:34 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 2:
|
|
|
|
phys2d_rm_go_handlers(go);
|
|
|
|
break;
|
2023-01-10 07:13:00 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 3:
|
|
|
|
id2go(go)->cbs.separate = c;
|
|
|
|
break;
|
|
|
|
}
|
2023-01-10 07:13:00 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
return JS_NULL;
|
|
|
|
}
|
2023-01-10 07:13:00 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue duk_sys_cmd(JSContext *js, JSValueConst this, int argc, JSValueConst *argv) {
|
|
|
|
int cmd = js2int(argv[0]);
|
2023-01-10 07:13:00 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
switch (cmd) {
|
|
|
|
case 0:
|
|
|
|
quit();
|
|
|
|
break;
|
2023-01-10 07:13:00 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 1:
|
|
|
|
sim_start();
|
|
|
|
cpSpaceReindexStatic(space);
|
|
|
|
break;
|
2023-01-10 07:13:00 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 2:
|
2023-08-29 17:11:36 -05:00
|
|
|
sim_pause();
|
2023-05-12 13:22:05 -05:00
|
|
|
break;
|
2023-01-10 07:13:00 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 3:
|
|
|
|
sim_pause();
|
|
|
|
break;
|
2023-01-10 07:13:00 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 4:
|
|
|
|
sim_step();
|
|
|
|
break;
|
2023-01-10 07:13:00 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 5:
|
|
|
|
return JS_NewBool(js, sim_playing());
|
2023-01-10 07:13:00 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 6:
|
|
|
|
return JS_NewBool(js, sim_paused());
|
2023-01-10 07:13:00 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 7:
|
|
|
|
return JS_NewInt64(js, MakeGameobject());
|
2023-01-10 07:13:00 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 8:
|
|
|
|
return JS_NewInt64(js, frame_fps());
|
|
|
|
|
|
|
|
case 9: /* Clear the level out */
|
|
|
|
new_level();
|
|
|
|
break;
|
2023-09-06 17:48:08 -05:00
|
|
|
|
|
|
|
case 10:
|
2023-09-19 12:35:12 -05:00
|
|
|
editor_mode = js2bool(argv[1]);
|
2023-09-06 17:48:08 -05:00
|
|
|
break;
|
2023-05-12 13:22:05 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
return JS_NULL;
|
2023-01-10 07:13:00 -06:00
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue duk_make_gameobject(JSContext *js, JSValueConst this, int argc, JSValueConst *argv) {
|
2023-09-20 13:33:11 -05:00
|
|
|
return JS_NewInt64(js, MakeGameobject());
|
2023-01-10 07:13:00 -06:00
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue duk_yughlog(JSContext *js, JSValueConst this, int argc, JSValueConst *argv) {
|
|
|
|
int cmd = js2int(argv[0]);
|
|
|
|
const char *s = JS_ToCString(js, argv[1]);
|
|
|
|
const char *f = JS_ToCString(js, argv[2]);
|
|
|
|
int line = js2int(argv[3]);
|
2023-01-10 14:02:24 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
mYughLog(1, cmd, line, f, s);
|
2023-01-10 14:02:24 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JS_FreeCString(js, s);
|
|
|
|
JS_FreeCString(js, f);
|
2023-04-19 16:58:17 -05:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
return JS_NULL;
|
2023-01-10 14:02:24 -06:00
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue duk_set_body(JSContext *js, JSValueConst this, int argc, JSValueConst *argv) {
|
2023-04-18 17:58:44 -05:00
|
|
|
int cmd = js2int(argv[0]);
|
|
|
|
int id = js2int(argv[1]);
|
2023-01-10 14:02:24 -06:00
|
|
|
struct gameobject *go = get_gameobject_from_id(id);
|
2023-05-24 20:45:50 -05:00
|
|
|
|
2023-04-18 17:58:44 -05:00
|
|
|
if (!go) return JS_NULL;
|
2023-01-10 14:02:24 -06:00
|
|
|
|
2023-01-13 13:07:44 -06:00
|
|
|
/* TODO: Possible that reindexing shapes only needs done for static shapes? */
|
2023-01-10 14:02:24 -06:00
|
|
|
switch (cmd) {
|
2023-05-12 13:22:05 -05:00
|
|
|
case 0:
|
|
|
|
gameobject_setangle(go, js2number(argv[2]));
|
|
|
|
break;
|
2023-01-10 14:02:24 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 1:
|
|
|
|
go->bodytype = js2int(argv[2]);
|
2023-05-27 07:01:17 -05:00
|
|
|
cpBodySetType(go->body, go->bodytype);
|
|
|
|
gameobject_apply(go);
|
2023-05-12 13:22:05 -05:00
|
|
|
break;
|
2023-01-10 14:02:24 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 2:
|
|
|
|
cpBodySetPosition(go->body, js2vec2(argv[2]));
|
|
|
|
break;
|
2023-01-10 14:02:24 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 3:
|
|
|
|
gameobject_move(go, js2vec2(argv[2]));
|
|
|
|
break;
|
2023-01-10 14:02:24 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 4:
|
|
|
|
cpBodyApplyImpulseAtWorldPoint(go->body, js2vec2(argv[2]), cpBodyGetPosition(go->body));
|
|
|
|
return JS_NULL;
|
2023-01-10 14:02:24 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 5:
|
|
|
|
go->flipx = JS_ToBool(js, argv[2]);
|
|
|
|
break;
|
2023-01-10 14:02:24 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 6:
|
|
|
|
go->flipy = JS_ToBool(js, argv[2]);
|
|
|
|
break;
|
2023-01-10 14:02:24 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 7:
|
2023-09-21 19:51:38 -05:00
|
|
|
go->mass = js2number(argv[2]);
|
2023-05-27 07:01:17 -05:00
|
|
|
if (go->bodytype == CP_BODY_TYPE_DYNAMIC)
|
2023-09-21 19:51:38 -05:00
|
|
|
cpBodySetMass(go->body, go->mass);
|
2023-05-12 13:22:05 -05:00
|
|
|
break;
|
2023-01-12 17:41:54 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 8:
|
|
|
|
cpBodySetAngularVelocity(go->body, js2number(argv[2]));
|
|
|
|
return JS_NULL;
|
2023-01-13 13:07:44 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 9:
|
|
|
|
cpBodySetVelocity(go->body, js2vec2(argv[2]));
|
|
|
|
return JS_NULL;
|
2023-01-13 13:07:44 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 10:
|
|
|
|
go->e = fmax(js2number(argv[2]), 0);
|
|
|
|
break;
|
2023-02-24 14:13:35 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 11:
|
|
|
|
go->f = fmax(js2number(argv[2]), 0);
|
|
|
|
break;
|
2023-03-17 10:25:35 -05:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 12:
|
|
|
|
cpBodyApplyForceAtWorldPoint(go->body, js2vec2(argv[2]), cpBodyGetPosition(go->body));
|
|
|
|
return JS_NULL;
|
2023-06-28 11:35:41 -05:00
|
|
|
|
|
|
|
case 13:
|
|
|
|
cpBodySetMoment(go->body, js2number(argv[2]));
|
|
|
|
return JS_NULL;
|
2023-01-10 14:02:24 -06:00
|
|
|
}
|
|
|
|
|
2023-01-25 21:32:58 -06:00
|
|
|
cpSpaceReindexShapesForBody(space, go->body);
|
|
|
|
|
2023-04-18 17:58:44 -05:00
|
|
|
return JS_NULL;
|
2023-01-10 14:02:24 -06:00
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue duk_q_body(JSContext *js, JSValueConst this, int argc, JSValueConst *argv) {
|
|
|
|
int q = js2int(argv[0]);
|
|
|
|
struct gameobject *go = get_gameobject_from_id(js2int(argv[1]));
|
2023-01-10 14:02:24 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
if (!go) return JS_NULL;
|
2023-01-11 16:57:34 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
switch (q) {
|
|
|
|
case 0:
|
|
|
|
return JS_NewInt64(js, cpBodyGetType(go->body));
|
2023-01-10 14:02:24 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 1:
|
|
|
|
return vec2js(cpBodyGetPosition(go->body));
|
2023-01-10 14:02:24 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 2:
|
|
|
|
return JS_NewFloat64(js, cpBodyGetAngle(go->body));
|
2023-01-11 16:57:34 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 3:
|
|
|
|
return vec2js(cpBodyGetVelocity(go->body));
|
2023-01-11 16:57:34 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 4:
|
|
|
|
return JS_NewFloat64(js, cpBodyGetAngularVelocity(go->body));
|
2023-03-10 13:13:48 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 5:
|
|
|
|
return JS_NewFloat64(js, cpBodyGetMass(go->body));
|
2023-03-17 10:25:35 -05:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 6:
|
|
|
|
return JS_NewFloat64(js, cpBodyGetMoment(go->body));
|
2023-01-10 14:02:24 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 7:
|
|
|
|
return JS_NewBool(js, phys2d_in_air(go->body));
|
|
|
|
}
|
|
|
|
|
|
|
|
return JS_NULL;
|
2023-01-10 14:02:24 -06:00
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue duk_make_sprite(JSContext *js, JSValueConst this, int argc, JSValueConst *argv) {
|
2023-09-21 12:50:39 -05:00
|
|
|
JSValue sprite = JS_NewObject(js);
|
|
|
|
JS_SetPropertyStr(js,sprite,"id",JS_NewInt64(js, make_sprite(js2int(argv[0]))));
|
|
|
|
return sprite;
|
2023-01-12 17:41:54 -06:00
|
|
|
}
|
|
|
|
|
2023-01-18 14:43:07 -06:00
|
|
|
/* Make anim from texture */
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue duk_make_anim2d(JSContext *js, JSValueConst this, int argc, JSValueConst *argv) {
|
2023-04-18 17:58:44 -05:00
|
|
|
const char *path = JS_ToCString(js, argv[0]);
|
|
|
|
int frames = js2int(argv[1]);
|
|
|
|
int fps = js2int(argv[2]);
|
2023-01-15 09:53:50 -06:00
|
|
|
|
2023-01-18 17:15:36 -06:00
|
|
|
struct TexAnim *anim = anim2d_from_tex(path, frames, fps);
|
2023-01-15 09:53:50 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JS_FreeCString(js, path);
|
2023-04-19 16:58:17 -05:00
|
|
|
|
2023-04-18 17:58:44 -05:00
|
|
|
return ptr2js(anim);
|
2023-01-13 13:07:44 -06:00
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue duk_make_box2d(JSContext *js, JSValueConst this, int argc, JSValueConst *argv) {
|
2023-04-18 17:58:44 -05:00
|
|
|
int go = js2int(argv[0]);
|
|
|
|
cpVect size = js2vec2(argv[1]);
|
|
|
|
cpVect offset = js2vec2(argv[2]);
|
2023-01-10 17:23:11 -06:00
|
|
|
|
2023-01-12 17:41:54 -06:00
|
|
|
struct phys2d_box *box = Make2DBox(go);
|
2023-01-10 17:23:11 -06:00
|
|
|
box->w = size.x;
|
|
|
|
box->h = size.y;
|
|
|
|
box->offset[0] = offset.x;
|
|
|
|
box->offset[1] = offset.y;
|
2023-01-12 17:41:54 -06:00
|
|
|
|
|
|
|
phys2d_applybox(box);
|
2023-01-10 17:23:11 -06:00
|
|
|
|
2023-04-18 17:58:44 -05:00
|
|
|
JSValue boxval = JS_NewObject(js);
|
|
|
|
JS_SetPropertyStr(js, boxval, "id", ptr2js(box));
|
|
|
|
JS_SetPropertyStr(js, boxval, "shape", ptr2js(&box->shape));
|
|
|
|
return boxval;
|
2023-01-17 13:04:08 -06:00
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue duk_cmd_box2d(JSContext *js, JSValueConst this, int argc, JSValueConst *argv) {
|
|
|
|
int cmd = js2int(argv[0]);
|
|
|
|
struct phys2d_box *box = js2ptr(argv[1]);
|
|
|
|
cpVect arg;
|
2023-01-19 18:30:23 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
if (!box) return JS_NULL;
|
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case 0:
|
|
|
|
arg = js2vec2(argv[2]);
|
|
|
|
box->w = arg.x;
|
|
|
|
box->h = arg.y;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 1:
|
|
|
|
arg = js2vec2(argv[2]);
|
|
|
|
box->offset[0] = arg.x;
|
|
|
|
box->offset[1] = arg.y;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 2:
|
|
|
|
box->rotation = js2number(argv[2]);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
phys2d_applybox(box);
|
|
|
|
return JS_NULL;
|
2023-01-19 10:44:29 -06:00
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue duk_make_circle2d(JSContext *js, JSValueConst this, int argc, JSValueConst *argv) {
|
2023-04-21 16:57:30 -05:00
|
|
|
int go = js2int(argv[0]);
|
2023-04-18 17:58:44 -05:00
|
|
|
double radius = js2number(argv[1]);
|
2023-01-10 17:23:11 -06:00
|
|
|
|
2023-04-21 16:57:30 -05:00
|
|
|
struct phys2d_circle *circle = Make2DCircle(go);
|
|
|
|
circle->radius = radius;
|
|
|
|
circle->offset = js2vec2(argv[2]);
|
2023-01-10 17:23:11 -06:00
|
|
|
|
2023-04-21 16:57:30 -05:00
|
|
|
phys2d_applycircle(circle);
|
2023-05-12 13:22:05 -05:00
|
|
|
|
2023-04-18 17:58:44 -05:00
|
|
|
JSValue circleval = JS_NewObject(js);
|
|
|
|
JS_SetPropertyStr(js, circleval, "id", ptr2js(circle));
|
|
|
|
JS_SetPropertyStr(js, circleval, "shape", ptr2js(&circle->shape));
|
|
|
|
return circleval;
|
2023-01-10 17:23:11 -06:00
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue duk_cmd_circle2d(JSContext *js, JSValueConst this, int argc, JSValueConst *argv) {
|
|
|
|
int cmd = js2int(argv[0]);
|
|
|
|
struct phys2d_circle *circle = js2ptr(argv[1]);
|
2023-01-19 13:06:32 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
if (!circle) return JS_NULL;
|
2023-01-19 13:06:32 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
switch (cmd) {
|
|
|
|
case 0:
|
|
|
|
circle->radius = js2number(argv[2]);
|
|
|
|
break;
|
2023-01-19 13:06:32 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
case 1:
|
|
|
|
circle->offset = js2vec2(argv[2]);
|
|
|
|
break;
|
2023-05-25 21:55:55 -05:00
|
|
|
|
|
|
|
case 2:
|
|
|
|
return num2js(circle->radius);
|
|
|
|
|
|
|
|
case 3:
|
|
|
|
return vec2js(circle->offset);
|
2023-05-12 13:22:05 -05:00
|
|
|
}
|
2023-01-19 13:06:32 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
phys2d_applycircle(circle);
|
|
|
|
return JS_NULL;
|
2023-01-19 10:44:29 -06:00
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue duk_make_poly2d(JSContext *js, JSValueConst this, int argc, JSValueConst *argv) {
|
2023-04-18 17:58:44 -05:00
|
|
|
int go = js2int(argv[0]);
|
2023-01-25 21:32:58 -06:00
|
|
|
struct phys2d_poly *poly = Make2DPoly(go);
|
2023-04-18 17:58:44 -05:00
|
|
|
phys2d_poly_setverts(poly, js2cpvec2arr(argv[1]));
|
2023-01-25 21:32:58 -06:00
|
|
|
|
2023-04-18 17:58:44 -05:00
|
|
|
JSValue polyval = JS_NewObject(js);
|
|
|
|
JS_SetPropertyStr(js, polyval, "id", ptr2js(poly));
|
|
|
|
JS_SetPropertyStr(js, polyval, "shape", ptr2js(&poly->shape));
|
|
|
|
return polyval;
|
2023-01-25 21:32:58 -06:00
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue duk_cmd_poly2d(JSContext *js, JSValueConst this, int argc, JSValueConst *argv) {
|
2023-04-18 17:58:44 -05:00
|
|
|
int cmd = js2int(argv[0]);
|
|
|
|
struct phys2d_poly *poly = js2ptr(argv[1]);
|
2023-02-24 14:13:35 -06:00
|
|
|
|
2023-04-18 17:58:44 -05:00
|
|
|
if (!poly) return JS_NULL;
|
2023-05-12 13:22:05 -05:00
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case 0:
|
|
|
|
phys2d_poly_setverts(poly, js2cpvec2arr(argv[2]));
|
|
|
|
break;
|
2023-02-17 22:32:23 -06:00
|
|
|
}
|
2023-05-12 13:22:05 -05:00
|
|
|
|
|
|
|
return JS_NULL;
|
2023-01-25 21:32:58 -06:00
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue duk_make_edge2d(JSContext *js, JSValueConst this, int argc, JSValueConst *argv) {
|
2023-04-18 17:58:44 -05:00
|
|
|
int go = js2int(argv[0]);
|
2023-01-25 21:32:58 -06:00
|
|
|
struct phys2d_edge *edge = Make2DEdge(go);
|
|
|
|
|
2023-04-18 17:58:44 -05:00
|
|
|
int n = js_arrlen(argv[1]);
|
2023-01-25 21:32:58 -06:00
|
|
|
cpVect points[n];
|
|
|
|
|
|
|
|
for (int i = 0; i < n; i++) {
|
2023-05-24 20:45:50 -05:00
|
|
|
points[i] = js2vec2(js_getpropidx(argv[1],i));
|
2023-05-12 13:22:05 -05:00
|
|
|
phys2d_edgeaddvert(edge);
|
|
|
|
phys2d_edge_setvert(edge, i, points[i]);
|
2023-01-25 21:32:58 -06:00
|
|
|
}
|
|
|
|
|
2023-04-18 17:58:44 -05:00
|
|
|
JSValue edgeval = JS_NewObject(js);
|
|
|
|
JS_SetPropertyStr(js, edgeval, "id", ptr2js(edge));
|
|
|
|
JS_SetPropertyStr(js, edgeval, "shape", ptr2js(&edge->shape));
|
|
|
|
return edgeval;
|
2023-01-25 21:32:58 -06:00
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue duk_cmd_edge2d(JSContext *js, JSValueConst this, int argc, JSValueConst *argv) {
|
2023-04-18 17:58:44 -05:00
|
|
|
int cmd = js2int(argv[0]);
|
|
|
|
struct phys2d_edge *edge = js2ptr(argv[1]);
|
2023-02-08 15:30:12 -06:00
|
|
|
|
2023-04-18 17:58:44 -05:00
|
|
|
if (!edge) return JS_NULL;
|
2023-02-24 14:13:35 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
switch (cmd) {
|
|
|
|
case 0:
|
|
|
|
phys2d_edge_clearverts(edge);
|
|
|
|
phys2d_edge_addverts(edge, js2cpvec2arr(argv[2]));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 1:
|
|
|
|
edge->thickness = js2number(argv[2]);
|
|
|
|
break;
|
2023-02-08 15:30:12 -06:00
|
|
|
}
|
2023-05-12 13:22:05 -05:00
|
|
|
|
2023-04-18 17:58:44 -05:00
|
|
|
return JS_NULL;
|
2023-01-25 21:32:58 -06:00
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue duk_inflate_cpv(JSContext *js, JSValueConst this, int argc, JSValueConst *argv) {
|
2023-04-18 17:58:44 -05:00
|
|
|
cpVect *points = js2cpvec2arr(argv[0]);
|
|
|
|
int n = js2int(argv[1]);
|
|
|
|
double d = js2number(argv[2]);
|
2023-03-24 14:01:01 -05:00
|
|
|
|
2023-03-19 20:33:05 -05:00
|
|
|
cpVect inflate_out[n];
|
|
|
|
cpVect inflate_in[n];
|
2023-05-12 13:22:05 -05:00
|
|
|
|
2023-03-19 20:33:05 -05:00
|
|
|
inflatepoints(inflate_out, points, d, n);
|
|
|
|
inflatepoints(inflate_in, points, -d, n);
|
2023-05-12 13:22:05 -05:00
|
|
|
|
2023-04-19 16:58:17 -05:00
|
|
|
JSValue arr = JS_NewArray(js);
|
2023-04-18 17:58:44 -05:00
|
|
|
JS_SetPropertyUint32(js, arr, 0, vecarr2js(inflate_out, n));
|
|
|
|
JS_SetPropertyUint32(js, arr, 1, vecarr2js(inflate_in, n));
|
|
|
|
return arr;
|
2023-03-19 20:33:05 -05:00
|
|
|
}
|
|
|
|
|
2023-01-18 17:15:36 -06:00
|
|
|
/* These are anims for controlling properties on an object */
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue duk_anim(JSContext *js, JSValueConst this, int argc, JSValueConst *argv) {
|
|
|
|
JSValue prop = argv[0];
|
|
|
|
int keyframes = js_arrlen(argv[1]);
|
|
|
|
YughInfo("Processing %d keyframes.", keyframes);
|
|
|
|
|
|
|
|
struct anim a = make_anim();
|
|
|
|
|
|
|
|
for (int i = 0; i < keyframes; i++) {
|
|
|
|
struct keyframe k;
|
2023-05-24 20:45:50 -05:00
|
|
|
cpVect v = js2vec2(js_getpropidx( argv[1], i));
|
2023-05-12 13:22:05 -05:00
|
|
|
k.time = v.y;
|
|
|
|
k.val = v.x;
|
|
|
|
a = anim_add_keyframe(a, k);
|
|
|
|
}
|
2023-01-10 17:23:11 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
for (double i = 0; i < 3.0; i = i + 0.1) {
|
|
|
|
YughInfo("Val is now %f at time %f", anim_val(a, i), i);
|
|
|
|
JSValue vv = num2js(anim_val(a, i));
|
2023-05-24 20:45:50 -05:00
|
|
|
JS_Call(js, prop, globalThis, 1, &vv);
|
2023-05-12 13:22:05 -05:00
|
|
|
}
|
2023-01-10 17:23:11 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
return JS_NULL;
|
2023-01-10 17:23:11 -06:00
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
JSValue duk_make_timer(JSContext *js, JSValueConst this, int argc, JSValueConst *argv) {
|
|
|
|
double secs = js2number(argv[1]);
|
|
|
|
struct callee *c = malloc(sizeof(*c));
|
|
|
|
c->fn = JS_DupValue(js, argv[0]);
|
2023-05-24 20:45:50 -05:00
|
|
|
c->obj = JS_DupValue(js, globalThis);
|
2023-09-13 07:31:00 -05:00
|
|
|
int id = timer_make(secs, call_callee, c, 1, js2bool(argv[2]));
|
2023-01-12 17:41:54 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
return JS_NewInt64(js, id);
|
2023-01-10 17:23:11 -06:00
|
|
|
}
|
|
|
|
|
2023-06-05 10:32:45 -05:00
|
|
|
JSValue duk_cmd_points(JSContext *js, JSValueConst this, int argc, JSValueConst *argv)
|
|
|
|
{
|
|
|
|
int n = js_arrlen(argv[1]);
|
|
|
|
cpVect points[n];
|
|
|
|
|
|
|
|
for (int i = 0; i < n; i++)
|
|
|
|
points[i] = js2vec2(js_arridx(argv[1], i));
|
|
|
|
|
|
|
|
int cmd = js2int(argv[0]);
|
|
|
|
|
|
|
|
switch(cmd) {
|
|
|
|
case 0:
|
|
|
|
draw_poly(points, n, js2color(argv[2]));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return JS_NULL;
|
|
|
|
}
|
|
|
|
|
2023-05-24 20:45:50 -05:00
|
|
|
#define DUK_FUNC(NAME, ARGS) JS_SetPropertyStr(js, globalThis, #NAME, JS_NewCFunction(js, duk_##NAME, #NAME, ARGS));
|
2023-01-10 14:02:24 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
void ffi_load() {
|
2023-05-24 20:45:50 -05:00
|
|
|
globalThis = JS_GetGlobalObject(js);
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
DUK_FUNC(yughlog, 4)
|
2023-09-12 23:32:14 -05:00
|
|
|
|
|
|
|
#ifndef NO_EDITOR
|
2023-05-12 13:22:05 -05:00
|
|
|
DUK_FUNC(nuke, 6)
|
2023-09-12 23:32:14 -05:00
|
|
|
#endif
|
|
|
|
|
2023-09-20 13:33:11 -05:00
|
|
|
DUK_FUNC(make_gameobject, 0)
|
2023-05-12 13:22:05 -05:00
|
|
|
DUK_FUNC(set_body, 3)
|
|
|
|
DUK_FUNC(q_body, 2)
|
|
|
|
|
|
|
|
DUK_FUNC(sys_cmd, 1)
|
|
|
|
|
2023-09-20 08:11:14 -05:00
|
|
|
DUK_FUNC(make_sprite, 1)
|
2023-05-12 13:22:05 -05:00
|
|
|
DUK_FUNC(make_anim2d, 3)
|
|
|
|
DUK_FUNC(spline_cmd, 6)
|
|
|
|
|
|
|
|
DUK_FUNC(make_box2d, 3)
|
|
|
|
DUK_FUNC(cmd_box2d, 6)
|
|
|
|
DUK_FUNC(make_circle2d, 3)
|
|
|
|
DUK_FUNC(cmd_circle2d, 6)
|
|
|
|
DUK_FUNC(make_poly2d, 2)
|
|
|
|
DUK_FUNC(cmd_poly2d, 6)
|
|
|
|
DUK_FUNC(make_edge2d, 3)
|
|
|
|
DUK_FUNC(cmd_edge2d, 6)
|
|
|
|
DUK_FUNC(make_timer, 3)
|
|
|
|
|
2023-06-05 10:32:45 -05:00
|
|
|
DUK_FUNC(cmd_points, 5);
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
DUK_FUNC(cmd, 6)
|
|
|
|
DUK_FUNC(register, 3)
|
|
|
|
DUK_FUNC(register_collide, 6)
|
|
|
|
|
|
|
|
DUK_FUNC(gui_text, 6)
|
|
|
|
DUK_FUNC(ui_text, 5)
|
|
|
|
DUK_FUNC(cursor_text, 5)
|
2023-06-06 15:49:55 -05:00
|
|
|
DUK_FUNC(gui_img, 10)
|
2023-05-12 13:22:05 -05:00
|
|
|
|
|
|
|
DUK_FUNC(inflate_cpv, 3)
|
|
|
|
|
|
|
|
DUK_FUNC(anim, 2)
|
2023-01-10 15:41:43 -06:00
|
|
|
}
|