krzosa/wasm_transcript_browser
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

remove date from core, app_wasm.html

Browse Source
This commit is contained in:
krzosa
2025-01-04 08:38:19 +01:00
parent 1fca44fcfc
commit 6f795b7ea6
14 changed files with 208 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/app/app_wasm.c
View File

@@ -36,6 +36,7 @@ while (true) {
}
*/
fn_wasm_import f64 wasm_get_milliseconds(void);
gb_wasm_export char wasm_temp_buff1[128] = {[127] = 0x13};
gb_wasm_export i32 wasm_temp_buff1_len = 127;

161
src/app/app_wasm.html Normal file
View File

@@ -0,0 +1,161 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<canvas class="fill-screen" id="canvas"></canvas>
</body>
<style>
@font-face {
font-family: open_sans_regular;
src: url(OpenSans-Regular.ttf);
}
* {
margin: 0;
padding: 0;
overflow: hidden;
}
.fill-screen {
position: absolute;
top: 0;
left: 0;
width: 100%;
height: 100%;
}
</style>
</html>
<script>
class memory_t {
exports = null; // this is set after wasm module created
constructor(wasm_memory) {
this.mem = wasm_memory;
this.u8 = new Uint8Array(this.mem.buffer);
this.data_view = new DataView(this.mem.buffer);
this.utf8decoder = new TextDecoder("utf-8");
this.utf8encoder = new TextEncoder("utf-8");
}
read_cstr(str, len) {
const arr = this.u8.subarray(str, str+len);
const text = this.utf8decoder.decode(arr);
return text;
}
write_string_into_cmemory(ptr, ptr_len, string) {
const bytes = this.utf8encoder.encode(string);
let i = 0;
for (; i < bytes.length && i < (ptr_len-1); i += 1) {
this.u8[ptr + i] = bytes[i];
}
this.u8[ptr + i] = 0;
}
write_string(temp, string) {
const ptr = this.exports[temp].value;
const len = this.data_view.getInt32(this.exports[temp + "_len"].value, true);
this.write_string_into_cmemory(ptr, len, string);
return ptr;
}
}
const canvas = document.getElementById("canvas");
const ctx2d = canvas.getContext('2d');
const mem = new memory_t(new WebAssembly['Memory']({ initial: 2000, maximum: 65536 }));
(async function main() {
if (!ctx2d) {
alert('Outdated browser, cant draw :(');
return;
}
const request = await fetch('main.wasm');
const binary = await request.arrayBuffer();
const wasm_imports = {
// core
memory: mem.mem,
wasm_parse_float: (str, len) => { return parseFloat(mem.read_cstr(str, len)); },
wasm_alert: (str, len) => { alert(mem.read_cstr(str,len)); },
wasm_trap: () => { throw new Error(); },
wasm_write_to_console: (str, len) => { console.log(mem.read_cstr(str, len)); },
wasm_get_milliseconds: () => { return performance.now(); },
// gfx
wasm_draw_text: (str, len, x, y, font_str, font_len, font_size, r, g, b, a) => {
ctx2d.font = `${font_size}px ${mem.read_cstr(font_str, font_len)}`;
ctx2d.fillStyle = `rgba(${r}, ${g}, ${b}, ${a})`;
ctx2d.textBaseline = "top"
ctx2d.fillText(mem.read_cstr(str, len), x, y)
},
wasm_measure_text: (str, len, font_str, font_len, font_size) => {
ctx2d.font = `${font_size}px ${mem.read_cstr(font_str, font_len)}`;
ctx2d.textBaseline = "top";
const metrics = ctx2d.measureText(mem.read_cstr(str, len));
return metrics.width;
},
wasm_get_font_height: (font_str, font_len, font_size) => {
ctx2d.font = `${font_size}px ${mem.read_cstr(font_str, font_len)}`;
ctx2d.textBaseline = "top";
return ctx2d.measureText('NothinBelowTheBaseline').actualBoundingBoxDescent;
},
wasm_draw_rect: (x, y, w, h, r, g, b, a) => {
ctx2d.beginPath();
ctx2d.rect(x, y, w, h);
ctx2d.fillStyle = `rgba(${r}, ${g}, ${b}, ${a})`;
ctx2d.fill();
},
wasm_clear: () => {
ctx2d.clearRect(0, 0, canvas.width, canvas.height);
},
wasm_set_clip: (x, y, w, h) => {
ctx2d.restore();
ctx2d.save();
ctx2d.beginPath();
ctx2d.rect(x, y, w, h);
ctx2d.clip();
},
};
const program = await WebAssembly['instantiate'](binary, { "env": wasm_imports });
const instance = program['instance'];
const wasm_exports = instance['exports'];
mem.exports = wasm_exports;
wasm_exports['wasm_init']();
addEventListener("keydown", (event) => {
wasm_exports["wasm_key_down"](mem.write_string("wasm_temp_buff1", event.key), event.ctrlKey, event.shiftKey, event.altKey, event.metaKey);
});
addEventListener("keyup", (event) => {
wasm_exports["wasm_key_up"](mem.write_string("wasm_temp_buff1", event.key), event.ctrlKey, event.shiftKey, event.altKey, event.metaKey);
});
addEventListener("mousemove", (event) => {
wasm_exports["wasm_mouse_move"](event.clientX, event.clientY, event.ctrlKey, event.shiftKey, event.altKey, event.metaKey);
});
addEventListener("mousedown", (event) => {
wasm_exports["wasm_mouse_down"](event.clientX, event.clientY, event.button, event.ctrlKey, event.shiftKey, event.altKey, event.metaKey);
});
addEventListener("mouseup", (event) => {
wasm_exports["wasm_mouse_up"](event.clientX, event.clientY, event.button, event.ctrlKey, event.shiftKey, event.altKey, event.metaKey);
});
addEventListener("wheel", (event) => {
wasm_exports["wasm_mouse_wheel"](event.clientX, event.clientY, event.deltaX, event.deltaY, event.deltaZ, event.ctrlKey, event.shiftKey, event.altKey, event.metaKey);
});
requestAnimationFrame(function update(time) {
const dpr = window.devicePixelRatio;
canvas.width = canvas.getBoundingClientRect().width * dpr;
canvas.height = canvas.getBoundingClientRect().height * dpr;
wasm_exports['wasm_update'](canvas.width, canvas.height, dpr);
requestAnimationFrame(update);
});
})()
</script>

17
src/core/core_log.c
View File

@@ -23,26 +23,9 @@ fn void log_basef(i32 module, log_level_t level, s8_t file_and_line, const char
fn void default_log_proc(log_event_t ev) {
ma_temp_t scratch = ma_begin_scratch();
sb8_t *sb = sb8_serial_begin(scratch.arena);
if (tcx.log.flags & log_flag_module_id) {
sb8_printf(sb, "[%d] ", ev.module);
}
if (tcx.log.flags & log_flag_level) {
sb8_printf(sb, "%-5s ", log_level_str(ev.level));
}
date_t date = {0};
{
b32 bdate = (tcx.log.flags & log_flag_date);
b32 btime = (tcx.log.flags & log_flag_time);
if (bdate || btime) {
date = os_date_now();
}
if (bdate) {
sb8_printf(sb, "%04u.%02u.%02u ", date.year, date.month, date.day);
}
if (btime) {
sb8_printf(sb, "%02u:%02u:%02u ", date.hour, date.min, date.sec);
}
}
if (tcx.log.flags & log_flag_file_path) {
sb8_printf(sb, "%S: ", ev.file_and_line);
}

5
src/core/core_log.h
View File

@@ -21,11 +21,8 @@ const i32 module_null = 0;
typedef enum {
log_flag_null = 0,
log_flag_level = 1,
log_flag_date = 2,
log_flag_time = 4,
log_flag_file_path = 8,
log_flag_module_id = 16,
log_flag_all = log_flag_level | log_flag_date | log_flag_time | log_flag_file_path | log_flag_module_id,
log_flag_all = log_flag_level | log_flag_file_path,
} log_flag_t;
typedef enum { // AFTER_CHANGING: modify type_info and log_level_str

13
src/core/core_platform.h
View File

@@ -1,18 +1,5 @@
typedef struct date_t date_t;
struct date_t {
u16 ms;
u16 sec;
u16 min;
u16 hour;
u16 day;
u16 month;
u16 year;
};
fn void os_error_box(char *str);
fn void os_console_log(char *str);
fn date_t os_date_now(void);
fn f64 os_milliseconds_now(void);
fn void *os_vmem_reserve(usize size);
fn b32 os_vmem_commit(void *p, usize size);

13
src/core/core_platform_unix.c
View File

@@ -19,19 +19,6 @@ fn b32 os_vmem_decommit(void *p, usize size) {
return true;
}
fn date_t os_date_now(void) {
date_t result = {0};
time_t time = time(NULL);
struct tm *lt = localtime(&time);
result.sec = lt->tm_sec;
result.min = lt->tm_min;
result.hour = lt->tm_hour;
result.day = lt->tm_mday;
result.month = lt->tm_month;
result.year = lt->tm_year;
return result;
}
fn void os_error_box(char *str) {
fprintf(stderr, "%s", str);
}

6
src/core/core_platform_wasm.c
View File

@@ -1,7 +1,6 @@
fn_wasm_import void wasm_alert(isize ptr, i32 len);
fn_wasm_import f64 wasm_parse_float(isize str, i32 len);
fn_wasm_import void wasm_write_to_console(isize str, i32 len);
fn_wasm_import f64 wasm_get_milliseconds(void);
extern char __heap_base;
@@ -21,11 +20,6 @@ fn b32 os_vmem_decommit(void *p, usize size) {
return true;
}
fn date_t os_date_now(void) {
date_t result = {0}; // don't need timed logs in browser
return result;
}
fn void os_error_box(char *str) {
wasm_alert((isize)str, str_len(str));
}

15
src/core/core_platform_win32.c
View File

@@ -7,7 +7,6 @@ fn b32 os_vmem_commit(void *p, usize size) {
void *result = VirtualAlloc(p, size, MEM_COMMIT, PAGE_READWRITE);
return result ? true : false;
}
fn b32 os_vmem_release(void *p) {
BOOL result = VirtualFree(p, 0, MEM_RELEASE);
return result ? true : false;
@@ -18,20 +17,6 @@ fn b32 os_vmem_decommit(void *p, usize size) {
return result ? true : false;
}
fn date_t os_date_now(void) {
date_t result = {0};
SYSTEMTIME lt;
GetLocalTime(&lt);
result.ms = lt.wMilliseconds;
result.sec = lt.wSecond;
result.min = lt.wMinute;
result.hour = lt.wHour;
result.day = lt.wDay;
result.month = lt.wMonth;
result.year = lt.wYear;
return result;
}
fn void os_error_box(char *str) {
MessageBoxA(NULL, str, "fatal error", MB_OK);
fprintf(stderr, "%s", str);

12
src/os/os.h
View File

@@ -0,0 +1,12 @@
typedef struct os_date_t os_date_t;
struct os_date_t {
u16 ms;
u16 sec;
u16 min;
u16 hour;
u16 day;
u16 month;
u16 year;
};
fn os_date_t os_date_now(void);

12
src/os/os_unix.c
View File

@@ -0,0 +1,12 @@
fn os_date_t os_date_now(void) {
os_date_t result = {0};
time_t time = time(NULL);
struct tm *lt = localtime(&time);
result.sec = lt->tm_sec;
result.min = lt->tm_min;
result.hour = lt->tm_hour;
result.day = lt->tm_mday;
result.month = lt->tm_month;
result.year = lt->tm_year;
return result;
}

4
src/os/os_wasm.c
View File

@@ -0,0 +1,4 @@
fn os_date_t os_date_now(void) {
os_date_t result = {0}; // don't need timed logs in browser
return result;
}

13
src/os/os_win32.c
View File

@@ -0,0 +1,13 @@
fn os_date_t os_date_now(void) {
os_date_t result = {0};
SYSTEMTIME lt;
GetLocalTime(&lt);
result.ms = lt.wMilliseconds;
result.sec = lt.wSecond;
result.min = lt.wMinute;
result.hour = lt.wHour;
result.day = lt.wDay;
result.month = lt.wMonth;
result.year = lt.wYear;
return result;
}