Removing run_tree files
This commit is contained in:
parent
203312a80e
commit
f7d9a213dc
|
|
@ -14,7 +14,7 @@ sysroot/
|
|||
*.dSYM
|
||||
run_tree/data/live_data
|
||||
run_tree/osx/*
|
||||
run_tree/win/*
|
||||
run_tree/win32/*
|
||||
run_tree/wasm/*
|
||||
run_tree/webgl/*
|
||||
run_tree/raspi/*
|
||||
|
|
|
|||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
|
|
@ -1,12 +0,0 @@
|
|||
<!doctype html>
|
||||
<html lang="en-us">
|
||||
<head>
|
||||
<meta charset="utf-8" />
|
||||
</head>
|
||||
<body>
|
||||
<canvas id="gl_canvas" width="640" height="480"></canvas>
|
||||
|
||||
<script type="text/javascript" src="lumenarium_wasm_imports.js"></script>
|
||||
<script type="text/javascript" src="loader.js"></script>
|
||||
</body>
|
||||
</html>
|
||||
|
|
@ -1,39 +0,0 @@
|
|||
|
||||
let module = null;
|
||||
let instance = null;
|
||||
|
||||
|
||||
async function load_webassembly_module ()
|
||||
{
|
||||
lumenarium_wasm_imports = webgl_add_imports("#gl_canvas", lumenarium_wasm_imports);
|
||||
|
||||
const path = "lumenarium.wasm";
|
||||
const promise = fetch(path);
|
||||
const module = await WebAssembly.compileStreaming(promise);
|
||||
|
||||
let memory = new WebAssembly.Memory({ initial: 2 });
|
||||
const env = {
|
||||
memory,
|
||||
...lumenarium_wasm_imports,
|
||||
};
|
||||
|
||||
let table = new WebAssembly.Table({ element: "anyfunc", initial: 32, });
|
||||
|
||||
instance = await WebAssembly.instantiate(module, { env })
|
||||
.then((res, err) => {
|
||||
return res;
|
||||
})
|
||||
.catch((a, b) => {
|
||||
console.log(a,b);
|
||||
});
|
||||
lumenarium_wasm_instance = instance;
|
||||
|
||||
// If function '__wasm_call_ctors' (global C++ constructors) exists, call it
|
||||
if (instance.exports.__wasm_call_ctors) instance.exports.__wasm_call_ctors();
|
||||
|
||||
// If function 'main' exists, call it with dummy arguments
|
||||
let result = 0;
|
||||
if (instance.exports.main) result = instance.exports.main();
|
||||
}
|
||||
|
||||
window.addEventListener("load", load_webassembly_module)
|
||||
|
|
@ -1,507 +0,0 @@
|
|||
var lumenarium_wasm_module = null;
|
||||
var lumenarium_wasm_instance = null;
|
||||
|
||||
var WASM_PAGE_SIZE = 65536;
|
||||
|
||||
function wasm_mem_get_u8_arr(inst, ptr, size)
|
||||
{
|
||||
let view = new Uint8Array(inst.exports.memory.buffer, ptr, size);
|
||||
return view;
|
||||
}
|
||||
|
||||
function wasm_read_string(inst, ptr, len)
|
||||
{
|
||||
let view = wasm_mem_get_u8_arr(inst, ptr, len);
|
||||
let string = '';
|
||||
for (let i = 0; i < len; i++)
|
||||
{
|
||||
string += String.fromCharCode(view[i]);
|
||||
}
|
||||
return string;
|
||||
}
|
||||
|
||||
function wasm_write_bytes(inst, src, ptr, len)
|
||||
{
|
||||
let view = wasm_mem_get_u8_arr(inst, ptr, len);
|
||||
for (let i = 0; i < len; i++) view[i] = src[i];
|
||||
}
|
||||
|
||||
function wasm_get_proc(inst, proc_ptr)
|
||||
{
|
||||
let result = inst.exports.__indirect_function_table.get(proc_ptr);
|
||||
return result;
|
||||
}
|
||||
|
||||
function fract (v) { return v % 1; }
|
||||
|
||||
function u32_to_byte_array_32 (v)
|
||||
{
|
||||
let result = [0, 0, 0, 0];
|
||||
result[0] = (v & 0xff);
|
||||
result[1] = (((v - result[0]) >> 8 ) & 0xff);
|
||||
result[2] = (((v - result[1]) >> 16) & 0xff);
|
||||
result[3] = (((v - result[2]) >> 24) & 0xff);
|
||||
return result;
|
||||
}
|
||||
|
||||
function byte_array_32_to_u32 (arr)
|
||||
{
|
||||
// NOTE(PS): the '>>>' operators in this function deal with the fact
|
||||
// that bit shift operators convert numbers to s32's. The >>> just
|
||||
// converts them back to u32s
|
||||
let r0 = ((arr[0] & 0xff) << 0 );
|
||||
let r1 = ((arr[1] & 0xff) << 8 );
|
||||
let r2 = ((arr[2] & 0xff) << 16);
|
||||
let r3 = (((arr[3] & 0xff) << 24) >>> 0);
|
||||
let result = (r0 | r1 | r2 | r3) >>> 0;
|
||||
return result;
|
||||
}
|
||||
|
||||
function put_u32 (ptr, value)
|
||||
{
|
||||
let src = u32_to_byte_array_32(value);
|
||||
wasm_write_bytes(lumenarium_wasm_instance, src, ptr, 4);
|
||||
}
|
||||
|
||||
var lumenarium_wasm_imports = {
|
||||
|
||||
memset: (dst, size, value) => {
|
||||
let view_dst = wasm_mem_get_u8_arr(lumenarium_wasm_instance, dst, size);
|
||||
for (let i = 0; i < size; i++)
|
||||
{
|
||||
view_dst[i] = value;
|
||||
}
|
||||
},
|
||||
|
||||
memcpy: (dst, src, size) => {
|
||||
let view_dst = wasm_mem_get_u8_arr(lumenarium_wasm_instance, dst, size);
|
||||
let view_src = wasm_mem_get_u8_arr(lumenarium_wasm_instance, src, size);
|
||||
for (let i = 0; i < size; i++)
|
||||
{
|
||||
view_dst[i] = view_src[i];
|
||||
}
|
||||
},
|
||||
|
||||
wasm_assert_always: (file, file_len, line) => {
|
||||
let file_str = wasm_read_string(lumenarium_wasm_instance, file, file_len);
|
||||
console.assert(false, "At: " + file_str + "::" + line);
|
||||
},
|
||||
|
||||
wasm_get_memory_size: () => {
|
||||
return instance.exports.memory.buffer.byteLength;
|
||||
},
|
||||
|
||||
wasm_mem_grow: (new_size) => {
|
||||
let new_size_ = new_size >>> 0;
|
||||
let pages = new_size_ / WASM_PAGE_SIZE;
|
||||
let pages_rem = fract(pages);
|
||||
if (pages_rem > 0) pages = Math.floor(pages) + 1;
|
||||
let size_before = lumenarium_wasm_instance.exports.memory.buffer.byteLength;
|
||||
let old_page_count = lumenarium_wasm_instance.exports.memory.grow(pages);
|
||||
|
||||
console.log("mem_grow\n",
|
||||
"req size: ", new_size_, "\n",
|
||||
"old size: ", (old_page_count * WASM_PAGE_SIZE), "\n",
|
||||
"old size: ", size_before, "\n",
|
||||
"grew by: ", (pages * WASM_PAGE_SIZE), "\n",
|
||||
"new size: ", lumenarium_wasm_instance.exports.memory.buffer.byteLength, "");
|
||||
},
|
||||
|
||||
malloc: (size) => {
|
||||
|
||||
},
|
||||
|
||||
free: (base) => {
|
||||
|
||||
},
|
||||
|
||||
sin: Math.sin,
|
||||
sinf: Math.sin,
|
||||
cos: Math.cos,
|
||||
cosf: Math.cos,
|
||||
tan: Math.tan,
|
||||
tanf: Math.tan,
|
||||
asin: Math.asin,
|
||||
asinf: Math.asin,
|
||||
acos: Math.acos,
|
||||
acosf: Math.acos,
|
||||
atan: Math.atan,
|
||||
atanf: Math.atan,
|
||||
pow: Math.pow,
|
||||
powf: Math.pow,
|
||||
fmodf: (f,d) => { return f % d; },
|
||||
strlen: (ptr) => {
|
||||
let len = 0;
|
||||
let len_checked = 0;
|
||||
let len_to_check = 256;
|
||||
let found_end = false;
|
||||
while (true)
|
||||
{
|
||||
let string = wasm_mem_get_u8_arr(lumenarium_wasm_instance, ptr, len_checked);
|
||||
for (let i = len_checked; i < len_to_check; i++)
|
||||
{
|
||||
if (string[i] == 0)
|
||||
{
|
||||
len = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
len_checked *= 2;
|
||||
}
|
||||
return len_checked;
|
||||
},
|
||||
|
||||
wasm_platform_file_async_work_on_job: (path, path_len, data, data_size, read, write) => {
|
||||
|
||||
},
|
||||
|
||||
wasm_performance_now: () => {
|
||||
return performance.now();
|
||||
},
|
||||
|
||||
wasm_sleep: (milliseconds) => {
|
||||
let start = Date.now();
|
||||
for (let at = Date.now(); (at - start) < milliseconds; at = Date.now()) {}
|
||||
},
|
||||
|
||||
wasm_fetch: async (file_path, file_path_len, dest, dest_size) => {
|
||||
let path = wasm_read_string(lumenarium_wasm_instance, file_path, file_path_len);
|
||||
fetch(path)
|
||||
.then(async (res) => {
|
||||
// TODO(PS): success checking
|
||||
let reader = res.body.getReader();
|
||||
let read_res = { done: false };
|
||||
|
||||
let view = wasm_mem_get_u8_arr(lumenarium_wasm_instance, dest, dest_size);
|
||||
let last_write = 0;
|
||||
while (!read_res.done)
|
||||
{
|
||||
read_res = await reader.read();
|
||||
if (read_res.done) break;
|
||||
|
||||
let len = read_res.value.length;
|
||||
let write_end = last_write + len;
|
||||
for (let i = last_write; i < write_end; i++)
|
||||
{
|
||||
view[i] = read_res.value[i - last_write];
|
||||
}
|
||||
last_write = write_end + 1;
|
||||
}
|
||||
});
|
||||
return 0;
|
||||
},
|
||||
|
||||
wasm_request_animation_frame: (cb) => {
|
||||
let cb_proc = wasm_get_proc(lumenarium_wasm_instance, cb);
|
||||
window.requestAnimationFrame(cb_proc);
|
||||
},
|
||||
|
||||
print: (str_base, len) => {
|
||||
let string = wasm_read_string(lumenarium_wasm_instance, str_base, len);
|
||||
console.log(string);
|
||||
},
|
||||
|
||||
wasm_get_canvas_dim: (w_ptr, h_ptr) => {
|
||||
const canvas = document.querySelector("#gl_canvas");
|
||||
|
||||
let w_view = wasm_mem_get_u8_arr(lumenarium_wasm_instance, w_ptr, 4);
|
||||
let w = canvas.width;
|
||||
let wb = u32_to_byte_array_32(w);
|
||||
for (let i = 0; i < 4; i++) w_view[i] = wb[i];
|
||||
|
||||
let h_view = wasm_mem_get_u8_arr(lumenarium_wasm_instance, h_ptr, 4);
|
||||
let h = canvas.height;
|
||||
let hb = u32_to_byte_array_32(h);
|
||||
for (let i = 0; i < 4; i++) h_view[i] = hb[i];
|
||||
},
|
||||
};
|
||||
|
||||
///////////////////////////////////////
|
||||
// Web GL Imports
|
||||
|
||||
let gl = null;
|
||||
let gl_error = false;
|
||||
|
||||
function glErrorReport(outer_args) {
|
||||
const err = gl.getError();
|
||||
if (err == gl.NO_ERROR) return;
|
||||
|
||||
gl_error = true;
|
||||
let msg = "";
|
||||
switch (err) {
|
||||
case gl.NO_ERROR: { msg = "NO_ERROR"; } break;
|
||||
case gl.INVALID_ENUM: { msg = "INVALID_ENUM"; } break;
|
||||
case gl.INVALID_VALUE: { msg = "INVALID_VALUE"; } break;
|
||||
case gl.INVALID_OPERATION: { msg = "INVALID_OPERATION"; } break;
|
||||
case gl.INVALID_FRAMEBUFFER_OPERATION: { msg = "INVALID_FRAMEBUFFER_OPERATION"; } break;
|
||||
case gl.OUT_OF_MEMORY: { msg = "OUT_OF_MEMORY"; } break;
|
||||
case gl.CONTEXT_LOST_WEBGL: { msg = "CONTEXT_LOST_WEBGL"; } break;
|
||||
default: { msg = "Uknown error"; } break;
|
||||
}
|
||||
console.error(`WebGL Error: ${msg} ${err}`, outer_args);
|
||||
}
|
||||
|
||||
// NOTE(PS): it seems like its not enough to set
|
||||
// the values of imports to gl.function
|
||||
// ie. imports.glClearColor = gl.clearColor
|
||||
// instead we need to wrap them for some reason.
|
||||
// Not sure why
|
||||
function glClearColor (r, g, b, a) { return gl.clearColor(r,g,b,a); }
|
||||
function glEnable(v) {
|
||||
const r = gl.enable(v);
|
||||
glErrorReport(arguments);
|
||||
return r;
|
||||
}
|
||||
function glDisable(v) {
|
||||
const r = gl.disable(v);
|
||||
glErrorReport(arguments);
|
||||
return r;
|
||||
}
|
||||
function glBlendFunc(a,b) {
|
||||
const r = gl.blendFunc(a,b);
|
||||
glErrorReport(arguments);
|
||||
return r;
|
||||
}
|
||||
function glViewport(xmin, ymin, xmax, ymax) { return gl.viewport(xmin,ymin,xmax,ymax); }
|
||||
function glDepthFunc(v) {
|
||||
const r = gl.depthFunc(v);
|
||||
glErrorReport(arguments);
|
||||
return r;
|
||||
}
|
||||
function glClear(mask) {
|
||||
const r = gl.clear(mask);
|
||||
glErrorReport(arguments);
|
||||
return r;
|
||||
}
|
||||
|
||||
let glBuffers = [];
|
||||
let glShaders = [];
|
||||
let glPrograms = [];
|
||||
let glTextures = [];
|
||||
function gl_get_managed_resource(arr, id) {
|
||||
if (id == 0) return null;
|
||||
return arr[id - 1];
|
||||
}
|
||||
function gl_get_buffer(id) { return gl_get_managed_resource(glBuffers, id); }
|
||||
function gl_get_shader(id) { return gl_get_managed_resource(glShaders, id); }
|
||||
function gl_get_program(id) { return gl_get_managed_resource(glPrograms, id); }
|
||||
function gl_get_texture(id) { return gl_get_managed_resource(glTextures, id); }
|
||||
|
||||
function glCreateBuffer() {
|
||||
let buffer = gl.createBuffer();
|
||||
glErrorReport(arguments);
|
||||
let new_len = glBuffers.push(buffer);
|
||||
return new_len;
|
||||
}
|
||||
|
||||
function glBindBuffer(buffer_kind, buffer_id)
|
||||
{
|
||||
const r = gl.bindBuffer(buffer_kind, gl_get_buffer(buffer_id));
|
||||
glErrorReport(arguments);
|
||||
return r;
|
||||
}
|
||||
|
||||
function glBufferData(target, size, ptr, usage)
|
||||
{
|
||||
let data = wasm_mem_get_u8_arr(lumenarium_wasm_instance, ptr, size);
|
||||
const r = gl.bufferData(target, data, usage);
|
||||
glErrorReport(arguments);
|
||||
return r;
|
||||
}
|
||||
|
||||
function glBufferSubData(target, offset, size, ptr)
|
||||
{
|
||||
let data = wasm_mem_get_u8_arr(lumenarium_wasm_instance, ptr, size);
|
||||
const r = gl.bufferSubData(target, offset, data, 0, size);
|
||||
glErrorReport(arguments);
|
||||
return r;
|
||||
}
|
||||
|
||||
function glCreateShader(kind)
|
||||
{
|
||||
let shader = gl.createShader(kind);
|
||||
glErrorReport(arguments);
|
||||
let new_len = glShaders.push(shader);
|
||||
return new_len;
|
||||
}
|
||||
|
||||
function glShaderSource(shader_id, shader_code, shader_code_len)
|
||||
{
|
||||
let str = wasm_read_string(lumenarium_wasm_instance, shader_code, shader_code_len);
|
||||
const r = gl.shaderSource(gl_get_shader(shader_id), str);
|
||||
glErrorReport(arguments);
|
||||
return r;
|
||||
}
|
||||
|
||||
function glCompileShader(shader_id)
|
||||
{
|
||||
let s = gl_get_shader(shader_id);
|
||||
let r = gl.compileShader(s);
|
||||
glErrorReport(arguments);
|
||||
let m = gl.getShaderInfoLog(s);
|
||||
glErrorReport(arguments);
|
||||
if (m.length > 0)
|
||||
{
|
||||
console.error("glCompileShader: \n\n" + m);
|
||||
}
|
||||
}
|
||||
|
||||
function glCreateProgram()
|
||||
{
|
||||
let prog = gl.createProgram();
|
||||
glErrorReport(arguments);
|
||||
let new_len = glPrograms.push(prog);
|
||||
return new_len;
|
||||
}
|
||||
|
||||
function glAttachShader(program, shader)
|
||||
{
|
||||
let s = gl_get_shader(shader);
|
||||
let p = gl_get_program(program);
|
||||
const r = gl.attachShader(p, s);
|
||||
glErrorReport(arguments);
|
||||
return r;
|
||||
}
|
||||
|
||||
function glLinkProgram(program)
|
||||
{
|
||||
let p = gl_get_program(program);
|
||||
gl.linkProgram(p);
|
||||
if (!gl.getProgramParameter(p, gl.LINK_STATUS)) {
|
||||
var info = gl.getProgramInfoLog(p);
|
||||
console.error("Failed to compile WebGL program. \n\n"+info);
|
||||
}
|
||||
}
|
||||
|
||||
function glUseProgram(program)
|
||||
{
|
||||
let p = gl_get_program(program);
|
||||
const r = gl.useProgram(p);
|
||||
glErrorReport(arguments);
|
||||
return r;
|
||||
}
|
||||
|
||||
function glGetAttribLocation(program, name, name_len)
|
||||
{
|
||||
let str = wasm_read_string(lumenarium_wasm_instance, name, name_len);
|
||||
const r = gl.getAttribLocation(gl_get_program(program), str);
|
||||
glErrorReport(arguments);
|
||||
return r;
|
||||
}
|
||||
|
||||
function glVertexAttribPointer(attr, size, type, normalized, stride, pointer)
|
||||
{
|
||||
const r = gl.vertexAttribPointer(attr, size, type, normalized, stride, pointer);
|
||||
glErrorReport(arguments);
|
||||
return r;
|
||||
}
|
||||
|
||||
function glEnableVertexAttribArray(index)
|
||||
{
|
||||
const r = gl.enableVertexAttribArray(index);
|
||||
glErrorReport(arguments);
|
||||
return r;
|
||||
}
|
||||
|
||||
function glDrawElements(type, index_count, ele_type, indices)
|
||||
{
|
||||
const r = gl.drawElements(type, index_count, ele_type, indices);
|
||||
glErrorReport(arguments);
|
||||
return r;
|
||||
}
|
||||
|
||||
function glGenTextures(count, ids_ptr, ids_size)
|
||||
{
|
||||
for (let i = 0; i < count; i++)
|
||||
{
|
||||
const tex = gl.createTexture();
|
||||
glErrorReport(arguments);
|
||||
let new_len = glTextures.push(tex);
|
||||
put_u32(ids_ptr + (i * 4), new_len);
|
||||
}
|
||||
}
|
||||
|
||||
function glBindTexture(slot, id)
|
||||
{
|
||||
let tex = gl_get_texture(id);
|
||||
const r = gl.bindTexture(slot, tex);
|
||||
glErrorReport(arguments);
|
||||
return r;
|
||||
}
|
||||
|
||||
function glTexParameteri(slot, param, value)
|
||||
{
|
||||
const r = gl.texParameteri(slot, param, value);
|
||||
glErrorReport(arguments);
|
||||
return r;
|
||||
}
|
||||
|
||||
function glTexImage2D(target, level, internalformat, width, height, border, format, type, data_ptr, data_size)
|
||||
{
|
||||
const data = wasm_mem_get_u8_arr(lumenarium_wasm_instance, data_ptr, data_size);
|
||||
const r = gl.texImage2D(target, level, internalformat, width, height, border, format, type, data);
|
||||
glErrorReport(arguments);
|
||||
return r;
|
||||
}
|
||||
|
||||
function glTexSubImage2D(target, level, offsetx, offsety, width, height, format, type, data_ptr, data_size)
|
||||
{
|
||||
const data = wasm_mem_get_u8_arr(lumenarium_wasm_instance, data_ptr, data_size);
|
||||
const r = gl.texSubImage2D(target, level, offsetx, offsety, width, height, format, type, data);
|
||||
glErrorReport(arguments);
|
||||
return r;
|
||||
}
|
||||
|
||||
function glGetUniformLocation(program, name, name_len)
|
||||
{
|
||||
// TODO(PS): complete
|
||||
return 0;
|
||||
}
|
||||
|
||||
function glUniformMatrix4fv()
|
||||
{
|
||||
// TODO(PS):
|
||||
}
|
||||
|
||||
function webgl_add_imports (canvas_selector, imports) {
|
||||
const canvas = document.querySelector(canvas_selector);
|
||||
if (!canvas) return console.error("no canvas");
|
||||
|
||||
gl = canvas.getContext("webgl2");
|
||||
if (gl === null) return console.error("no webgl ctx");
|
||||
|
||||
imports.glHadError = () => { return gl_error; };
|
||||
imports.glClearColor = glClearColor;
|
||||
imports.glEnable = glEnable;
|
||||
imports.glDisable = glDisable;
|
||||
imports.glBlendFunc = glBlendFunc;
|
||||
imports.glViewport = glViewport;
|
||||
imports.glDepthFunc = glDepthFunc;
|
||||
imports.glClear = glClear;
|
||||
|
||||
imports.glCreateBuffer = glCreateBuffer;
|
||||
imports.glBindBuffer = glBindBuffer;
|
||||
imports.glBufferData = glBufferData;
|
||||
imports.glBufferSubData = glBufferSubData;
|
||||
imports.glCreateShader = glCreateShader;
|
||||
imports.glShaderSource = glShaderSource;
|
||||
imports.glCompileShader = glCompileShader;
|
||||
imports.glCreateProgram = glCreateProgram;
|
||||
imports.glAttachShader = glAttachShader;
|
||||
imports.glLinkProgram = glLinkProgram;
|
||||
imports.glUseProgram = glUseProgram;
|
||||
imports.glGetAttribLocation = glGetAttribLocation;
|
||||
imports.glVertexAttribPointer = glVertexAttribPointer;
|
||||
imports.glEnableVertexAttribArray = glEnableVertexAttribArray;
|
||||
imports.glDrawElements = glDrawElements;
|
||||
imports.glGenTextures = glGenTextures;
|
||||
imports.glBindTexture = glBindTexture;
|
||||
imports.glTexParameteri = glTexParameteri;
|
||||
imports.glTexImage2D = glTexImage2D;
|
||||
imports.glTexSubImage2D = glTexSubImage2D;
|
||||
imports.glBindTexture = glBindTexture;
|
||||
imports.glGetUniformLocation = glGetUniformLocation;
|
||||
imports.glUniformMatrix4fv = glUniformMatrix4fv;
|
||||
|
||||
return imports;
|
||||
}
|
||||
Binary file not shown.
|
|
@ -1,167 +0,0 @@
|
|||
var lumenarium_wasm_module = null;
|
||||
var lumenarium_wasm_instance = null;
|
||||
|
||||
var WASM_PAGE_SIZE = 65536;
|
||||
|
||||
function wasm_mem_get_u8_arr(inst, ptr, size)
|
||||
{
|
||||
let view = new Uint8Array(inst.exports.memory.buffer, ptr, size);
|
||||
return view;
|
||||
}
|
||||
|
||||
function wasm_read_string(inst, ptr, len)
|
||||
{
|
||||
let view = wasm_mem_get_u8_arr(inst, ptr, len);
|
||||
let string = '';
|
||||
for (let i = 0; i < len; i++)
|
||||
{
|
||||
string += String.fromCharCode(view[i]);
|
||||
}
|
||||
return string;
|
||||
}
|
||||
|
||||
function wasm_write_bytes(inst, src, ptr, len)
|
||||
{
|
||||
let view = wasm_mem_get_u8_arr(inst, ptr, len);
|
||||
for (let i = 0; i < len; i++) view[i] = src[i];
|
||||
}
|
||||
|
||||
function wasm_get_proc(inst, proc_ptr)
|
||||
{
|
||||
let result = inst.exports.__indirect_function_table.get(proc_ptr);
|
||||
return result;
|
||||
}
|
||||
|
||||
function fract (v) { return v % 1; }
|
||||
|
||||
var lumenarium_wasm_imports = {
|
||||
|
||||
memset: (dst, size, value) => {
|
||||
let view_dst = wasm_mem_get_u8_arr(lumenarium_wasm_instance, dst, size);
|
||||
for (let i = 0; i < size; i++)
|
||||
{
|
||||
view_dst[i] = value;
|
||||
}
|
||||
},
|
||||
|
||||
memcpy: (dst, src, size) => {
|
||||
let view_dst = wasm_mem_get_u8_arr(lumenarium_wasm_instance, dst, size);
|
||||
let view_src = wasm_mem_get_u8_arr(lumenarium_wasm_instance, src, size);
|
||||
for (let i = 0; i < size; i++)
|
||||
{
|
||||
view_dst[i] = view_src[i];
|
||||
}
|
||||
},
|
||||
|
||||
wasm_assert_always: () => {
|
||||
console.assert(false);
|
||||
},
|
||||
|
||||
wasm_get_memory_size: () => {
|
||||
return instance.exports.memory.buffer.byteLength;
|
||||
},
|
||||
|
||||
wasm_mem_grow: (new_size) => {
|
||||
let pages = new_size / WASM_PAGE_SIZE;
|
||||
let pages_rem = fract(pages);
|
||||
if (pages_rem > 0) pages = Math.floor(pages) + 1;
|
||||
let size_before = lumenarium_wasm_instance.exports.memory.buffer.byteLength;
|
||||
let old_page_count = lumenarium_wasm_instance.exports.memory.grow(pages);
|
||||
|
||||
console.log("mem_grow\n",
|
||||
"req size: ", new_size, "\n",
|
||||
"old size: ", (old_page_count * WASM_PAGE_SIZE), "\n",
|
||||
"old size: ", size_before, "\n",
|
||||
"grew by: ", (pages * WASM_PAGE_SIZE), "\n",
|
||||
"new size: ", lumenarium_wasm_instance.exports.memory.buffer.byteLength, "");
|
||||
},
|
||||
|
||||
wasm_performance_now: () => {
|
||||
return performance.now();
|
||||
},
|
||||
|
||||
wasm_sleep: (milliseconds) => {
|
||||
let start = Date.now();
|
||||
for (let at = Date.now(); (at - start) < milliseconds; at = Date.now()) {}
|
||||
},
|
||||
|
||||
wasm_fetch: async (file_path, file_path_len, dest, dest_size) => {
|
||||
let path = wasm_read_string(lumenarium_wasm_instance, file_path, file_path_len);
|
||||
fetch(path)
|
||||
.then(async (res) => {
|
||||
// TODO(PS): success checking
|
||||
let reader = res.body.getReader();
|
||||
let read_res = { done: false };
|
||||
|
||||
let view = wasm_mem_get_u8_arr(lumenarium_wasm_instance, dest, dest_size);
|
||||
let last_write = 0;
|
||||
while (!read_res.done)
|
||||
{
|
||||
read_res = await reader.read();
|
||||
if (read_res.done) break;
|
||||
|
||||
let len = read_res.value.length;
|
||||
let write_end = last_write + len;
|
||||
for (let i = last_write; i < write_end; i++)
|
||||
{
|
||||
view[i] = read_res.value[i - last_write];
|
||||
}
|
||||
last_write = write_end + 1;
|
||||
}
|
||||
});
|
||||
return 0;
|
||||
},
|
||||
|
||||
wasm_request_animation_frame: (cb) => {
|
||||
let cb_proc = wasm_get_proc(lumenarium_wasm_instance, cb);
|
||||
window.requestAnimationFrame(cb_proc);
|
||||
},
|
||||
|
||||
print: (str_base, len) => {
|
||||
let string = wasm_read_string(lumenarium_wasm_instance, str_base, len);
|
||||
console.log(string);
|
||||
},
|
||||
};
|
||||
|
||||
let gl = null;
|
||||
|
||||
function glClearColor (r, g, b, a) { gl.clearColor(r,g,b,a); }
|
||||
function glEnable(v) { gl.enable(v); }
|
||||
function glDisable(v) { gl.disable(v); }
|
||||
function glBlendFunc(a,b) { gl.blendFunc(a,b); }
|
||||
function glViewport(xmin, ymin, xmax, ymax) { gl.viewport(xmin,ymin,xmax,ymax); }
|
||||
function glDepthFunc(v) { gl.depthFunc(v); }
|
||||
function glClear(mask) { gl.clear(mask); }
|
||||
|
||||
function webgl_add_imports (canvas_selector, imports) {
|
||||
const canvas = document.querySelector(canvas_selector);
|
||||
if (!canvas) return console.error("no canvas");
|
||||
|
||||
gl = canvas.getContext("webgl");
|
||||
if (gl === null) return console.error("no webgl ctx");
|
||||
|
||||
///////////////////////////////////////
|
||||
// Constants
|
||||
|
||||
imports.GL_TEXTURE_2D = gl.TEXTURE_2D;
|
||||
imports.GL_BLEND = gl.BLEND;
|
||||
imports.GL_SRC_ALPHA = gl.SRC_ALPHA;
|
||||
imports.GL_ONE_MINUS_SRC_ALPHA = gl.ONE_MINUS_SRC_ALPHA;
|
||||
imports.GL_DEPTH_TEST = gl.DEPTH_TEST;
|
||||
imports.GL_LESS = gl.LESS;
|
||||
imports.GL_COLOR_BUFFER_BIT = gl.COLOR_BUFFER_BIT;
|
||||
imports.GL_DEPTH_BUFFER_BIT = gl.DEPTH_BUFFER_BIT;
|
||||
|
||||
///////////////////////////////////////
|
||||
// Functions
|
||||
|
||||
imports.glClearColor = glClearColor;
|
||||
imports.glEnable = glEnable;
|
||||
imports.glDisable = glDisable;
|
||||
imports.glBlendFunc = glBlendFunc;
|
||||
imports.glViewport = glViewport;
|
||||
imports.glDepthFunc = glDepthFunc;
|
||||
imports.glClear = glClear;
|
||||
|
||||
return imports;
|
||||
}
|
||||
Binary file not shown.
|
|
@ -1 +0,0 @@
|
|||
OpenGL Version: 3.3.0 - Build 27.20.100.9778
|
||||
Binary file not shown.
Binary file not shown.
Loading…
Reference in New Issue