void StyleContext::setKeyword(const std::string& _key, Value _val) {
auto keywordKey = Filter::keywordType(_key);
if (keywordKey == FilterKeyword::undefined) {
LOG("Undefined Keyword: %s", _key.c_str());
return;
}
// Unset shortcuts in case setKeyword was not called by
// the helper functions above.
if (_key == key_zoom) { m_keywordZoom = -1; }
if (_key == key_geom) { m_keywordGeom = -1; }
Value& entry = m_keywords[static_cast<uint8_t>(keywordKey)];
if (entry == _val) { return; }
if (_val.is<std::string>()) {
duk_push_string(m_ctx, _val.get<std::string>().c_str());
duk_put_global_string(m_ctx, _key.c_str());
} else if (_val.is<double>()) {
duk_push_number(m_ctx, _val.get<double>());
duk_put_global_string(m_ctx, _key.c_str());
}
entry = std::move(_val);
}
void test(duk_context *ctx) {
duk_eval_string(ctx, "1+2");
printf("1+2=%d\n", (int) duk_get_int(ctx, -1));
duk_pop(ctx);
duk_push_c_function(ctx, native_print, 1);
duk_put_global_string(ctx, "print");
duk_push_c_function(ctx, native_adder, DUK_VARARGS);
duk_put_global_string(ctx, "adder");
duk_eval_string_noresult(ctx, "print('2+3=' + adder(2, 3));");
}
StyleContext::StyleContext() {
m_ctx = duk_create_heap_default();
//// Create global geometry constants
// TODO make immutable
duk_push_number(m_ctx, GeometryType::points);
duk_put_global_string(m_ctx, "point");
duk_push_number(m_ctx, GeometryType::lines);
duk_put_global_string(m_ctx, "line");
duk_push_number(m_ctx, GeometryType::polygons);
duk_put_global_string(m_ctx, "polygon");
//// Create global 'feature' object
// Get Proxy constructor
// -> [cons]
duk_eval_string(m_ctx, "Proxy");
// Add feature object
// -> [cons, { __obj: this }]
duk_idx_t featureObj = duk_push_object(m_ctx);
duk_push_pointer(m_ctx, this);
duk_put_prop_string(m_ctx, featureObj, INSTANCE_ID);
// Add handler object
// -> [cons, {...}, { get: func, has: func }]
duk_idx_t handlerObj = duk_push_object(m_ctx);
// Add 'get' property to handler
duk_push_c_function(m_ctx, jsGetProperty, 3 /*nargs*/);
duk_put_prop_string(m_ctx, handlerObj, "get");
// Add 'has' property to handler
duk_push_c_function(m_ctx, jsHasProperty, 2 /*nargs*/);
duk_put_prop_string(m_ctx, handlerObj, "has");
// Call proxy constructor
// [cons, feature, handler ] -> [obj|error]
if (duk_pnew(m_ctx, 2) == 0) {
// put feature proxy object in global scope
if (!duk_put_global_string(m_ctx, "feature")) {
LOGE("Initialization failed");
}
} else {
LOGE("Failure: %s", duk_safe_to_string(m_ctx, -1));
duk_pop(m_ctx);
}
DUMP("init\n");
}
/* Thread with shared and fresh globals. */
static duk_ret_t test_2(duk_context *ctx, void *udata) {
duk_context *ctx_a;
duk_context *ctx_b;
(void) udata;
duk_eval_string_noresult(ctx, "this.globalFoo = 'bar';");
duk_push_thread(ctx);
ctx_a = duk_require_context(ctx, -1);
duk_push_thread_new_globalenv(ctx);
ctx_b = duk_require_context(ctx, -1);
printf("top: %ld\n", (long) duk_get_top(ctx));
/* Dummy print() binding. */
duk_push_c_function(ctx_b, my_print, 1);
duk_put_global_string(ctx_b, "print");
/* index 0: thread with globals shared with 'ctx' (has globalFoo)
* index 1: thread with globals separate with 'ctx'
*/
/* Print globalFoo. */
duk_peval_string_noresult(ctx_a, "print('context a: ' + String(this.globalFoo));");
duk_peval_string_noresult(ctx_b, "print('context b: ' + String(this.globalFoo));");
return 0;
}
bool StyleContext::setFunctions(const std::vector<std::string>& _functions) {
auto arr_idx = duk_push_array(m_ctx);
int id = 0;
bool ok = true;
for (auto& function : _functions) {
duk_push_string(m_ctx, function.c_str());
duk_push_string(m_ctx, "");
if (duk_pcompile(m_ctx, DUK_COMPILE_FUNCTION) == 0) {
duk_put_prop_index(m_ctx, arr_idx, id);
} else {
LOGW("Compile failed: %s\n%s\n---",
duk_safe_to_string(m_ctx, -1),
function.c_str());
duk_pop(m_ctx);
ok = false;
}
id++;
}
if (!duk_put_global_string(m_ctx, FUNC_ID)) {
LOGE("'fns' object not set");
}
DUMP("setFunctions\n");
return ok;
}
void
_gum_duk_process_init (GumDukProcess * self,
GumDukCore * core)
{
GumDukScope scope = GUM_DUK_SCOPE_INIT (core);
duk_context * ctx = scope.ctx;
self->core = core;
duk_push_c_function (ctx, gumjs_process_construct, 0);
duk_push_object (ctx);
duk_put_function_list (ctx, -1, gumjs_process_functions);
duk_push_string (ctx, GUM_SCRIPT_ARCH);
duk_put_prop_string (ctx, -2, "arch");
duk_push_string (ctx, GUM_SCRIPT_PLATFORM);
duk_put_prop_string (ctx, -2, "platform");
duk_push_uint (ctx, gum_query_page_size ());
duk_put_prop_string (ctx, -2, "pageSize");
duk_push_uint (ctx, GLIB_SIZEOF_VOID_P);
duk_put_prop_string (ctx, -2, "pointerSize");
duk_put_prop_string (ctx, -2, "prototype");
duk_new (ctx, 0);
_gum_duk_put_data (ctx, -1, self);
duk_put_global_string (ctx, "Process");
}
static duk_ret_t test_modsearch_module(duk_context *ignored_ctx, void *udata) {
duk_context *ctx;
(void) udata;
ctx = duk_create_heap_default();
if (!ctx) {
printf("Failed to create heap\n");
return 0;
}
/* Dummy print() binding. */
duk_push_c_function(ctx, my_print, 1);
duk_put_global_string(ctx, "print");
/* Register Duktape.modSearch. */
duk_eval_string(ctx, "(function (fun) { Duktape.modSearch = fun; })");
duk_push_c_function(ctx, my_modsearch, 4 /*nargs*/);
duk_call(ctx, 1);
duk_pop(ctx);
/* Require test. */
duk_eval_string_noresult(ctx, "var mod = require('my_module'); print(mod.FLAG_FOO); mod.func1();");
printf("final top: %ld\n", (long) duk_get_top(ctx));
duk_destroy_heap(ctx);
return 0;
}
void StyleContext::initFunctions(const Scene& _scene) {
if (_scene.id == m_sceneId) {
return;
}
m_sceneId = _scene.id;
auto arr_idx = duk_push_array(m_ctx);
int id = 0;
for (auto& function : _scene.functions()) {
//logMsg("compile '%s'\n", function.c_str());
duk_push_string(m_ctx, function.c_str());
duk_push_string(m_ctx, "");
if (duk_pcompile(m_ctx, DUK_COMPILE_FUNCTION) == 0) {
duk_put_prop_index(m_ctx, arr_idx, id);
} else {
logMsg("Error: compile failed: %s\n", duk_safe_to_string(m_ctx, -1));
duk_pop(m_ctx);
}
id++;
}
if (!duk_put_global_string(m_ctx, FUNC_ID)) {
logMsg("Error: 'fns' object not set\n");
}
DUMP("setScene - %d functions\n", id);
}
void Expose_Light(duk_context* ctx)
{
duk_push_object(ctx);
duk_put_function_list(ctx, -1, Light_StaticFunctions);
duk_push_number(ctx, 0);
duk_put_prop_string(ctx, -2, "PointLight");
duk_push_number(ctx, 1);
duk_put_prop_string(ctx, -2, "Spotlight");
duk_push_number(ctx, 2);
duk_put_prop_string(ctx, -2, "DirectionalLight");
duk_push_object(ctx);
duk_put_function_list(ctx, -1, Light_Functions);
DefineProperty(ctx, "ComponentNameChanged", Light_Get_ComponentNameChanged, nullptr);
DefineProperty(ctx, "ParentEntitySet", Light_Get_ParentEntitySet, nullptr);
DefineProperty(ctx, "ParentEntityAboutToBeDetached", Light_Get_ParentEntityAboutToBeDetached, nullptr);
DefineProperty(ctx, "typeName", Light_TypeName, nullptr);
DefineProperty(ctx, "typeId", Light_TypeId, nullptr);
DefineProperty(ctx, "name", Light_Name, Light_SetName_String);
DefineProperty(ctx, "replicated", Light_IsReplicated, Light_SetReplicated_bool);
DefineProperty(ctx, "local", Light_IsLocal, nullptr);
DefineProperty(ctx, "unacked", Light_IsUnacked, nullptr);
DefineProperty(ctx, "updateMode", Light_UpdateMode, Light_SetUpdateMode_AttributeChange__Type);
DefineProperty(ctx, "id", Light_Id, nullptr);
DefineProperty(ctx, "temporary", Light_IsTemporary, Light_SetTemporary_bool);
DefineProperty(ctx, "viewEnabled", Light_ViewEnabled, nullptr);
duk_put_prop_string(ctx, -2, "prototype");
duk_put_global_string(ctx, Light_ID);
}
void StyleContext::setGlobal(const std::string& _key, const Value& _val) {
Value& entry = m_globals[_key];
if (entry == _val) {
return;
}
entry = _val;
if (_val.is<float>()) {
duk_push_number(m_ctx, _val.get<float>());
duk_put_global_string(m_ctx, _key.c_str());
} else if (_val.is<std::string>()) {
duk_push_string(m_ctx, _val.get<std::string>().c_str());
duk_put_global_string(m_ctx, _key.c_str());
}
}
void Expose_EntityReference(duk_context* ctx)
{
duk_push_c_function(ctx, EntityReference_Ctor_Selector, DUK_VARARGS);
duk_push_object(ctx);
duk_put_function_list(ctx, -1, EntityReference_Functions);
DefineProperty(ctx, "ref", EntityReference_Get_ref, EntityReference_Set_ref);
duk_put_prop_string(ctx, -2, "prototype");
duk_put_global_string(ctx, EntityReference_ID);
}
static duk_int_t load_file(duk_context *ctx, const char *filename, const char *var) {
size_t len; char *buf = read_file(filename, &len);
if(!buf) FAIL_LOAD
duk_push_external_buffer(ctx);
duk_config_buffer(ctx, -1, buf, len);
duk_put_global_string(ctx, var);
return 0;
}
void Expose_AssetReferenceList(duk_context* ctx)
{
duk_push_c_function(ctx, AssetReferenceList_Ctor_Selector, DUK_VARARGS);
duk_push_object(ctx);
duk_put_function_list(ctx, -1, AssetReferenceList_Functions);
DefineProperty(ctx, "refs", AssetReferenceList_Get_refs, AssetReferenceList_Set_refs);
DefineProperty(ctx, "type", AssetReferenceList_Get_type, AssetReferenceList_Set_type);
duk_put_prop_string(ctx, -2, "prototype");
duk_put_global_string(ctx, AssetReferenceList_ID);
}
static int dukzip_core(duk_context *ctx) {
int mod = duk_push_object(ctx);
/* create readable archive prototype */
duk_push_object(ctx);
duk_push_c_function(ctx, dukzip_unz_finalizer, 1);
duk_set_finalizer(ctx, -2);
duk_put_function_list(ctx, -1, dukzip_unz_prototype);
duk_put_global_string(ctx, DUKZIP_UNZ_PROTOTYPE);
/* create writable archive prototype */
duk_push_object(ctx);
duk_push_c_function(ctx, dukzip_zip_finalizer, 1);
duk_set_finalizer(ctx, -2);
duk_put_function_list(ctx, -1, dukzip_zip_prototype);
duk_put_global_string(ctx, DUKZIP_ZIP_PROTOTYPE);
duk_put_function_list(ctx, -1, dukzip_module);
return mod;
}
void Expose_Line(duk_context* ctx)
{
duk_push_c_function(ctx, Line_Ctor_Selector, DUK_VARARGS);
duk_put_function_list(ctx, -1, Line_StaticFunctions);
duk_push_object(ctx);
duk_put_function_list(ctx, -1, Line_Functions);
DefineProperty(ctx, "pos", Line_Get_pos, Line_Set_pos);
DefineProperty(ctx, "dir", Line_Get_dir, Line_Set_dir);
duk_put_prop_string(ctx, -2, "prototype");
duk_put_global_string(ctx, Line_ID);
}
int main(int argc, char *argv[]) {
duk_context *ctx;
int i;
int exitcode = 0;
ctx = duk_create_heap_default();
if (!ctx) {
return 1;
}
duk_push_c_function(ctx, handle_print, 1);
duk_put_global_string(ctx, "print");
duk_push_c_function(ctx, handle_assert, 2);
duk_put_global_string(ctx, "assert");
duk_push_object(ctx);
duk_push_c_function(ctx, cb_resolve_module, DUK_VARARGS);
duk_put_prop_string(ctx, -2, "resolve");
duk_push_c_function(ctx, cb_load_module, DUK_VARARGS);
duk_put_prop_string(ctx, -2, "load");
duk_module_node_init(ctx);
printf("top after init: %ld\n", (long) duk_get_top(ctx));
for (i = 1; i < argc; i++) {
printf("Evaling: %s\n", argv[i]);
if (duk_peval_string(ctx, argv[i]) != 0) {
if (duk_get_prop_string(ctx, -1, "stack")) {
duk_replace(ctx, -2);
} else {
duk_pop(ctx);
}
exitcode = 1;
}
printf("--> %s\n", duk_safe_to_string(ctx, -1));
duk_pop(ctx);
}
printf("Done\n");
duk_destroy_heap(ctx);
return exitcode;
}
void
_gum_duk_store_module_data (duk_context * ctx,
const gchar * module_id,
gpointer data)
{
guint8 key[32];
key[0] = 0xff;
g_strlcpy ((gchar *) (key + 1), module_id, sizeof (key) - 1);
duk_push_pointer (ctx, data);
duk_put_global_string (ctx, (const gchar *) key);
}
void duk_console_init(duk_context *ctx, duk_uint_t flags) {
duk_push_object(ctx);
/* Custom function to format objects; user can replace.
* For now, try JX-formatting and if that fails, fall back
* to ToString(v).
*/
duk_eval_string(ctx,
"(function format(v){"
"try{"
"return Duktape.enc('jx',v);"
"}catch(e){"
"return ''+v;"
"}"
"})");
duk_put_prop_string(ctx, -2, "format");
duk__console_reg_vararg_func(ctx, duk__console_assert, "assert");
duk__console_reg_vararg_func(ctx, duk__console_log, "log");
duk__console_reg_vararg_func(ctx, duk__console_log, "debug"); /* alias to console.log */
duk__console_reg_vararg_func(ctx, duk__console_trace, "trace");
duk__console_reg_vararg_func(ctx, duk__console_info, "info");
duk__console_reg_vararg_func(ctx, duk__console_warn, "warn");
duk__console_reg_vararg_func(ctx, duk__console_error, "error");
duk__console_reg_vararg_func(ctx, duk__console_error, "exception"); /* alias to console.error */
duk__console_reg_vararg_func(ctx, duk__console_dir, "dir");
duk_put_global_string(ctx, "console");
/* Proxy wrapping: ensures any undefined console method calls are
* ignored silently. This is required specifically by the
* DeveloperToolsWG proposal (and is implemented also by Firefox:
* https://bugzilla.mozilla.org/show_bug.cgi?id=629607).
*/
if (flags & DUK_CONSOLE_PROXY_WRAPPER) {
/* Tolerate errors: Proxy may be disabled. */
duk_peval_string_noresult(ctx,
"(function(){"
"var D=function(){};"
"console=new Proxy(console,{"
"get:function(t,k){"
"var v=t[k];"
"return typeof v==='function'?v:D;"
"}"
"});"
"})();"
);
}
}
char *initPlugin(pluginHandler *_ph){
slog(DEBUG,DEBUG,"Plugin "PLUGIN_SCOPE" initializing.");
ph=_ph;
ctx = ph->ctx;
wally_put_function_list(ph,c_watchdogMethods);
duk_push_c_function(ctx, js_watchdog_ctor, 7 );
duk_push_object(ctx);
duk_put_function_list(ctx, -1, watchdogMethods);
duk_put_prop_string(ctx, -2, "prototype");
duk_put_global_string(ctx, JS_SCOPE);
return PLUGIN_SCOPE;
}
void Expose_IAssetTransfer(duk_context* ctx)
{
duk_push_object(ctx);
duk_push_object(ctx);
duk_put_function_list(ctx, -1, IAssetTransfer_Functions);
DefineProperty(ctx, "asset", IAssetTransfer_Get_asset, IAssetTransfer_Set_asset);
DefineProperty(ctx, "source", IAssetTransfer_Get_source, IAssetTransfer_Set_source);
DefineProperty(ctx, "assetType", IAssetTransfer_Get_assetType, IAssetTransfer_Set_assetType);
DefineProperty(ctx, "internalResourceName", IAssetTransfer_Get_internalResourceName, IAssetTransfer_Set_internalResourceName);
DefineProperty(ctx, "Downloaded", IAssetTransfer_Get_Downloaded, nullptr);
DefineProperty(ctx, "Succeeded", IAssetTransfer_Get_Succeeded, nullptr);
DefineProperty(ctx, "Failed", IAssetTransfer_Get_Failed, nullptr);
duk_put_prop_string(ctx, -2, "prototype");
duk_put_global_string(ctx, IAssetTransfer_ID);
}
char *initPlugin(pluginHandler *_ph){
slog(DEBUG,FULLDEBUG,"Plugin "PLUGIN_SCOPE" initializing.");
ph=_ph;
ctx = ph->ctx;
wally_put_function(PLUGIN_SCOPE"::info", WFUNC_SYNC, myPluginInfo, 0);
duk_push_c_function(ctx, js_myPlugin_ctor, 1 );
duk_push_object(ctx);
duk_put_function_list(ctx, -1, myPluginMethods);
duk_put_prop_string(ctx, -2, "prototype");
duk_put_global_string(ctx, "myPlugin"); /* -> stack: [ ] */
return PLUGIN_SCOPE;
}
void StyleContext::setSceneGlobals(const std::unordered_map<std::string, YAML::Node>& sceneGlobals) {
if (sceneGlobals.size() == 0) { return; }
//[ "ctx" ]
auto globalObject = duk_push_object(m_ctx);
for (auto& global : sceneGlobals) {
auto key = global.first;
if (key.find(":") != std::string::npos) { continue; }
parseSceneGlobals(global.second, key, 0, globalObject);
}
duk_put_global_string(m_ctx, "global");
}
static duk_ret_t test_basic(duk_context *ctx, void *udata) {
duk_bool_t ret;
(void) udata;
printf("top: %ld\n", (long) duk_get_top(ctx));
duk_push_string(ctx, "1.2.3");
ret = duk_put_global_string(ctx, "myAppVersion");
printf("top: %ld\n", (long) duk_get_top(ctx));
printf("ret: %ld\n", (long) ret);
duk_eval_string_noresult(ctx, "print(myAppVersion);");
printf("final top: %ld\n", (long) duk_get_top(ctx));
return 0;
}
static duk_ret_t test_api_example(duk_context *ctx) {
void *ptr;
duk_eval_string(ctx, "({ foo: 'bar' })");
ptr = duk_get_heapptr(ctx, -1);
duk_put_global_string(ctx, "ref");
duk_set_top(ctx, 0);
duk_push_heapptr(ctx, ptr);
duk_get_prop_string(ctx, -1, "foo");
printf("obj.foo: %s\n", duk_safe_to_string(ctx, -1)); /* prints 'bar' */
printf("final top: %ld\n", (long) duk_get_top(ctx));
return 0;
}
AJ_Status AJS_RegisterIO(duk_context* ctx, duk_idx_t ioIdx)
{
duk_idx_t pinIdx;
duk_idx_t i;
uint16_t numPins = AJS_TargetIO_GetNumPins();
/*
* Create base pin protoype
*/
pinIdx = duk_push_object(ctx);
AJS_SetPropertyAccessors(ctx, pinIdx, "functions", NULL, NativeFunctionsGetter);
AJS_SetPropertyAccessors(ctx, pinIdx, "info", NULL, NativeInfoGetter);
/*
* Create the pin objects
*/
duk_push_array(ctx);
for (i = 0; i < numPins; ++i) {
AJS_CreateObjectFromPrototype(ctx, pinIdx);
duk_push_int(ctx, i);
duk_put_prop_string(ctx, -2, "id");
duk_put_prop_index(ctx, -2, i);
}
duk_put_prop_string(ctx, ioIdx, "pin");
duk_pop(ctx);
/*
* Register the native functions
*/
AJS_PutFunctionList(ctx, ioIdx, io_native_functions, TRUE);
/*
* GPIO attribute constants
*/
duk_put_number_list(ctx, ioIdx, io_constants);
/*
* A hidden property for keeping track of triggers
*/
duk_push_string(ctx, AJS_HIDDEN_PROP("trigs"));
duk_push_array(ctx);
duk_def_prop(ctx, ioIdx, DUK_DEFPROP_HAVE_VALUE | DUK_DEFPROP_HAVE_WRITABLE);
/*
* Compact the IO object and set it on the global object
*/
duk_compact(ctx, ioIdx);
duk_dup(ctx, ioIdx);
duk_put_global_string(ctx, AJS_IOObjectName);
return AJ_OK;
}
void js_client_init(duk_context *ctx) {
slog(DEBUG,DEBUG,"Constructing cloud object");
#ifndef WITH_SEADUK
duv_ref_setup(ctx);
#endif
duk_push_c_function(ctx, js_client_ctor, 5 );
/* Push Client.prototype object. */
duk_push_object(ctx);
duk_put_function_list(ctx, -1, clientMethods);
duk_put_prop_string(ctx, -2, "prototype");
/* Finally, register Client to the global object */
duk_put_global_string(ctx, "CloudClient"); /* -> stack: [ ] */
}
void
_gum_duk_kernel_init (GumDukKernel * self,
GumDukCore * core)
{
GumDukScope scope = GUM_DUK_SCOPE_INIT (core);
duk_context * ctx = scope.ctx;
self->core = core;
duk_push_object (ctx);
duk_push_uint (ctx, gum_kernel_query_page_size ());
duk_put_prop_string (ctx, -2, "pageSize");
_gum_duk_add_properties_to_class_by_heapptr (ctx,
duk_require_heapptr (ctx, -1), gumjs_kernel_values);
duk_put_function_list (ctx, -1, gumjs_kernel_functions);
duk_put_global_string (ctx, "Kernel");
}
bool StyleContext::addFunction(const std::string& _name, const std::string& _func) {
duk_push_string(m_ctx, _func.c_str());
duk_push_string(m_ctx, _name.c_str());
if (duk_pcompile(m_ctx, DUK_COMPILE_FUNCTION) != 0) {
logMsg("Error: compile failed: %s\n", duk_safe_to_string(m_ctx, -1));
return false;
}
// Put function in global scope
duk_put_global_string(m_ctx, _name.c_str());
DUMP("addFunction\n");
return true;
}
void Expose_PhysicsWorld(duk_context* ctx)
{
duk_push_object(ctx);
duk_push_object(ctx);
duk_put_function_list(ctx, -1, PhysicsWorld_Functions);
DefineProperty(ctx, "PhysicsCollision", PhysicsWorld_Get_PhysicsCollision, nullptr);
DefineProperty(ctx, "NewPhysicsCollision", PhysicsWorld_Get_NewPhysicsCollision, nullptr);
DefineProperty(ctx, "AboutToUpdate", PhysicsWorld_Get_AboutToUpdate, nullptr);
DefineProperty(ctx, "Updated", PhysicsWorld_Get_Updated, nullptr);
DefineProperty(ctx, "physicsUpdatePeriod", PhysicsWorld_PhysicsUpdatePeriod, PhysicsWorld_SetPhysicsUpdatePeriod_float);
DefineProperty(ctx, "maxSubSteps", PhysicsWorld_MaxSubSteps, PhysicsWorld_SetMaxSubSteps_int);
DefineProperty(ctx, "gravity", PhysicsWorld_Gravity, PhysicsWorld_SetGravity_float3);
DefineProperty(ctx, "debugGeometryEnabled", PhysicsWorld_IsDebugGeometryEnabled, PhysicsWorld_SetDebugGeometryEnabled_bool);
DefineProperty(ctx, "running", PhysicsWorld_IsRunning, PhysicsWorld_SetRunning_bool);
DefineProperty(ctx, "client", PhysicsWorld_IsClient, nullptr);
duk_put_prop_string(ctx, -2, "prototype");
duk_put_global_string(ctx, PhysicsWorld_ID);
}
void Expose_IAsset(duk_context* ctx)
{
duk_push_object(ctx);
duk_push_number(ctx, 0);
duk_put_prop_string(ctx, -2, "Original");
duk_push_number(ctx, 1);
duk_put_prop_string(ctx, -2, "Cached");
duk_push_number(ctx, 2);
duk_put_prop_string(ctx, -2, "Programmatic");
duk_push_number(ctx, 3);
duk_put_prop_string(ctx, -2, "Bundle");
duk_push_object(ctx);
duk_put_function_list(ctx, -1, IAsset_Functions);
DefineProperty(ctx, "Unloaded", IAsset_Get_Unloaded, nullptr);
DefineProperty(ctx, "Loaded", IAsset_Get_Loaded, nullptr);
DefineProperty(ctx, "PropertyStatusChanged", IAsset_Get_PropertyStatusChanged, nullptr);
duk_put_prop_string(ctx, -2, "prototype");
duk_put_global_string(ctx, IAsset_ID);
}
