@almadar/kernel 19.0.0 → 19.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/package.json +4 -2
- package/pkg/orbital_wasm.d.ts +231 -9
- package/pkg/orbital_wasm.js +3284 -205
- package/pkg/orbital_wasm_bg.wasm +0 -0
- package/pkg/orbital_wasm_bg.wasm.d.ts +84 -6
- package/pkg-client/orbital_wasm.d.ts +231 -9
- package/pkg-client/orbital_wasm.js +3284 -205
- package/pkg-client/orbital_wasm_bg.wasm +0 -0
- package/pkg-client/orbital_wasm_bg.wasm.d.ts +84 -6
|
@@ -1,5 +1,203 @@
|
|
|
1
1
|
/* @ts-self-types="./orbital_wasm.d.ts" */
|
|
2
2
|
|
|
3
|
+
export class Canvas3D {
|
|
4
|
+
static __wrap(ptr) {
|
|
5
|
+
const obj = Object.create(Canvas3D.prototype);
|
|
6
|
+
obj.__wbg_ptr = ptr;
|
|
7
|
+
Canvas3DFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
8
|
+
return obj;
|
|
9
|
+
}
|
|
10
|
+
__destroy_into_raw() {
|
|
11
|
+
const ptr = this.__wbg_ptr;
|
|
12
|
+
this.__wbg_ptr = 0;
|
|
13
|
+
Canvas3DFinalization.unregister(this);
|
|
14
|
+
return ptr;
|
|
15
|
+
}
|
|
16
|
+
free() {
|
|
17
|
+
const ptr = this.__destroy_into_raw();
|
|
18
|
+
wasm.__wbg_canvas3d_free(ptr, 0);
|
|
19
|
+
}
|
|
20
|
+
/**
|
|
21
|
+
* The camera as the user moved it, as JSON (`eye`, `target`, `up`, `projection`, `near`, `far`).
|
|
22
|
+
* @returns {string}
|
|
23
|
+
*/
|
|
24
|
+
camera() {
|
|
25
|
+
let deferred1_0;
|
|
26
|
+
let deferred1_1;
|
|
27
|
+
try {
|
|
28
|
+
const ret = wasm.canvas3d_camera(this.__wbg_ptr);
|
|
29
|
+
deferred1_0 = ret[0];
|
|
30
|
+
deferred1_1 = ret[1];
|
|
31
|
+
return getStringFromWasm0(ret[0], ret[1]);
|
|
32
|
+
} finally {
|
|
33
|
+
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
34
|
+
}
|
|
35
|
+
}
|
|
36
|
+
/**
|
|
37
|
+
* Opens (or joins) the shared device and makes a surface on `canvas`.
|
|
38
|
+
* @param {HTMLCanvasElement} canvas
|
|
39
|
+
* @returns {Promise<Canvas3D>}
|
|
40
|
+
*/
|
|
41
|
+
static create(canvas) {
|
|
42
|
+
const ret = wasm.canvas3d_create(canvas);
|
|
43
|
+
return ret;
|
|
44
|
+
}
|
|
45
|
+
/**
|
|
46
|
+
* Advances the canvas clock to `now_ms` (`performance.now()`) with the page clock `epoch_ms`
|
|
47
|
+
* (`performance.timeOrigin + now`); true when the frame changed.
|
|
48
|
+
* @param {number} now_ms
|
|
49
|
+
* @param {number} epoch_ms
|
|
50
|
+
* @returns {boolean}
|
|
51
|
+
*/
|
|
52
|
+
frame(now_ms, epoch_ms) {
|
|
53
|
+
const ret = wasm.canvas3d_frame(this.__wbg_ptr, now_ms, epoch_ms);
|
|
54
|
+
if (ret[2]) {
|
|
55
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
56
|
+
}
|
|
57
|
+
return ret[0] !== 0;
|
|
58
|
+
}
|
|
59
|
+
/**
|
|
60
|
+
* @param {string} target_json
|
|
61
|
+
* @returns {boolean}
|
|
62
|
+
*/
|
|
63
|
+
lookAt(target_json) {
|
|
64
|
+
const ptr0 = passStringToWasm0(target_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
65
|
+
const len0 = WASM_VECTOR_LEN;
|
|
66
|
+
const ret = wasm.canvas3d_lookAt(this.__wbg_ptr, ptr0, len0);
|
|
67
|
+
if (ret[2]) {
|
|
68
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
69
|
+
}
|
|
70
|
+
return ret[0] !== 0;
|
|
71
|
+
}
|
|
72
|
+
/**
|
|
73
|
+
* @param {number} id
|
|
74
|
+
* @param {number} x
|
|
75
|
+
* @param {number} y
|
|
76
|
+
* @param {number} button_code
|
|
77
|
+
* @param {boolean} touch
|
|
78
|
+
*/
|
|
79
|
+
pointerDown(id, x, y, button_code, touch) {
|
|
80
|
+
wasm.canvas3d_pointerDown(this.__wbg_ptr, id, x, y, button_code, touch);
|
|
81
|
+
}
|
|
82
|
+
pointerLeave() {
|
|
83
|
+
wasm.canvas3d_pointerLeave(this.__wbg_ptr);
|
|
84
|
+
}
|
|
85
|
+
/**
|
|
86
|
+
* @param {number} id
|
|
87
|
+
* @param {number} x
|
|
88
|
+
* @param {number} y
|
|
89
|
+
* @returns {boolean}
|
|
90
|
+
*/
|
|
91
|
+
pointerMove(id, x, y) {
|
|
92
|
+
const ret = wasm.canvas3d_pointerMove(this.__wbg_ptr, id, x, y);
|
|
93
|
+
if (ret[2]) {
|
|
94
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
95
|
+
}
|
|
96
|
+
return ret[0] !== 0;
|
|
97
|
+
}
|
|
98
|
+
/**
|
|
99
|
+
* What the release did, as JSON: `{"unit":{"id","x","z"}}`, `{"tile":{"x","z"}}`, `{"select":{"id"}}`,
|
|
100
|
+
* `{"move":{"id","x","y"}}`, `{"shape":<the pattern's click payload>}`, or `null`.
|
|
101
|
+
* @param {number} id
|
|
102
|
+
* @param {number} x
|
|
103
|
+
* @param {number} y
|
|
104
|
+
* @param {boolean} unit_events
|
|
105
|
+
* @param {boolean} tile_events
|
|
106
|
+
* @returns {string}
|
|
107
|
+
*/
|
|
108
|
+
pointerUp(id, x, y, unit_events, tile_events) {
|
|
109
|
+
let deferred2_0;
|
|
110
|
+
let deferred2_1;
|
|
111
|
+
try {
|
|
112
|
+
const ret = wasm.canvas3d_pointerUp(this.__wbg_ptr, id, x, y, unit_events, tile_events);
|
|
113
|
+
var ptr1 = ret[0];
|
|
114
|
+
var len1 = ret[1];
|
|
115
|
+
if (ret[3]) {
|
|
116
|
+
ptr1 = 0; len1 = 0;
|
|
117
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
118
|
+
}
|
|
119
|
+
deferred2_0 = ptr1;
|
|
120
|
+
deferred2_1 = len1;
|
|
121
|
+
return getStringFromWasm0(ptr1, len1);
|
|
122
|
+
} finally {
|
|
123
|
+
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
124
|
+
}
|
|
125
|
+
}
|
|
126
|
+
render() {
|
|
127
|
+
const ret = wasm.canvas3d_render(this.__wbg_ptr);
|
|
128
|
+
if (ret[1]) {
|
|
129
|
+
throw takeFromExternrefTable0(ret[0]);
|
|
130
|
+
}
|
|
131
|
+
}
|
|
132
|
+
/**
|
|
133
|
+
* @returns {boolean}
|
|
134
|
+
*/
|
|
135
|
+
resetCamera() {
|
|
136
|
+
const ret = wasm.canvas3d_resetCamera(this.__wbg_ptr);
|
|
137
|
+
return ret !== 0;
|
|
138
|
+
}
|
|
139
|
+
/**
|
|
140
|
+
* @param {number} css_width
|
|
141
|
+
* @param {number} css_height
|
|
142
|
+
* @param {number} pixel_ratio
|
|
143
|
+
*/
|
|
144
|
+
resize(css_width, css_height, pixel_ratio) {
|
|
145
|
+
wasm.canvas3d_resize(this.__wbg_ptr, css_width, css_height, pixel_ratio);
|
|
146
|
+
}
|
|
147
|
+
/**
|
|
148
|
+
* `[x, y, z]` as JSON; true when the camera moved.
|
|
149
|
+
* @param {string} position_json
|
|
150
|
+
* @returns {boolean}
|
|
151
|
+
*/
|
|
152
|
+
setCameraPosition(position_json) {
|
|
153
|
+
const ptr0 = passStringToWasm0(position_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
154
|
+
const len0 = WASM_VECTOR_LEN;
|
|
155
|
+
const ret = wasm.canvas3d_setCameraPosition(this.__wbg_ptr, ptr0, len0);
|
|
156
|
+
if (ret[2]) {
|
|
157
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
158
|
+
}
|
|
159
|
+
return ret[0] !== 0;
|
|
160
|
+
}
|
|
161
|
+
/**
|
|
162
|
+
* @param {boolean} reduced
|
|
163
|
+
*/
|
|
164
|
+
setReducedMotion(reduced) {
|
|
165
|
+
wasm.canvas3d_setReducedMotion(this.__wbg_ptr, reduced);
|
|
166
|
+
}
|
|
167
|
+
/**
|
|
168
|
+
* `node_json`: the 3D render node; `theme_json`: the page's resolved canvas theme, or `null` for none.
|
|
169
|
+
* @param {string} node_json
|
|
170
|
+
* @param {string} theme_json
|
|
171
|
+
*/
|
|
172
|
+
setScene(node_json, theme_json) {
|
|
173
|
+
const ptr0 = passStringToWasm0(node_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
174
|
+
const len0 = WASM_VECTOR_LEN;
|
|
175
|
+
const ptr1 = passStringToWasm0(theme_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
176
|
+
const len1 = WASM_VECTOR_LEN;
|
|
177
|
+
const ret = wasm.canvas3d_setScene(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
178
|
+
if (ret[1]) {
|
|
179
|
+
throw takeFromExternrefTable0(ret[0]);
|
|
180
|
+
}
|
|
181
|
+
}
|
|
182
|
+
/**
|
|
183
|
+
* False when this canvas runs on the WebGL2 fallback (no GPU drawables there).
|
|
184
|
+
* @returns {boolean}
|
|
185
|
+
*/
|
|
186
|
+
webgpu() {
|
|
187
|
+
const ret = wasm.canvas3d_webgpu(this.__wbg_ptr);
|
|
188
|
+
return ret !== 0;
|
|
189
|
+
}
|
|
190
|
+
/**
|
|
191
|
+
* @param {number} delta_y
|
|
192
|
+
* @returns {boolean}
|
|
193
|
+
*/
|
|
194
|
+
wheel(delta_y) {
|
|
195
|
+
const ret = wasm.canvas3d_wheel(this.__wbg_ptr, delta_y);
|
|
196
|
+
return ret !== 0;
|
|
197
|
+
}
|
|
198
|
+
}
|
|
199
|
+
if (Symbol.dispose) Canvas3D.prototype[Symbol.dispose] = Canvas3D.prototype.free;
|
|
200
|
+
|
|
3
201
|
/**
|
|
4
202
|
* The encrypted credential store for a host whose rows answer asynchronously: the host lists its rows and `load`s them,
|
|
5
203
|
* runs an operation, then applies `takeWrites()` to its medium in order. See `credentials::VaultApi`.
|
|
@@ -408,6 +606,29 @@ export class CredentialVault {
|
|
|
408
606
|
}
|
|
409
607
|
if (Symbol.dispose) CredentialVault.prototype[Symbol.dispose] = CredentialVault.prototype.free;
|
|
410
608
|
|
|
609
|
+
export class GpuHost {
|
|
610
|
+
__destroy_into_raw() {
|
|
611
|
+
const ptr = this.__wbg_ptr;
|
|
612
|
+
this.__wbg_ptr = 0;
|
|
613
|
+
GpuHostFinalization.unregister(this);
|
|
614
|
+
return ptr;
|
|
615
|
+
}
|
|
616
|
+
free() {
|
|
617
|
+
const ptr = this.__destroy_into_raw();
|
|
618
|
+
wasm.__wbg_gpuhost_free(ptr, 0);
|
|
619
|
+
}
|
|
620
|
+
closeAll() {
|
|
621
|
+
wasm.gpuhost_closeAll(this.__wbg_ptr);
|
|
622
|
+
}
|
|
623
|
+
constructor() {
|
|
624
|
+
const ret = wasm.gpuhost_new();
|
|
625
|
+
this.__wbg_ptr = ret;
|
|
626
|
+
GpuHostFinalization.register(this, this.__wbg_ptr, this);
|
|
627
|
+
return this;
|
|
628
|
+
}
|
|
629
|
+
}
|
|
630
|
+
if (Symbol.dispose) GpuHost.prototype[Symbol.dispose] = GpuHost.prototype.free;
|
|
631
|
+
|
|
411
632
|
export class Kernel {
|
|
412
633
|
__destroy_into_raw() {
|
|
413
634
|
const ptr = this.__wbg_ptr;
|
|
@@ -580,6 +801,38 @@ export class Kernel {
|
|
|
580
801
|
wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
|
|
581
802
|
}
|
|
582
803
|
}
|
|
804
|
+
/**
|
|
805
|
+
* Dispatch a held completion: `event` on `traitName` with the payload held under `heldPayload`, taken once.
|
|
806
|
+
* @param {string} trait_name
|
|
807
|
+
* @param {string | null | undefined} entity_id
|
|
808
|
+
* @param {string} event
|
|
809
|
+
* @param {number} held_payload
|
|
810
|
+
* @returns {string}
|
|
811
|
+
*/
|
|
812
|
+
dispatchHeld(trait_name, entity_id, event, held_payload) {
|
|
813
|
+
let deferred5_0;
|
|
814
|
+
let deferred5_1;
|
|
815
|
+
try {
|
|
816
|
+
const ptr0 = passStringToWasm0(trait_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
817
|
+
const len0 = WASM_VECTOR_LEN;
|
|
818
|
+
var ptr1 = isLikeNone(entity_id) ? 0 : passStringToWasm0(entity_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
819
|
+
var len1 = WASM_VECTOR_LEN;
|
|
820
|
+
const ptr2 = passStringToWasm0(event, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
821
|
+
const len2 = WASM_VECTOR_LEN;
|
|
822
|
+
const ret = wasm.kernel_dispatchHeld(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, held_payload);
|
|
823
|
+
var ptr4 = ret[0];
|
|
824
|
+
var len4 = ret[1];
|
|
825
|
+
if (ret[3]) {
|
|
826
|
+
ptr4 = 0; len4 = 0;
|
|
827
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
828
|
+
}
|
|
829
|
+
deferred5_0 = ptr4;
|
|
830
|
+
deferred5_1 = len4;
|
|
831
|
+
return getStringFromWasm0(ptr4, len4);
|
|
832
|
+
} finally {
|
|
833
|
+
wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
|
|
834
|
+
}
|
|
835
|
+
}
|
|
583
836
|
/**
|
|
584
837
|
* The kernel's dispatch mode for a registered trait, as JSON text.
|
|
585
838
|
* @param {string} trait_name
|
|
@@ -609,11 +862,12 @@ export class Kernel {
|
|
|
609
862
|
* @param {string} seeds_json
|
|
610
863
|
* @param {string | null} [entity_id]
|
|
611
864
|
* @param {string | null} [payload_json]
|
|
865
|
+
* @param {string | null} [route]
|
|
612
866
|
* @returns {string}
|
|
613
867
|
*/
|
|
614
|
-
dispatchMount(seeds_json, entity_id, payload_json) {
|
|
615
|
-
let
|
|
616
|
-
let
|
|
868
|
+
dispatchMount(seeds_json, entity_id, payload_json, route) {
|
|
869
|
+
let deferred6_0;
|
|
870
|
+
let deferred6_1;
|
|
617
871
|
try {
|
|
618
872
|
const ptr0 = passStringToWasm0(seeds_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
619
873
|
const len0 = WASM_VECTOR_LEN;
|
|
@@ -621,19 +875,33 @@ export class Kernel {
|
|
|
621
875
|
var len1 = WASM_VECTOR_LEN;
|
|
622
876
|
var ptr2 = isLikeNone(payload_json) ? 0 : passStringToWasm0(payload_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
623
877
|
var len2 = WASM_VECTOR_LEN;
|
|
624
|
-
|
|
625
|
-
var
|
|
626
|
-
|
|
878
|
+
var ptr3 = isLikeNone(route) ? 0 : passStringToWasm0(route, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
879
|
+
var len3 = WASM_VECTOR_LEN;
|
|
880
|
+
const ret = wasm.kernel_dispatchMount(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
|
|
881
|
+
var ptr5 = ret[0];
|
|
882
|
+
var len5 = ret[1];
|
|
627
883
|
if (ret[3]) {
|
|
628
|
-
|
|
884
|
+
ptr5 = 0; len5 = 0;
|
|
629
885
|
throw takeFromExternrefTable0(ret[2]);
|
|
630
886
|
}
|
|
631
|
-
|
|
632
|
-
|
|
633
|
-
return getStringFromWasm0(
|
|
887
|
+
deferred6_0 = ptr5;
|
|
888
|
+
deferred6_1 = len5;
|
|
889
|
+
return getStringFromWasm0(ptr5, len5);
|
|
634
890
|
} finally {
|
|
635
|
-
wasm.__wbindgen_free(
|
|
891
|
+
wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
|
|
892
|
+
}
|
|
893
|
+
}
|
|
894
|
+
/**
|
|
895
|
+
* Drop a held completion payload no dispatch will take (the host could not deliver it).
|
|
896
|
+
* @param {number} held_payload
|
|
897
|
+
* @returns {boolean}
|
|
898
|
+
*/
|
|
899
|
+
dropHeldPayload(held_payload) {
|
|
900
|
+
const ret = wasm.kernel_dropHeldPayload(this.__wbg_ptr, held_payload);
|
|
901
|
+
if (ret[2]) {
|
|
902
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
636
903
|
}
|
|
904
|
+
return ret[0] !== 0;
|
|
637
905
|
}
|
|
638
906
|
/**
|
|
639
907
|
* @param {number} flight
|
|
@@ -795,6 +1063,17 @@ export class Kernel {
|
|
|
795
1063
|
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
796
1064
|
}
|
|
797
1065
|
}
|
|
1066
|
+
/**
|
|
1067
|
+
* Install the GPU answerer: from now on every `gpu/` ask is held in the kernel and answered here in ask order, and
|
|
1068
|
+
* each outcome's route event is handed to `onCompletion` (see [`drain_client_gpu`]) for the host to dispatch with
|
|
1069
|
+
* `dispatchHeld`, so no handle or byte crosses to JavaScript.
|
|
1070
|
+
* @param {GpuHost} gpu
|
|
1071
|
+
* @param {Function} on_completion
|
|
1072
|
+
*/
|
|
1073
|
+
installGpu(gpu, on_completion) {
|
|
1074
|
+
_assertClass(gpu, GpuHost);
|
|
1075
|
+
wasm.kernel_installGpu(this.__wbg_ptr, gpu.__wbg_ptr, on_completion);
|
|
1076
|
+
}
|
|
798
1077
|
/**
|
|
799
1078
|
* @returns {string}
|
|
800
1079
|
*/
|
|
@@ -1079,20 +1358,6 @@ export class Kernel {
|
|
|
1079
1358
|
setHostFansOut(fans_out) {
|
|
1080
1359
|
wasm.kernel_setHostFansOut(this.__wbg_ptr, fans_out);
|
|
1081
1360
|
}
|
|
1082
|
-
/**
|
|
1083
|
-
* @param {string} locales_json
|
|
1084
|
-
* @param {string} catalogs_json
|
|
1085
|
-
*/
|
|
1086
|
-
setMessages(locales_json, catalogs_json) {
|
|
1087
|
-
const ptr0 = passStringToWasm0(locales_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1088
|
-
const len0 = WASM_VECTOR_LEN;
|
|
1089
|
-
const ptr1 = passStringToWasm0(catalogs_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1090
|
-
const len1 = WASM_VECTOR_LEN;
|
|
1091
|
-
const ret = wasm.kernel_setMessages(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
1092
|
-
if (ret[1]) {
|
|
1093
|
-
throw takeFromExternrefTable0(ret[0]);
|
|
1094
|
-
}
|
|
1095
|
-
}
|
|
1096
1361
|
/**
|
|
1097
1362
|
* Carry each hop's `@entity` before and after it on the dispatch's transitions (`observed`), for a verifier
|
|
1098
1363
|
* judging `@ensures`. Off by default (EXEC-STEP-10).
|
|
@@ -1112,6 +1377,13 @@ export class Kernel {
|
|
|
1112
1377
|
throw takeFromExternrefTable0(ret[0]);
|
|
1113
1378
|
}
|
|
1114
1379
|
}
|
|
1380
|
+
/**
|
|
1381
|
+
* Record each dispatch as a trace item while on, for the host's `program/live { kind: "trace" }` streams.
|
|
1382
|
+
* @param {boolean} on
|
|
1383
|
+
*/
|
|
1384
|
+
setTraceOn(on) {
|
|
1385
|
+
wasm.kernel_setTraceOn(this.__wbg_ptr, on);
|
|
1386
|
+
}
|
|
1115
1387
|
/**
|
|
1116
1388
|
* The host's report of whether a trait's rendered output is on screen; gates its `[visible]` ticks.
|
|
1117
1389
|
* @param {string} trait_name
|
|
@@ -1122,6 +1394,18 @@ export class Kernel {
|
|
|
1122
1394
|
const len0 = WASM_VECTOR_LEN;
|
|
1123
1395
|
wasm.kernel_setTraitOnScreen(this.__wbg_ptr, ptr0, len0, on_screen);
|
|
1124
1396
|
}
|
|
1397
|
+
/**
|
|
1398
|
+
* The page's locale `i18n/t` paints in when a dispatch names none; the program carries its own messages.
|
|
1399
|
+
* @param {string | null} [locale]
|
|
1400
|
+
*/
|
|
1401
|
+
setViewerLocale(locale) {
|
|
1402
|
+
var ptr0 = isLikeNone(locale) ? 0 : passStringToWasm0(locale, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1403
|
+
var len0 = WASM_VECTOR_LEN;
|
|
1404
|
+
const ret = wasm.kernel_setViewerLocale(this.__wbg_ptr, ptr0, len0);
|
|
1405
|
+
if (ret[1]) {
|
|
1406
|
+
throw takeFromExternrefTable0(ret[0]);
|
|
1407
|
+
}
|
|
1408
|
+
}
|
|
1125
1409
|
/**
|
|
1126
1410
|
* @returns {string}
|
|
1127
1411
|
*/
|
|
@@ -1167,6 +1451,28 @@ export class Kernel {
|
|
|
1167
1451
|
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
1168
1452
|
}
|
|
1169
1453
|
}
|
|
1454
|
+
/**
|
|
1455
|
+
* The trace items recorded since the last take, in dispatch order: a JSON array.
|
|
1456
|
+
* @returns {string}
|
|
1457
|
+
*/
|
|
1458
|
+
takeTrace() {
|
|
1459
|
+
let deferred2_0;
|
|
1460
|
+
let deferred2_1;
|
|
1461
|
+
try {
|
|
1462
|
+
const ret = wasm.kernel_takeTrace(this.__wbg_ptr);
|
|
1463
|
+
var ptr1 = ret[0];
|
|
1464
|
+
var len1 = ret[1];
|
|
1465
|
+
if (ret[3]) {
|
|
1466
|
+
ptr1 = 0; len1 = 0;
|
|
1467
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
1468
|
+
}
|
|
1469
|
+
deferred2_0 = ptr1;
|
|
1470
|
+
deferred2_1 = len1;
|
|
1471
|
+
return getStringFromWasm0(ptr1, len1);
|
|
1472
|
+
} finally {
|
|
1473
|
+
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
1474
|
+
}
|
|
1475
|
+
}
|
|
1170
1476
|
/**
|
|
1171
1477
|
* @param {string} trait_name
|
|
1172
1478
|
* @param {string} tick_name
|
|
@@ -1577,42 +1883,181 @@ export class MemoryStore {
|
|
|
1577
1883
|
}
|
|
1578
1884
|
if (Symbol.dispose) MemoryStore.prototype[Symbol.dispose] = MemoryStore.prototype.free;
|
|
1579
1885
|
|
|
1580
|
-
|
|
1581
|
-
* The server role: `start` a request, answer the I/O it asks for, `resume` the flight until it is done.
|
|
1582
|
-
*/
|
|
1583
|
-
export class Server {
|
|
1886
|
+
export class SceneCanvas {
|
|
1584
1887
|
static __wrap(ptr) {
|
|
1585
|
-
const obj = Object.create(
|
|
1888
|
+
const obj = Object.create(SceneCanvas.prototype);
|
|
1586
1889
|
obj.__wbg_ptr = ptr;
|
|
1587
|
-
|
|
1890
|
+
SceneCanvasFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
1588
1891
|
return obj;
|
|
1589
1892
|
}
|
|
1590
1893
|
__destroy_into_raw() {
|
|
1591
1894
|
const ptr = this.__wbg_ptr;
|
|
1592
1895
|
this.__wbg_ptr = 0;
|
|
1593
|
-
|
|
1896
|
+
SceneCanvasFinalization.unregister(this);
|
|
1594
1897
|
return ptr;
|
|
1595
1898
|
}
|
|
1596
1899
|
free() {
|
|
1597
1900
|
const ptr = this.__destroy_into_raw();
|
|
1598
|
-
wasm.
|
|
1901
|
+
wasm.__wbg_scenecanvas_free(ptr, 0);
|
|
1599
1902
|
}
|
|
1600
1903
|
/**
|
|
1601
|
-
* @param {
|
|
1602
|
-
* @returns {
|
|
1904
|
+
* @param {HTMLCanvasElement} canvas
|
|
1905
|
+
* @returns {Promise<SceneCanvas>}
|
|
1603
1906
|
*/
|
|
1604
|
-
|
|
1605
|
-
const ret = wasm.
|
|
1606
|
-
|
|
1607
|
-
throw takeFromExternrefTable0(ret[1]);
|
|
1608
|
-
}
|
|
1609
|
-
return ret[0] !== 0;
|
|
1907
|
+
static create(canvas) {
|
|
1908
|
+
const ret = wasm.scenecanvas_create(canvas);
|
|
1909
|
+
return ret;
|
|
1610
1910
|
}
|
|
1611
1911
|
/**
|
|
1612
|
-
* @param {
|
|
1613
|
-
* @
|
|
1912
|
+
* @param {number} x
|
|
1913
|
+
* @param {number} y
|
|
1614
1914
|
*/
|
|
1615
|
-
|
|
1915
|
+
doubleTap(x, y) {
|
|
1916
|
+
wasm.scenecanvas_doubleTap(this.__wbg_ptr, x, y);
|
|
1917
|
+
}
|
|
1918
|
+
/**
|
|
1919
|
+
* Advances the scene clock to `now_ms`; true while the page should keep drawing.
|
|
1920
|
+
* @param {number} now_ms
|
|
1921
|
+
* @returns {boolean}
|
|
1922
|
+
*/
|
|
1923
|
+
frame(now_ms) {
|
|
1924
|
+
const ret = wasm.scenecanvas_frame(this.__wbg_ptr, now_ms);
|
|
1925
|
+
return ret !== 0;
|
|
1926
|
+
}
|
|
1927
|
+
/**
|
|
1928
|
+
* A pointer event in CSS pixels: `touch-down`, `touch-move`, `touch-up` or `touch-cancel`.
|
|
1929
|
+
* @param {string} kind
|
|
1930
|
+
* @param {number} x
|
|
1931
|
+
* @param {number} y
|
|
1932
|
+
* @param {number} button
|
|
1933
|
+
*/
|
|
1934
|
+
input(kind, x, y, button) {
|
|
1935
|
+
const ptr0 = passStringToWasm0(kind, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1936
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1937
|
+
wasm.scenecanvas_input(this.__wbg_ptr, ptr0, len0, x, y, button);
|
|
1938
|
+
}
|
|
1939
|
+
render() {
|
|
1940
|
+
const ret = wasm.scenecanvas_render(this.__wbg_ptr);
|
|
1941
|
+
if (ret[1]) {
|
|
1942
|
+
throw takeFromExternrefTable0(ret[0]);
|
|
1943
|
+
}
|
|
1944
|
+
}
|
|
1945
|
+
/**
|
|
1946
|
+
* @param {number} css_width
|
|
1947
|
+
* @param {number} css_height
|
|
1948
|
+
* @param {number} pixel_ratio
|
|
1949
|
+
*/
|
|
1950
|
+
resize(css_width, css_height, pixel_ratio) {
|
|
1951
|
+
const ret = wasm.scenecanvas_resize(this.__wbg_ptr, css_width, css_height, pixel_ratio);
|
|
1952
|
+
if (ret[1]) {
|
|
1953
|
+
throw takeFromExternrefTable0(ret[0]);
|
|
1954
|
+
}
|
|
1955
|
+
}
|
|
1956
|
+
/**
|
|
1957
|
+
* @param {boolean} enabled
|
|
1958
|
+
*/
|
|
1959
|
+
setMotion(enabled) {
|
|
1960
|
+
wasm.scenecanvas_setMotion(this.__wbg_ptr, enabled);
|
|
1961
|
+
}
|
|
1962
|
+
/**
|
|
1963
|
+
* `node_json`: the render node (`{ "type": "physics-canvas", … }`).
|
|
1964
|
+
* @param {string} node_json
|
|
1965
|
+
*/
|
|
1966
|
+
setScene(node_json) {
|
|
1967
|
+
const ptr0 = passStringToWasm0(node_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1968
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1969
|
+
const ret = wasm.scenecanvas_setScene(this.__wbg_ptr, ptr0, len0);
|
|
1970
|
+
if (ret[1]) {
|
|
1971
|
+
throw takeFromExternrefTable0(ret[0]);
|
|
1972
|
+
}
|
|
1973
|
+
}
|
|
1974
|
+
/**
|
|
1975
|
+
* The scene events input queued, as JSON `[{ "event", "payload" }]`.
|
|
1976
|
+
* @returns {string}
|
|
1977
|
+
*/
|
|
1978
|
+
takeEvents() {
|
|
1979
|
+
let deferred1_0;
|
|
1980
|
+
let deferred1_1;
|
|
1981
|
+
try {
|
|
1982
|
+
const ret = wasm.scenecanvas_takeEvents(this.__wbg_ptr);
|
|
1983
|
+
deferred1_0 = ret[0];
|
|
1984
|
+
deferred1_1 = ret[1];
|
|
1985
|
+
return getStringFromWasm0(ret[0], ret[1]);
|
|
1986
|
+
} finally {
|
|
1987
|
+
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
1988
|
+
}
|
|
1989
|
+
}
|
|
1990
|
+
/**
|
|
1991
|
+
* @returns {boolean}
|
|
1992
|
+
*/
|
|
1993
|
+
webgpu() {
|
|
1994
|
+
const ret = wasm.scenecanvas_webgpu(this.__wbg_ptr);
|
|
1995
|
+
return ret !== 0;
|
|
1996
|
+
}
|
|
1997
|
+
/**
|
|
1998
|
+
* Whether the scene took the zoom; the page scrolls when it did not.
|
|
1999
|
+
* @param {number} factor
|
|
2000
|
+
* @param {number} x
|
|
2001
|
+
* @param {number} y
|
|
2002
|
+
* @returns {boolean}
|
|
2003
|
+
*/
|
|
2004
|
+
zoom(factor, x, y) {
|
|
2005
|
+
const ret = wasm.scenecanvas_zoom(this.__wbg_ptr, factor, x, y);
|
|
2006
|
+
return ret !== 0;
|
|
2007
|
+
}
|
|
2008
|
+
}
|
|
2009
|
+
if (Symbol.dispose) SceneCanvas.prototype[Symbol.dispose] = SceneCanvas.prototype.free;
|
|
2010
|
+
|
|
2011
|
+
/**
|
|
2012
|
+
* The server role: `start` a request, answer the I/O it asks for, `resume` the flight until it is done.
|
|
2013
|
+
*/
|
|
2014
|
+
export class Server {
|
|
2015
|
+
static __wrap(ptr) {
|
|
2016
|
+
const obj = Object.create(Server.prototype);
|
|
2017
|
+
obj.__wbg_ptr = ptr;
|
|
2018
|
+
ServerFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
2019
|
+
return obj;
|
|
2020
|
+
}
|
|
2021
|
+
__destroy_into_raw() {
|
|
2022
|
+
const ptr = this.__wbg_ptr;
|
|
2023
|
+
this.__wbg_ptr = 0;
|
|
2024
|
+
ServerFinalization.unregister(this);
|
|
2025
|
+
return ptr;
|
|
2026
|
+
}
|
|
2027
|
+
free() {
|
|
2028
|
+
const ptr = this.__destroy_into_raw();
|
|
2029
|
+
wasm.__wbg_server_free(ptr, 0);
|
|
2030
|
+
}
|
|
2031
|
+
/**
|
|
2032
|
+
* @param {number} flight
|
|
2033
|
+
* @returns {boolean}
|
|
2034
|
+
*/
|
|
2035
|
+
abandon(flight) {
|
|
2036
|
+
const ret = wasm.server_abandon(this.__wbg_ptr, flight);
|
|
2037
|
+
if (ret[2]) {
|
|
2038
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
2039
|
+
}
|
|
2040
|
+
return ret[0] !== 0;
|
|
2041
|
+
}
|
|
2042
|
+
/**
|
|
2043
|
+
* Answer the held `gpu/` ask `ticket` (an `IoRequestWire` of kind `gpu`): resolves to the `IoAnswerWire` JSON to
|
|
2044
|
+
* reply with. A deferred completion is handed to `onCompletion` (see [`answer_held`]).
|
|
2045
|
+
* @param {number} ticket
|
|
2046
|
+
* @param {Function} on_completion
|
|
2047
|
+
* @returns {Promise<any>}
|
|
2048
|
+
*/
|
|
2049
|
+
answerGpu(ticket, on_completion) {
|
|
2050
|
+
const ret = wasm.server_answerGpu(this.__wbg_ptr, ticket, on_completion);
|
|
2051
|
+
if (ret[2]) {
|
|
2052
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
2053
|
+
}
|
|
2054
|
+
return takeFromExternrefTable0(ret[0]);
|
|
2055
|
+
}
|
|
2056
|
+
/**
|
|
2057
|
+
* @param {string} side
|
|
2058
|
+
* @returns {string}
|
|
2059
|
+
*/
|
|
2060
|
+
bootMounts(side) {
|
|
1616
2061
|
let deferred3_0;
|
|
1617
2062
|
let deferred3_1;
|
|
1618
2063
|
try {
|
|
@@ -1696,6 +2141,18 @@ export class Server {
|
|
|
1696
2141
|
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
1697
2142
|
}
|
|
1698
2143
|
}
|
|
2144
|
+
/**
|
|
2145
|
+
* Drop a held completion payload the host will not start (its call was cancelled).
|
|
2146
|
+
* @param {number} ticket
|
|
2147
|
+
* @returns {boolean}
|
|
2148
|
+
*/
|
|
2149
|
+
dropHeldPayload(ticket) {
|
|
2150
|
+
const ret = wasm.server_dropHeldPayload(this.__wbg_ptr, ticket);
|
|
2151
|
+
if (ret[2]) {
|
|
2152
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
2153
|
+
}
|
|
2154
|
+
return ret[0] !== 0;
|
|
2155
|
+
}
|
|
1699
2156
|
/**
|
|
1700
2157
|
* @param {string} url
|
|
1701
2158
|
* @returns {boolean}
|
|
@@ -1791,6 +2248,15 @@ export class Server {
|
|
|
1791
2248
|
const ret = wasm.server_inFlight(this.__wbg_ptr);
|
|
1792
2249
|
return ret >>> 0;
|
|
1793
2250
|
}
|
|
2251
|
+
/**
|
|
2252
|
+
* Install the GPU answerer: from now on the server holds every `gpu/` ask, and the host answers it by ticket
|
|
2253
|
+
* with `answerGpu`, so no argument or answer crosses to JavaScript.
|
|
2254
|
+
* @param {GpuHost} gpu
|
|
2255
|
+
*/
|
|
2256
|
+
installGpu(gpu) {
|
|
2257
|
+
_assertClass(gpu, GpuHost);
|
|
2258
|
+
wasm.server_installGpu(this.__wbg_ptr, gpu.__wbg_ptr);
|
|
2259
|
+
}
|
|
1794
2260
|
/**
|
|
1795
2261
|
* @returns {string}
|
|
1796
2262
|
*/
|
|
@@ -2142,20 +2608,6 @@ export class Server {
|
|
|
2142
2608
|
throw takeFromExternrefTable0(ret[0]);
|
|
2143
2609
|
}
|
|
2144
2610
|
}
|
|
2145
|
-
/**
|
|
2146
|
-
* @param {string} locales_json
|
|
2147
|
-
* @param {string} catalogs_json
|
|
2148
|
-
*/
|
|
2149
|
-
setMessages(locales_json, catalogs_json) {
|
|
2150
|
-
const ptr0 = passStringToWasm0(locales_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2151
|
-
const len0 = WASM_VECTOR_LEN;
|
|
2152
|
-
const ptr1 = passStringToWasm0(catalogs_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2153
|
-
const len1 = WASM_VECTOR_LEN;
|
|
2154
|
-
const ret = wasm.server_setMessages(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
2155
|
-
if (ret[1]) {
|
|
2156
|
-
throw takeFromExternrefTable0(ret[0]);
|
|
2157
|
-
}
|
|
2158
|
-
}
|
|
2159
2611
|
/**
|
|
2160
2612
|
* @param {string} anchors_json
|
|
2161
2613
|
* @returns {string}
|
|
@@ -2481,6 +2933,75 @@ export function eventWires(schema_json) {
|
|
|
2481
2933
|
}
|
|
2482
2934
|
}
|
|
2483
2935
|
|
|
2936
|
+
/**
|
|
2937
|
+
* @param {string} layer_json
|
|
2938
|
+
* @param {number} epoch_now_ms
|
|
2939
|
+
* @param {string} dimension
|
|
2940
|
+
* @param {number} tile_width
|
|
2941
|
+
* @returns {string}
|
|
2942
|
+
*/
|
|
2943
|
+
export function expandFxLayer(layer_json, epoch_now_ms, dimension, tile_width) {
|
|
2944
|
+
let deferred4_0;
|
|
2945
|
+
let deferred4_1;
|
|
2946
|
+
try {
|
|
2947
|
+
const ptr0 = passStringToWasm0(layer_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2948
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2949
|
+
const ptr1 = passStringToWasm0(dimension, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2950
|
+
const len1 = WASM_VECTOR_LEN;
|
|
2951
|
+
const ret = wasm.expandFxLayer(ptr0, len0, epoch_now_ms, ptr1, len1, tile_width);
|
|
2952
|
+
var ptr3 = ret[0];
|
|
2953
|
+
var len3 = ret[1];
|
|
2954
|
+
if (ret[3]) {
|
|
2955
|
+
ptr3 = 0; len3 = 0;
|
|
2956
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2957
|
+
}
|
|
2958
|
+
deferred4_0 = ptr3;
|
|
2959
|
+
deferred4_1 = len3;
|
|
2960
|
+
return getStringFromWasm0(ptr3, len3);
|
|
2961
|
+
} finally {
|
|
2962
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
2963
|
+
}
|
|
2964
|
+
}
|
|
2965
|
+
|
|
2966
|
+
/**
|
|
2967
|
+
* @param {string} seed
|
|
2968
|
+
* @param {number} salt
|
|
2969
|
+
* @returns {number}
|
|
2970
|
+
*/
|
|
2971
|
+
export function fxHash01(seed, salt) {
|
|
2972
|
+
const ptr0 = passStringToWasm0(seed, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2973
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2974
|
+
const ret = wasm.fxHash01(ptr0, len0, salt);
|
|
2975
|
+
return ret;
|
|
2976
|
+
}
|
|
2977
|
+
|
|
2978
|
+
/**
|
|
2979
|
+
* @param {string} view_json
|
|
2980
|
+
* @param {number} epoch_now_ms
|
|
2981
|
+
* @param {number} tick_ms
|
|
2982
|
+
* @returns {string}
|
|
2983
|
+
*/
|
|
2984
|
+
export function fxLifecycle(view_json, epoch_now_ms, tick_ms) {
|
|
2985
|
+
let deferred3_0;
|
|
2986
|
+
let deferred3_1;
|
|
2987
|
+
try {
|
|
2988
|
+
const ptr0 = passStringToWasm0(view_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2989
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2990
|
+
const ret = wasm.fxLifecycle(ptr0, len0, epoch_now_ms, tick_ms);
|
|
2991
|
+
var ptr2 = ret[0];
|
|
2992
|
+
var len2 = ret[1];
|
|
2993
|
+
if (ret[3]) {
|
|
2994
|
+
ptr2 = 0; len2 = 0;
|
|
2995
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2996
|
+
}
|
|
2997
|
+
deferred3_0 = ptr2;
|
|
2998
|
+
deferred3_1 = len2;
|
|
2999
|
+
return getStringFromWasm0(ptr2, len2);
|
|
3000
|
+
} finally {
|
|
3001
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
3002
|
+
}
|
|
3003
|
+
}
|
|
3004
|
+
|
|
2484
3005
|
/**
|
|
2485
3006
|
* Install the language data a host assembles from its installed `@almadar/core` and `@almadar/std`
|
|
2486
3007
|
* (`readLanguageBundle`): the operator table that routes `program/*` and the other host effects.
|
|
@@ -2652,6 +3173,34 @@ export function report_panics() {
|
|
|
2652
3173
|
wasm.report_panics();
|
|
2653
3174
|
}
|
|
2654
3175
|
|
|
3176
|
+
/**
|
|
3177
|
+
* @param {string} item_json
|
|
3178
|
+
* @param {string | null} [presets_json]
|
|
3179
|
+
* @returns {string}
|
|
3180
|
+
*/
|
|
3181
|
+
export function resolveFxView(item_json, presets_json) {
|
|
3182
|
+
let deferred4_0;
|
|
3183
|
+
let deferred4_1;
|
|
3184
|
+
try {
|
|
3185
|
+
const ptr0 = passStringToWasm0(item_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3186
|
+
const len0 = WASM_VECTOR_LEN;
|
|
3187
|
+
var ptr1 = isLikeNone(presets_json) ? 0 : passStringToWasm0(presets_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3188
|
+
var len1 = WASM_VECTOR_LEN;
|
|
3189
|
+
const ret = wasm.resolveFxView(ptr0, len0, ptr1, len1);
|
|
3190
|
+
var ptr3 = ret[0];
|
|
3191
|
+
var len3 = ret[1];
|
|
3192
|
+
if (ret[3]) {
|
|
3193
|
+
ptr3 = 0; len3 = 0;
|
|
3194
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
3195
|
+
}
|
|
3196
|
+
deferred4_0 = ptr3;
|
|
3197
|
+
deferred4_1 = len3;
|
|
3198
|
+
return getStringFromWasm0(ptr3, len3);
|
|
3199
|
+
} finally {
|
|
3200
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
3201
|
+
}
|
|
3202
|
+
}
|
|
3203
|
+
|
|
2655
3204
|
/**
|
|
2656
3205
|
* What a `@user`/`@payload`/`@config`/`@now` term folds to for a row predicate (`RowBindingWire` as JSON).
|
|
2657
3206
|
* @param {string} term
|
|
@@ -2750,72 +3299,46 @@ export function scopeRows(bindings_json, rows_json, policy_json, filter_json, en
|
|
|
2750
3299
|
}
|
|
2751
3300
|
|
|
2752
3301
|
/**
|
|
2753
|
-
* @param {string}
|
|
2754
|
-
* @param {
|
|
2755
|
-
* @param {
|
|
2756
|
-
* @param {string} args_json
|
|
2757
|
-
* @param {string} outcome_json
|
|
3302
|
+
* @param {string} matrix_json
|
|
3303
|
+
* @param {number} x
|
|
3304
|
+
* @param {number} y
|
|
2758
3305
|
* @returns {string}
|
|
2759
3306
|
*/
|
|
2760
|
-
export function
|
|
2761
|
-
let
|
|
2762
|
-
let
|
|
3307
|
+
export function skinApplyAffine(matrix_json, x, y) {
|
|
3308
|
+
let deferred3_0;
|
|
3309
|
+
let deferred3_1;
|
|
2763
3310
|
try {
|
|
2764
|
-
const ptr0 = passStringToWasm0(
|
|
3311
|
+
const ptr0 = passStringToWasm0(matrix_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2765
3312
|
const len0 = WASM_VECTOR_LEN;
|
|
2766
|
-
const
|
|
2767
|
-
|
|
2768
|
-
|
|
2769
|
-
const len2 = WASM_VECTOR_LEN;
|
|
2770
|
-
const ptr3 = passStringToWasm0(args_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2771
|
-
const len3 = WASM_VECTOR_LEN;
|
|
2772
|
-
const ptr4 = passStringToWasm0(outcome_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2773
|
-
const len4 = WASM_VECTOR_LEN;
|
|
2774
|
-
const ret = wasm.substrateCompletionEvent(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
|
|
2775
|
-
var ptr6 = ret[0];
|
|
2776
|
-
var len6 = ret[1];
|
|
3313
|
+
const ret = wasm.skinApplyAffine(ptr0, len0, x, y);
|
|
3314
|
+
var ptr2 = ret[0];
|
|
3315
|
+
var len2 = ret[1];
|
|
2777
3316
|
if (ret[3]) {
|
|
2778
|
-
|
|
3317
|
+
ptr2 = 0; len2 = 0;
|
|
2779
3318
|
throw takeFromExternrefTable0(ret[2]);
|
|
2780
3319
|
}
|
|
2781
|
-
|
|
2782
|
-
|
|
2783
|
-
return getStringFromWasm0(
|
|
3320
|
+
deferred3_0 = ptr2;
|
|
3321
|
+
deferred3_1 = len2;
|
|
3322
|
+
return getStringFromWasm0(ptr2, len2);
|
|
2784
3323
|
} finally {
|
|
2785
|
-
wasm.__wbindgen_free(
|
|
3324
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
2786
3325
|
}
|
|
2787
3326
|
}
|
|
2788
3327
|
|
|
2789
3328
|
/**
|
|
2790
|
-
*
|
|
2791
|
-
* @param {string}
|
|
2792
|
-
* @param {string} url
|
|
2793
|
-
* @returns {boolean}
|
|
2794
|
-
*/
|
|
2795
|
-
export function tabUrlMatches(pattern, url) {
|
|
2796
|
-
const ptr0 = passStringToWasm0(pattern, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2797
|
-
const len0 = WASM_VECTOR_LEN;
|
|
2798
|
-
const ptr1 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2799
|
-
const len1 = WASM_VECTOR_LEN;
|
|
2800
|
-
const ret = wasm.tabUrlMatches(ptr0, len0, ptr1, len1);
|
|
2801
|
-
return ret !== 0;
|
|
2802
|
-
}
|
|
2803
|
-
|
|
2804
|
-
/**
|
|
2805
|
-
* Effects run in order against a row (`TraceEffectsWire` as JSON): a trace per effect, the events raised, the writes made.
|
|
2806
|
-
* @param {string} context_json
|
|
2807
|
-
* @param {string} effects_json
|
|
3329
|
+
* @param {string} a_json
|
|
3330
|
+
* @param {string} b_json
|
|
2808
3331
|
* @returns {string}
|
|
2809
3332
|
*/
|
|
2810
|
-
export function
|
|
3333
|
+
export function skinComposeAffine(a_json, b_json) {
|
|
2811
3334
|
let deferred4_0;
|
|
2812
3335
|
let deferred4_1;
|
|
2813
3336
|
try {
|
|
2814
|
-
const ptr0 = passStringToWasm0(
|
|
3337
|
+
const ptr0 = passStringToWasm0(a_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2815
3338
|
const len0 = WASM_VECTOR_LEN;
|
|
2816
|
-
const ptr1 = passStringToWasm0(
|
|
3339
|
+
const ptr1 = passStringToWasm0(b_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2817
3340
|
const len1 = WASM_VECTOR_LEN;
|
|
2818
|
-
const ret = wasm.
|
|
3341
|
+
const ret = wasm.skinComposeAffine(ptr0, len0, ptr1, len1);
|
|
2819
3342
|
var ptr3 = ret[0];
|
|
2820
3343
|
var len3 = ret[1];
|
|
2821
3344
|
if (ret[3]) {
|
|
@@ -2831,15 +3354,234 @@ export function traceEffects(context_json, effects_json) {
|
|
|
2831
3354
|
}
|
|
2832
3355
|
|
|
2833
3356
|
/**
|
|
2834
|
-
*
|
|
2835
|
-
* @param {
|
|
3357
|
+
* @param {string} matrix_json
|
|
3358
|
+
* @param {number} bone
|
|
3359
|
+
* @returns {string}
|
|
2836
3360
|
*/
|
|
2837
|
-
export function
|
|
2838
|
-
|
|
2839
|
-
|
|
2840
|
-
|
|
2841
|
-
|
|
2842
|
-
|
|
3361
|
+
export function skinInvertAffine(matrix_json, bone) {
|
|
3362
|
+
let deferred3_0;
|
|
3363
|
+
let deferred3_1;
|
|
3364
|
+
try {
|
|
3365
|
+
const ptr0 = passStringToWasm0(matrix_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3366
|
+
const len0 = WASM_VECTOR_LEN;
|
|
3367
|
+
const ret = wasm.skinInvertAffine(ptr0, len0, bone);
|
|
3368
|
+
var ptr2 = ret[0];
|
|
3369
|
+
var len2 = ret[1];
|
|
3370
|
+
if (ret[3]) {
|
|
3371
|
+
ptr2 = 0; len2 = 0;
|
|
3372
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
3373
|
+
}
|
|
3374
|
+
deferred3_0 = ptr2;
|
|
3375
|
+
deferred3_1 = len2;
|
|
3376
|
+
return getStringFromWasm0(ptr2, len2);
|
|
3377
|
+
} finally {
|
|
3378
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
3379
|
+
}
|
|
3380
|
+
}
|
|
3381
|
+
|
|
3382
|
+
/**
|
|
3383
|
+
* @param {string} src_json
|
|
3384
|
+
* @param {string} dst_json
|
|
3385
|
+
* @returns {string}
|
|
3386
|
+
*/
|
|
3387
|
+
export function skinTriangleAffine(src_json, dst_json) {
|
|
3388
|
+
let deferred4_0;
|
|
3389
|
+
let deferred4_1;
|
|
3390
|
+
try {
|
|
3391
|
+
const ptr0 = passStringToWasm0(src_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3392
|
+
const len0 = WASM_VECTOR_LEN;
|
|
3393
|
+
const ptr1 = passStringToWasm0(dst_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3394
|
+
const len1 = WASM_VECTOR_LEN;
|
|
3395
|
+
const ret = wasm.skinTriangleAffine(ptr0, len0, ptr1, len1);
|
|
3396
|
+
var ptr3 = ret[0];
|
|
3397
|
+
var len3 = ret[1];
|
|
3398
|
+
if (ret[3]) {
|
|
3399
|
+
ptr3 = 0; len3 = 0;
|
|
3400
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
3401
|
+
}
|
|
3402
|
+
deferred4_0 = ptr3;
|
|
3403
|
+
deferred4_1 = len3;
|
|
3404
|
+
return getStringFromWasm0(ptr3, len3);
|
|
3405
|
+
} finally {
|
|
3406
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
3407
|
+
}
|
|
3408
|
+
}
|
|
3409
|
+
|
|
3410
|
+
/**
|
|
3411
|
+
* @param {string} points_json
|
|
3412
|
+
* @returns {string}
|
|
3413
|
+
*/
|
|
3414
|
+
export function skinVertexBounds(points_json) {
|
|
3415
|
+
let deferred3_0;
|
|
3416
|
+
let deferred3_1;
|
|
3417
|
+
try {
|
|
3418
|
+
const ptr0 = passStringToWasm0(points_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3419
|
+
const len0 = WASM_VECTOR_LEN;
|
|
3420
|
+
const ret = wasm.skinVertexBounds(ptr0, len0);
|
|
3421
|
+
var ptr2 = ret[0];
|
|
3422
|
+
var len2 = ret[1];
|
|
3423
|
+
if (ret[3]) {
|
|
3424
|
+
ptr2 = 0; len2 = 0;
|
|
3425
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
3426
|
+
}
|
|
3427
|
+
deferred3_0 = ptr2;
|
|
3428
|
+
deferred3_1 = len2;
|
|
3429
|
+
return getStringFromWasm0(ptr2, len2);
|
|
3430
|
+
} finally {
|
|
3431
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
3432
|
+
}
|
|
3433
|
+
}
|
|
3434
|
+
|
|
3435
|
+
/**
|
|
3436
|
+
* @param {string} mesh_json
|
|
3437
|
+
* @param {string} bind_json
|
|
3438
|
+
* @param {string} current_json
|
|
3439
|
+
* @returns {string}
|
|
3440
|
+
*/
|
|
3441
|
+
export function skinVertices(mesh_json, bind_json, current_json) {
|
|
3442
|
+
let deferred5_0;
|
|
3443
|
+
let deferred5_1;
|
|
3444
|
+
try {
|
|
3445
|
+
const ptr0 = passStringToWasm0(mesh_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3446
|
+
const len0 = WASM_VECTOR_LEN;
|
|
3447
|
+
const ptr1 = passStringToWasm0(bind_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3448
|
+
const len1 = WASM_VECTOR_LEN;
|
|
3449
|
+
const ptr2 = passStringToWasm0(current_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3450
|
+
const len2 = WASM_VECTOR_LEN;
|
|
3451
|
+
const ret = wasm.skinVertices(ptr0, len0, ptr1, len1, ptr2, len2);
|
|
3452
|
+
var ptr4 = ret[0];
|
|
3453
|
+
var len4 = ret[1];
|
|
3454
|
+
if (ret[3]) {
|
|
3455
|
+
ptr4 = 0; len4 = 0;
|
|
3456
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
3457
|
+
}
|
|
3458
|
+
deferred5_0 = ptr4;
|
|
3459
|
+
deferred5_1 = len4;
|
|
3460
|
+
return getStringFromWasm0(ptr4, len4);
|
|
3461
|
+
} finally {
|
|
3462
|
+
wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
|
|
3463
|
+
}
|
|
3464
|
+
}
|
|
3465
|
+
|
|
3466
|
+
/**
|
|
3467
|
+
* @param {string} bones_json
|
|
3468
|
+
* @param {string} pose_json
|
|
3469
|
+
* @returns {string}
|
|
3470
|
+
*/
|
|
3471
|
+
export function skinWorldMatrices(bones_json, pose_json) {
|
|
3472
|
+
let deferred4_0;
|
|
3473
|
+
let deferred4_1;
|
|
3474
|
+
try {
|
|
3475
|
+
const ptr0 = passStringToWasm0(bones_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3476
|
+
const len0 = WASM_VECTOR_LEN;
|
|
3477
|
+
const ptr1 = passStringToWasm0(pose_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3478
|
+
const len1 = WASM_VECTOR_LEN;
|
|
3479
|
+
const ret = wasm.skinWorldMatrices(ptr0, len0, ptr1, len1);
|
|
3480
|
+
var ptr3 = ret[0];
|
|
3481
|
+
var len3 = ret[1];
|
|
3482
|
+
if (ret[3]) {
|
|
3483
|
+
ptr3 = 0; len3 = 0;
|
|
3484
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
3485
|
+
}
|
|
3486
|
+
deferred4_0 = ptr3;
|
|
3487
|
+
deferred4_1 = len3;
|
|
3488
|
+
return getStringFromWasm0(ptr3, len3);
|
|
3489
|
+
} finally {
|
|
3490
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
3491
|
+
}
|
|
3492
|
+
}
|
|
3493
|
+
|
|
3494
|
+
/**
|
|
3495
|
+
* @param {string} site_json
|
|
3496
|
+
* @param {string} key
|
|
3497
|
+
* @param {string} op
|
|
3498
|
+
* @param {string} args_json
|
|
3499
|
+
* @param {string} outcome_json
|
|
3500
|
+
* @returns {string}
|
|
3501
|
+
*/
|
|
3502
|
+
export function substrateCompletionEvent(site_json, key, op, args_json, outcome_json) {
|
|
3503
|
+
let deferred7_0;
|
|
3504
|
+
let deferred7_1;
|
|
3505
|
+
try {
|
|
3506
|
+
const ptr0 = passStringToWasm0(site_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3507
|
+
const len0 = WASM_VECTOR_LEN;
|
|
3508
|
+
const ptr1 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3509
|
+
const len1 = WASM_VECTOR_LEN;
|
|
3510
|
+
const ptr2 = passStringToWasm0(op, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3511
|
+
const len2 = WASM_VECTOR_LEN;
|
|
3512
|
+
const ptr3 = passStringToWasm0(args_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3513
|
+
const len3 = WASM_VECTOR_LEN;
|
|
3514
|
+
const ptr4 = passStringToWasm0(outcome_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3515
|
+
const len4 = WASM_VECTOR_LEN;
|
|
3516
|
+
const ret = wasm.substrateCompletionEvent(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
|
|
3517
|
+
var ptr6 = ret[0];
|
|
3518
|
+
var len6 = ret[1];
|
|
3519
|
+
if (ret[3]) {
|
|
3520
|
+
ptr6 = 0; len6 = 0;
|
|
3521
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
3522
|
+
}
|
|
3523
|
+
deferred7_0 = ptr6;
|
|
3524
|
+
deferred7_1 = len6;
|
|
3525
|
+
return getStringFromWasm0(ptr6, len6);
|
|
3526
|
+
} finally {
|
|
3527
|
+
wasm.__wbindgen_free(deferred7_0, deferred7_1, 1);
|
|
3528
|
+
}
|
|
3529
|
+
}
|
|
3530
|
+
|
|
3531
|
+
/**
|
|
3532
|
+
* Whether the Chrome match pattern `pattern` matches `url`.
|
|
3533
|
+
* @param {string} pattern
|
|
3534
|
+
* @param {string} url
|
|
3535
|
+
* @returns {boolean}
|
|
3536
|
+
*/
|
|
3537
|
+
export function tabUrlMatches(pattern, url) {
|
|
3538
|
+
const ptr0 = passStringToWasm0(pattern, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3539
|
+
const len0 = WASM_VECTOR_LEN;
|
|
3540
|
+
const ptr1 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3541
|
+
const len1 = WASM_VECTOR_LEN;
|
|
3542
|
+
const ret = wasm.tabUrlMatches(ptr0, len0, ptr1, len1);
|
|
3543
|
+
return ret !== 0;
|
|
3544
|
+
}
|
|
3545
|
+
|
|
3546
|
+
/**
|
|
3547
|
+
* Effects run in order against a row (`TraceEffectsWire` as JSON): a trace per effect, the events raised, the writes made.
|
|
3548
|
+
* @param {string} context_json
|
|
3549
|
+
* @param {string} effects_json
|
|
3550
|
+
* @returns {string}
|
|
3551
|
+
*/
|
|
3552
|
+
export function traceEffects(context_json, effects_json) {
|
|
3553
|
+
let deferred4_0;
|
|
3554
|
+
let deferred4_1;
|
|
3555
|
+
try {
|
|
3556
|
+
const ptr0 = passStringToWasm0(context_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3557
|
+
const len0 = WASM_VECTOR_LEN;
|
|
3558
|
+
const ptr1 = passStringToWasm0(effects_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3559
|
+
const len1 = WASM_VECTOR_LEN;
|
|
3560
|
+
const ret = wasm.traceEffects(ptr0, len0, ptr1, len1);
|
|
3561
|
+
var ptr3 = ret[0];
|
|
3562
|
+
var len3 = ret[1];
|
|
3563
|
+
if (ret[3]) {
|
|
3564
|
+
ptr3 = 0; len3 = 0;
|
|
3565
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
3566
|
+
}
|
|
3567
|
+
deferred4_0 = ptr3;
|
|
3568
|
+
deferred4_1 = len3;
|
|
3569
|
+
return getStringFromWasm0(ptr3, len3);
|
|
3570
|
+
} finally {
|
|
3571
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
3572
|
+
}
|
|
3573
|
+
}
|
|
3574
|
+
|
|
3575
|
+
/**
|
|
3576
|
+
* The kernel's verdict on language packs (`[{ package, definition }]` as JSON): throws the refusal that names each pack, section and word.
|
|
3577
|
+
* @param {string} packs_json
|
|
3578
|
+
*/
|
|
3579
|
+
export function validatePacks(packs_json) {
|
|
3580
|
+
const ptr0 = passStringToWasm0(packs_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3581
|
+
const len0 = WASM_VECTOR_LEN;
|
|
3582
|
+
const ret = wasm.validatePacks(ptr0, len0);
|
|
3583
|
+
if (ret[1]) {
|
|
3584
|
+
throw takeFromExternrefTable0(ret[0]);
|
|
2843
3585
|
}
|
|
2844
3586
|
}
|
|
2845
3587
|
function __wbg_get_imports() {
|
|
@@ -2849,136 +3591,2173 @@ function __wbg_get_imports() {
|
|
|
2849
3591
|
const ret = Error(getStringFromWasm0(arg0, arg1));
|
|
2850
3592
|
return ret;
|
|
2851
3593
|
},
|
|
2852
|
-
|
|
2853
|
-
const ret =
|
|
2854
|
-
return ret;
|
|
3594
|
+
__wbg_Window_defb2c76b3875a73: function(arg0) {
|
|
3595
|
+
const ret = arg0.Window;
|
|
3596
|
+
return ret;
|
|
3597
|
+
},
|
|
3598
|
+
__wbg_WorkerGlobalScope_184e45d6565eb3f0: function(arg0) {
|
|
3599
|
+
const ret = arg0.WorkerGlobalScope;
|
|
3600
|
+
return ret;
|
|
3601
|
+
},
|
|
3602
|
+
__wbg___wbindgen_boolean_get_fa956cfa2d1bd751: function(arg0) {
|
|
3603
|
+
const v = arg0;
|
|
3604
|
+
const ret = typeof(v) === 'boolean' ? v : undefined;
|
|
3605
|
+
return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
|
|
3606
|
+
},
|
|
3607
|
+
__wbg___wbindgen_debug_string_c25d447a39f5578f: function(arg0, arg1) {
|
|
3608
|
+
const ret = debugString(arg1);
|
|
3609
|
+
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3610
|
+
const len1 = WASM_VECTOR_LEN;
|
|
3611
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
3612
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
3613
|
+
},
|
|
3614
|
+
__wbg___wbindgen_is_function_1ff95bcc5517c252: function(arg0) {
|
|
3615
|
+
const ret = typeof(arg0) === 'function';
|
|
3616
|
+
return ret;
|
|
3617
|
+
},
|
|
3618
|
+
__wbg___wbindgen_is_null_ea9085d691f535d3: function(arg0) {
|
|
3619
|
+
const ret = arg0 === null;
|
|
3620
|
+
return ret;
|
|
3621
|
+
},
|
|
3622
|
+
__wbg___wbindgen_is_object_a27215656b807791: function(arg0) {
|
|
3623
|
+
const val = arg0;
|
|
3624
|
+
const ret = typeof(val) === 'object' && val !== null;
|
|
3625
|
+
return ret;
|
|
3626
|
+
},
|
|
3627
|
+
__wbg___wbindgen_is_string_ea5e6cc2e4141dfe: function(arg0) {
|
|
3628
|
+
const ret = typeof(arg0) === 'string';
|
|
3629
|
+
return ret;
|
|
3630
|
+
},
|
|
3631
|
+
__wbg___wbindgen_is_undefined_c05833b95a3cf397: function(arg0) {
|
|
3632
|
+
const ret = arg0 === undefined;
|
|
3633
|
+
return ret;
|
|
3634
|
+
},
|
|
3635
|
+
__wbg___wbindgen_number_get_394265ed1e1b84ee: function(arg0, arg1) {
|
|
3636
|
+
const obj = arg1;
|
|
3637
|
+
const ret = typeof(obj) === 'number' ? obj : undefined;
|
|
3638
|
+
getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
|
|
3639
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
|
|
3640
|
+
},
|
|
3641
|
+
__wbg___wbindgen_string_get_b0ca35b86a603356: function(arg0, arg1) {
|
|
3642
|
+
const obj = arg1;
|
|
3643
|
+
const ret = typeof(obj) === 'string' ? obj : undefined;
|
|
3644
|
+
var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3645
|
+
var len1 = WASM_VECTOR_LEN;
|
|
3646
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
3647
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
3648
|
+
},
|
|
3649
|
+
__wbg___wbindgen_throw_344f42d3211c4765: function(arg0, arg1) {
|
|
3650
|
+
throw new Error(getStringFromWasm0(arg0, arg1));
|
|
3651
|
+
},
|
|
3652
|
+
__wbg__wbg_cb_unref_fffb441def202758: function(arg0) {
|
|
3653
|
+
arg0._wbg_cb_unref();
|
|
3654
|
+
},
|
|
3655
|
+
__wbg_activeTexture_92b04d918019d603: function(arg0, arg1) {
|
|
3656
|
+
arg0.activeTexture(arg1 >>> 0);
|
|
3657
|
+
},
|
|
3658
|
+
__wbg_activeTexture_d12958674e97a118: function(arg0, arg1) {
|
|
3659
|
+
arg0.activeTexture(arg1 >>> 0);
|
|
3660
|
+
},
|
|
3661
|
+
__wbg_arrayBuffer_3b637f0fa65c5351: function() { return handleError(function (arg0) {
|
|
3662
|
+
const ret = arg0.arrayBuffer();
|
|
3663
|
+
return ret;
|
|
3664
|
+
}, arguments); },
|
|
3665
|
+
__wbg_attachShader_5f7f4077e124e23b: function(arg0, arg1, arg2) {
|
|
3666
|
+
arg0.attachShader(arg1, arg2);
|
|
3667
|
+
},
|
|
3668
|
+
__wbg_attachShader_8971266b4c9bc514: function(arg0, arg1, arg2) {
|
|
3669
|
+
arg0.attachShader(arg1, arg2);
|
|
3670
|
+
},
|
|
3671
|
+
__wbg_beginComputePass_1fc169dd9fc89475: function(arg0, arg1) {
|
|
3672
|
+
const ret = arg0.beginComputePass(arg1);
|
|
3673
|
+
return ret;
|
|
3674
|
+
},
|
|
3675
|
+
__wbg_beginQuery_042a1f99e870066c: function(arg0, arg1, arg2) {
|
|
3676
|
+
arg0.beginQuery(arg1 >>> 0, arg2);
|
|
3677
|
+
},
|
|
3678
|
+
__wbg_beginRenderPass_8f60a9940800c223: function() { return handleError(function (arg0, arg1) {
|
|
3679
|
+
const ret = arg0.beginRenderPass(arg1);
|
|
3680
|
+
return ret;
|
|
3681
|
+
}, arguments); },
|
|
3682
|
+
__wbg_bindAttribLocation_0fe5da7e01ac0d15: function(arg0, arg1, arg2, arg3, arg4) {
|
|
3683
|
+
arg0.bindAttribLocation(arg1, arg2 >>> 0, getStringFromWasm0(arg3, arg4));
|
|
3684
|
+
},
|
|
3685
|
+
__wbg_bindAttribLocation_94202d7a59ab7863: function(arg0, arg1, arg2, arg3, arg4) {
|
|
3686
|
+
arg0.bindAttribLocation(arg1, arg2 >>> 0, getStringFromWasm0(arg3, arg4));
|
|
3687
|
+
},
|
|
3688
|
+
__wbg_bindBufferRange_f5c29912db0476e9: function(arg0, arg1, arg2, arg3, arg4, arg5) {
|
|
3689
|
+
arg0.bindBufferRange(arg1 >>> 0, arg2 >>> 0, arg3, arg4, arg5);
|
|
3690
|
+
},
|
|
3691
|
+
__wbg_bindBuffer_1e00cfb4321ef9a4: function(arg0, arg1, arg2) {
|
|
3692
|
+
arg0.bindBuffer(arg1 >>> 0, arg2);
|
|
3693
|
+
},
|
|
3694
|
+
__wbg_bindBuffer_a01497b1abdcdd9a: function(arg0, arg1, arg2) {
|
|
3695
|
+
arg0.bindBuffer(arg1 >>> 0, arg2);
|
|
3696
|
+
},
|
|
3697
|
+
__wbg_bindFramebuffer_390311eff3896937: function(arg0, arg1, arg2) {
|
|
3698
|
+
arg0.bindFramebuffer(arg1 >>> 0, arg2);
|
|
3699
|
+
},
|
|
3700
|
+
__wbg_bindFramebuffer_658e4b06f7ee8bb4: function(arg0, arg1, arg2) {
|
|
3701
|
+
arg0.bindFramebuffer(arg1 >>> 0, arg2);
|
|
3702
|
+
},
|
|
3703
|
+
__wbg_bindRenderbuffer_75e8469e930840fa: function(arg0, arg1, arg2) {
|
|
3704
|
+
arg0.bindRenderbuffer(arg1 >>> 0, arg2);
|
|
3705
|
+
},
|
|
3706
|
+
__wbg_bindRenderbuffer_c3d0c4b8cd1c3891: function(arg0, arg1, arg2) {
|
|
3707
|
+
arg0.bindRenderbuffer(arg1 >>> 0, arg2);
|
|
3708
|
+
},
|
|
3709
|
+
__wbg_bindSampler_ce608f0de9d31acf: function(arg0, arg1, arg2) {
|
|
3710
|
+
arg0.bindSampler(arg1 >>> 0, arg2);
|
|
3711
|
+
},
|
|
3712
|
+
__wbg_bindTexture_28eff4bbd8aaab54: function(arg0, arg1, arg2) {
|
|
3713
|
+
arg0.bindTexture(arg1 >>> 0, arg2);
|
|
3714
|
+
},
|
|
3715
|
+
__wbg_bindTexture_9b04b1b7c00d4dd6: function(arg0, arg1, arg2) {
|
|
3716
|
+
arg0.bindTexture(arg1 >>> 0, arg2);
|
|
3717
|
+
},
|
|
3718
|
+
__wbg_bindVertexArrayOES_5cad2205a17e8990: function(arg0, arg1) {
|
|
3719
|
+
arg0.bindVertexArrayOES(arg1);
|
|
3720
|
+
},
|
|
3721
|
+
__wbg_bindVertexArray_427eeac0c1764d8a: function(arg0, arg1) {
|
|
3722
|
+
arg0.bindVertexArray(arg1);
|
|
3723
|
+
},
|
|
3724
|
+
__wbg_blendColor_793b560dc69ddd0b: function(arg0, arg1, arg2, arg3, arg4) {
|
|
3725
|
+
arg0.blendColor(arg1, arg2, arg3, arg4);
|
|
3726
|
+
},
|
|
3727
|
+
__wbg_blendColor_eae0cd578a2c7d15: function(arg0, arg1, arg2, arg3, arg4) {
|
|
3728
|
+
arg0.blendColor(arg1, arg2, arg3, arg4);
|
|
3729
|
+
},
|
|
3730
|
+
__wbg_blendEquationSeparate_043e2f50f6ecb2d3: function(arg0, arg1, arg2) {
|
|
3731
|
+
arg0.blendEquationSeparate(arg1 >>> 0, arg2 >>> 0);
|
|
3732
|
+
},
|
|
3733
|
+
__wbg_blendEquationSeparate_c7e2b2261c94e1c5: function(arg0, arg1, arg2) {
|
|
3734
|
+
arg0.blendEquationSeparate(arg1 >>> 0, arg2 >>> 0);
|
|
3735
|
+
},
|
|
3736
|
+
__wbg_blendEquation_455b8986ededabc0: function(arg0, arg1) {
|
|
3737
|
+
arg0.blendEquation(arg1 >>> 0);
|
|
3738
|
+
},
|
|
3739
|
+
__wbg_blendEquation_f5c5272993f6cb01: function(arg0, arg1) {
|
|
3740
|
+
arg0.blendEquation(arg1 >>> 0);
|
|
3741
|
+
},
|
|
3742
|
+
__wbg_blendFuncSeparate_37156309688f8f88: function(arg0, arg1, arg2, arg3, arg4) {
|
|
3743
|
+
arg0.blendFuncSeparate(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4 >>> 0);
|
|
3744
|
+
},
|
|
3745
|
+
__wbg_blendFuncSeparate_3ee6d939a9f3938b: function(arg0, arg1, arg2, arg3, arg4) {
|
|
3746
|
+
arg0.blendFuncSeparate(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4 >>> 0);
|
|
3747
|
+
},
|
|
3748
|
+
__wbg_blendFunc_114dc7056ccfeb8d: function(arg0, arg1, arg2) {
|
|
3749
|
+
arg0.blendFunc(arg1 >>> 0, arg2 >>> 0);
|
|
3750
|
+
},
|
|
3751
|
+
__wbg_blendFunc_a854d7e4459150ba: function(arg0, arg1, arg2) {
|
|
3752
|
+
arg0.blendFunc(arg1 >>> 0, arg2 >>> 0);
|
|
3753
|
+
},
|
|
3754
|
+
__wbg_blitFramebuffer_a1215976f663b058: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) {
|
|
3755
|
+
arg0.blitFramebuffer(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 >>> 0, arg10 >>> 0);
|
|
3756
|
+
},
|
|
3757
|
+
__wbg_bufferData_073a7c6abef7a55f: function(arg0, arg1, arg2, arg3) {
|
|
3758
|
+
arg0.bufferData(arg1 >>> 0, arg2, arg3 >>> 0);
|
|
3759
|
+
},
|
|
3760
|
+
__wbg_bufferData_3d4f29bdfb1fa46c: function(arg0, arg1, arg2, arg3) {
|
|
3761
|
+
arg0.bufferData(arg1 >>> 0, arg2, arg3 >>> 0);
|
|
3762
|
+
},
|
|
3763
|
+
__wbg_bufferData_90ef588bac2be2f5: function(arg0, arg1, arg2, arg3) {
|
|
3764
|
+
arg0.bufferData(arg1 >>> 0, arg2, arg3 >>> 0);
|
|
3765
|
+
},
|
|
3766
|
+
__wbg_bufferData_ce4f44d56e9ddab5: function(arg0, arg1, arg2, arg3) {
|
|
3767
|
+
arg0.bufferData(arg1 >>> 0, arg2, arg3 >>> 0);
|
|
3768
|
+
},
|
|
3769
|
+
__wbg_bufferSubData_bae930b21e9c1c48: function(arg0, arg1, arg2, arg3) {
|
|
3770
|
+
arg0.bufferSubData(arg1 >>> 0, arg2, arg3);
|
|
3771
|
+
},
|
|
3772
|
+
__wbg_bufferSubData_ce9854d3d337e2cf: function(arg0, arg1, arg2, arg3) {
|
|
3773
|
+
arg0.bufferSubData(arg1 >>> 0, arg2, arg3);
|
|
3774
|
+
},
|
|
3775
|
+
__wbg_buffer_54b87055582c8a81: function(arg0) {
|
|
3776
|
+
const ret = arg0.buffer;
|
|
3777
|
+
return ret;
|
|
3778
|
+
},
|
|
3779
|
+
__wbg_call_a6e5c5dce5018821: function() { return handleError(function (arg0, arg1, arg2) {
|
|
3780
|
+
const ret = arg0.call(arg1, arg2);
|
|
3781
|
+
return ret;
|
|
3782
|
+
}, arguments); },
|
|
3783
|
+
__wbg_canvas3d_new: function(arg0) {
|
|
3784
|
+
const ret = Canvas3D.__wrap(arg0);
|
|
3785
|
+
return ret;
|
|
3786
|
+
},
|
|
3787
|
+
__wbg_clearBuffer_5c4f30438f07155a: function(arg0, arg1, arg2, arg3) {
|
|
3788
|
+
arg0.clearBuffer(arg1, arg2, arg3);
|
|
3789
|
+
},
|
|
3790
|
+
__wbg_clearBuffer_de7e8cd418b56c30: function(arg0, arg1, arg2) {
|
|
3791
|
+
arg0.clearBuffer(arg1, arg2);
|
|
3792
|
+
},
|
|
3793
|
+
__wbg_clearBufferfv_2e0f1a0ea56de859: function(arg0, arg1, arg2, arg3, arg4) {
|
|
3794
|
+
arg0.clearBufferfv(arg1 >>> 0, arg2, getArrayF32FromWasm0(arg3, arg4));
|
|
3795
|
+
},
|
|
3796
|
+
__wbg_clearBufferiv_0360269bf6e34c54: function(arg0, arg1, arg2, arg3, arg4) {
|
|
3797
|
+
arg0.clearBufferiv(arg1 >>> 0, arg2, getArrayI32FromWasm0(arg3, arg4));
|
|
3798
|
+
},
|
|
3799
|
+
__wbg_clearBufferuiv_df94a395d4915377: function(arg0, arg1, arg2, arg3, arg4) {
|
|
3800
|
+
arg0.clearBufferuiv(arg1 >>> 0, arg2, getArrayU32FromWasm0(arg3, arg4));
|
|
3801
|
+
},
|
|
3802
|
+
__wbg_clearDepth_8b5d226aae155082: function(arg0, arg1) {
|
|
3803
|
+
arg0.clearDepth(arg1);
|
|
3804
|
+
},
|
|
3805
|
+
__wbg_clearDepth_ca9b22d41551b513: function(arg0, arg1) {
|
|
3806
|
+
arg0.clearDepth(arg1);
|
|
3807
|
+
},
|
|
3808
|
+
__wbg_clearStencil_58f2af46612bccae: function(arg0, arg1) {
|
|
3809
|
+
arg0.clearStencil(arg1);
|
|
3810
|
+
},
|
|
3811
|
+
__wbg_clearStencil_a66fe23df6313fc7: function(arg0, arg1) {
|
|
3812
|
+
arg0.clearStencil(arg1);
|
|
3813
|
+
},
|
|
3814
|
+
__wbg_clear_53d71d234e14e4c1: function(arg0, arg1) {
|
|
3815
|
+
arg0.clear(arg1 >>> 0);
|
|
3816
|
+
},
|
|
3817
|
+
__wbg_clear_dd06a0da4ce8e13f: function(arg0, arg1) {
|
|
3818
|
+
arg0.clear(arg1 >>> 0);
|
|
3819
|
+
},
|
|
3820
|
+
__wbg_clientWaitSync_cf8e49f8ba228377: function(arg0, arg1, arg2, arg3) {
|
|
3821
|
+
const ret = arg0.clientWaitSync(arg1, arg2 >>> 0, arg3 >>> 0);
|
|
3822
|
+
return ret;
|
|
3823
|
+
},
|
|
3824
|
+
__wbg_colorMask_44ebb91cad2502f2: function(arg0, arg1, arg2, arg3, arg4) {
|
|
3825
|
+
arg0.colorMask(arg1 !== 0, arg2 !== 0, arg3 !== 0, arg4 !== 0);
|
|
3826
|
+
},
|
|
3827
|
+
__wbg_colorMask_a4d164c2039b5731: function(arg0, arg1, arg2, arg3, arg4) {
|
|
3828
|
+
arg0.colorMask(arg1 !== 0, arg2 !== 0, arg3 !== 0, arg4 !== 0);
|
|
3829
|
+
},
|
|
3830
|
+
__wbg_compileShader_9bdfd792722cf704: function(arg0, arg1) {
|
|
3831
|
+
arg0.compileShader(arg1);
|
|
3832
|
+
},
|
|
3833
|
+
__wbg_compileShader_fc2e4b73240d4fd7: function(arg0, arg1) {
|
|
3834
|
+
arg0.compileShader(arg1);
|
|
3835
|
+
},
|
|
3836
|
+
__wbg_compressedTexSubImage2D_c1362291573c7268: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
|
|
3837
|
+
arg0.compressedTexSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8, arg9);
|
|
3838
|
+
},
|
|
3839
|
+
__wbg_compressedTexSubImage2D_da01674d2975d1ae: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) {
|
|
3840
|
+
arg0.compressedTexSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8);
|
|
3841
|
+
},
|
|
3842
|
+
__wbg_compressedTexSubImage2D_dd6dc580749eb5cf: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) {
|
|
3843
|
+
arg0.compressedTexSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8);
|
|
3844
|
+
},
|
|
3845
|
+
__wbg_compressedTexSubImage3D_04cb8b046c4321fe: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) {
|
|
3846
|
+
arg0.compressedTexSubImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 >>> 0, arg10, arg11);
|
|
3847
|
+
},
|
|
3848
|
+
__wbg_compressedTexSubImage3D_af0228a80ffd5993: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) {
|
|
3849
|
+
arg0.compressedTexSubImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 >>> 0, arg10);
|
|
3850
|
+
},
|
|
3851
|
+
__wbg_configure_6e4ddb3faabc6005: function() { return handleError(function (arg0, arg1) {
|
|
3852
|
+
arg0.configure(arg1);
|
|
3853
|
+
}, arguments); },
|
|
3854
|
+
__wbg_copyBufferSubData_cdf61f74aa6e0902: function(arg0, arg1, arg2, arg3, arg4, arg5) {
|
|
3855
|
+
arg0.copyBufferSubData(arg1 >>> 0, arg2 >>> 0, arg3, arg4, arg5);
|
|
3856
|
+
},
|
|
3857
|
+
__wbg_copyBufferToBuffer_55e9540007aef863: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
|
|
3858
|
+
arg0.copyBufferToBuffer(arg1, arg2, arg3, arg4);
|
|
3859
|
+
}, arguments); },
|
|
3860
|
+
__wbg_copyBufferToBuffer_7adcb79ef87447dc: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
|
|
3861
|
+
arg0.copyBufferToBuffer(arg1, arg2, arg3, arg4, arg5);
|
|
3862
|
+
}, arguments); },
|
|
3863
|
+
__wbg_copyBufferToTexture_f0fc6311345a3dea: function() { return handleError(function (arg0, arg1, arg2, arg3) {
|
|
3864
|
+
arg0.copyBufferToTexture(arg1, arg2, arg3);
|
|
3865
|
+
}, arguments); },
|
|
3866
|
+
__wbg_copyTexSubImage2D_8daea651fc408645: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) {
|
|
3867
|
+
arg0.copyTexSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
|
|
3868
|
+
},
|
|
3869
|
+
__wbg_copyTexSubImage2D_c73f91f1d7022402: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) {
|
|
3870
|
+
arg0.copyTexSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
|
|
3871
|
+
},
|
|
3872
|
+
__wbg_copyTexSubImage3D_bfe7a14dac9ad777: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
|
|
3873
|
+
arg0.copyTexSubImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
|
|
3874
|
+
},
|
|
3875
|
+
__wbg_copyTextureToBuffer_09ba100a04b1b001: function() { return handleError(function (arg0, arg1, arg2, arg3) {
|
|
3876
|
+
arg0.copyTextureToBuffer(arg1, arg2, arg3);
|
|
3877
|
+
}, arguments); },
|
|
3878
|
+
__wbg_copyTextureToTexture_66ab51b863dec546: function() { return handleError(function (arg0, arg1, arg2, arg3) {
|
|
3879
|
+
arg0.copyTextureToTexture(arg1, arg2, arg3);
|
|
3880
|
+
}, arguments); },
|
|
3881
|
+
__wbg_createBindGroupLayout_1dad97f44fda2929: function() { return handleError(function (arg0, arg1) {
|
|
3882
|
+
const ret = arg0.createBindGroupLayout(arg1);
|
|
3883
|
+
return ret;
|
|
3884
|
+
}, arguments); },
|
|
3885
|
+
__wbg_createBindGroup_0ee0646375643dfb: function(arg0, arg1) {
|
|
3886
|
+
const ret = arg0.createBindGroup(arg1);
|
|
3887
|
+
return ret;
|
|
3888
|
+
},
|
|
3889
|
+
__wbg_createBuffer_01568a9d930d90dd: function(arg0) {
|
|
3890
|
+
const ret = arg0.createBuffer();
|
|
3891
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
3892
|
+
},
|
|
3893
|
+
__wbg_createBuffer_2075765bde5035d5: function(arg0) {
|
|
3894
|
+
const ret = arg0.createBuffer();
|
|
3895
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
3896
|
+
},
|
|
3897
|
+
__wbg_createBuffer_474baee88e74f68a: function() { return handleError(function (arg0, arg1) {
|
|
3898
|
+
const ret = arg0.createBuffer(arg1);
|
|
3899
|
+
return ret;
|
|
3900
|
+
}, arguments); },
|
|
3901
|
+
__wbg_createCommandEncoder_5229e112300218b4: function(arg0, arg1) {
|
|
3902
|
+
const ret = arg0.createCommandEncoder(arg1);
|
|
3903
|
+
return ret;
|
|
3904
|
+
},
|
|
3905
|
+
__wbg_createComputePipeline_1cd8bf7e02a1a06d: function(arg0, arg1) {
|
|
3906
|
+
const ret = arg0.createComputePipeline(arg1);
|
|
3907
|
+
return ret;
|
|
3908
|
+
},
|
|
3909
|
+
__wbg_createFramebuffer_b24d2c80a8b9e7cc: function(arg0) {
|
|
3910
|
+
const ret = arg0.createFramebuffer();
|
|
3911
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
3912
|
+
},
|
|
3913
|
+
__wbg_createFramebuffer_de0d521f546e7534: function(arg0) {
|
|
3914
|
+
const ret = arg0.createFramebuffer();
|
|
3915
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
3916
|
+
},
|
|
3917
|
+
__wbg_createPipelineLayout_bf0deba7918ca157: function(arg0, arg1) {
|
|
3918
|
+
const ret = arg0.createPipelineLayout(arg1);
|
|
3919
|
+
return ret;
|
|
3920
|
+
},
|
|
3921
|
+
__wbg_createProgram_118becaac3a20318: function(arg0) {
|
|
3922
|
+
const ret = arg0.createProgram();
|
|
3923
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
3924
|
+
},
|
|
3925
|
+
__wbg_createProgram_538c9777a4ac084f: function(arg0) {
|
|
3926
|
+
const ret = arg0.createProgram();
|
|
3927
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
3928
|
+
},
|
|
3929
|
+
__wbg_createQuerySet_595e31c333f5e833: function() { return handleError(function (arg0, arg1) {
|
|
3930
|
+
const ret = arg0.createQuerySet(arg1);
|
|
3931
|
+
return ret;
|
|
3932
|
+
}, arguments); },
|
|
3933
|
+
__wbg_createQuery_047c7c524e4ac4f8: function(arg0) {
|
|
3934
|
+
const ret = arg0.createQuery();
|
|
3935
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
3936
|
+
},
|
|
3937
|
+
__wbg_createRenderPipeline_7baf812b1e7e39e8: function() { return handleError(function (arg0, arg1) {
|
|
3938
|
+
const ret = arg0.createRenderPipeline(arg1);
|
|
3939
|
+
return ret;
|
|
3940
|
+
}, arguments); },
|
|
3941
|
+
__wbg_createRenderbuffer_71af5c0d615e9271: function(arg0) {
|
|
3942
|
+
const ret = arg0.createRenderbuffer();
|
|
3943
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
3944
|
+
},
|
|
3945
|
+
__wbg_createRenderbuffer_9d801bf44c314f44: function(arg0) {
|
|
3946
|
+
const ret = arg0.createRenderbuffer();
|
|
3947
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
3948
|
+
},
|
|
3949
|
+
__wbg_createSampler_5970d585f322df95: function(arg0, arg1) {
|
|
3950
|
+
const ret = arg0.createSampler(arg1);
|
|
3951
|
+
return ret;
|
|
3952
|
+
},
|
|
3953
|
+
__wbg_createSampler_70c8392d98896235: function(arg0) {
|
|
3954
|
+
const ret = arg0.createSampler();
|
|
3955
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
3956
|
+
},
|
|
3957
|
+
__wbg_createShaderModule_744311a1dd685c14: function(arg0, arg1) {
|
|
3958
|
+
const ret = arg0.createShaderModule(arg1);
|
|
3959
|
+
return ret;
|
|
3960
|
+
},
|
|
3961
|
+
__wbg_createShader_78bc8b7e9a88e1a8: function(arg0, arg1) {
|
|
3962
|
+
const ret = arg0.createShader(arg1 >>> 0);
|
|
3963
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
3964
|
+
},
|
|
3965
|
+
__wbg_createShader_7d139f2d50f77365: function(arg0, arg1) {
|
|
3966
|
+
const ret = arg0.createShader(arg1 >>> 0);
|
|
3967
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
3968
|
+
},
|
|
3969
|
+
__wbg_createTexture_0ee0fa5f924f3d14: function(arg0) {
|
|
3970
|
+
const ret = arg0.createTexture();
|
|
3971
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
3972
|
+
},
|
|
3973
|
+
__wbg_createTexture_d13f98e0d3d912f4: function(arg0) {
|
|
3974
|
+
const ret = arg0.createTexture();
|
|
3975
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
3976
|
+
},
|
|
3977
|
+
__wbg_createTexture_f357c38256411287: function() { return handleError(function (arg0, arg1) {
|
|
3978
|
+
const ret = arg0.createTexture(arg1);
|
|
3979
|
+
return ret;
|
|
3980
|
+
}, arguments); },
|
|
3981
|
+
__wbg_createVertexArrayOES_2fa3e59eebd5f674: function(arg0) {
|
|
3982
|
+
const ret = arg0.createVertexArrayOES();
|
|
3983
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
3984
|
+
},
|
|
3985
|
+
__wbg_createVertexArray_baf9eef7ea5a2c7a: function(arg0) {
|
|
3986
|
+
const ret = arg0.createVertexArray();
|
|
3987
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
3988
|
+
},
|
|
3989
|
+
__wbg_createView_e7a36ec95c4190f3: function() { return handleError(function (arg0, arg1) {
|
|
3990
|
+
const ret = arg0.createView(arg1);
|
|
3991
|
+
return ret;
|
|
3992
|
+
}, arguments); },
|
|
3993
|
+
__wbg_crypto_38df2bab126b63dc: function(arg0) {
|
|
3994
|
+
const ret = arg0.crypto;
|
|
3995
|
+
return ret;
|
|
3996
|
+
},
|
|
3997
|
+
__wbg_cullFace_62bbea3bef0e6b99: function(arg0, arg1) {
|
|
3998
|
+
arg0.cullFace(arg1 >>> 0);
|
|
3999
|
+
},
|
|
4000
|
+
__wbg_cullFace_f1c75ae19b07eaf3: function(arg0, arg1) {
|
|
4001
|
+
arg0.cullFace(arg1 >>> 0);
|
|
4002
|
+
},
|
|
4003
|
+
__wbg_deleteBuffer_08eb938e35c27967: function(arg0, arg1) {
|
|
4004
|
+
arg0.deleteBuffer(arg1);
|
|
4005
|
+
},
|
|
4006
|
+
__wbg_deleteBuffer_1ca3ffe668a488e7: function(arg0, arg1) {
|
|
4007
|
+
arg0.deleteBuffer(arg1);
|
|
4008
|
+
},
|
|
4009
|
+
__wbg_deleteFramebuffer_963cd69957209d37: function(arg0, arg1) {
|
|
4010
|
+
arg0.deleteFramebuffer(arg1);
|
|
4011
|
+
},
|
|
4012
|
+
__wbg_deleteFramebuffer_d1a36e889b009344: function(arg0, arg1) {
|
|
4013
|
+
arg0.deleteFramebuffer(arg1);
|
|
4014
|
+
},
|
|
4015
|
+
__wbg_deleteProgram_09bd45a51105b2f6: function(arg0, arg1) {
|
|
4016
|
+
arg0.deleteProgram(arg1);
|
|
4017
|
+
},
|
|
4018
|
+
__wbg_deleteProgram_132e191baa9fa84f: function(arg0, arg1) {
|
|
4019
|
+
arg0.deleteProgram(arg1);
|
|
4020
|
+
},
|
|
4021
|
+
__wbg_deleteQuery_0d1dcc4402a86ee1: function(arg0, arg1) {
|
|
4022
|
+
arg0.deleteQuery(arg1);
|
|
4023
|
+
},
|
|
4024
|
+
__wbg_deleteRenderbuffer_52bdbf5ab2cbe62a: function(arg0, arg1) {
|
|
4025
|
+
arg0.deleteRenderbuffer(arg1);
|
|
4026
|
+
},
|
|
4027
|
+
__wbg_deleteRenderbuffer_ca999f7883b777af: function(arg0, arg1) {
|
|
4028
|
+
arg0.deleteRenderbuffer(arg1);
|
|
4029
|
+
},
|
|
4030
|
+
__wbg_deleteSampler_0abb528566c4ab3b: function(arg0, arg1) {
|
|
4031
|
+
arg0.deleteSampler(arg1);
|
|
4032
|
+
},
|
|
4033
|
+
__wbg_deleteShader_3120790d36063afe: function(arg0, arg1) {
|
|
4034
|
+
arg0.deleteShader(arg1);
|
|
4035
|
+
},
|
|
4036
|
+
__wbg_deleteShader_993edb4beb3c4d53: function(arg0, arg1) {
|
|
4037
|
+
arg0.deleteShader(arg1);
|
|
4038
|
+
},
|
|
4039
|
+
__wbg_deleteSync_9b0e43580942a0f6: function(arg0, arg1) {
|
|
4040
|
+
arg0.deleteSync(arg1);
|
|
4041
|
+
},
|
|
4042
|
+
__wbg_deleteTexture_2b163b157ea1be24: function(arg0, arg1) {
|
|
4043
|
+
arg0.deleteTexture(arg1);
|
|
4044
|
+
},
|
|
4045
|
+
__wbg_deleteTexture_bdc2202d7a50dcea: function(arg0, arg1) {
|
|
4046
|
+
arg0.deleteTexture(arg1);
|
|
4047
|
+
},
|
|
4048
|
+
__wbg_deleteVertexArrayOES_7fa59c32cfdfa6fa: function(arg0, arg1) {
|
|
4049
|
+
arg0.deleteVertexArrayOES(arg1);
|
|
4050
|
+
},
|
|
4051
|
+
__wbg_deleteVertexArray_475d4e969aac1dd0: function(arg0, arg1) {
|
|
4052
|
+
arg0.deleteVertexArray(arg1);
|
|
4053
|
+
},
|
|
4054
|
+
__wbg_depthFunc_455cfeb8a9d2fb4c: function(arg0, arg1) {
|
|
4055
|
+
arg0.depthFunc(arg1 >>> 0);
|
|
4056
|
+
},
|
|
4057
|
+
__wbg_depthFunc_74a8f8acf8973c86: function(arg0, arg1) {
|
|
4058
|
+
arg0.depthFunc(arg1 >>> 0);
|
|
4059
|
+
},
|
|
4060
|
+
__wbg_depthMask_4bd6c73b1339d257: function(arg0, arg1) {
|
|
4061
|
+
arg0.depthMask(arg1 !== 0);
|
|
4062
|
+
},
|
|
4063
|
+
__wbg_depthMask_a644a67deced3257: function(arg0, arg1) {
|
|
4064
|
+
arg0.depthMask(arg1 !== 0);
|
|
4065
|
+
},
|
|
4066
|
+
__wbg_depthRange_38b2287ffbea14fd: function(arg0, arg1, arg2) {
|
|
4067
|
+
arg0.depthRange(arg1, arg2);
|
|
4068
|
+
},
|
|
4069
|
+
__wbg_depthRange_5e90d4d236280ff5: function(arg0, arg1, arg2) {
|
|
4070
|
+
arg0.depthRange(arg1, arg2);
|
|
4071
|
+
},
|
|
4072
|
+
__wbg_destroy_5c2c9c8b0b52b456: function(arg0) {
|
|
4073
|
+
arg0.destroy();
|
|
4074
|
+
},
|
|
4075
|
+
__wbg_destroy_8a3f7d0f7c49852f: function(arg0) {
|
|
4076
|
+
arg0.destroy();
|
|
4077
|
+
},
|
|
4078
|
+
__wbg_disableVertexAttribArray_160060fbd7e97de0: function(arg0, arg1) {
|
|
4079
|
+
arg0.disableVertexAttribArray(arg1 >>> 0);
|
|
4080
|
+
},
|
|
4081
|
+
__wbg_disableVertexAttribArray_c7915eb0de6dd8f1: function(arg0, arg1) {
|
|
4082
|
+
arg0.disableVertexAttribArray(arg1 >>> 0);
|
|
4083
|
+
},
|
|
4084
|
+
__wbg_disable_1659d1b7d50c31e7: function(arg0, arg1) {
|
|
4085
|
+
arg0.disable(arg1 >>> 0);
|
|
4086
|
+
},
|
|
4087
|
+
__wbg_disable_40c3975167c1ee07: function(arg0, arg1) {
|
|
4088
|
+
arg0.disable(arg1 >>> 0);
|
|
4089
|
+
},
|
|
4090
|
+
__wbg_dispatchWorkgroups_727fa35f9c69d73c: function(arg0, arg1, arg2, arg3) {
|
|
4091
|
+
arg0.dispatchWorkgroups(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0);
|
|
4092
|
+
},
|
|
4093
|
+
__wbg_document_179650d6cb13c263: function(arg0) {
|
|
4094
|
+
const ret = arg0.document;
|
|
4095
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
4096
|
+
},
|
|
4097
|
+
__wbg_drawArraysInstancedANGLE_d58dbd2d38fdebaa: function(arg0, arg1, arg2, arg3, arg4) {
|
|
4098
|
+
arg0.drawArraysInstancedANGLE(arg1 >>> 0, arg2, arg3, arg4);
|
|
4099
|
+
},
|
|
4100
|
+
__wbg_drawArraysInstanced_51b161548a3f10c4: function(arg0, arg1, arg2, arg3, arg4) {
|
|
4101
|
+
arg0.drawArraysInstanced(arg1 >>> 0, arg2, arg3, arg4);
|
|
4102
|
+
},
|
|
4103
|
+
__wbg_drawArrays_676becae0149ed65: function(arg0, arg1, arg2, arg3) {
|
|
4104
|
+
arg0.drawArrays(arg1 >>> 0, arg2, arg3);
|
|
4105
|
+
},
|
|
4106
|
+
__wbg_drawArrays_b0c59a6e158122f2: function(arg0, arg1, arg2, arg3) {
|
|
4107
|
+
arg0.drawArrays(arg1 >>> 0, arg2, arg3);
|
|
4108
|
+
},
|
|
4109
|
+
__wbg_drawBuffersWEBGL_c9b47f7f207125cf: function(arg0, arg1) {
|
|
4110
|
+
arg0.drawBuffersWEBGL(arg1);
|
|
4111
|
+
},
|
|
4112
|
+
__wbg_drawBuffers_1c1ec9b292442a2a: function(arg0, arg1) {
|
|
4113
|
+
arg0.drawBuffers(arg1);
|
|
4114
|
+
},
|
|
4115
|
+
__wbg_drawElementsInstancedANGLE_9b58c4013373b180: function(arg0, arg1, arg2, arg3, arg4, arg5) {
|
|
4116
|
+
arg0.drawElementsInstancedANGLE(arg1 >>> 0, arg2, arg3 >>> 0, arg4, arg5);
|
|
4117
|
+
},
|
|
4118
|
+
__wbg_drawElementsInstanced_c7f96ea02e6d5326: function(arg0, arg1, arg2, arg3, arg4, arg5) {
|
|
4119
|
+
arg0.drawElementsInstanced(arg1 >>> 0, arg2, arg3 >>> 0, arg4, arg5);
|
|
4120
|
+
},
|
|
4121
|
+
__wbg_drawIndexed_2ab8259f769f352d: function(arg0, arg1, arg2, arg3, arg4, arg5) {
|
|
4122
|
+
arg0.drawIndexed(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4, arg5 >>> 0);
|
|
4123
|
+
},
|
|
4124
|
+
__wbg_draw_b93abd56938fa3b6: function(arg0, arg1, arg2, arg3, arg4) {
|
|
4125
|
+
arg0.draw(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4 >>> 0);
|
|
4126
|
+
},
|
|
4127
|
+
__wbg_enableVertexAttribArray_4c08219124740f14: function(arg0, arg1) {
|
|
4128
|
+
arg0.enableVertexAttribArray(arg1 >>> 0);
|
|
4129
|
+
},
|
|
4130
|
+
__wbg_enableVertexAttribArray_7470ba2dcf2606e3: function(arg0, arg1) {
|
|
4131
|
+
arg0.enableVertexAttribArray(arg1 >>> 0);
|
|
4132
|
+
},
|
|
4133
|
+
__wbg_enable_28bbeed576131d1f: function(arg0, arg1) {
|
|
4134
|
+
arg0.enable(arg1 >>> 0);
|
|
4135
|
+
},
|
|
4136
|
+
__wbg_enable_611804c0ac1504ce: function(arg0, arg1) {
|
|
4137
|
+
arg0.enable(arg1 >>> 0);
|
|
4138
|
+
},
|
|
4139
|
+
__wbg_endQuery_a50f7fc49cfe56e9: function(arg0, arg1) {
|
|
4140
|
+
arg0.endQuery(arg1 >>> 0);
|
|
4141
|
+
},
|
|
4142
|
+
__wbg_end_2398df10208cf1ee: function(arg0) {
|
|
4143
|
+
arg0.end();
|
|
4144
|
+
},
|
|
4145
|
+
__wbg_end_2fdce848e1c526bc: function(arg0) {
|
|
4146
|
+
arg0.end();
|
|
4147
|
+
},
|
|
4148
|
+
__wbg_error_96e899f14d8344a2: function(arg0, arg1) {
|
|
4149
|
+
console.error(getStringFromWasm0(arg0, arg1));
|
|
4150
|
+
},
|
|
4151
|
+
__wbg_features_139b41635cafee99: function(arg0) {
|
|
4152
|
+
const ret = arg0.features;
|
|
4153
|
+
return ret;
|
|
4154
|
+
},
|
|
4155
|
+
__wbg_features_3fa0fe4fc37163a7: function(arg0) {
|
|
4156
|
+
const ret = arg0.features;
|
|
4157
|
+
return ret;
|
|
4158
|
+
},
|
|
4159
|
+
__wbg_fenceSync_fe2cdba4a0d73679: function(arg0, arg1, arg2) {
|
|
4160
|
+
const ret = arg0.fenceSync(arg1 >>> 0, arg2 >>> 0);
|
|
4161
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
4162
|
+
},
|
|
4163
|
+
__wbg_fetch_58167e2c1ef32e0a: function(arg0, arg1, arg2) {
|
|
4164
|
+
const ret = arg0.fetch(getStringFromWasm0(arg1, arg2));
|
|
4165
|
+
return ret;
|
|
4166
|
+
},
|
|
4167
|
+
__wbg_finish_7370ad1c0e62b448: function(arg0) {
|
|
4168
|
+
const ret = arg0.finish();
|
|
4169
|
+
return ret;
|
|
4170
|
+
},
|
|
4171
|
+
__wbg_finish_797b32d15bab2338: function(arg0, arg1) {
|
|
4172
|
+
const ret = arg0.finish(arg1);
|
|
4173
|
+
return ret;
|
|
4174
|
+
},
|
|
4175
|
+
__wbg_flush_db77b4a63d6b337d: function(arg0) {
|
|
4176
|
+
arg0.flush();
|
|
4177
|
+
},
|
|
4178
|
+
__wbg_flush_e03c08da6863b5ab: function(arg0) {
|
|
4179
|
+
arg0.flush();
|
|
4180
|
+
},
|
|
4181
|
+
__wbg_framebufferRenderbuffer_4404cf9f9cb76937: function(arg0, arg1, arg2, arg3, arg4) {
|
|
4182
|
+
arg0.framebufferRenderbuffer(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4);
|
|
4183
|
+
},
|
|
4184
|
+
__wbg_framebufferRenderbuffer_ba8bd5e008ee87eb: function(arg0, arg1, arg2, arg3, arg4) {
|
|
4185
|
+
arg0.framebufferRenderbuffer(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4);
|
|
4186
|
+
},
|
|
4187
|
+
__wbg_framebufferTexture2D_3c2abd606fc53f31: function(arg0, arg1, arg2, arg3, arg4, arg5) {
|
|
4188
|
+
arg0.framebufferTexture2D(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4, arg5);
|
|
4189
|
+
},
|
|
4190
|
+
__wbg_framebufferTexture2D_e1fb64212fcda219: function(arg0, arg1, arg2, arg3, arg4, arg5) {
|
|
4191
|
+
arg0.framebufferTexture2D(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4, arg5);
|
|
4192
|
+
},
|
|
4193
|
+
__wbg_framebufferTextureLayer_f2d9db097bfbb863: function(arg0, arg1, arg2, arg3, arg4, arg5) {
|
|
4194
|
+
arg0.framebufferTextureLayer(arg1 >>> 0, arg2 >>> 0, arg3, arg4, arg5);
|
|
4195
|
+
},
|
|
4196
|
+
__wbg_framebufferTextureMultiviewOVR_28d492b9dc484220: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
|
|
4197
|
+
arg0.framebufferTextureMultiviewOVR(arg1 >>> 0, arg2 >>> 0, arg3, arg4, arg5, arg6);
|
|
4198
|
+
},
|
|
4199
|
+
__wbg_frontFace_29ef7151de8b5ed9: function(arg0, arg1) {
|
|
4200
|
+
arg0.frontFace(arg1 >>> 0);
|
|
4201
|
+
},
|
|
4202
|
+
__wbg_frontFace_fc6d98dafa42de87: function(arg0, arg1) {
|
|
4203
|
+
arg0.frontFace(arg1 >>> 0);
|
|
4204
|
+
},
|
|
4205
|
+
__wbg_getBindGroupLayout_0b3b7dd9f45e8e19: function(arg0, arg1) {
|
|
4206
|
+
const ret = arg0.getBindGroupLayout(arg1 >>> 0);
|
|
4207
|
+
return ret;
|
|
4208
|
+
},
|
|
4209
|
+
__wbg_getBindGroupLayout_9fc232d022bf8cca: function(arg0, arg1) {
|
|
4210
|
+
const ret = arg0.getBindGroupLayout(arg1 >>> 0);
|
|
4211
|
+
return ret;
|
|
4212
|
+
},
|
|
4213
|
+
__wbg_getBufferSubData_11018928c908ac2c: function(arg0, arg1, arg2, arg3) {
|
|
4214
|
+
arg0.getBufferSubData(arg1 >>> 0, arg2, arg3);
|
|
4215
|
+
},
|
|
4216
|
+
__wbg_getContext_7476e39fa008047e: function() { return handleError(function (arg0, arg1, arg2, arg3) {
|
|
4217
|
+
const ret = arg0.getContext(getStringFromWasm0(arg1, arg2), arg3);
|
|
4218
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
4219
|
+
}, arguments); },
|
|
4220
|
+
__wbg_getContext_ca12bb65aab778a4: function() { return handleError(function (arg0, arg1, arg2, arg3) {
|
|
4221
|
+
const ret = arg0.getContext(getStringFromWasm0(arg1, arg2), arg3);
|
|
4222
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
4223
|
+
}, arguments); },
|
|
4224
|
+
__wbg_getContext_e79ddf6a9cb3cc76: function() { return handleError(function (arg0, arg1, arg2) {
|
|
4225
|
+
const ret = arg0.getContext(getStringFromWasm0(arg1, arg2));
|
|
4226
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
4227
|
+
}, arguments); },
|
|
4228
|
+
__wbg_getContext_fd298c901058eb31: function() { return handleError(function (arg0, arg1, arg2) {
|
|
4229
|
+
const ret = arg0.getContext(getStringFromWasm0(arg1, arg2));
|
|
4230
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
4231
|
+
}, arguments); },
|
|
4232
|
+
__wbg_getCurrentTexture_628ddb7c08d25190: function() { return handleError(function (arg0) {
|
|
4233
|
+
const ret = arg0.getCurrentTexture();
|
|
4234
|
+
return ret;
|
|
4235
|
+
}, arguments); },
|
|
4236
|
+
__wbg_getDate_a1a40c1c5f40fe3b: function(arg0) {
|
|
4237
|
+
const ret = arg0.getDate();
|
|
4238
|
+
return ret;
|
|
4239
|
+
},
|
|
4240
|
+
__wbg_getDay_aa318cce5da74c49: function(arg0) {
|
|
4241
|
+
const ret = arg0.getDay();
|
|
4242
|
+
return ret;
|
|
4243
|
+
},
|
|
4244
|
+
__wbg_getExtension_101c7e41de3e4d90: function() { return handleError(function (arg0, arg1, arg2) {
|
|
4245
|
+
const ret = arg0.getExtension(getStringFromWasm0(arg1, arg2));
|
|
4246
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
4247
|
+
}, arguments); },
|
|
4248
|
+
__wbg_getFullYear_6af8b229792ae254: function(arg0) {
|
|
4249
|
+
const ret = arg0.getFullYear();
|
|
4250
|
+
return ret;
|
|
4251
|
+
},
|
|
4252
|
+
__wbg_getHours_9f6561095682ce51: function(arg0) {
|
|
4253
|
+
const ret = arg0.getHours();
|
|
4254
|
+
return ret;
|
|
4255
|
+
},
|
|
4256
|
+
__wbg_getIndexedParameter_6d7a5bcccaa0f3e2: function() { return handleError(function (arg0, arg1, arg2) {
|
|
4257
|
+
const ret = arg0.getIndexedParameter(arg1 >>> 0, arg2 >>> 0);
|
|
4258
|
+
return ret;
|
|
4259
|
+
}, arguments); },
|
|
4260
|
+
__wbg_getMappedRange_9f13d158ba3946fd: function() { return handleError(function (arg0, arg1, arg2) {
|
|
4261
|
+
const ret = arg0.getMappedRange(arg1, arg2);
|
|
4262
|
+
return ret;
|
|
4263
|
+
}, arguments); },
|
|
4264
|
+
__wbg_getMinutes_b0d5cd90bf9b8f22: function(arg0) {
|
|
4265
|
+
const ret = arg0.getMinutes();
|
|
4266
|
+
return ret;
|
|
4267
|
+
},
|
|
4268
|
+
__wbg_getMonth_fffe29d654d5eb69: function(arg0) {
|
|
4269
|
+
const ret = arg0.getMonth();
|
|
4270
|
+
return ret;
|
|
4271
|
+
},
|
|
4272
|
+
__wbg_getParameter_039a5899307fab55: function() { return handleError(function (arg0, arg1) {
|
|
4273
|
+
const ret = arg0.getParameter(arg1 >>> 0);
|
|
4274
|
+
return ret;
|
|
4275
|
+
}, arguments); },
|
|
4276
|
+
__wbg_getParameter_d39f59581389af1b: function() { return handleError(function (arg0, arg1) {
|
|
4277
|
+
const ret = arg0.getParameter(arg1 >>> 0);
|
|
4278
|
+
return ret;
|
|
4279
|
+
}, arguments); },
|
|
4280
|
+
__wbg_getPreferredCanvasFormat_a2b6306e828c2f60: function(arg0) {
|
|
4281
|
+
const ret = arg0.getPreferredCanvasFormat();
|
|
4282
|
+
return (__wbindgen_enum_GpuTextureFormat.indexOf(ret) + 1 || 96) - 1;
|
|
4283
|
+
},
|
|
4284
|
+
__wbg_getProgramInfoLog_c4762e0513468a26: function(arg0, arg1, arg2) {
|
|
4285
|
+
const ret = arg1.getProgramInfoLog(arg2);
|
|
4286
|
+
var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
4287
|
+
var len1 = WASM_VECTOR_LEN;
|
|
4288
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
4289
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
4290
|
+
},
|
|
4291
|
+
__wbg_getProgramInfoLog_d1ce570463a68779: function(arg0, arg1, arg2) {
|
|
4292
|
+
const ret = arg1.getProgramInfoLog(arg2);
|
|
4293
|
+
var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
4294
|
+
var len1 = WASM_VECTOR_LEN;
|
|
4295
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
4296
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
4297
|
+
},
|
|
4298
|
+
__wbg_getProgramParameter_b9995b56c258ac86: function(arg0, arg1, arg2) {
|
|
4299
|
+
const ret = arg0.getProgramParameter(arg1, arg2 >>> 0);
|
|
4300
|
+
return ret;
|
|
4301
|
+
},
|
|
4302
|
+
__wbg_getProgramParameter_c8d1154fbb3c0890: function(arg0, arg1, arg2) {
|
|
4303
|
+
const ret = arg0.getProgramParameter(arg1, arg2 >>> 0);
|
|
4304
|
+
return ret;
|
|
4305
|
+
},
|
|
4306
|
+
__wbg_getQueryParameter_919125495ccb17ca: function(arg0, arg1, arg2) {
|
|
4307
|
+
const ret = arg0.getQueryParameter(arg1, arg2 >>> 0);
|
|
4308
|
+
return ret;
|
|
4309
|
+
},
|
|
4310
|
+
__wbg_getRandomValues_c44a50d8cfdaebeb: function() { return handleError(function (arg0, arg1) {
|
|
4311
|
+
arg0.getRandomValues(arg1);
|
|
4312
|
+
}, arguments); },
|
|
4313
|
+
__wbg_getShaderInfoLog_5cee2add982c7165: function(arg0, arg1, arg2) {
|
|
4314
|
+
const ret = arg1.getShaderInfoLog(arg2);
|
|
4315
|
+
var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
4316
|
+
var len1 = WASM_VECTOR_LEN;
|
|
4317
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
4318
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
4319
|
+
},
|
|
4320
|
+
__wbg_getShaderInfoLog_bc236afe696c1283: function(arg0, arg1, arg2) {
|
|
4321
|
+
const ret = arg1.getShaderInfoLog(arg2);
|
|
4322
|
+
var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
4323
|
+
var len1 = WASM_VECTOR_LEN;
|
|
4324
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
4325
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
4326
|
+
},
|
|
4327
|
+
__wbg_getShaderParameter_3394e75dcb97f380: function(arg0, arg1, arg2) {
|
|
4328
|
+
const ret = arg0.getShaderParameter(arg1, arg2 >>> 0);
|
|
4329
|
+
return ret;
|
|
4330
|
+
},
|
|
4331
|
+
__wbg_getShaderParameter_cbcc0995e8e16214: function(arg0, arg1, arg2) {
|
|
4332
|
+
const ret = arg0.getShaderParameter(arg1, arg2 >>> 0);
|
|
4333
|
+
return ret;
|
|
4334
|
+
},
|
|
4335
|
+
__wbg_getSupportedExtensions_2a7458ec45e82560: function(arg0) {
|
|
4336
|
+
const ret = arg0.getSupportedExtensions();
|
|
4337
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
4338
|
+
},
|
|
4339
|
+
__wbg_getSupportedProfiles_90a4f330938d0241: function(arg0) {
|
|
4340
|
+
const ret = arg0.getSupportedProfiles();
|
|
4341
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
4342
|
+
},
|
|
4343
|
+
__wbg_getSyncParameter_d8f6c145657a3550: function(arg0, arg1, arg2) {
|
|
4344
|
+
const ret = arg0.getSyncParameter(arg1, arg2 >>> 0);
|
|
4345
|
+
return ret;
|
|
4346
|
+
},
|
|
4347
|
+
__wbg_getUniformBlockIndex_cfee6ff6d323c784: function(arg0, arg1, arg2, arg3) {
|
|
4348
|
+
const ret = arg0.getUniformBlockIndex(arg1, getStringFromWasm0(arg2, arg3));
|
|
4349
|
+
return ret;
|
|
4350
|
+
},
|
|
4351
|
+
__wbg_getUniformLocation_24ef46cdda2148ab: function(arg0, arg1, arg2, arg3) {
|
|
4352
|
+
const ret = arg0.getUniformLocation(arg1, getStringFromWasm0(arg2, arg3));
|
|
4353
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
4354
|
+
},
|
|
4355
|
+
__wbg_getUniformLocation_788a34295dd6fabe: function(arg0, arg1, arg2, arg3) {
|
|
4356
|
+
const ret = arg0.getUniformLocation(arg1, getStringFromWasm0(arg2, arg3));
|
|
4357
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
4358
|
+
},
|
|
4359
|
+
__wbg_get_18e0163e38e5048d: function() { return handleError(function (arg0, arg1, arg2, arg3) {
|
|
4360
|
+
const ret = arg1.get(getStringFromWasm0(arg2, arg3));
|
|
4361
|
+
var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
4362
|
+
var len1 = WASM_VECTOR_LEN;
|
|
4363
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
4364
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
4365
|
+
}, arguments); },
|
|
4366
|
+
__wbg_get_b2053e9bfdf3ca8e: function(arg0, arg1) {
|
|
4367
|
+
const ret = arg0[arg1 >>> 0];
|
|
4368
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
4369
|
+
},
|
|
4370
|
+
__wbg_get_unchecked_6e0ad6d2a41b06f6: function(arg0, arg1) {
|
|
4371
|
+
const ret = arg0[arg1 >>> 0];
|
|
4372
|
+
return ret;
|
|
4373
|
+
},
|
|
4374
|
+
__wbg_gpu_ac6dc8fb638a26c3: function(arg0) {
|
|
4375
|
+
const ret = arg0.gpu;
|
|
4376
|
+
return ret;
|
|
4377
|
+
},
|
|
4378
|
+
__wbg_has_ffcf0ac839d1b8fb: function(arg0, arg1, arg2) {
|
|
4379
|
+
const ret = arg0.has(getStringFromWasm0(arg1, arg2));
|
|
4380
|
+
return ret;
|
|
4381
|
+
},
|
|
4382
|
+
__wbg_headers_cf9c80f30e2a4eff: function(arg0) {
|
|
4383
|
+
const ret = arg0.headers;
|
|
4384
|
+
return ret;
|
|
4385
|
+
},
|
|
4386
|
+
__wbg_height_6eec812c213259a1: function(arg0) {
|
|
4387
|
+
const ret = arg0.height;
|
|
4388
|
+
return ret;
|
|
4389
|
+
},
|
|
4390
|
+
__wbg_includes_78c9a3115b08eddc: function(arg0, arg1, arg2) {
|
|
4391
|
+
const ret = arg0.includes(arg1, arg2);
|
|
4392
|
+
return ret;
|
|
4393
|
+
},
|
|
4394
|
+
__wbg_instanceof_GpuAdapter_fb230cdccb184887: function(arg0) {
|
|
4395
|
+
let result;
|
|
4396
|
+
try {
|
|
4397
|
+
result = arg0 instanceof GPUAdapter;
|
|
4398
|
+
} catch (_) {
|
|
4399
|
+
result = false;
|
|
4400
|
+
}
|
|
4401
|
+
const ret = result;
|
|
4402
|
+
return ret;
|
|
4403
|
+
},
|
|
4404
|
+
__wbg_instanceof_GpuCanvasContext_48ec5330c4425d84: function(arg0) {
|
|
4405
|
+
let result;
|
|
4406
|
+
try {
|
|
4407
|
+
result = arg0 instanceof GPUCanvasContext;
|
|
4408
|
+
} catch (_) {
|
|
4409
|
+
result = false;
|
|
4410
|
+
}
|
|
4411
|
+
const ret = result;
|
|
4412
|
+
return ret;
|
|
4413
|
+
},
|
|
4414
|
+
__wbg_instanceof_GpuOutOfMemoryError_7b1554dded417c4f: function(arg0) {
|
|
4415
|
+
let result;
|
|
4416
|
+
try {
|
|
4417
|
+
result = arg0 instanceof GPUOutOfMemoryError;
|
|
4418
|
+
} catch (_) {
|
|
4419
|
+
result = false;
|
|
4420
|
+
}
|
|
4421
|
+
const ret = result;
|
|
4422
|
+
return ret;
|
|
4423
|
+
},
|
|
4424
|
+
__wbg_instanceof_GpuValidationError_124458c5a6bb3b58: function(arg0) {
|
|
4425
|
+
let result;
|
|
4426
|
+
try {
|
|
4427
|
+
result = arg0 instanceof GPUValidationError;
|
|
4428
|
+
} catch (_) {
|
|
4429
|
+
result = false;
|
|
4430
|
+
}
|
|
4431
|
+
const ret = result;
|
|
4432
|
+
return ret;
|
|
4433
|
+
},
|
|
4434
|
+
__wbg_instanceof_HtmlCanvasElement_ed02ed9136056019: function(arg0) {
|
|
4435
|
+
let result;
|
|
4436
|
+
try {
|
|
4437
|
+
result = arg0 instanceof HTMLCanvasElement;
|
|
4438
|
+
} catch (_) {
|
|
4439
|
+
result = false;
|
|
4440
|
+
}
|
|
4441
|
+
const ret = result;
|
|
4442
|
+
return ret;
|
|
4443
|
+
},
|
|
4444
|
+
__wbg_instanceof_Object_33f20e6f12439f3e: function(arg0) {
|
|
4445
|
+
let result;
|
|
4446
|
+
try {
|
|
4447
|
+
result = arg0 instanceof Object;
|
|
4448
|
+
} catch (_) {
|
|
4449
|
+
result = false;
|
|
4450
|
+
}
|
|
4451
|
+
const ret = result;
|
|
4452
|
+
return ret;
|
|
4453
|
+
},
|
|
4454
|
+
__wbg_instanceof_Response_c8b64b2256f01bec: function(arg0) {
|
|
4455
|
+
let result;
|
|
4456
|
+
try {
|
|
4457
|
+
result = arg0 instanceof Response;
|
|
4458
|
+
} catch (_) {
|
|
4459
|
+
result = false;
|
|
4460
|
+
}
|
|
4461
|
+
const ret = result;
|
|
4462
|
+
return ret;
|
|
4463
|
+
},
|
|
4464
|
+
__wbg_instanceof_WebGl2RenderingContext_90225152e4e3c799: function(arg0) {
|
|
4465
|
+
let result;
|
|
4466
|
+
try {
|
|
4467
|
+
result = arg0 instanceof WebGL2RenderingContext;
|
|
4468
|
+
} catch (_) {
|
|
4469
|
+
result = false;
|
|
4470
|
+
}
|
|
4471
|
+
const ret = result;
|
|
4472
|
+
return ret;
|
|
4473
|
+
},
|
|
4474
|
+
__wbg_instanceof_Window_05ba1ee4f6781663: function(arg0) {
|
|
4475
|
+
let result;
|
|
4476
|
+
try {
|
|
4477
|
+
result = arg0 instanceof Window;
|
|
4478
|
+
} catch (_) {
|
|
4479
|
+
result = false;
|
|
4480
|
+
}
|
|
4481
|
+
const ret = result;
|
|
4482
|
+
return ret;
|
|
4483
|
+
},
|
|
4484
|
+
__wbg_invalidateFramebuffer_343bbfb15e6835fd: function() { return handleError(function (arg0, arg1, arg2) {
|
|
4485
|
+
arg0.invalidateFramebuffer(arg1 >>> 0, arg2);
|
|
4486
|
+
}, arguments); },
|
|
4487
|
+
__wbg_is_7b9d0b289033c7de: function(arg0, arg1) {
|
|
4488
|
+
const ret = Object.is(arg0, arg1);
|
|
4489
|
+
return ret;
|
|
4490
|
+
},
|
|
4491
|
+
__wbg_label_84abde6506fa15b7: function(arg0, arg1) {
|
|
4492
|
+
const ret = arg1.label;
|
|
4493
|
+
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
4494
|
+
const len1 = WASM_VECTOR_LEN;
|
|
4495
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
4496
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
4497
|
+
},
|
|
4498
|
+
__wbg_length_1f0964f4a5e2c6d8: function(arg0) {
|
|
4499
|
+
const ret = arg0.length;
|
|
4500
|
+
return ret;
|
|
4501
|
+
},
|
|
4502
|
+
__wbg_length_370319915dc99107: function(arg0) {
|
|
4503
|
+
const ret = arg0.length;
|
|
4504
|
+
return ret;
|
|
4505
|
+
},
|
|
4506
|
+
__wbg_limits_a80585efb442d985: function(arg0) {
|
|
4507
|
+
const ret = arg0.limits;
|
|
4508
|
+
return ret;
|
|
4509
|
+
},
|
|
4510
|
+
__wbg_limits_d4ef440224084d65: function(arg0) {
|
|
4511
|
+
const ret = arg0.limits;
|
|
4512
|
+
return ret;
|
|
4513
|
+
},
|
|
4514
|
+
__wbg_linkProgram_4e047fb3197a0348: function(arg0, arg1) {
|
|
4515
|
+
arg0.linkProgram(arg1);
|
|
4516
|
+
},
|
|
4517
|
+
__wbg_linkProgram_d7c71c539c8c6a43: function(arg0, arg1) {
|
|
4518
|
+
arg0.linkProgram(arg1);
|
|
4519
|
+
},
|
|
4520
|
+
__wbg_mapAsync_3546b4b874e14738: function(arg0, arg1, arg2, arg3) {
|
|
4521
|
+
const ret = arg0.mapAsync(arg1 >>> 0, arg2, arg3);
|
|
4522
|
+
return ret;
|
|
4523
|
+
},
|
|
4524
|
+
__wbg_maxBindGroups_2fac2855adae76bb: function(arg0) {
|
|
4525
|
+
const ret = arg0.maxBindGroups;
|
|
4526
|
+
return ret;
|
|
4527
|
+
},
|
|
4528
|
+
__wbg_maxBindingsPerBindGroup_7b8b526a1900701d: function(arg0) {
|
|
4529
|
+
const ret = arg0.maxBindingsPerBindGroup;
|
|
4530
|
+
return ret;
|
|
4531
|
+
},
|
|
4532
|
+
__wbg_maxBufferSize_475dcdac4810587e: function(arg0) {
|
|
4533
|
+
const ret = arg0.maxBufferSize;
|
|
4534
|
+
return ret;
|
|
4535
|
+
},
|
|
4536
|
+
__wbg_maxColorAttachmentBytesPerSample_5a04a2d5a9e122bb: function(arg0) {
|
|
4537
|
+
const ret = arg0.maxColorAttachmentBytesPerSample;
|
|
4538
|
+
return ret;
|
|
4539
|
+
},
|
|
4540
|
+
__wbg_maxColorAttachments_2a487bb283cf8f08: function(arg0) {
|
|
4541
|
+
const ret = arg0.maxColorAttachments;
|
|
4542
|
+
return ret;
|
|
4543
|
+
},
|
|
4544
|
+
__wbg_maxComputeInvocationsPerWorkgroup_72908780df74614a: function(arg0) {
|
|
4545
|
+
const ret = arg0.maxComputeInvocationsPerWorkgroup;
|
|
4546
|
+
return ret;
|
|
4547
|
+
},
|
|
4548
|
+
__wbg_maxComputeWorkgroupSizeX_92eeefd082aefd07: function(arg0) {
|
|
4549
|
+
const ret = arg0.maxComputeWorkgroupSizeX;
|
|
4550
|
+
return ret;
|
|
4551
|
+
},
|
|
4552
|
+
__wbg_maxComputeWorkgroupSizeY_54fecee60bfa33ae: function(arg0) {
|
|
4553
|
+
const ret = arg0.maxComputeWorkgroupSizeY;
|
|
4554
|
+
return ret;
|
|
4555
|
+
},
|
|
4556
|
+
__wbg_maxComputeWorkgroupSizeZ_868f559f4eebf95f: function(arg0) {
|
|
4557
|
+
const ret = arg0.maxComputeWorkgroupSizeZ;
|
|
4558
|
+
return ret;
|
|
4559
|
+
},
|
|
4560
|
+
__wbg_maxComputeWorkgroupStorageSize_b4fd07bd827bde34: function(arg0) {
|
|
4561
|
+
const ret = arg0.maxComputeWorkgroupStorageSize;
|
|
4562
|
+
return ret;
|
|
4563
|
+
},
|
|
4564
|
+
__wbg_maxComputeWorkgroupsPerDimension_2d88e3f8e1f984fc: function(arg0) {
|
|
4565
|
+
const ret = arg0.maxComputeWorkgroupsPerDimension;
|
|
4566
|
+
return ret;
|
|
4567
|
+
},
|
|
4568
|
+
__wbg_maxDynamicStorageBuffersPerPipelineLayout_d6f0075161a2ec8e: function(arg0) {
|
|
4569
|
+
const ret = arg0.maxDynamicStorageBuffersPerPipelineLayout;
|
|
4570
|
+
return ret;
|
|
4571
|
+
},
|
|
4572
|
+
__wbg_maxDynamicUniformBuffersPerPipelineLayout_4fc01fff17019d2b: function(arg0) {
|
|
4573
|
+
const ret = arg0.maxDynamicUniformBuffersPerPipelineLayout;
|
|
4574
|
+
return ret;
|
|
4575
|
+
},
|
|
4576
|
+
__wbg_maxSampledTexturesPerShaderStage_224452301226d09a: function(arg0) {
|
|
4577
|
+
const ret = arg0.maxSampledTexturesPerShaderStage;
|
|
4578
|
+
return ret;
|
|
4579
|
+
},
|
|
4580
|
+
__wbg_maxSamplersPerShaderStage_34936f99dde7ae66: function(arg0) {
|
|
4581
|
+
const ret = arg0.maxSamplersPerShaderStage;
|
|
4582
|
+
return ret;
|
|
4583
|
+
},
|
|
4584
|
+
__wbg_maxStorageBufferBindingSize_9582c7cfe68faac0: function(arg0) {
|
|
4585
|
+
const ret = arg0.maxStorageBufferBindingSize;
|
|
4586
|
+
return ret;
|
|
4587
|
+
},
|
|
4588
|
+
__wbg_maxStorageBuffersPerShaderStage_6403069e851040db: function(arg0) {
|
|
4589
|
+
const ret = arg0.maxStorageBuffersPerShaderStage;
|
|
4590
|
+
return ret;
|
|
4591
|
+
},
|
|
4592
|
+
__wbg_maxStorageTexturesPerShaderStage_e44d7d6ed85de663: function(arg0) {
|
|
4593
|
+
const ret = arg0.maxStorageTexturesPerShaderStage;
|
|
4594
|
+
return ret;
|
|
4595
|
+
},
|
|
4596
|
+
__wbg_maxTextureArrayLayers_0f2fe636cc0fa44f: function(arg0) {
|
|
4597
|
+
const ret = arg0.maxTextureArrayLayers;
|
|
4598
|
+
return ret;
|
|
4599
|
+
},
|
|
4600
|
+
__wbg_maxTextureDimension1D_501e1e21119c564f: function(arg0) {
|
|
4601
|
+
const ret = arg0.maxTextureDimension1D;
|
|
4602
|
+
return ret;
|
|
4603
|
+
},
|
|
4604
|
+
__wbg_maxTextureDimension2D_ac594a0008180ab6: function(arg0) {
|
|
4605
|
+
const ret = arg0.maxTextureDimension2D;
|
|
4606
|
+
return ret;
|
|
4607
|
+
},
|
|
4608
|
+
__wbg_maxTextureDimension3D_8e5638a46d5786b0: function(arg0) {
|
|
4609
|
+
const ret = arg0.maxTextureDimension3D;
|
|
4610
|
+
return ret;
|
|
4611
|
+
},
|
|
4612
|
+
__wbg_maxUniformBufferBindingSize_a4c4feca62b81571: function(arg0) {
|
|
4613
|
+
const ret = arg0.maxUniformBufferBindingSize;
|
|
4614
|
+
return ret;
|
|
4615
|
+
},
|
|
4616
|
+
__wbg_maxUniformBuffersPerShaderStage_505f14dd3f814492: function(arg0) {
|
|
4617
|
+
const ret = arg0.maxUniformBuffersPerShaderStage;
|
|
4618
|
+
return ret;
|
|
4619
|
+
},
|
|
4620
|
+
__wbg_maxVertexAttributes_c4f4881b2d20616b: function(arg0) {
|
|
4621
|
+
const ret = arg0.maxVertexAttributes;
|
|
4622
|
+
return ret;
|
|
4623
|
+
},
|
|
4624
|
+
__wbg_maxVertexBufferArrayStride_da0782b779fc1a38: function(arg0) {
|
|
4625
|
+
const ret = arg0.maxVertexBufferArrayStride;
|
|
4626
|
+
return ret;
|
|
4627
|
+
},
|
|
4628
|
+
__wbg_maxVertexBuffers_90e848bae7f01af3: function(arg0) {
|
|
4629
|
+
const ret = arg0.maxVertexBuffers;
|
|
4630
|
+
return ret;
|
|
4631
|
+
},
|
|
4632
|
+
__wbg_message_bd5755a324c3b999: function(arg0, arg1) {
|
|
4633
|
+
const ret = arg1.message;
|
|
4634
|
+
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
4635
|
+
const len1 = WASM_VECTOR_LEN;
|
|
4636
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
4637
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
4638
|
+
},
|
|
4639
|
+
__wbg_minStorageBufferOffsetAlignment_58fcc139ce14bbb9: function(arg0) {
|
|
4640
|
+
const ret = arg0.minStorageBufferOffsetAlignment;
|
|
4641
|
+
return ret;
|
|
4642
|
+
},
|
|
4643
|
+
__wbg_minUniformBufferOffsetAlignment_33ca7570ff80f825: function(arg0) {
|
|
4644
|
+
const ret = arg0.minUniformBufferOffsetAlignment;
|
|
4645
|
+
return ret;
|
|
4646
|
+
},
|
|
4647
|
+
__wbg_msCrypto_bd5a034af96bcba6: function(arg0) {
|
|
4648
|
+
const ret = arg0.msCrypto;
|
|
4649
|
+
return ret;
|
|
4650
|
+
},
|
|
4651
|
+
__wbg_navigator_51379c10a84aeec9: function(arg0) {
|
|
4652
|
+
const ret = arg0.navigator;
|
|
4653
|
+
return ret;
|
|
4654
|
+
},
|
|
4655
|
+
__wbg_navigator_99621db14b3f1099: function(arg0) {
|
|
4656
|
+
const ret = arg0.navigator;
|
|
4657
|
+
return ret;
|
|
4658
|
+
},
|
|
4659
|
+
__wbg_new_0_3da9e97f24fc69be: function() {
|
|
4660
|
+
const ret = new Date();
|
|
4661
|
+
return ret;
|
|
4662
|
+
},
|
|
4663
|
+
__wbg_new_32b398fb48b6d94a: function() {
|
|
4664
|
+
const ret = new Array();
|
|
4665
|
+
return ret;
|
|
4666
|
+
},
|
|
4667
|
+
__wbg_new_cd45aabdf6073e84: function(arg0) {
|
|
4668
|
+
const ret = new Uint8Array(arg0);
|
|
4669
|
+
return ret;
|
|
4670
|
+
},
|
|
4671
|
+
__wbg_new_da52cf8fe3429cb2: function() {
|
|
4672
|
+
const ret = new Object();
|
|
4673
|
+
return ret;
|
|
4674
|
+
},
|
|
4675
|
+
__wbg_new_from_slice_77cdfb7977362f3c: function(arg0, arg1) {
|
|
4676
|
+
const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
|
|
4677
|
+
return ret;
|
|
4678
|
+
},
|
|
4679
|
+
__wbg_new_typed_1824d93f294193e5: function(arg0, arg1) {
|
|
4680
|
+
try {
|
|
4681
|
+
var state0 = {a: arg0, b: arg1};
|
|
4682
|
+
var cb0 = (arg0, arg1) => {
|
|
4683
|
+
const a = state0.a;
|
|
4684
|
+
state0.a = 0;
|
|
4685
|
+
try {
|
|
4686
|
+
return wasm_bindgen__convert__closures_____invoke__h1149b643047c36f1(a, state0.b, arg0, arg1);
|
|
4687
|
+
} finally {
|
|
4688
|
+
state0.a = a;
|
|
4689
|
+
}
|
|
4690
|
+
};
|
|
4691
|
+
const ret = new Promise(cb0);
|
|
4692
|
+
return ret;
|
|
4693
|
+
} finally {
|
|
4694
|
+
state0.a = 0;
|
|
4695
|
+
}
|
|
4696
|
+
},
|
|
4697
|
+
__wbg_new_with_byte_offset_and_length_54c7724ee3ec7d82: function(arg0, arg1, arg2) {
|
|
4698
|
+
const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
|
|
4699
|
+
return ret;
|
|
4700
|
+
},
|
|
4701
|
+
__wbg_new_with_length_e6785c33c8e4cce8: function(arg0) {
|
|
4702
|
+
const ret = new Uint8Array(arg0 >>> 0);
|
|
4703
|
+
return ret;
|
|
4704
|
+
},
|
|
4705
|
+
__wbg_node_84ea875411254db1: function(arg0) {
|
|
4706
|
+
const ret = arg0.node;
|
|
4707
|
+
return ret;
|
|
4708
|
+
},
|
|
4709
|
+
__wbg_now_86c0d4ba3fa605b8: function() {
|
|
4710
|
+
const ret = Date.now();
|
|
4711
|
+
return ret;
|
|
4712
|
+
},
|
|
4713
|
+
__wbg_of_85f52f8b6491a7ca: function(arg0) {
|
|
4714
|
+
const ret = Array.of(arg0);
|
|
4715
|
+
return ret;
|
|
4716
|
+
},
|
|
4717
|
+
__wbg_ok_acc5e3fb89668864: function(arg0) {
|
|
4718
|
+
const ret = arg0.ok;
|
|
4719
|
+
return ret;
|
|
4720
|
+
},
|
|
4721
|
+
__wbg_onSubmittedWorkDone_5c020973b11ab15f: function(arg0) {
|
|
4722
|
+
const ret = arg0.onSubmittedWorkDone();
|
|
4723
|
+
return ret;
|
|
4724
|
+
},
|
|
4725
|
+
__wbg_parse_1c0d8a8656d7e016: function() { return handleError(function (arg0, arg1) {
|
|
4726
|
+
const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
|
|
4727
|
+
return ret;
|
|
4728
|
+
}, arguments); },
|
|
4729
|
+
__wbg_pixelStorei_2a93b18efde9acf8: function(arg0, arg1, arg2) {
|
|
4730
|
+
arg0.pixelStorei(arg1 >>> 0, arg2);
|
|
4731
|
+
},
|
|
4732
|
+
__wbg_pixelStorei_c844cd0db4f1fde6: function(arg0, arg1, arg2) {
|
|
4733
|
+
arg0.pixelStorei(arg1 >>> 0, arg2);
|
|
4734
|
+
},
|
|
4735
|
+
__wbg_polygonOffset_4eb460adf41db6cd: function(arg0, arg1, arg2) {
|
|
4736
|
+
arg0.polygonOffset(arg1, arg2);
|
|
4737
|
+
},
|
|
4738
|
+
__wbg_polygonOffset_eccb68e40a18f861: function(arg0, arg1, arg2) {
|
|
4739
|
+
arg0.polygonOffset(arg1, arg2);
|
|
4740
|
+
},
|
|
4741
|
+
__wbg_popErrorScope_20ec53d3d70b2173: function(arg0) {
|
|
4742
|
+
const ret = arg0.popErrorScope();
|
|
4743
|
+
return ret;
|
|
4744
|
+
},
|
|
4745
|
+
__wbg_process_44c7a14e11e9f69e: function(arg0) {
|
|
4746
|
+
const ret = arg0.process;
|
|
4747
|
+
return ret;
|
|
4748
|
+
},
|
|
4749
|
+
__wbg_prototypesetcall_4770620bbe4688a0: function(arg0, arg1, arg2) {
|
|
4750
|
+
Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
|
|
4751
|
+
},
|
|
4752
|
+
__wbg_pushErrorScope_d3e17b69be8837df: function(arg0, arg1) {
|
|
4753
|
+
arg0.pushErrorScope(__wbindgen_enum_GpuErrorFilter[arg1]);
|
|
4754
|
+
},
|
|
4755
|
+
__wbg_push_d2ae3af0c1217ae6: function(arg0, arg1) {
|
|
4756
|
+
const ret = arg0.push(arg1);
|
|
4757
|
+
return ret;
|
|
4758
|
+
},
|
|
4759
|
+
__wbg_queryCounterEXT_b74a4567ddfeecf0: function(arg0, arg1, arg2) {
|
|
4760
|
+
arg0.queryCounterEXT(arg1, arg2 >>> 0);
|
|
4761
|
+
},
|
|
4762
|
+
__wbg_querySelectorAll_7e98cbe256deaadd: function() { return handleError(function (arg0, arg1, arg2) {
|
|
4763
|
+
const ret = arg0.querySelectorAll(getStringFromWasm0(arg1, arg2));
|
|
4764
|
+
return ret;
|
|
4765
|
+
}, arguments); },
|
|
4766
|
+
__wbg_querySelector_fd7d157ebe17cd16: function() { return handleError(function (arg0, arg1, arg2) {
|
|
4767
|
+
const ret = arg0.querySelector(getStringFromWasm0(arg1, arg2));
|
|
4768
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
4769
|
+
}, arguments); },
|
|
4770
|
+
__wbg_queueMicrotask_0ab5b2d2393e99b9: function(arg0) {
|
|
4771
|
+
const ret = arg0.queueMicrotask;
|
|
4772
|
+
return ret;
|
|
4773
|
+
},
|
|
4774
|
+
__wbg_queueMicrotask_6a09b7bc46549209: function(arg0) {
|
|
4775
|
+
queueMicrotask(arg0);
|
|
4776
|
+
},
|
|
4777
|
+
__wbg_queue_8cb065d04b06cb13: function(arg0) {
|
|
4778
|
+
const ret = arg0.queue;
|
|
4779
|
+
return ret;
|
|
4780
|
+
},
|
|
4781
|
+
__wbg_randomFillSync_6c25eac9869eb53c: function() { return handleError(function (arg0, arg1) {
|
|
4782
|
+
arg0.randomFillSync(arg1);
|
|
4783
|
+
}, arguments); },
|
|
4784
|
+
__wbg_readBuffer_4271437a70aae481: function(arg0, arg1) {
|
|
4785
|
+
arg0.readBuffer(arg1 >>> 0);
|
|
4786
|
+
},
|
|
4787
|
+
__wbg_readPixels_5f013a7d85b23800: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
|
|
4788
|
+
arg0.readPixels(arg1, arg2, arg3, arg4, arg5 >>> 0, arg6 >>> 0, arg7);
|
|
4789
|
+
}, arguments); },
|
|
4790
|
+
__wbg_readPixels_82c9dee754d58176: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
|
|
4791
|
+
arg0.readPixels(arg1, arg2, arg3, arg4, arg5 >>> 0, arg6 >>> 0, arg7);
|
|
4792
|
+
}, arguments); },
|
|
4793
|
+
__wbg_readPixels_c7861e25836bf57b: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
|
|
4794
|
+
arg0.readPixels(arg1, arg2, arg3, arg4, arg5 >>> 0, arg6 >>> 0, arg7);
|
|
4795
|
+
}, arguments); },
|
|
4796
|
+
__wbg_renderbufferStorageMultisample_5c6e5d20c0eaa6ba: function(arg0, arg1, arg2, arg3, arg4, arg5) {
|
|
4797
|
+
arg0.renderbufferStorageMultisample(arg1 >>> 0, arg2, arg3 >>> 0, arg4, arg5);
|
|
4798
|
+
},
|
|
4799
|
+
__wbg_renderbufferStorage_0a8de92542893819: function(arg0, arg1, arg2, arg3, arg4) {
|
|
4800
|
+
arg0.renderbufferStorage(arg1 >>> 0, arg2 >>> 0, arg3, arg4);
|
|
4801
|
+
},
|
|
4802
|
+
__wbg_renderbufferStorage_ab5f745ff8efce3d: function(arg0, arg1, arg2, arg3, arg4) {
|
|
4803
|
+
arg0.renderbufferStorage(arg1 >>> 0, arg2 >>> 0, arg3, arg4);
|
|
4804
|
+
},
|
|
4805
|
+
__wbg_requestAdapter_4814cb479d2dcf15: function(arg0, arg1) {
|
|
4806
|
+
const ret = arg0.requestAdapter(arg1);
|
|
4807
|
+
return ret;
|
|
4808
|
+
},
|
|
4809
|
+
__wbg_requestDevice_1b8f321791aa8b00: function(arg0, arg1) {
|
|
4810
|
+
const ret = arg0.requestDevice(arg1);
|
|
4811
|
+
return ret;
|
|
4812
|
+
},
|
|
4813
|
+
__wbg_require_b4edbdcf3e2a1ef0: function() { return handleError(function () {
|
|
4814
|
+
const ret = module.require;
|
|
4815
|
+
return ret;
|
|
4816
|
+
}, arguments); },
|
|
4817
|
+
__wbg_resolve_2191a4dfe481c25b: function(arg0) {
|
|
4818
|
+
const ret = Promise.resolve(arg0);
|
|
4819
|
+
return ret;
|
|
4820
|
+
},
|
|
4821
|
+
__wbg_samplerParameterf_0b3308eeb1faa3a1: function(arg0, arg1, arg2, arg3) {
|
|
4822
|
+
arg0.samplerParameterf(arg1, arg2 >>> 0, arg3);
|
|
4823
|
+
},
|
|
4824
|
+
__wbg_samplerParameteri_7b1b4091de49aabb: function(arg0, arg1, arg2, arg3) {
|
|
4825
|
+
arg0.samplerParameteri(arg1, arg2 >>> 0, arg3);
|
|
4826
|
+
},
|
|
4827
|
+
__wbg_scenecanvas_new: function(arg0) {
|
|
4828
|
+
const ret = SceneCanvas.__wrap(arg0);
|
|
4829
|
+
return ret;
|
|
4830
|
+
},
|
|
4831
|
+
__wbg_scissor_105e756596bc35df: function(arg0, arg1, arg2, arg3, arg4) {
|
|
4832
|
+
arg0.scissor(arg1, arg2, arg3, arg4);
|
|
4833
|
+
},
|
|
4834
|
+
__wbg_scissor_573b844152316b8d: function(arg0, arg1, arg2, arg3, arg4) {
|
|
4835
|
+
arg0.scissor(arg1, arg2, arg3, arg4);
|
|
4836
|
+
},
|
|
4837
|
+
__wbg_setBindGroup_67bd9a0c57486387: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
|
|
4838
|
+
arg0.setBindGroup(arg1 >>> 0, arg2, getArrayU32FromWasm0(arg3, arg4), arg5, arg6 >>> 0);
|
|
4839
|
+
}, arguments); },
|
|
4840
|
+
__wbg_setBindGroup_9fdf11fd244aa68a: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
|
|
4841
|
+
arg0.setBindGroup(arg1 >>> 0, arg2, getArrayU32FromWasm0(arg3, arg4), arg5, arg6 >>> 0);
|
|
4842
|
+
}, arguments); },
|
|
4843
|
+
__wbg_setBindGroup_a2a4442ac2a0be99: function(arg0, arg1, arg2) {
|
|
4844
|
+
arg0.setBindGroup(arg1 >>> 0, arg2);
|
|
4845
|
+
},
|
|
4846
|
+
__wbg_setBindGroup_a7e88440d0ecac88: function(arg0, arg1, arg2) {
|
|
4847
|
+
arg0.setBindGroup(arg1 >>> 0, arg2);
|
|
4848
|
+
},
|
|
4849
|
+
__wbg_setIndexBuffer_34f864cca07ffcec: function(arg0, arg1, arg2, arg3) {
|
|
4850
|
+
arg0.setIndexBuffer(arg1, __wbindgen_enum_GpuIndexFormat[arg2], arg3);
|
|
4851
|
+
},
|
|
4852
|
+
__wbg_setIndexBuffer_495adb9486108a2f: function(arg0, arg1, arg2, arg3, arg4) {
|
|
4853
|
+
arg0.setIndexBuffer(arg1, __wbindgen_enum_GpuIndexFormat[arg2], arg3, arg4);
|
|
4854
|
+
},
|
|
4855
|
+
__wbg_setPipeline_092493bfd77760ee: function(arg0, arg1) {
|
|
4856
|
+
arg0.setPipeline(arg1);
|
|
4857
|
+
},
|
|
4858
|
+
__wbg_setPipeline_50cfc53a5d0eb1d7: function(arg0, arg1) {
|
|
4859
|
+
arg0.setPipeline(arg1);
|
|
4860
|
+
},
|
|
4861
|
+
__wbg_setScissorRect_ab5c9964f1440456: function(arg0, arg1, arg2, arg3, arg4) {
|
|
4862
|
+
arg0.setScissorRect(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4 >>> 0);
|
|
4863
|
+
},
|
|
4864
|
+
__wbg_setVertexBuffer_1ed692dc2726f6c3: function(arg0, arg1, arg2, arg3, arg4) {
|
|
4865
|
+
arg0.setVertexBuffer(arg1 >>> 0, arg2, arg3, arg4);
|
|
4866
|
+
},
|
|
4867
|
+
__wbg_setVertexBuffer_cc6e95bb408da360: function(arg0, arg1, arg2, arg3) {
|
|
4868
|
+
arg0.setVertexBuffer(arg1 >>> 0, arg2, arg3);
|
|
4869
|
+
},
|
|
4870
|
+
__wbg_setViewport_de0ebf5f8450da7e: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
|
|
4871
|
+
arg0.setViewport(arg1, arg2, arg3, arg4, arg5, arg6);
|
|
4872
|
+
},
|
|
4873
|
+
__wbg_set_61e45ae8061eca11: function(arg0, arg1, arg2) {
|
|
4874
|
+
arg0.set(arg1, arg2 >>> 0);
|
|
4875
|
+
},
|
|
4876
|
+
__wbg_set_8535240470bf2500: function() { return handleError(function (arg0, arg1, arg2) {
|
|
4877
|
+
const ret = Reflect.set(arg0, arg1, arg2);
|
|
4878
|
+
return ret;
|
|
4879
|
+
}, arguments); },
|
|
4880
|
+
__wbg_set_a_9b35e9a1b60244b3: function(arg0, arg1) {
|
|
4881
|
+
arg0.a = arg1;
|
|
4882
|
+
},
|
|
4883
|
+
__wbg_set_access_67a4b0ae1c0f32f5: function(arg0, arg1) {
|
|
4884
|
+
arg0.access = __wbindgen_enum_GpuStorageTextureAccess[arg1];
|
|
4885
|
+
},
|
|
4886
|
+
__wbg_set_address_mode_u_1a44abe112b27750: function(arg0, arg1) {
|
|
4887
|
+
arg0.addressModeU = __wbindgen_enum_GpuAddressMode[arg1];
|
|
4888
|
+
},
|
|
4889
|
+
__wbg_set_address_mode_v_764da2dbc77dbf3e: function(arg0, arg1) {
|
|
4890
|
+
arg0.addressModeV = __wbindgen_enum_GpuAddressMode[arg1];
|
|
4891
|
+
},
|
|
4892
|
+
__wbg_set_address_mode_w_7c5135c7d56f9b4c: function(arg0, arg1) {
|
|
4893
|
+
arg0.addressModeW = __wbindgen_enum_GpuAddressMode[arg1];
|
|
4894
|
+
},
|
|
4895
|
+
__wbg_set_alpha_52d96a0bda4f4afe: function(arg0, arg1) {
|
|
4896
|
+
arg0.alpha = arg1;
|
|
4897
|
+
},
|
|
4898
|
+
__wbg_set_alpha_mode_5c1f4c4115bbe318: function(arg0, arg1) {
|
|
4899
|
+
arg0.alphaMode = __wbindgen_enum_GpuCanvasAlphaMode[arg1];
|
|
4900
|
+
},
|
|
4901
|
+
__wbg_set_alpha_to_coverage_enabled_36cef063cffb5d84: function(arg0, arg1) {
|
|
4902
|
+
arg0.alphaToCoverageEnabled = arg1 !== 0;
|
|
4903
|
+
},
|
|
4904
|
+
__wbg_set_array_layer_count_c2e975f5b62596bb: function(arg0, arg1) {
|
|
4905
|
+
arg0.arrayLayerCount = arg1 >>> 0;
|
|
4906
|
+
},
|
|
4907
|
+
__wbg_set_array_stride_eb9d409a95d2c1b3: function(arg0, arg1) {
|
|
4908
|
+
arg0.arrayStride = arg1;
|
|
4909
|
+
},
|
|
4910
|
+
__wbg_set_aspect_a453970e75d8e849: function(arg0, arg1) {
|
|
4911
|
+
arg0.aspect = __wbindgen_enum_GpuTextureAspect[arg1];
|
|
4912
|
+
},
|
|
4913
|
+
__wbg_set_attributes_edcbef656678a257: function(arg0, arg1) {
|
|
4914
|
+
arg0.attributes = arg1;
|
|
4915
|
+
},
|
|
4916
|
+
__wbg_set_b_5708a52cef50b19f: function(arg0, arg1) {
|
|
4917
|
+
arg0.b = arg1;
|
|
4918
|
+
},
|
|
4919
|
+
__wbg_set_base_array_layer_b67db9750fbc7053: function(arg0, arg1) {
|
|
4920
|
+
arg0.baseArrayLayer = arg1 >>> 0;
|
|
4921
|
+
},
|
|
4922
|
+
__wbg_set_base_mip_level_35f2fc3293e96083: function(arg0, arg1) {
|
|
4923
|
+
arg0.baseMipLevel = arg1 >>> 0;
|
|
4924
|
+
},
|
|
4925
|
+
__wbg_set_beginning_of_pass_write_index_8e570668cd8cad5e: function(arg0, arg1) {
|
|
4926
|
+
arg0.beginningOfPassWriteIndex = arg1 >>> 0;
|
|
4927
|
+
},
|
|
4928
|
+
__wbg_set_beginning_of_pass_write_index_ddfc55f615254cc1: function(arg0, arg1) {
|
|
4929
|
+
arg0.beginningOfPassWriteIndex = arg1 >>> 0;
|
|
4930
|
+
},
|
|
4931
|
+
__wbg_set_bind_group_layouts_436bd62a9b35e1ab: function(arg0, arg1) {
|
|
4932
|
+
arg0.bindGroupLayouts = arg1;
|
|
4933
|
+
},
|
|
4934
|
+
__wbg_set_binding_b575483e08d5ba4a: function(arg0, arg1) {
|
|
4935
|
+
arg0.binding = arg1 >>> 0;
|
|
4936
|
+
},
|
|
4937
|
+
__wbg_set_binding_c9feebb53a130ebe: function(arg0, arg1) {
|
|
4938
|
+
arg0.binding = arg1 >>> 0;
|
|
4939
|
+
},
|
|
4940
|
+
__wbg_set_blend_765238525504b1db: function(arg0, arg1) {
|
|
4941
|
+
arg0.blend = arg1;
|
|
4942
|
+
},
|
|
4943
|
+
__wbg_set_buffer_468874ee2bc9df02: function(arg0, arg1) {
|
|
4944
|
+
arg0.buffer = arg1;
|
|
4945
|
+
},
|
|
4946
|
+
__wbg_set_buffer_6c45652fb024e808: function(arg0, arg1) {
|
|
4947
|
+
arg0.buffer = arg1;
|
|
4948
|
+
},
|
|
4949
|
+
__wbg_set_buffer_83041e80a2b2c1b9: function(arg0, arg1) {
|
|
4950
|
+
arg0.buffer = arg1;
|
|
4951
|
+
},
|
|
4952
|
+
__wbg_set_buffers_986b265eda61fae6: function(arg0, arg1) {
|
|
4953
|
+
arg0.buffers = arg1;
|
|
4954
|
+
},
|
|
4955
|
+
__wbg_set_bytes_per_row_c127092e4fe9be22: function(arg0, arg1) {
|
|
4956
|
+
arg0.bytesPerRow = arg1 >>> 0;
|
|
4957
|
+
},
|
|
4958
|
+
__wbg_set_bytes_per_row_fecf7d0d8d5038d0: function(arg0, arg1) {
|
|
4959
|
+
arg0.bytesPerRow = arg1 >>> 0;
|
|
4960
|
+
},
|
|
4961
|
+
__wbg_set_clear_value_764be6f32f502d0a: function(arg0, arg1) {
|
|
4962
|
+
arg0.clearValue = arg1;
|
|
4963
|
+
},
|
|
4964
|
+
__wbg_set_code_0a82fa86cf58ca3b: function(arg0, arg1, arg2) {
|
|
4965
|
+
arg0.code = getStringFromWasm0(arg1, arg2);
|
|
4966
|
+
},
|
|
4967
|
+
__wbg_set_color_attachments_fad73def169d9610: function(arg0, arg1) {
|
|
4968
|
+
arg0.colorAttachments = arg1;
|
|
4969
|
+
},
|
|
4970
|
+
__wbg_set_color_c25fb8769b4f010f: function(arg0, arg1) {
|
|
4971
|
+
arg0.color = arg1;
|
|
4972
|
+
},
|
|
4973
|
+
__wbg_set_compare_1e2214a402af6db3: function(arg0, arg1) {
|
|
4974
|
+
arg0.compare = __wbindgen_enum_GpuCompareFunction[arg1];
|
|
4975
|
+
},
|
|
4976
|
+
__wbg_set_compare_e61cc62d8f7e2191: function(arg0, arg1) {
|
|
4977
|
+
arg0.compare = __wbindgen_enum_GpuCompareFunction[arg1];
|
|
4978
|
+
},
|
|
4979
|
+
__wbg_set_compute_dc74d722ba27aa5b: function(arg0, arg1) {
|
|
4980
|
+
arg0.compute = arg1;
|
|
4981
|
+
},
|
|
4982
|
+
__wbg_set_count_39e1b3c03c19b528: function(arg0, arg1) {
|
|
4983
|
+
arg0.count = arg1 >>> 0;
|
|
4984
|
+
},
|
|
4985
|
+
__wbg_set_count_f285d8c62f4de679: function(arg0, arg1) {
|
|
4986
|
+
arg0.count = arg1 >>> 0;
|
|
4987
|
+
},
|
|
4988
|
+
__wbg_set_cull_mode_e6ca97d167dede04: function(arg0, arg1) {
|
|
4989
|
+
arg0.cullMode = __wbindgen_enum_GpuCullMode[arg1];
|
|
4990
|
+
},
|
|
4991
|
+
__wbg_set_depth_bias_clamp_e8da3e9edc037b18: function(arg0, arg1) {
|
|
4992
|
+
arg0.depthBiasClamp = arg1;
|
|
4993
|
+
},
|
|
4994
|
+
__wbg_set_depth_bias_edf83e7d032bdd2a: function(arg0, arg1) {
|
|
4995
|
+
arg0.depthBias = arg1;
|
|
4996
|
+
},
|
|
4997
|
+
__wbg_set_depth_bias_slope_scale_1746553a2d960310: function(arg0, arg1) {
|
|
4998
|
+
arg0.depthBiasSlopeScale = arg1;
|
|
4999
|
+
},
|
|
5000
|
+
__wbg_set_depth_clear_value_f6f20e460b0c4012: function(arg0, arg1) {
|
|
5001
|
+
arg0.depthClearValue = arg1;
|
|
5002
|
+
},
|
|
5003
|
+
__wbg_set_depth_compare_f18e709a5dc4a0b0: function(arg0, arg1) {
|
|
5004
|
+
arg0.depthCompare = __wbindgen_enum_GpuCompareFunction[arg1];
|
|
5005
|
+
},
|
|
5006
|
+
__wbg_set_depth_fail_op_45f4179ddfc376cd: function(arg0, arg1) {
|
|
5007
|
+
arg0.depthFailOp = __wbindgen_enum_GpuStencilOperation[arg1];
|
|
5008
|
+
},
|
|
5009
|
+
__wbg_set_depth_load_op_c3d15137e916dd5a: function(arg0, arg1) {
|
|
5010
|
+
arg0.depthLoadOp = __wbindgen_enum_GpuLoadOp[arg1];
|
|
5011
|
+
},
|
|
5012
|
+
__wbg_set_depth_or_array_layers_17284e1eac0007a1: function(arg0, arg1) {
|
|
5013
|
+
arg0.depthOrArrayLayers = arg1 >>> 0;
|
|
5014
|
+
},
|
|
5015
|
+
__wbg_set_depth_read_only_9a8994459a0acf9e: function(arg0, arg1) {
|
|
5016
|
+
arg0.depthReadOnly = arg1 !== 0;
|
|
5017
|
+
},
|
|
5018
|
+
__wbg_set_depth_stencil_8716a627d44d796e: function(arg0, arg1) {
|
|
5019
|
+
arg0.depthStencil = arg1;
|
|
5020
|
+
},
|
|
5021
|
+
__wbg_set_depth_stencil_attachment_08fe1db9243adb49: function(arg0, arg1) {
|
|
5022
|
+
arg0.depthStencilAttachment = arg1;
|
|
5023
|
+
},
|
|
5024
|
+
__wbg_set_depth_store_op_881c8dbe0d67045d: function(arg0, arg1) {
|
|
5025
|
+
arg0.depthStoreOp = __wbindgen_enum_GpuStoreOp[arg1];
|
|
5026
|
+
},
|
|
5027
|
+
__wbg_set_depth_write_enabled_9b608c3bf190f04a: function(arg0, arg1) {
|
|
5028
|
+
arg0.depthWriteEnabled = arg1 !== 0;
|
|
5029
|
+
},
|
|
5030
|
+
__wbg_set_device_bf67f52a587f9aab: function(arg0, arg1) {
|
|
5031
|
+
arg0.device = arg1;
|
|
5032
|
+
},
|
|
5033
|
+
__wbg_set_dimension_3144c827eb67b110: function(arg0, arg1) {
|
|
5034
|
+
arg0.dimension = __wbindgen_enum_GpuTextureViewDimension[arg1];
|
|
5035
|
+
},
|
|
5036
|
+
__wbg_set_dimension_9054f7ab0acbfd31: function(arg0, arg1) {
|
|
5037
|
+
arg0.dimension = __wbindgen_enum_GpuTextureDimension[arg1];
|
|
5038
|
+
},
|
|
5039
|
+
__wbg_set_dst_factor_77c088c0ad43b684: function(arg0, arg1) {
|
|
5040
|
+
arg0.dstFactor = __wbindgen_enum_GpuBlendFactor[arg1];
|
|
5041
|
+
},
|
|
5042
|
+
__wbg_set_end_of_pass_write_index_568e7295b1b273a3: function(arg0, arg1) {
|
|
5043
|
+
arg0.endOfPassWriteIndex = arg1 >>> 0;
|
|
5044
|
+
},
|
|
5045
|
+
__wbg_set_end_of_pass_write_index_786588764311c9aa: function(arg0, arg1) {
|
|
5046
|
+
arg0.endOfPassWriteIndex = arg1 >>> 0;
|
|
5047
|
+
},
|
|
5048
|
+
__wbg_set_entries_247b5e665db79583: function(arg0, arg1) {
|
|
5049
|
+
arg0.entries = arg1;
|
|
5050
|
+
},
|
|
5051
|
+
__wbg_set_entries_bfbb6a7f04b96709: function(arg0, arg1) {
|
|
5052
|
+
arg0.entries = arg1;
|
|
5053
|
+
},
|
|
5054
|
+
__wbg_set_entry_point_1d7ecf099e15fa2b: function(arg0, arg1, arg2) {
|
|
5055
|
+
arg0.entryPoint = getStringFromWasm0(arg1, arg2);
|
|
5056
|
+
},
|
|
5057
|
+
__wbg_set_entry_point_3b13db51cfe0c5d6: function(arg0, arg1, arg2) {
|
|
5058
|
+
arg0.entryPoint = getStringFromWasm0(arg1, arg2);
|
|
5059
|
+
},
|
|
5060
|
+
__wbg_set_entry_point_a698bc91b472d5a9: function(arg0, arg1, arg2) {
|
|
5061
|
+
arg0.entryPoint = getStringFromWasm0(arg1, arg2);
|
|
5062
|
+
},
|
|
5063
|
+
__wbg_set_external_texture_a0db2eb13c76e01c: function(arg0, arg1) {
|
|
5064
|
+
arg0.externalTexture = arg1;
|
|
5065
|
+
},
|
|
5066
|
+
__wbg_set_fail_op_a6890cff6b560a14: function(arg0, arg1) {
|
|
5067
|
+
arg0.failOp = __wbindgen_enum_GpuStencilOperation[arg1];
|
|
5068
|
+
},
|
|
5069
|
+
__wbg_set_format_237b3e4047d1be9a: function(arg0, arg1) {
|
|
5070
|
+
arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
|
|
5071
|
+
},
|
|
5072
|
+
__wbg_set_format_53479155b45c92ea: function(arg0, arg1) {
|
|
5073
|
+
arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
|
|
5074
|
+
},
|
|
5075
|
+
__wbg_set_format_7c20bfc7e4802e1e: function(arg0, arg1) {
|
|
5076
|
+
arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
|
|
5077
|
+
},
|
|
5078
|
+
__wbg_set_format_84af8ed546a319fa: function(arg0, arg1) {
|
|
5079
|
+
arg0.format = __wbindgen_enum_GpuVertexFormat[arg1];
|
|
5080
|
+
},
|
|
5081
|
+
__wbg_set_format_9f32450123336995: function(arg0, arg1) {
|
|
5082
|
+
arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
|
|
5083
|
+
},
|
|
5084
|
+
__wbg_set_format_c9dcecebf9c1e619: function(arg0, arg1) {
|
|
5085
|
+
arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
|
|
5086
|
+
},
|
|
5087
|
+
__wbg_set_format_d9d3420c1a9d1c59: function(arg0, arg1) {
|
|
5088
|
+
arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
|
|
5089
|
+
},
|
|
5090
|
+
__wbg_set_fragment_2c6f6192456fed1c: function(arg0, arg1) {
|
|
5091
|
+
arg0.fragment = arg1;
|
|
5092
|
+
},
|
|
5093
|
+
__wbg_set_front_face_fd34f06ac9239d11: function(arg0, arg1) {
|
|
5094
|
+
arg0.frontFace = __wbindgen_enum_GpuFrontFace[arg1];
|
|
5095
|
+
},
|
|
5096
|
+
__wbg_set_g_7bb456722103c5e6: function(arg0, arg1) {
|
|
5097
|
+
arg0.g = arg1;
|
|
5098
|
+
},
|
|
5099
|
+
__wbg_set_has_dynamic_offset_0c8a607543be8069: function(arg0, arg1) {
|
|
5100
|
+
arg0.hasDynamicOffset = arg1 !== 0;
|
|
5101
|
+
},
|
|
5102
|
+
__wbg_set_height_7d9d8f892e6964c6: function(arg0, arg1) {
|
|
5103
|
+
arg0.height = arg1 >>> 0;
|
|
5104
|
+
},
|
|
5105
|
+
__wbg_set_height_96611e96eee67c44: function(arg0, arg1) {
|
|
5106
|
+
arg0.height = arg1 >>> 0;
|
|
5107
|
+
},
|
|
5108
|
+
__wbg_set_height_bbeef8f354041577: function(arg0, arg1) {
|
|
5109
|
+
arg0.height = arg1 >>> 0;
|
|
5110
|
+
},
|
|
5111
|
+
__wbg_set_label_01228663ea03b92f: function(arg0, arg1, arg2) {
|
|
5112
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
5113
|
+
},
|
|
5114
|
+
__wbg_set_label_13a2dd9810399e8b: function(arg0, arg1, arg2) {
|
|
5115
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
5116
|
+
},
|
|
5117
|
+
__wbg_set_label_22e57f4c5b38215f: function(arg0, arg1, arg2) {
|
|
5118
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
5119
|
+
},
|
|
5120
|
+
__wbg_set_label_3341f59be0eb3205: function(arg0, arg1, arg2) {
|
|
5121
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
5122
|
+
},
|
|
5123
|
+
__wbg_set_label_382417d222111912: function(arg0, arg1, arg2) {
|
|
5124
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
5125
|
+
},
|
|
5126
|
+
__wbg_set_label_4d049edb707ba31c: function(arg0, arg1, arg2) {
|
|
5127
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
5128
|
+
},
|
|
5129
|
+
__wbg_set_label_5724e5c6286e8a4e: function(arg0, arg1, arg2) {
|
|
5130
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
5131
|
+
},
|
|
5132
|
+
__wbg_set_label_66fc1d23dd10d4f5: function(arg0, arg1, arg2) {
|
|
5133
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
5134
|
+
},
|
|
5135
|
+
__wbg_set_label_806446f85d68e201: function(arg0, arg1, arg2) {
|
|
5136
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
5137
|
+
},
|
|
5138
|
+
__wbg_set_label_8354c6463558484f: function(arg0, arg1, arg2) {
|
|
5139
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
5140
|
+
},
|
|
5141
|
+
__wbg_set_label_acd66edf00f8e40f: function(arg0, arg1, arg2) {
|
|
5142
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
5143
|
+
},
|
|
5144
|
+
__wbg_set_label_b3da7636c69f1a4c: function(arg0, arg1, arg2) {
|
|
5145
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
5146
|
+
},
|
|
5147
|
+
__wbg_set_label_b7f797c13bc822c4: function(arg0, arg1, arg2) {
|
|
5148
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
5149
|
+
},
|
|
5150
|
+
__wbg_set_label_e026aa2aea731594: function(arg0, arg1, arg2) {
|
|
5151
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
5152
|
+
},
|
|
5153
|
+
__wbg_set_label_e6bc3b86ef6deeb8: function(arg0, arg1, arg2) {
|
|
5154
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
5155
|
+
},
|
|
5156
|
+
__wbg_set_label_e7f76bba99d72971: function(arg0, arg1, arg2) {
|
|
5157
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
5158
|
+
},
|
|
5159
|
+
__wbg_set_layout_210c56f1b01e883b: function(arg0, arg1) {
|
|
5160
|
+
arg0.layout = arg1;
|
|
5161
|
+
},
|
|
5162
|
+
__wbg_set_layout_44943c4c7d78f826: function(arg0, arg1) {
|
|
5163
|
+
arg0.layout = arg1;
|
|
5164
|
+
},
|
|
5165
|
+
__wbg_set_layout_726c6ae6f5919730: function(arg0, arg1) {
|
|
5166
|
+
arg0.layout = arg1;
|
|
5167
|
+
},
|
|
5168
|
+
__wbg_set_load_op_103e6ce0a06327b3: function(arg0, arg1) {
|
|
5169
|
+
arg0.loadOp = __wbindgen_enum_GpuLoadOp[arg1];
|
|
5170
|
+
},
|
|
5171
|
+
__wbg_set_lod_max_clamp_3706b17de6a5a11a: function(arg0, arg1) {
|
|
5172
|
+
arg0.lodMaxClamp = arg1;
|
|
5173
|
+
},
|
|
5174
|
+
__wbg_set_lod_min_clamp_1f4b28d77d0c87c4: function(arg0, arg1) {
|
|
5175
|
+
arg0.lodMinClamp = arg1;
|
|
5176
|
+
},
|
|
5177
|
+
__wbg_set_mag_filter_2c8c212ff297b151: function(arg0, arg1) {
|
|
5178
|
+
arg0.magFilter = __wbindgen_enum_GpuFilterMode[arg1];
|
|
5179
|
+
},
|
|
5180
|
+
__wbg_set_mapped_at_creation_12773dff1bb6ea0f: function(arg0, arg1) {
|
|
5181
|
+
arg0.mappedAtCreation = arg1 !== 0;
|
|
5182
|
+
},
|
|
5183
|
+
__wbg_set_mask_94311bacf22c96b1: function(arg0, arg1) {
|
|
5184
|
+
arg0.mask = arg1 >>> 0;
|
|
5185
|
+
},
|
|
5186
|
+
__wbg_set_max_anisotropy_56bff110d0b4830f: function(arg0, arg1) {
|
|
5187
|
+
arg0.maxAnisotropy = arg1;
|
|
5188
|
+
},
|
|
5189
|
+
__wbg_set_min_binding_size_164df827e02821e1: function(arg0, arg1) {
|
|
5190
|
+
arg0.minBindingSize = arg1;
|
|
5191
|
+
},
|
|
5192
|
+
__wbg_set_min_filter_66d70efb70601bf9: function(arg0, arg1) {
|
|
5193
|
+
arg0.minFilter = __wbindgen_enum_GpuFilterMode[arg1];
|
|
5194
|
+
},
|
|
5195
|
+
__wbg_set_mip_level_7f56c1c607dda5cf: function(arg0, arg1) {
|
|
5196
|
+
arg0.mipLevel = arg1 >>> 0;
|
|
5197
|
+
},
|
|
5198
|
+
__wbg_set_mip_level_count_3402f5315a423b69: function(arg0, arg1) {
|
|
5199
|
+
arg0.mipLevelCount = arg1 >>> 0;
|
|
5200
|
+
},
|
|
5201
|
+
__wbg_set_mip_level_count_ed029120a0ee12b8: function(arg0, arg1) {
|
|
5202
|
+
arg0.mipLevelCount = arg1 >>> 0;
|
|
5203
|
+
},
|
|
5204
|
+
__wbg_set_mipmap_filter_1b3d153bd834ec26: function(arg0, arg1) {
|
|
5205
|
+
arg0.mipmapFilter = __wbindgen_enum_GpuMipmapFilterMode[arg1];
|
|
5206
|
+
},
|
|
5207
|
+
__wbg_set_module_119c125107e59165: function(arg0, arg1) {
|
|
5208
|
+
arg0.module = arg1;
|
|
5209
|
+
},
|
|
5210
|
+
__wbg_set_module_3336e0ce2672c07c: function(arg0, arg1) {
|
|
5211
|
+
arg0.module = arg1;
|
|
5212
|
+
},
|
|
5213
|
+
__wbg_set_module_af2f871a0bed003c: function(arg0, arg1) {
|
|
5214
|
+
arg0.module = arg1;
|
|
5215
|
+
},
|
|
5216
|
+
__wbg_set_multisample_1cdb4998c4f73341: function(arg0, arg1) {
|
|
5217
|
+
arg0.multisample = arg1;
|
|
5218
|
+
},
|
|
5219
|
+
__wbg_set_multisampled_e9d7bed0e68d1d6f: function(arg0, arg1) {
|
|
5220
|
+
arg0.multisampled = arg1 !== 0;
|
|
5221
|
+
},
|
|
5222
|
+
__wbg_set_offset_01c04218a4ccfa08: function(arg0, arg1) {
|
|
5223
|
+
arg0.offset = arg1;
|
|
5224
|
+
},
|
|
5225
|
+
__wbg_set_offset_5ea55c758ce6f103: function(arg0, arg1) {
|
|
5226
|
+
arg0.offset = arg1;
|
|
5227
|
+
},
|
|
5228
|
+
__wbg_set_offset_bd11f79890456c6f: function(arg0, arg1) {
|
|
5229
|
+
arg0.offset = arg1;
|
|
5230
|
+
},
|
|
5231
|
+
__wbg_set_offset_f07a73165707eb4c: function(arg0, arg1) {
|
|
5232
|
+
arg0.offset = arg1;
|
|
5233
|
+
},
|
|
5234
|
+
__wbg_set_operation_845ee9de4c1808be: function(arg0, arg1) {
|
|
5235
|
+
arg0.operation = __wbindgen_enum_GpuBlendOperation[arg1];
|
|
5236
|
+
},
|
|
5237
|
+
__wbg_set_origin_6be40076fb0623f4: function(arg0, arg1) {
|
|
5238
|
+
arg0.origin = arg1;
|
|
5239
|
+
},
|
|
5240
|
+
__wbg_set_pass_op_f4a566b4a6b819e0: function(arg0, arg1) {
|
|
5241
|
+
arg0.passOp = __wbindgen_enum_GpuStencilOperation[arg1];
|
|
5242
|
+
},
|
|
5243
|
+
__wbg_set_power_preference_0721cf46746c0c7d: function(arg0, arg1) {
|
|
5244
|
+
arg0.powerPreference = __wbindgen_enum_GpuPowerPreference[arg1];
|
|
5245
|
+
},
|
|
5246
|
+
__wbg_set_primitive_94234ea756a4c469: function(arg0, arg1) {
|
|
5247
|
+
arg0.primitive = arg1;
|
|
5248
|
+
},
|
|
5249
|
+
__wbg_set_query_set_667d2dcfcedd1ec2: function(arg0, arg1) {
|
|
5250
|
+
arg0.querySet = arg1;
|
|
5251
|
+
},
|
|
5252
|
+
__wbg_set_query_set_aadbb433c8390a5c: function(arg0, arg1) {
|
|
5253
|
+
arg0.querySet = arg1;
|
|
5254
|
+
},
|
|
5255
|
+
__wbg_set_r_13b3eba61d4ba4d9: function(arg0, arg1) {
|
|
5256
|
+
arg0.r = arg1;
|
|
5257
|
+
},
|
|
5258
|
+
__wbg_set_required_features_5202fa8cd082e531: function(arg0, arg1) {
|
|
5259
|
+
arg0.requiredFeatures = arg1;
|
|
5260
|
+
},
|
|
5261
|
+
__wbg_set_resolve_target_8251ec563ce24501: function(arg0, arg1) {
|
|
5262
|
+
arg0.resolveTarget = arg1;
|
|
5263
|
+
},
|
|
5264
|
+
__wbg_set_resource_c73d0c2d815f7211: function(arg0, arg1) {
|
|
5265
|
+
arg0.resource = arg1;
|
|
5266
|
+
},
|
|
5267
|
+
__wbg_set_rows_per_image_00c8e938dae40dae: function(arg0, arg1) {
|
|
5268
|
+
arg0.rowsPerImage = arg1 >>> 0;
|
|
5269
|
+
},
|
|
5270
|
+
__wbg_set_rows_per_image_e6e2c0c4a7e4fa8d: function(arg0, arg1) {
|
|
5271
|
+
arg0.rowsPerImage = arg1 >>> 0;
|
|
5272
|
+
},
|
|
5273
|
+
__wbg_set_sample_count_05dcc9952f4fa7ac: function(arg0, arg1) {
|
|
5274
|
+
arg0.sampleCount = arg1 >>> 0;
|
|
5275
|
+
},
|
|
5276
|
+
__wbg_set_sample_type_93886b8f9794f85c: function(arg0, arg1) {
|
|
5277
|
+
arg0.sampleType = __wbindgen_enum_GpuTextureSampleType[arg1];
|
|
5278
|
+
},
|
|
5279
|
+
__wbg_set_sampler_02989e99b27a50db: function(arg0, arg1) {
|
|
5280
|
+
arg0.sampler = arg1;
|
|
5281
|
+
},
|
|
5282
|
+
__wbg_set_shader_location_33bfc2cc417fdde2: function(arg0, arg1) {
|
|
5283
|
+
arg0.shaderLocation = arg1 >>> 0;
|
|
5284
|
+
},
|
|
5285
|
+
__wbg_set_size_b3e6b2bf58d62082: function(arg0, arg1) {
|
|
5286
|
+
arg0.size = arg1;
|
|
5287
|
+
},
|
|
5288
|
+
__wbg_set_size_c2a556d5571231f5: function(arg0, arg1) {
|
|
5289
|
+
arg0.size = arg1;
|
|
5290
|
+
},
|
|
5291
|
+
__wbg_set_size_f7b29f6cb1669c4d: function(arg0, arg1) {
|
|
5292
|
+
arg0.size = arg1;
|
|
5293
|
+
},
|
|
5294
|
+
__wbg_set_src_factor_deefdfd4b6427b5e: function(arg0, arg1) {
|
|
5295
|
+
arg0.srcFactor = __wbindgen_enum_GpuBlendFactor[arg1];
|
|
5296
|
+
},
|
|
5297
|
+
__wbg_set_stencil_back_9971eece60c613eb: function(arg0, arg1) {
|
|
5298
|
+
arg0.stencilBack = arg1;
|
|
5299
|
+
},
|
|
5300
|
+
__wbg_set_stencil_clear_value_4b82f2d7e6d9f496: function(arg0, arg1) {
|
|
5301
|
+
arg0.stencilClearValue = arg1 >>> 0;
|
|
5302
|
+
},
|
|
5303
|
+
__wbg_set_stencil_front_c82ccf19db426a5b: function(arg0, arg1) {
|
|
5304
|
+
arg0.stencilFront = arg1;
|
|
5305
|
+
},
|
|
5306
|
+
__wbg_set_stencil_load_op_dbc3af9713146f24: function(arg0, arg1) {
|
|
5307
|
+
arg0.stencilLoadOp = __wbindgen_enum_GpuLoadOp[arg1];
|
|
5308
|
+
},
|
|
5309
|
+
__wbg_set_stencil_read_mask_926bce469fa8eaf3: function(arg0, arg1) {
|
|
5310
|
+
arg0.stencilReadMask = arg1 >>> 0;
|
|
5311
|
+
},
|
|
5312
|
+
__wbg_set_stencil_read_only_88136eaf94225fec: function(arg0, arg1) {
|
|
5313
|
+
arg0.stencilReadOnly = arg1 !== 0;
|
|
5314
|
+
},
|
|
5315
|
+
__wbg_set_stencil_store_op_e10e50255bf42e8b: function(arg0, arg1) {
|
|
5316
|
+
arg0.stencilStoreOp = __wbindgen_enum_GpuStoreOp[arg1];
|
|
5317
|
+
},
|
|
5318
|
+
__wbg_set_stencil_write_mask_3a7b75284ae036de: function(arg0, arg1) {
|
|
5319
|
+
arg0.stencilWriteMask = arg1 >>> 0;
|
|
5320
|
+
},
|
|
5321
|
+
__wbg_set_step_mode_2a36020da93d6f16: function(arg0, arg1) {
|
|
5322
|
+
arg0.stepMode = __wbindgen_enum_GpuVertexStepMode[arg1];
|
|
5323
|
+
},
|
|
5324
|
+
__wbg_set_storage_texture_50af47fec531be02: function(arg0, arg1) {
|
|
5325
|
+
arg0.storageTexture = arg1;
|
|
5326
|
+
},
|
|
5327
|
+
__wbg_set_store_op_23c150f1deb52749: function(arg0, arg1) {
|
|
5328
|
+
arg0.storeOp = __wbindgen_enum_GpuStoreOp[arg1];
|
|
5329
|
+
},
|
|
5330
|
+
__wbg_set_strip_index_format_bd4035f66052e74e: function(arg0, arg1) {
|
|
5331
|
+
arg0.stripIndexFormat = __wbindgen_enum_GpuIndexFormat[arg1];
|
|
5332
|
+
},
|
|
5333
|
+
__wbg_set_targets_d4d849b9c6abd35a: function(arg0, arg1) {
|
|
5334
|
+
arg0.targets = arg1;
|
|
5335
|
+
},
|
|
5336
|
+
__wbg_set_texture_884f2777c0fe1e91: function(arg0, arg1) {
|
|
5337
|
+
arg0.texture = arg1;
|
|
5338
|
+
},
|
|
5339
|
+
__wbg_set_texture_a1baf7da91d20351: function(arg0, arg1) {
|
|
5340
|
+
arg0.texture = arg1;
|
|
5341
|
+
},
|
|
5342
|
+
__wbg_set_timestamp_writes_7fa18118aa24ddc1: function(arg0, arg1) {
|
|
5343
|
+
arg0.timestampWrites = arg1;
|
|
5344
|
+
},
|
|
5345
|
+
__wbg_set_timestamp_writes_fdf8168751575b7f: function(arg0, arg1) {
|
|
5346
|
+
arg0.timestampWrites = arg1;
|
|
5347
|
+
},
|
|
5348
|
+
__wbg_set_topology_0a07d5f484aff275: function(arg0, arg1) {
|
|
5349
|
+
arg0.topology = __wbindgen_enum_GpuPrimitiveTopology[arg1];
|
|
5350
|
+
},
|
|
5351
|
+
__wbg_set_type_109702a7ec65b49d: function(arg0, arg1) {
|
|
5352
|
+
arg0.type = __wbindgen_enum_GpuSamplerBindingType[arg1];
|
|
5353
|
+
},
|
|
5354
|
+
__wbg_set_type_55112c374bcc5a9d: function(arg0, arg1) {
|
|
5355
|
+
arg0.type = __wbindgen_enum_GpuBufferBindingType[arg1];
|
|
5356
|
+
},
|
|
5357
|
+
__wbg_set_type_9b9ab9961bd236f7: function(arg0, arg1) {
|
|
5358
|
+
arg0.type = __wbindgen_enum_GpuQueryType[arg1];
|
|
5359
|
+
},
|
|
5360
|
+
__wbg_set_unclipped_depth_b15740038a226817: function(arg0, arg1) {
|
|
5361
|
+
arg0.unclippedDepth = arg1 !== 0;
|
|
5362
|
+
},
|
|
5363
|
+
__wbg_set_usage_75d0e81d39ff5284: function(arg0, arg1) {
|
|
5364
|
+
arg0.usage = arg1 >>> 0;
|
|
5365
|
+
},
|
|
5366
|
+
__wbg_set_usage_ac04cadda4108c1a: function(arg0, arg1) {
|
|
5367
|
+
arg0.usage = arg1 >>> 0;
|
|
5368
|
+
},
|
|
5369
|
+
__wbg_set_usage_ad30cd3b0e0f4244: function(arg0, arg1) {
|
|
5370
|
+
arg0.usage = arg1 >>> 0;
|
|
5371
|
+
},
|
|
5372
|
+
__wbg_set_usage_cc34543608cf3335: function(arg0, arg1) {
|
|
5373
|
+
arg0.usage = arg1 >>> 0;
|
|
5374
|
+
},
|
|
5375
|
+
__wbg_set_vertex_13029c78ba2f0430: function(arg0, arg1) {
|
|
5376
|
+
arg0.vertex = arg1;
|
|
5377
|
+
},
|
|
5378
|
+
__wbg_set_view_6f2831c0da43be15: function(arg0, arg1) {
|
|
5379
|
+
arg0.view = arg1;
|
|
5380
|
+
},
|
|
5381
|
+
__wbg_set_view_b18c2cccd427261d: function(arg0, arg1) {
|
|
5382
|
+
arg0.view = arg1;
|
|
5383
|
+
},
|
|
5384
|
+
__wbg_set_view_dimension_50f3edb06107948f: function(arg0, arg1) {
|
|
5385
|
+
arg0.viewDimension = __wbindgen_enum_GpuTextureViewDimension[arg1];
|
|
5386
|
+
},
|
|
5387
|
+
__wbg_set_view_dimension_925bb358df1f2b9d: function(arg0, arg1) {
|
|
5388
|
+
arg0.viewDimension = __wbindgen_enum_GpuTextureViewDimension[arg1];
|
|
5389
|
+
},
|
|
5390
|
+
__wbg_set_view_formats_3d2a72ffb1f55a75: function(arg0, arg1) {
|
|
5391
|
+
arg0.viewFormats = arg1;
|
|
5392
|
+
},
|
|
5393
|
+
__wbg_set_view_formats_ae87e8e12aa858fc: function(arg0, arg1) {
|
|
5394
|
+
arg0.viewFormats = arg1;
|
|
5395
|
+
},
|
|
5396
|
+
__wbg_set_visibility_bdebc70a7c0f236d: function(arg0, arg1) {
|
|
5397
|
+
arg0.visibility = arg1 >>> 0;
|
|
5398
|
+
},
|
|
5399
|
+
__wbg_set_width_40592253da7b2113: function(arg0, arg1) {
|
|
5400
|
+
arg0.width = arg1 >>> 0;
|
|
5401
|
+
},
|
|
5402
|
+
__wbg_set_width_49ac9b7d914afc85: function(arg0, arg1) {
|
|
5403
|
+
arg0.width = arg1 >>> 0;
|
|
5404
|
+
},
|
|
5405
|
+
__wbg_set_width_8e30d010cd66830d: function(arg0, arg1) {
|
|
5406
|
+
arg0.width = arg1 >>> 0;
|
|
5407
|
+
},
|
|
5408
|
+
__wbg_set_write_mask_c03e8a45a9236e80: function(arg0, arg1) {
|
|
5409
|
+
arg0.writeMask = arg1 >>> 0;
|
|
5410
|
+
},
|
|
5411
|
+
__wbg_set_x_3c1cb8191b848172: function(arg0, arg1) {
|
|
5412
|
+
arg0.x = arg1 >>> 0;
|
|
5413
|
+
},
|
|
5414
|
+
__wbg_set_y_9024331910317eff: function(arg0, arg1) {
|
|
5415
|
+
arg0.y = arg1 >>> 0;
|
|
5416
|
+
},
|
|
5417
|
+
__wbg_set_z_b6182f4c230116a7: function(arg0, arg1) {
|
|
5418
|
+
arg0.z = arg1 >>> 0;
|
|
5419
|
+
},
|
|
5420
|
+
__wbg_shaderSource_4cf90af97621ff49: function(arg0, arg1, arg2, arg3) {
|
|
5421
|
+
arg0.shaderSource(arg1, getStringFromWasm0(arg2, arg3));
|
|
5422
|
+
},
|
|
5423
|
+
__wbg_shaderSource_c3469dc2221dd528: function(arg0, arg1, arg2, arg3) {
|
|
5424
|
+
arg0.shaderSource(arg1, getStringFromWasm0(arg2, arg3));
|
|
5425
|
+
},
|
|
5426
|
+
__wbg_static_accessor_GLOBAL_4ef717fb391d88b7: function() {
|
|
5427
|
+
const ret = typeof global === 'undefined' ? null : global;
|
|
5428
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
5429
|
+
},
|
|
5430
|
+
__wbg_static_accessor_GLOBAL_THIS_8d1badc68b5a74f4: function() {
|
|
5431
|
+
const ret = typeof globalThis === 'undefined' ? null : globalThis;
|
|
5432
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
5433
|
+
},
|
|
5434
|
+
__wbg_static_accessor_SELF_146583524fe1469b: function() {
|
|
5435
|
+
const ret = typeof self === 'undefined' ? null : self;
|
|
5436
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
5437
|
+
},
|
|
5438
|
+
__wbg_static_accessor_WINDOW_f2829a2234d7819e: function() {
|
|
5439
|
+
const ret = typeof window === 'undefined' ? null : window;
|
|
5440
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
5441
|
+
},
|
|
5442
|
+
__wbg_status_c45b3b9b3033184a: function(arg0) {
|
|
5443
|
+
const ret = arg0.status;
|
|
5444
|
+
return ret;
|
|
5445
|
+
},
|
|
5446
|
+
__wbg_stencilFuncSeparate_35136c4e5153406f: function(arg0, arg1, arg2, arg3, arg4) {
|
|
5447
|
+
arg0.stencilFuncSeparate(arg1 >>> 0, arg2 >>> 0, arg3, arg4 >>> 0);
|
|
5448
|
+
},
|
|
5449
|
+
__wbg_stencilFuncSeparate_814300446c2969ef: function(arg0, arg1, arg2, arg3, arg4) {
|
|
5450
|
+
arg0.stencilFuncSeparate(arg1 >>> 0, arg2 >>> 0, arg3, arg4 >>> 0);
|
|
5451
|
+
},
|
|
5452
|
+
__wbg_stencilMaskSeparate_49367b0b5883a8bd: function(arg0, arg1, arg2) {
|
|
5453
|
+
arg0.stencilMaskSeparate(arg1 >>> 0, arg2 >>> 0);
|
|
5454
|
+
},
|
|
5455
|
+
__wbg_stencilMaskSeparate_63976cc45fb94d84: function(arg0, arg1, arg2) {
|
|
5456
|
+
arg0.stencilMaskSeparate(arg1 >>> 0, arg2 >>> 0);
|
|
5457
|
+
},
|
|
5458
|
+
__wbg_stencilMask_1c99b79b516d12dd: function(arg0, arg1) {
|
|
5459
|
+
arg0.stencilMask(arg1 >>> 0);
|
|
5460
|
+
},
|
|
5461
|
+
__wbg_stencilMask_9a844dc58a89992f: function(arg0, arg1) {
|
|
5462
|
+
arg0.stencilMask(arg1 >>> 0);
|
|
5463
|
+
},
|
|
5464
|
+
__wbg_stencilOpSeparate_b2cb9af05b803e02: function(arg0, arg1, arg2, arg3, arg4) {
|
|
5465
|
+
arg0.stencilOpSeparate(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4 >>> 0);
|
|
5466
|
+
},
|
|
5467
|
+
__wbg_stencilOpSeparate_c77fcb47561d0aee: function(arg0, arg1, arg2, arg3, arg4) {
|
|
5468
|
+
arg0.stencilOpSeparate(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4 >>> 0);
|
|
5469
|
+
},
|
|
5470
|
+
__wbg_subarray_3ed232c8a6baee09: function(arg0, arg1, arg2) {
|
|
5471
|
+
const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
|
|
5472
|
+
return ret;
|
|
5473
|
+
},
|
|
5474
|
+
__wbg_submit_fc5b9a1154201a58: function(arg0, arg1) {
|
|
5475
|
+
arg0.submit(arg1);
|
|
5476
|
+
},
|
|
5477
|
+
__wbg_texImage2D_3813406af5bf54c8: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
|
|
5478
|
+
arg0.texImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
|
|
5479
|
+
}, arguments); },
|
|
5480
|
+
__wbg_texImage2D_5abd8779d1d033c7: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
|
|
5481
|
+
arg0.texImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
|
|
5482
|
+
}, arguments); },
|
|
5483
|
+
__wbg_texImage2D_8d168171984f2a40: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
|
|
5484
|
+
arg0.texImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
|
|
5485
|
+
}, arguments); },
|
|
5486
|
+
__wbg_texImage3D_bdd9bebe42ed1f52: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) {
|
|
5487
|
+
arg0.texImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8 >>> 0, arg9 >>> 0, arg10);
|
|
5488
|
+
}, arguments); },
|
|
5489
|
+
__wbg_texImage3D_ef16a1f721b3f908: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) {
|
|
5490
|
+
arg0.texImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8 >>> 0, arg9 >>> 0, arg10);
|
|
5491
|
+
}, arguments); },
|
|
5492
|
+
__wbg_texParameteri_1fc451e0964fc91c: function(arg0, arg1, arg2, arg3) {
|
|
5493
|
+
arg0.texParameteri(arg1 >>> 0, arg2 >>> 0, arg3);
|
|
5494
|
+
},
|
|
5495
|
+
__wbg_texParameteri_9d0daa263d3a863f: function(arg0, arg1, arg2, arg3) {
|
|
5496
|
+
arg0.texParameteri(arg1 >>> 0, arg2 >>> 0, arg3);
|
|
5497
|
+
},
|
|
5498
|
+
__wbg_texStorage2D_7f947efc63dac273: function(arg0, arg1, arg2, arg3, arg4, arg5) {
|
|
5499
|
+
arg0.texStorage2D(arg1 >>> 0, arg2, arg3 >>> 0, arg4, arg5);
|
|
5500
|
+
},
|
|
5501
|
+
__wbg_texStorage3D_f8f2e4b3386736f9: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
|
|
5502
|
+
arg0.texStorage3D(arg1 >>> 0, arg2, arg3 >>> 0, arg4, arg5, arg6);
|
|
5503
|
+
},
|
|
5504
|
+
__wbg_texSubImage2D_047380bb2660e4f9: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
|
|
5505
|
+
arg0.texSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
|
|
5506
|
+
}, arguments); },
|
|
5507
|
+
__wbg_texSubImage2D_5058af3d30a8e205: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
|
|
5508
|
+
arg0.texSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
|
|
5509
|
+
}, arguments); },
|
|
5510
|
+
__wbg_texSubImage2D_6a376bfc3a31436b: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
|
|
5511
|
+
arg0.texSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
|
|
5512
|
+
}, arguments); },
|
|
5513
|
+
__wbg_texSubImage2D_98c43894eb217aa7: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
|
|
5514
|
+
arg0.texSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
|
|
5515
|
+
}, arguments); },
|
|
5516
|
+
__wbg_texSubImage2D_bed5e7a3cd81d409: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
|
|
5517
|
+
arg0.texSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
|
|
5518
|
+
}, arguments); },
|
|
5519
|
+
__wbg_texSubImage2D_d1af697e69f8a9e4: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
|
|
5520
|
+
arg0.texSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
|
|
5521
|
+
}, arguments); },
|
|
5522
|
+
__wbg_texSubImage2D_d3cd09d0ffcb27be: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
|
|
5523
|
+
arg0.texSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
|
|
5524
|
+
}, arguments); },
|
|
5525
|
+
__wbg_texSubImage2D_e107b4f88c19b920: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
|
|
5526
|
+
arg0.texSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
|
|
5527
|
+
}, arguments); },
|
|
5528
|
+
__wbg_texSubImage3D_45e498ae6298998c: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) {
|
|
5529
|
+
arg0.texSubImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 >>> 0, arg10 >>> 0, arg11);
|
|
5530
|
+
}, arguments); },
|
|
5531
|
+
__wbg_texSubImage3D_4fdd4cd95a2925c2: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) {
|
|
5532
|
+
arg0.texSubImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 >>> 0, arg10 >>> 0, arg11);
|
|
5533
|
+
}, arguments); },
|
|
5534
|
+
__wbg_texSubImage3D_6cb6cfd732dad145: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) {
|
|
5535
|
+
arg0.texSubImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 >>> 0, arg10 >>> 0, arg11);
|
|
5536
|
+
}, arguments); },
|
|
5537
|
+
__wbg_texSubImage3D_8077e90ec309c414: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) {
|
|
5538
|
+
arg0.texSubImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 >>> 0, arg10 >>> 0, arg11);
|
|
5539
|
+
}, arguments); },
|
|
5540
|
+
__wbg_texSubImage3D_93b38c69acb735c8: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) {
|
|
5541
|
+
arg0.texSubImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 >>> 0, arg10 >>> 0, arg11);
|
|
5542
|
+
}, arguments); },
|
|
5543
|
+
__wbg_texSubImage3D_c9e5a071796d412f: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) {
|
|
5544
|
+
arg0.texSubImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 >>> 0, arg10 >>> 0, arg11);
|
|
5545
|
+
}, arguments); },
|
|
5546
|
+
__wbg_texSubImage3D_feebaf7f0f4594c6: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) {
|
|
5547
|
+
arg0.texSubImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 >>> 0, arg10 >>> 0, arg11);
|
|
5548
|
+
}, arguments); },
|
|
5549
|
+
__wbg_then_16d107c451e9905d: function(arg0, arg1, arg2) {
|
|
5550
|
+
const ret = arg0.then(arg1, arg2);
|
|
5551
|
+
return ret;
|
|
5552
|
+
},
|
|
5553
|
+
__wbg_then_4a0b9283a66c4a8a: function(arg0, arg1, arg2) {
|
|
5554
|
+
const ret = arg0.then(arg1, arg2);
|
|
5555
|
+
return ret;
|
|
5556
|
+
},
|
|
5557
|
+
__wbg_then_6ec10ae38b3e92f7: function(arg0, arg1) {
|
|
5558
|
+
const ret = arg0.then(arg1);
|
|
5559
|
+
return ret;
|
|
5560
|
+
},
|
|
5561
|
+
__wbg_uniform1f_62692c8fa8e7bf1e: function(arg0, arg1, arg2) {
|
|
5562
|
+
arg0.uniform1f(arg1, arg2);
|
|
5563
|
+
},
|
|
5564
|
+
__wbg_uniform1f_b79d0c5667f9fb40: function(arg0, arg1, arg2) {
|
|
5565
|
+
arg0.uniform1f(arg1, arg2);
|
|
5566
|
+
},
|
|
5567
|
+
__wbg_uniform1i_5830de6702add20a: function(arg0, arg1, arg2) {
|
|
5568
|
+
arg0.uniform1i(arg1, arg2);
|
|
5569
|
+
},
|
|
5570
|
+
__wbg_uniform1i_7621f908f78177df: function(arg0, arg1, arg2) {
|
|
5571
|
+
arg0.uniform1i(arg1, arg2);
|
|
5572
|
+
},
|
|
5573
|
+
__wbg_uniform1ui_cd7ad5581093b3df: function(arg0, arg1, arg2) {
|
|
5574
|
+
arg0.uniform1ui(arg1, arg2 >>> 0);
|
|
5575
|
+
},
|
|
5576
|
+
__wbg_uniform2fv_1b43656b33177d21: function(arg0, arg1, arg2, arg3) {
|
|
5577
|
+
arg0.uniform2fv(arg1, getArrayF32FromWasm0(arg2, arg3));
|
|
5578
|
+
},
|
|
5579
|
+
__wbg_uniform2fv_948dab6a82b428ac: function(arg0, arg1, arg2, arg3) {
|
|
5580
|
+
arg0.uniform2fv(arg1, getArrayF32FromWasm0(arg2, arg3));
|
|
5581
|
+
},
|
|
5582
|
+
__wbg_uniform2iv_859048b9d60f46ae: function(arg0, arg1, arg2, arg3) {
|
|
5583
|
+
arg0.uniform2iv(arg1, getArrayI32FromWasm0(arg2, arg3));
|
|
5584
|
+
},
|
|
5585
|
+
__wbg_uniform2iv_f84a24961c0cfcd0: function(arg0, arg1, arg2, arg3) {
|
|
5586
|
+
arg0.uniform2iv(arg1, getArrayI32FromWasm0(arg2, arg3));
|
|
5587
|
+
},
|
|
5588
|
+
__wbg_uniform2uiv_8a9cb3155271213b: function(arg0, arg1, arg2, arg3) {
|
|
5589
|
+
arg0.uniform2uiv(arg1, getArrayU32FromWasm0(arg2, arg3));
|
|
2855
5590
|
},
|
|
2856
|
-
|
|
2857
|
-
|
|
2858
|
-
const ret = typeof(val) === 'object' && val !== null;
|
|
2859
|
-
return ret;
|
|
5591
|
+
__wbg_uniform3fv_8ecb5ebb510b7bce: function(arg0, arg1, arg2, arg3) {
|
|
5592
|
+
arg0.uniform3fv(arg1, getArrayF32FromWasm0(arg2, arg3));
|
|
2860
5593
|
},
|
|
2861
|
-
|
|
2862
|
-
|
|
2863
|
-
return ret;
|
|
5594
|
+
__wbg_uniform3fv_95d1933ea1440725: function(arg0, arg1, arg2, arg3) {
|
|
5595
|
+
arg0.uniform3fv(arg1, getArrayF32FromWasm0(arg2, arg3));
|
|
2864
5596
|
},
|
|
2865
|
-
|
|
2866
|
-
|
|
2867
|
-
return ret;
|
|
5597
|
+
__wbg_uniform3iv_09abae5eabd6b9d6: function(arg0, arg1, arg2, arg3) {
|
|
5598
|
+
arg0.uniform3iv(arg1, getArrayI32FromWasm0(arg2, arg3));
|
|
2868
5599
|
},
|
|
2869
|
-
|
|
2870
|
-
|
|
5600
|
+
__wbg_uniform3iv_a3a7008990fd84f0: function(arg0, arg1, arg2, arg3) {
|
|
5601
|
+
arg0.uniform3iv(arg1, getArrayI32FromWasm0(arg2, arg3));
|
|
2871
5602
|
},
|
|
2872
|
-
|
|
2873
|
-
|
|
2874
|
-
return ret;
|
|
2875
|
-
}, arguments); },
|
|
2876
|
-
__wbg_crypto_38df2bab126b63dc: function(arg0) {
|
|
2877
|
-
const ret = arg0.crypto;
|
|
2878
|
-
return ret;
|
|
5603
|
+
__wbg_uniform3uiv_3c0b163732f5b8f0: function(arg0, arg1, arg2, arg3) {
|
|
5604
|
+
arg0.uniform3uiv(arg1, getArrayU32FromWasm0(arg2, arg3));
|
|
2879
5605
|
},
|
|
2880
|
-
|
|
2881
|
-
|
|
5606
|
+
__wbg_uniform4f_9ff60fc65b0ed726: function(arg0, arg1, arg2, arg3, arg4, arg5) {
|
|
5607
|
+
arg0.uniform4f(arg1, arg2, arg3, arg4, arg5);
|
|
2882
5608
|
},
|
|
2883
|
-
|
|
2884
|
-
|
|
2885
|
-
return ret;
|
|
5609
|
+
__wbg_uniform4f_b25e39808b830021: function(arg0, arg1, arg2, arg3, arg4, arg5) {
|
|
5610
|
+
arg0.uniform4f(arg1, arg2, arg3, arg4, arg5);
|
|
2886
5611
|
},
|
|
2887
|
-
|
|
2888
|
-
|
|
2889
|
-
return ret;
|
|
5612
|
+
__wbg_uniform4fv_4ca8c114ca3de099: function(arg0, arg1, arg2, arg3) {
|
|
5613
|
+
arg0.uniform4fv(arg1, getArrayF32FromWasm0(arg2, arg3));
|
|
2890
5614
|
},
|
|
2891
|
-
|
|
2892
|
-
|
|
2893
|
-
return ret;
|
|
5615
|
+
__wbg_uniform4fv_674a247aeb15012d: function(arg0, arg1, arg2, arg3) {
|
|
5616
|
+
arg0.uniform4fv(arg1, getArrayF32FromWasm0(arg2, arg3));
|
|
2894
5617
|
},
|
|
2895
|
-
|
|
2896
|
-
|
|
2897
|
-
return ret;
|
|
5618
|
+
__wbg_uniform4iv_45ab52abcb3f882c: function(arg0, arg1, arg2, arg3) {
|
|
5619
|
+
arg0.uniform4iv(arg1, getArrayI32FromWasm0(arg2, arg3));
|
|
2898
5620
|
},
|
|
2899
|
-
|
|
2900
|
-
|
|
2901
|
-
return ret;
|
|
5621
|
+
__wbg_uniform4iv_d02934d7b94df609: function(arg0, arg1, arg2, arg3) {
|
|
5622
|
+
arg0.uniform4iv(arg1, getArrayI32FromWasm0(arg2, arg3));
|
|
2902
5623
|
},
|
|
2903
|
-
|
|
2904
|
-
|
|
2905
|
-
return ret;
|
|
5624
|
+
__wbg_uniform4uiv_0d1a8ed214f10c31: function(arg0, arg1, arg2, arg3) {
|
|
5625
|
+
arg0.uniform4uiv(arg1, getArrayU32FromWasm0(arg2, arg3));
|
|
2906
5626
|
},
|
|
2907
|
-
|
|
2908
|
-
arg0.
|
|
2909
|
-
}, arguments); },
|
|
2910
|
-
__wbg_length_1f0964f4a5e2c6d8: function(arg0) {
|
|
2911
|
-
const ret = arg0.length;
|
|
2912
|
-
return ret;
|
|
5627
|
+
__wbg_uniformBlockBinding_a9ed6b750199e03c: function(arg0, arg1, arg2, arg3) {
|
|
5628
|
+
arg0.uniformBlockBinding(arg1, arg2 >>> 0, arg3 >>> 0);
|
|
2913
5629
|
},
|
|
2914
|
-
|
|
2915
|
-
|
|
2916
|
-
return ret;
|
|
5630
|
+
__wbg_uniformMatrix2fv_769725d64641341f: function(arg0, arg1, arg2, arg3, arg4) {
|
|
5631
|
+
arg0.uniformMatrix2fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
|
|
2917
5632
|
},
|
|
2918
|
-
|
|
2919
|
-
|
|
2920
|
-
return ret;
|
|
5633
|
+
__wbg_uniformMatrix2fv_9284424cc6aac672: function(arg0, arg1, arg2, arg3, arg4) {
|
|
5634
|
+
arg0.uniformMatrix2fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
|
|
2921
5635
|
},
|
|
2922
|
-
|
|
2923
|
-
|
|
2924
|
-
return ret;
|
|
5636
|
+
__wbg_uniformMatrix2x3fv_dba00c4fc8eefe47: function(arg0, arg1, arg2, arg3, arg4) {
|
|
5637
|
+
arg0.uniformMatrix2x3fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
|
|
2925
5638
|
},
|
|
2926
|
-
|
|
2927
|
-
|
|
2928
|
-
return ret;
|
|
5639
|
+
__wbg_uniformMatrix2x4fv_d801a561c3c18169: function(arg0, arg1, arg2, arg3, arg4) {
|
|
5640
|
+
arg0.uniformMatrix2x4fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
|
|
2929
5641
|
},
|
|
2930
|
-
|
|
2931
|
-
|
|
5642
|
+
__wbg_uniformMatrix3fv_33e96c7d29dc1e22: function(arg0, arg1, arg2, arg3, arg4) {
|
|
5643
|
+
arg0.uniformMatrix3fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
|
|
5644
|
+
},
|
|
5645
|
+
__wbg_uniformMatrix3fv_568aa181379c8a75: function(arg0, arg1, arg2, arg3, arg4) {
|
|
5646
|
+
arg0.uniformMatrix3fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
|
|
5647
|
+
},
|
|
5648
|
+
__wbg_uniformMatrix3x2fv_ce43e8186ea60a1e: function(arg0, arg1, arg2, arg3, arg4) {
|
|
5649
|
+
arg0.uniformMatrix3x2fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
|
|
5650
|
+
},
|
|
5651
|
+
__wbg_uniformMatrix3x4fv_8abccc5745b0dd90: function(arg0, arg1, arg2, arg3, arg4) {
|
|
5652
|
+
arg0.uniformMatrix3x4fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
|
|
5653
|
+
},
|
|
5654
|
+
__wbg_uniformMatrix4fv_25115a23e04f6db7: function(arg0, arg1, arg2, arg3, arg4) {
|
|
5655
|
+
arg0.uniformMatrix4fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
|
|
5656
|
+
},
|
|
5657
|
+
__wbg_uniformMatrix4fv_423b958042692150: function(arg0, arg1, arg2, arg3, arg4) {
|
|
5658
|
+
arg0.uniformMatrix4fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
|
|
5659
|
+
},
|
|
5660
|
+
__wbg_uniformMatrix4x2fv_1ac2bf986a322e3f: function(arg0, arg1, arg2, arg3, arg4) {
|
|
5661
|
+
arg0.uniformMatrix4x2fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
|
|
5662
|
+
},
|
|
5663
|
+
__wbg_uniformMatrix4x3fv_8640fa85b90ea910: function(arg0, arg1, arg2, arg3, arg4) {
|
|
5664
|
+
arg0.uniformMatrix4x3fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
|
|
5665
|
+
},
|
|
5666
|
+
__wbg_unmap_50b3be4aaf23fa39: function(arg0) {
|
|
5667
|
+
arg0.unmap();
|
|
5668
|
+
},
|
|
5669
|
+
__wbg_useProgram_182d120fe476921b: function(arg0, arg1) {
|
|
5670
|
+
arg0.useProgram(arg1);
|
|
5671
|
+
},
|
|
5672
|
+
__wbg_useProgram_49495850b446fa56: function(arg0, arg1) {
|
|
5673
|
+
arg0.useProgram(arg1);
|
|
5674
|
+
},
|
|
5675
|
+
__wbg_versions_276b2795b1c6a219: function(arg0) {
|
|
5676
|
+
const ret = arg0.versions;
|
|
2932
5677
|
return ret;
|
|
2933
5678
|
},
|
|
2934
|
-
|
|
2935
|
-
|
|
5679
|
+
__wbg_vertexAttribDivisorANGLE_978337b09d11ed84: function(arg0, arg1, arg2) {
|
|
5680
|
+
arg0.vertexAttribDivisorANGLE(arg1 >>> 0, arg2 >>> 0);
|
|
5681
|
+
},
|
|
5682
|
+
__wbg_vertexAttribDivisor_fb31b5ed9bc856da: function(arg0, arg1, arg2) {
|
|
5683
|
+
arg0.vertexAttribDivisor(arg1 >>> 0, arg2 >>> 0);
|
|
5684
|
+
},
|
|
5685
|
+
__wbg_vertexAttribIPointer_de08a8d8b625e253: function(arg0, arg1, arg2, arg3, arg4, arg5) {
|
|
5686
|
+
arg0.vertexAttribIPointer(arg1 >>> 0, arg2, arg3 >>> 0, arg4, arg5);
|
|
5687
|
+
},
|
|
5688
|
+
__wbg_vertexAttribPointer_a8f0af57269c2067: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
|
|
5689
|
+
arg0.vertexAttribPointer(arg1 >>> 0, arg2, arg3 >>> 0, arg4 !== 0, arg5, arg6);
|
|
5690
|
+
},
|
|
5691
|
+
__wbg_vertexAttribPointer_b300c8e000cdac93: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
|
|
5692
|
+
arg0.vertexAttribPointer(arg1 >>> 0, arg2, arg3 >>> 0, arg4 !== 0, arg5, arg6);
|
|
5693
|
+
},
|
|
5694
|
+
__wbg_viewport_affdf15c559df1e2: function(arg0, arg1, arg2, arg3, arg4) {
|
|
5695
|
+
arg0.viewport(arg1, arg2, arg3, arg4);
|
|
5696
|
+
},
|
|
5697
|
+
__wbg_viewport_e8a16ca4a5085e5f: function(arg0, arg1, arg2, arg3, arg4) {
|
|
5698
|
+
arg0.viewport(arg1, arg2, arg3, arg4);
|
|
5699
|
+
},
|
|
5700
|
+
__wbg_width_6d9315ecc7140ff6: function(arg0) {
|
|
5701
|
+
const ret = arg0.width;
|
|
2936
5702
|
return ret;
|
|
5703
|
+
},
|
|
5704
|
+
__wbg_writeBuffer_7d54524c36f1c7e2: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
|
|
5705
|
+
arg0.writeBuffer(arg1, arg2, arg3, arg4, arg5);
|
|
2937
5706
|
}, arguments); },
|
|
2938
|
-
|
|
2939
|
-
|
|
5707
|
+
__wbg_writeTexture_9d4c493be748d189: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
|
|
5708
|
+
arg0.writeTexture(arg1, arg2, arg3, arg4);
|
|
5709
|
+
}, arguments); },
|
|
5710
|
+
__wbindgen_cast_0000000000000001: function(arg0, arg1) {
|
|
5711
|
+
// Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 2255, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
|
|
5712
|
+
const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h1592ff3f91e1224b);
|
|
2940
5713
|
return ret;
|
|
2941
5714
|
},
|
|
2942
|
-
|
|
2943
|
-
|
|
5715
|
+
__wbindgen_cast_0000000000000002: function(arg0, arg1) {
|
|
5716
|
+
// Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 5955, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
|
|
5717
|
+
const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h63cbec796bb507b5);
|
|
5718
|
+
return ret;
|
|
2944
5719
|
},
|
|
2945
|
-
|
|
2946
|
-
|
|
2947
|
-
|
|
2948
|
-
__wbg_require_b4edbdcf3e2a1ef0: function() { return handleError(function () {
|
|
2949
|
-
const ret = module.require;
|
|
5720
|
+
__wbindgen_cast_0000000000000003: function(arg0) {
|
|
5721
|
+
// Cast intrinsic for `F64 -> Externref`.
|
|
5722
|
+
const ret = arg0;
|
|
2950
5723
|
return ret;
|
|
2951
|
-
}, arguments); },
|
|
2952
|
-
__wbg_static_accessor_GLOBAL_4ef717fb391d88b7: function() {
|
|
2953
|
-
const ret = typeof global === 'undefined' ? null : global;
|
|
2954
|
-
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
2955
5724
|
},
|
|
2956
|
-
|
|
2957
|
-
|
|
2958
|
-
|
|
5725
|
+
__wbindgen_cast_0000000000000004: function(arg0, arg1) {
|
|
5726
|
+
// Cast intrinsic for `Ref(Slice(F32)) -> NamedExternref("Float32Array")`.
|
|
5727
|
+
const ret = getArrayF32FromWasm0(arg0, arg1);
|
|
5728
|
+
return ret;
|
|
2959
5729
|
},
|
|
2960
|
-
|
|
2961
|
-
|
|
2962
|
-
|
|
5730
|
+
__wbindgen_cast_0000000000000005: function(arg0, arg1) {
|
|
5731
|
+
// Cast intrinsic for `Ref(Slice(I16)) -> NamedExternref("Int16Array")`.
|
|
5732
|
+
const ret = getArrayI16FromWasm0(arg0, arg1);
|
|
5733
|
+
return ret;
|
|
2963
5734
|
},
|
|
2964
|
-
|
|
2965
|
-
|
|
2966
|
-
|
|
5735
|
+
__wbindgen_cast_0000000000000006: function(arg0, arg1) {
|
|
5736
|
+
// Cast intrinsic for `Ref(Slice(I32)) -> NamedExternref("Int32Array")`.
|
|
5737
|
+
const ret = getArrayI32FromWasm0(arg0, arg1);
|
|
5738
|
+
return ret;
|
|
2967
5739
|
},
|
|
2968
|
-
|
|
2969
|
-
|
|
5740
|
+
__wbindgen_cast_0000000000000007: function(arg0, arg1) {
|
|
5741
|
+
// Cast intrinsic for `Ref(Slice(I8)) -> NamedExternref("Int8Array")`.
|
|
5742
|
+
const ret = getArrayI8FromWasm0(arg0, arg1);
|
|
2970
5743
|
return ret;
|
|
2971
5744
|
},
|
|
2972
|
-
|
|
2973
|
-
|
|
5745
|
+
__wbindgen_cast_0000000000000008: function(arg0, arg1) {
|
|
5746
|
+
// Cast intrinsic for `Ref(Slice(U16)) -> NamedExternref("Uint16Array")`.
|
|
5747
|
+
const ret = getArrayU16FromWasm0(arg0, arg1);
|
|
2974
5748
|
return ret;
|
|
2975
5749
|
},
|
|
2976
|
-
|
|
5750
|
+
__wbindgen_cast_0000000000000009: function(arg0, arg1) {
|
|
5751
|
+
// Cast intrinsic for `Ref(Slice(U32)) -> NamedExternref("Uint32Array")`.
|
|
5752
|
+
const ret = getArrayU32FromWasm0(arg0, arg1);
|
|
5753
|
+
return ret;
|
|
5754
|
+
},
|
|
5755
|
+
__wbindgen_cast_000000000000000a: function(arg0, arg1) {
|
|
2977
5756
|
// Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
|
|
2978
5757
|
const ret = getArrayU8FromWasm0(arg0, arg1);
|
|
2979
5758
|
return ret;
|
|
2980
5759
|
},
|
|
2981
|
-
|
|
5760
|
+
__wbindgen_cast_000000000000000b: function(arg0, arg1) {
|
|
2982
5761
|
// Cast intrinsic for `Ref(String) -> Externref`.
|
|
2983
5762
|
const ret = getStringFromWasm0(arg0, arg1);
|
|
2984
5763
|
return ret;
|
|
@@ -2999,15 +5778,119 @@ function __wbg_get_imports() {
|
|
|
2999
5778
|
};
|
|
3000
5779
|
}
|
|
3001
5780
|
|
|
5781
|
+
function wasm_bindgen__convert__closures_____invoke__h1592ff3f91e1224b(arg0, arg1, arg2) {
|
|
5782
|
+
wasm.wasm_bindgen__convert__closures_____invoke__h1592ff3f91e1224b(arg0, arg1, arg2);
|
|
5783
|
+
}
|
|
5784
|
+
|
|
5785
|
+
function wasm_bindgen__convert__closures_____invoke__h63cbec796bb507b5(arg0, arg1, arg2) {
|
|
5786
|
+
const ret = wasm.wasm_bindgen__convert__closures_____invoke__h63cbec796bb507b5(arg0, arg1, arg2);
|
|
5787
|
+
if (ret[1]) {
|
|
5788
|
+
throw takeFromExternrefTable0(ret[0]);
|
|
5789
|
+
}
|
|
5790
|
+
}
|
|
5791
|
+
|
|
5792
|
+
function wasm_bindgen__convert__closures_____invoke__h1149b643047c36f1(arg0, arg1, arg2, arg3) {
|
|
5793
|
+
wasm.wasm_bindgen__convert__closures_____invoke__h1149b643047c36f1(arg0, arg1, arg2, arg3);
|
|
5794
|
+
}
|
|
5795
|
+
|
|
5796
|
+
|
|
5797
|
+
const __wbindgen_enum_GpuAddressMode = ["clamp-to-edge", "repeat", "mirror-repeat"];
|
|
5798
|
+
|
|
5799
|
+
|
|
5800
|
+
const __wbindgen_enum_GpuBlendFactor = ["zero", "one", "src", "one-minus-src", "src-alpha", "one-minus-src-alpha", "dst", "one-minus-dst", "dst-alpha", "one-minus-dst-alpha", "src-alpha-saturated", "constant", "one-minus-constant", "src1", "one-minus-src1", "src1-alpha", "one-minus-src1-alpha"];
|
|
5801
|
+
|
|
5802
|
+
|
|
5803
|
+
const __wbindgen_enum_GpuBlendOperation = ["add", "subtract", "reverse-subtract", "min", "max"];
|
|
5804
|
+
|
|
5805
|
+
|
|
5806
|
+
const __wbindgen_enum_GpuBufferBindingType = ["uniform", "storage", "read-only-storage"];
|
|
5807
|
+
|
|
5808
|
+
|
|
5809
|
+
const __wbindgen_enum_GpuCanvasAlphaMode = ["opaque", "premultiplied"];
|
|
5810
|
+
|
|
5811
|
+
|
|
5812
|
+
const __wbindgen_enum_GpuCompareFunction = ["never", "less", "equal", "less-equal", "greater", "not-equal", "greater-equal", "always"];
|
|
5813
|
+
|
|
5814
|
+
|
|
5815
|
+
const __wbindgen_enum_GpuCullMode = ["none", "front", "back"];
|
|
5816
|
+
|
|
5817
|
+
|
|
5818
|
+
const __wbindgen_enum_GpuErrorFilter = ["validation", "out-of-memory", "internal"];
|
|
5819
|
+
|
|
5820
|
+
|
|
5821
|
+
const __wbindgen_enum_GpuFilterMode = ["nearest", "linear"];
|
|
5822
|
+
|
|
5823
|
+
|
|
5824
|
+
const __wbindgen_enum_GpuFrontFace = ["ccw", "cw"];
|
|
5825
|
+
|
|
5826
|
+
|
|
5827
|
+
const __wbindgen_enum_GpuIndexFormat = ["uint16", "uint32"];
|
|
5828
|
+
|
|
5829
|
+
|
|
5830
|
+
const __wbindgen_enum_GpuLoadOp = ["load", "clear"];
|
|
5831
|
+
|
|
5832
|
+
|
|
5833
|
+
const __wbindgen_enum_GpuMipmapFilterMode = ["nearest", "linear"];
|
|
5834
|
+
|
|
5835
|
+
|
|
5836
|
+
const __wbindgen_enum_GpuPowerPreference = ["low-power", "high-performance"];
|
|
5837
|
+
|
|
5838
|
+
|
|
5839
|
+
const __wbindgen_enum_GpuPrimitiveTopology = ["point-list", "line-list", "line-strip", "triangle-list", "triangle-strip"];
|
|
5840
|
+
|
|
5841
|
+
|
|
5842
|
+
const __wbindgen_enum_GpuQueryType = ["occlusion", "timestamp"];
|
|
5843
|
+
|
|
5844
|
+
|
|
5845
|
+
const __wbindgen_enum_GpuSamplerBindingType = ["filtering", "non-filtering", "comparison"];
|
|
5846
|
+
|
|
5847
|
+
|
|
5848
|
+
const __wbindgen_enum_GpuStencilOperation = ["keep", "zero", "replace", "invert", "increment-clamp", "decrement-clamp", "increment-wrap", "decrement-wrap"];
|
|
5849
|
+
|
|
5850
|
+
|
|
5851
|
+
const __wbindgen_enum_GpuStorageTextureAccess = ["write-only", "read-only", "read-write"];
|
|
5852
|
+
|
|
5853
|
+
|
|
5854
|
+
const __wbindgen_enum_GpuStoreOp = ["store", "discard"];
|
|
5855
|
+
|
|
5856
|
+
|
|
5857
|
+
const __wbindgen_enum_GpuTextureAspect = ["all", "stencil-only", "depth-only"];
|
|
5858
|
+
|
|
5859
|
+
|
|
5860
|
+
const __wbindgen_enum_GpuTextureDimension = ["1d", "2d", "3d"];
|
|
5861
|
+
|
|
5862
|
+
|
|
5863
|
+
const __wbindgen_enum_GpuTextureFormat = ["r8unorm", "r8snorm", "r8uint", "r8sint", "r16uint", "r16sint", "r16float", "rg8unorm", "rg8snorm", "rg8uint", "rg8sint", "r32uint", "r32sint", "r32float", "rg16uint", "rg16sint", "rg16float", "rgba8unorm", "rgba8unorm-srgb", "rgba8snorm", "rgba8uint", "rgba8sint", "bgra8unorm", "bgra8unorm-srgb", "rgb9e5ufloat", "rgb10a2uint", "rgb10a2unorm", "rg11b10ufloat", "rg32uint", "rg32sint", "rg32float", "rgba16uint", "rgba16sint", "rgba16float", "rgba32uint", "rgba32sint", "rgba32float", "stencil8", "depth16unorm", "depth24plus", "depth24plus-stencil8", "depth32float", "depth32float-stencil8", "bc1-rgba-unorm", "bc1-rgba-unorm-srgb", "bc2-rgba-unorm", "bc2-rgba-unorm-srgb", "bc3-rgba-unorm", "bc3-rgba-unorm-srgb", "bc4-r-unorm", "bc4-r-snorm", "bc5-rg-unorm", "bc5-rg-snorm", "bc6h-rgb-ufloat", "bc6h-rgb-float", "bc7-rgba-unorm", "bc7-rgba-unorm-srgb", "etc2-rgb8unorm", "etc2-rgb8unorm-srgb", "etc2-rgb8a1unorm", "etc2-rgb8a1unorm-srgb", "etc2-rgba8unorm", "etc2-rgba8unorm-srgb", "eac-r11unorm", "eac-r11snorm", "eac-rg11unorm", "eac-rg11snorm", "astc-4x4-unorm", "astc-4x4-unorm-srgb", "astc-5x4-unorm", "astc-5x4-unorm-srgb", "astc-5x5-unorm", "astc-5x5-unorm-srgb", "astc-6x5-unorm", "astc-6x5-unorm-srgb", "astc-6x6-unorm", "astc-6x6-unorm-srgb", "astc-8x5-unorm", "astc-8x5-unorm-srgb", "astc-8x6-unorm", "astc-8x6-unorm-srgb", "astc-8x8-unorm", "astc-8x8-unorm-srgb", "astc-10x5-unorm", "astc-10x5-unorm-srgb", "astc-10x6-unorm", "astc-10x6-unorm-srgb", "astc-10x8-unorm", "astc-10x8-unorm-srgb", "astc-10x10-unorm", "astc-10x10-unorm-srgb", "astc-12x10-unorm", "astc-12x10-unorm-srgb", "astc-12x12-unorm", "astc-12x12-unorm-srgb"];
|
|
5864
|
+
|
|
5865
|
+
|
|
5866
|
+
const __wbindgen_enum_GpuTextureSampleType = ["float", "unfilterable-float", "depth", "sint", "uint"];
|
|
5867
|
+
|
|
5868
|
+
|
|
5869
|
+
const __wbindgen_enum_GpuTextureViewDimension = ["1d", "2d", "2d-array", "cube", "cube-array", "3d"];
|
|
5870
|
+
|
|
5871
|
+
|
|
5872
|
+
const __wbindgen_enum_GpuVertexFormat = ["uint8", "uint8x2", "uint8x4", "sint8", "sint8x2", "sint8x4", "unorm8", "unorm8x2", "unorm8x4", "snorm8", "snorm8x2", "snorm8x4", "uint16", "uint16x2", "uint16x4", "sint16", "sint16x2", "sint16x4", "unorm16", "unorm16x2", "unorm16x4", "snorm16", "snorm16x2", "snorm16x4", "float16", "float16x2", "float16x4", "float32", "float32x2", "float32x3", "float32x4", "uint32", "uint32x2", "uint32x3", "uint32x4", "sint32", "sint32x2", "sint32x3", "sint32x4", "unorm10-10-10-2", "unorm8x4-bgra"];
|
|
5873
|
+
|
|
5874
|
+
|
|
5875
|
+
const __wbindgen_enum_GpuVertexStepMode = ["vertex", "instance"];
|
|
5876
|
+
const Canvas3DFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
5877
|
+
? { register: () => {}, unregister: () => {} }
|
|
5878
|
+
: new FinalizationRegistry(ptr => wasm.__wbg_canvas3d_free(ptr, 1));
|
|
3002
5879
|
const CredentialVaultFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
3003
5880
|
? { register: () => {}, unregister: () => {} }
|
|
3004
5881
|
: new FinalizationRegistry(ptr => wasm.__wbg_credentialvault_free(ptr, 1));
|
|
5882
|
+
const GpuHostFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
5883
|
+
? { register: () => {}, unregister: () => {} }
|
|
5884
|
+
: new FinalizationRegistry(ptr => wasm.__wbg_gpuhost_free(ptr, 1));
|
|
3005
5885
|
const KernelFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
3006
5886
|
? { register: () => {}, unregister: () => {} }
|
|
3007
5887
|
: new FinalizationRegistry(ptr => wasm.__wbg_kernel_free(ptr, 1));
|
|
3008
5888
|
const MemoryStoreFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
3009
5889
|
? { register: () => {}, unregister: () => {} }
|
|
3010
5890
|
: new FinalizationRegistry(ptr => wasm.__wbg_memorystore_free(ptr, 1));
|
|
5891
|
+
const SceneCanvasFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
5892
|
+
? { register: () => {}, unregister: () => {} }
|
|
5893
|
+
: new FinalizationRegistry(ptr => wasm.__wbg_scenecanvas_free(ptr, 1));
|
|
3011
5894
|
const ServerFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
3012
5895
|
? { register: () => {}, unregister: () => {} }
|
|
3013
5896
|
: new FinalizationRegistry(ptr => wasm.__wbg_server_free(ptr, 1));
|
|
@@ -3018,15 +5901,176 @@ function addToExternrefTable0(obj) {
|
|
|
3018
5901
|
return idx;
|
|
3019
5902
|
}
|
|
3020
5903
|
|
|
5904
|
+
function _assertClass(instance, klass) {
|
|
5905
|
+
if (!(instance instanceof klass)) {
|
|
5906
|
+
throw new Error(`expected instance of ${klass.name}`);
|
|
5907
|
+
}
|
|
5908
|
+
}
|
|
5909
|
+
|
|
5910
|
+
const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
|
|
5911
|
+
? { register: () => {}, unregister: () => {} }
|
|
5912
|
+
: new FinalizationRegistry(state => wasm.__wbindgen_destroy_closure(state.a, state.b));
|
|
5913
|
+
|
|
5914
|
+
function debugString(val) {
|
|
5915
|
+
// primitive types
|
|
5916
|
+
const type = typeof val;
|
|
5917
|
+
if (type == 'number' || type == 'boolean' || val == null) {
|
|
5918
|
+
return `${val}`;
|
|
5919
|
+
}
|
|
5920
|
+
if (type == 'string') {
|
|
5921
|
+
return `"${val}"`;
|
|
5922
|
+
}
|
|
5923
|
+
if (type == 'symbol') {
|
|
5924
|
+
const description = val.description;
|
|
5925
|
+
if (description == null) {
|
|
5926
|
+
return 'Symbol';
|
|
5927
|
+
} else {
|
|
5928
|
+
return `Symbol(${description})`;
|
|
5929
|
+
}
|
|
5930
|
+
}
|
|
5931
|
+
if (type == 'function') {
|
|
5932
|
+
const name = val.name;
|
|
5933
|
+
if (typeof name == 'string' && name.length > 0) {
|
|
5934
|
+
return `Function(${name})`;
|
|
5935
|
+
} else {
|
|
5936
|
+
return 'Function';
|
|
5937
|
+
}
|
|
5938
|
+
}
|
|
5939
|
+
// objects
|
|
5940
|
+
if (Array.isArray(val)) {
|
|
5941
|
+
const length = val.length;
|
|
5942
|
+
let debug = '[';
|
|
5943
|
+
if (length > 0) {
|
|
5944
|
+
debug += debugString(val[0]);
|
|
5945
|
+
}
|
|
5946
|
+
for(let i = 1; i < length; i++) {
|
|
5947
|
+
debug += ', ' + debugString(val[i]);
|
|
5948
|
+
}
|
|
5949
|
+
debug += ']';
|
|
5950
|
+
return debug;
|
|
5951
|
+
}
|
|
5952
|
+
// Test for built-in
|
|
5953
|
+
const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
|
|
5954
|
+
let className;
|
|
5955
|
+
if (builtInMatches && builtInMatches.length > 1) {
|
|
5956
|
+
className = builtInMatches[1];
|
|
5957
|
+
} else {
|
|
5958
|
+
// Failed to match the standard '[object ClassName]'
|
|
5959
|
+
return toString.call(val);
|
|
5960
|
+
}
|
|
5961
|
+
if (className == 'Object') {
|
|
5962
|
+
// we're a user defined class or Object
|
|
5963
|
+
// JSON.stringify avoids problems with cycles, and is generally much
|
|
5964
|
+
// easier than looping through ownProperties of `val`.
|
|
5965
|
+
try {
|
|
5966
|
+
return 'Object(' + JSON.stringify(val) + ')';
|
|
5967
|
+
} catch (_) {
|
|
5968
|
+
return 'Object';
|
|
5969
|
+
}
|
|
5970
|
+
}
|
|
5971
|
+
// errors
|
|
5972
|
+
if (val instanceof Error) {
|
|
5973
|
+
return `${val.name}: ${val.message}\n${val.stack}`;
|
|
5974
|
+
}
|
|
5975
|
+
// TODO we could test for more things here, like `Set`s and `Map`s.
|
|
5976
|
+
return className;
|
|
5977
|
+
}
|
|
5978
|
+
|
|
5979
|
+
function getArrayF32FromWasm0(ptr, len) {
|
|
5980
|
+
ptr = ptr >>> 0;
|
|
5981
|
+
return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
|
|
5982
|
+
}
|
|
5983
|
+
|
|
5984
|
+
function getArrayI16FromWasm0(ptr, len) {
|
|
5985
|
+
ptr = ptr >>> 0;
|
|
5986
|
+
return getInt16ArrayMemory0().subarray(ptr / 2, ptr / 2 + len);
|
|
5987
|
+
}
|
|
5988
|
+
|
|
5989
|
+
function getArrayI32FromWasm0(ptr, len) {
|
|
5990
|
+
ptr = ptr >>> 0;
|
|
5991
|
+
return getInt32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
|
|
5992
|
+
}
|
|
5993
|
+
|
|
5994
|
+
function getArrayI8FromWasm0(ptr, len) {
|
|
5995
|
+
ptr = ptr >>> 0;
|
|
5996
|
+
return getInt8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
|
|
5997
|
+
}
|
|
5998
|
+
|
|
5999
|
+
function getArrayU16FromWasm0(ptr, len) {
|
|
6000
|
+
ptr = ptr >>> 0;
|
|
6001
|
+
return getUint16ArrayMemory0().subarray(ptr / 2, ptr / 2 + len);
|
|
6002
|
+
}
|
|
6003
|
+
|
|
6004
|
+
function getArrayU32FromWasm0(ptr, len) {
|
|
6005
|
+
ptr = ptr >>> 0;
|
|
6006
|
+
return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
|
|
6007
|
+
}
|
|
6008
|
+
|
|
3021
6009
|
function getArrayU8FromWasm0(ptr, len) {
|
|
3022
6010
|
ptr = ptr >>> 0;
|
|
3023
6011
|
return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
|
|
3024
6012
|
}
|
|
3025
6013
|
|
|
6014
|
+
let cachedDataViewMemory0 = null;
|
|
6015
|
+
function getDataViewMemory0() {
|
|
6016
|
+
if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
|
|
6017
|
+
cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
|
|
6018
|
+
}
|
|
6019
|
+
return cachedDataViewMemory0;
|
|
6020
|
+
}
|
|
6021
|
+
|
|
6022
|
+
let cachedFloat32ArrayMemory0 = null;
|
|
6023
|
+
function getFloat32ArrayMemory0() {
|
|
6024
|
+
if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
|
|
6025
|
+
cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
|
|
6026
|
+
}
|
|
6027
|
+
return cachedFloat32ArrayMemory0;
|
|
6028
|
+
}
|
|
6029
|
+
|
|
6030
|
+
let cachedInt16ArrayMemory0 = null;
|
|
6031
|
+
function getInt16ArrayMemory0() {
|
|
6032
|
+
if (cachedInt16ArrayMemory0 === null || cachedInt16ArrayMemory0.byteLength === 0) {
|
|
6033
|
+
cachedInt16ArrayMemory0 = new Int16Array(wasm.memory.buffer);
|
|
6034
|
+
}
|
|
6035
|
+
return cachedInt16ArrayMemory0;
|
|
6036
|
+
}
|
|
6037
|
+
|
|
6038
|
+
let cachedInt32ArrayMemory0 = null;
|
|
6039
|
+
function getInt32ArrayMemory0() {
|
|
6040
|
+
if (cachedInt32ArrayMemory0 === null || cachedInt32ArrayMemory0.byteLength === 0) {
|
|
6041
|
+
cachedInt32ArrayMemory0 = new Int32Array(wasm.memory.buffer);
|
|
6042
|
+
}
|
|
6043
|
+
return cachedInt32ArrayMemory0;
|
|
6044
|
+
}
|
|
6045
|
+
|
|
6046
|
+
let cachedInt8ArrayMemory0 = null;
|
|
6047
|
+
function getInt8ArrayMemory0() {
|
|
6048
|
+
if (cachedInt8ArrayMemory0 === null || cachedInt8ArrayMemory0.byteLength === 0) {
|
|
6049
|
+
cachedInt8ArrayMemory0 = new Int8Array(wasm.memory.buffer);
|
|
6050
|
+
}
|
|
6051
|
+
return cachedInt8ArrayMemory0;
|
|
6052
|
+
}
|
|
6053
|
+
|
|
3026
6054
|
function getStringFromWasm0(ptr, len) {
|
|
3027
6055
|
return decodeText(ptr >>> 0, len);
|
|
3028
6056
|
}
|
|
3029
6057
|
|
|
6058
|
+
let cachedUint16ArrayMemory0 = null;
|
|
6059
|
+
function getUint16ArrayMemory0() {
|
|
6060
|
+
if (cachedUint16ArrayMemory0 === null || cachedUint16ArrayMemory0.byteLength === 0) {
|
|
6061
|
+
cachedUint16ArrayMemory0 = new Uint16Array(wasm.memory.buffer);
|
|
6062
|
+
}
|
|
6063
|
+
return cachedUint16ArrayMemory0;
|
|
6064
|
+
}
|
|
6065
|
+
|
|
6066
|
+
let cachedUint32ArrayMemory0 = null;
|
|
6067
|
+
function getUint32ArrayMemory0() {
|
|
6068
|
+
if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
|
|
6069
|
+
cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
|
|
6070
|
+
}
|
|
6071
|
+
return cachedUint32ArrayMemory0;
|
|
6072
|
+
}
|
|
6073
|
+
|
|
3030
6074
|
let cachedUint8ArrayMemory0 = null;
|
|
3031
6075
|
function getUint8ArrayMemory0() {
|
|
3032
6076
|
if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
|
|
@@ -3048,6 +6092,34 @@ function isLikeNone(x) {
|
|
|
3048
6092
|
return x === undefined || x === null;
|
|
3049
6093
|
}
|
|
3050
6094
|
|
|
6095
|
+
function makeMutClosure(arg0, arg1, f) {
|
|
6096
|
+
const state = { a: arg0, b: arg1, cnt: 1 };
|
|
6097
|
+
const real = (...args) => {
|
|
6098
|
+
|
|
6099
|
+
// First up with a closure we increment the internal reference
|
|
6100
|
+
// count. This ensures that the Rust closure environment won't
|
|
6101
|
+
// be deallocated while we're invoking it.
|
|
6102
|
+
state.cnt++;
|
|
6103
|
+
const a = state.a;
|
|
6104
|
+
state.a = 0;
|
|
6105
|
+
try {
|
|
6106
|
+
return f(a, state.b, ...args);
|
|
6107
|
+
} finally {
|
|
6108
|
+
state.a = a;
|
|
6109
|
+
real._wbg_cb_unref();
|
|
6110
|
+
}
|
|
6111
|
+
};
|
|
6112
|
+
real._wbg_cb_unref = () => {
|
|
6113
|
+
if (--state.cnt === 0) {
|
|
6114
|
+
wasm.__wbindgen_destroy_closure(state.a, state.b);
|
|
6115
|
+
state.a = 0;
|
|
6116
|
+
CLOSURE_DTORS.unregister(state);
|
|
6117
|
+
}
|
|
6118
|
+
};
|
|
6119
|
+
CLOSURE_DTORS.register(real, state, state);
|
|
6120
|
+
return real;
|
|
6121
|
+
}
|
|
6122
|
+
|
|
3051
6123
|
function passStringToWasm0(arg, malloc, realloc) {
|
|
3052
6124
|
if (realloc === undefined) {
|
|
3053
6125
|
const buf = cachedTextEncoder.encode(arg);
|
|
@@ -3125,6 +6197,13 @@ function __wbg_finalize_init(instance, module) {
|
|
|
3125
6197
|
wasmInstance = instance;
|
|
3126
6198
|
wasm = instance.exports;
|
|
3127
6199
|
wasmModule = module;
|
|
6200
|
+
cachedDataViewMemory0 = null;
|
|
6201
|
+
cachedFloat32ArrayMemory0 = null;
|
|
6202
|
+
cachedInt16ArrayMemory0 = null;
|
|
6203
|
+
cachedInt32ArrayMemory0 = null;
|
|
6204
|
+
cachedInt8ArrayMemory0 = null;
|
|
6205
|
+
cachedUint16ArrayMemory0 = null;
|
|
6206
|
+
cachedUint32ArrayMemory0 = null;
|
|
3128
6207
|
cachedUint8ArrayMemory0 = null;
|
|
3129
6208
|
wasm.__wbindgen_start();
|
|
3130
6209
|
return wasm;
|