From d58e3f6c5b62956de847ef6408ea6ab11784660a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Aurimas=20Bla=C5=BEulionis?= <0x60@pm.me>
Date: Mon, 25 Dec 2023 22:50:53 +0200
Subject: [PATCH] Add blog with 0.2 article
---
main.py | 1 +
mdrend.py | 23 +-
src/blog/index.md | 3 +
src/blog/memflow-0.2.0.md | 280 ++++++++++
src/quick_start.md | 22 +-
src/static/js/asciirend/asciirend.js | 640 ++++++++++++++++++++++
src/static/js/asciirend/asciirend_bg.wasm | Bin 0 -> 193097 bytes
src/static/js/draw.js | 239 ++++++++
templates/main.html | 2 +-
9 files changed, 1187 insertions(+), 23 deletions(-)
create mode 100644 src/blog/index.md
create mode 100644 src/blog/memflow-0.2.0.md
create mode 100644 src/static/js/asciirend/asciirend.js
create mode 100644 src/static/js/asciirend/asciirend_bg.wasm
create mode 100644 src/static/js/draw.js
diff --git a/main.py b/main.py
index d7d6f91..b71584e 100644
--- a/main.py
+++ b/main.py
@@ -16,6 +16,7 @@
template_vars = {
'navbar': [
('/', 'Home'),
+ ('blog/', 'Blog'),
('about/', 'About'),
('quick_start/', 'Quick start guide'),
('docs/', 'Documentation'),
diff --git a/mdrend.py b/mdrend.py
index f21dc64..448b411 100644
--- a/mdrend.py
+++ b/mdrend.py
@@ -58,16 +58,18 @@ def ascii_render(self, code):
scene = '{' + d[1]
color = int(props['color']) if 'color' in props else 0
- w = int(props['w']) if 'w' in props else 64
+ w = int(props['w']) if 'w' in props else 72
h = int(props['h']) if 'h' in props else 32
aspect = float(w / (2 * h))
+
+ # These parameters are not actually used in latest asciirend
ortho = bool(props['ortho']) if 'ortho' in props else True
fov = float(props['fov']) if 'fov' in props else 1.0
znear = float(props['znear']) if 'znear' in props else 0.1
zfar = float(props['zfar']) if 'zfar' in props else 100.0
self.scene_props[div_id] = {
- 'scene': scene,
+ 'scene': scene.replace('\n', ''),
'w': w,
'h': h,
'aspect': aspect,
@@ -77,9 +79,11 @@ def ascii_render(self, code):
'zfar': zfar,
'dynamic_w': bool(props['dynamic_w']) if 'dynamic_w' in props else False,
'dynamic_h': bool(props['dynamic_h']) if 'dynamic_h' in props else False,
+ 'show_usage': bool(props['show_usage']) if 'show_usage' in props else True,
+ 'disable_zoom': bool(props['disable_zoom']) if 'disable_zoom' in props else False,
}
- rendered = ar.ascii_render(scene, color, w, h, aspect, ortho, fov, znear, zfar)
+ rendered = ar.ascii_render(scene, color, w, h, aspect, ortho, fov, znear, zfar, 0.0)
return f'
';
def gh_users_render(self, code):
@@ -102,8 +106,6 @@ def gh_users_render(self, code):
"""
- print(line)
-
return output
def block_code(self, code, lang=None):
@@ -119,8 +121,6 @@ def block_code(self, code, lang=None):
except ClassNotFound:
lexer = get_lexer_by_name("html", stripall=True)
- print(str(lexer))
-
formatter = HtmlFormatter()
return highlight(code, lexer, formatter)
@@ -159,19 +159,20 @@ def shortdown(value):
md_rend = md.create_markdown(renderer=renderer, plugins=['strikethrough'])
return md_rend(trimmed)
-def markdown(value):
+def markdown(value, backlink):
+ print(backlink)
renderer = CustomizedRenderer()
md_rend = md.create_markdown(renderer=renderer, plugins=['task_lists', 'table', 'footnotes', 'strikethrough'], escape=False)
rendered = md_rend(value)
if renderer.scene_cnt > 0:
- javascript = """
+ javascript = f"""
"""
diff --git a/src/blog/index.md b/src/blog/index.md
new file mode 100644
index 0000000..094a19b
--- /dev/null
+++ b/src/blog/index.md
@@ -0,0 +1,3 @@
+# Blog
+
+## [Announcing memflow 0.2.0](memflow-0.2.0/)
diff --git a/src/blog/memflow-0.2.0.md b/src/blog/memflow-0.2.0.md
new file mode 100644
index 0000000..4ea0876
--- /dev/null
+++ b/src/blog/memflow-0.2.0.md
@@ -0,0 +1,280 @@
+# Announcing memflow 0.2.0
+
+Today, we are proud to release the first stable version of memflow 0.2! 3 years in the making, this
+is certainly a monumental release. In this post, we will go through the key changes to the fastest
+and most flexible physical memory introspection and forensics framework to date.
+
+## Key changes
+
+### 0. [memflowup](https://github.com/memflow/memflowup)
+
+Not a library change, but the ecosystem change! We now have a rust-written memflowup utility that
+makes it much easier to manage your memflow installation. Key features:
+
+- Download binary builds (optional).
+- Split between stable and dev versions.
+- Custom install scripts, for more complicated plugins
+ - Used by [`memflow-kvm`](https://github.com/memflow/memflow-kvm) for DKMS install.
+ - Entry point for these is `install.rhai` script at the root of the package's repo.
+
+You can get started with memflowup by running the following:
+
+```
+> curl --proto '=https' --tlsv1.2 -sSf https://sh.memflow.io | sh
+```
+
+### 1. OS layers and modularity
+
+With the advent of 0.2 series, we now abstracted most of `memflow-win32` functionality behind
+shared set of traits. These traits allow the user to interact with the operating system in unified
+manner. In addition, we now made OS a plugin, just as Connectors were in 0.1! And finally, we do
+indeed have multiple OS backends available, right now:
+
+- [`memflow-win32`](https://github.com/memflow/memflow-win32), for Windows analysis, given physical
+ memory access.
+- [`memflow-native`](https://github.com/memflow/memflow-native), for syscall based interaction with
+ the running operating system.
+- WIP: `memflow-linux`
+ - Don't expect much anytime soon, because the challenge of cross-version, zero-knowledge linux
+ support is a tricky one.
+
+With this, OS-independent code that works with `memflow-win32`, should also work on local OS. Here's
+an example of such code:
+
+```rust
+use memflow::prelude::v1::*;
+
+// We don't care what type of process we get, so long as it's a process
+fn module_address(process: &mut impl Process, module: &str) -> Result {
+ let module = process.module_by_name(module)?;
+ Ok(module.base)
+}
+```
+
+In addition, modularization of operating systems allows for greater portability of connectors. For
+instance, we have now split `memflow-qemu-procfs` into
+[`memflow-qemu`](https://github.com/memflow/memflow-qemu), which (optionally) accepts an OS layer.
+This way, you can not only analyze QEMU VMs running on your computer, but you can also open them up
+in a nested way on a machine that is already being analyzed through DMA. As seen in this chart:
+
+```asciirend
+dynamic_w = true
+dynamic_h = false
+fov = 4.5
+ortho = true
+disable_zoom = true
+# Scene:
+{
+ "camera_props": {
+ "proj_mode": "Orthographic",
+ "fov": 1.0,
+ "near": 0.01,
+ "far": 100.0
+ },
+ "camera_controller":{"fov_y":1.0,"focus_point":[0.0,0.0,0.0],"rot":[-0.19996414, -0.08282786, 0.37361234, 0.90197986],"dist":2.0,"in_motion":"None","scroll_sensitivity":0.02,"orbit_sensitivity":1.0,"last_down":false,"pressed":false},
+ "objects":[
+ {
+ "transform":[
+ 1.0,0.0,0.0,0.0,
+ 0.0,1.0,0.0,0.0,
+ 0.0,0.0,1.0,0.0,
+ 0.0,0.0,0.0,1.0
+ ],
+ "material":0,
+ "ty":{
+ "Primitive":{
+ "Line":{
+ "start":[-0.75,0.0,1.5,1.0],
+ "end":[-0.25,0.0,0.5,1.0]
+ }
+ }
+ }
+ },
+ {
+ "transform":[
+ 1.0,0.0,0.0,0.0,
+ 0.0,1.0,0.0,0.0,
+ 0.0,0.0,1.0,0.0,
+ 0.0,0.0,0.0,1.0
+ ],
+ "material":0,
+ "ty":{
+ "Primitive":{
+ "Line":{
+ "start":[-0.25,0.0,0.5,1.0],
+ "end":[0.25,0.0,-0.5,1.0]
+ }
+ }
+ }
+ },
+ {
+ "transform":[
+ 1.0,0.0,0.0,0.0,
+ 0.0,1.0,0.0,0.0,
+ 0.0,0.0,1.0,0.0,
+ 0.0,0.0,0.0,1.0
+ ],
+ "material":0,
+ "ty":{
+ "Primitive":{
+ "Line":{
+ "start":[0.25,0.0,-0.5,1.0],
+ "end":[0.75,0.0,-1.5,1.0]
+ }
+ }
+ }
+ },
+ {
+ "transform":[
+ 1.0,0.0,0.0,0.0,
+ 0.0,1.0,0.0,0.0,
+ 0.0,0.0,1.0,0.0,
+ -0.75,0.0,1.5,1.0
+ ],"material":1,"ty":{"Cube":{"size":[1.0,1.0,0.5]}},"text":"memflow-kvm"
+ },
+ {
+ "transform":[
+ 1.0,0.0,0.0,0.0,
+ 0.0,1.0,0.0,0.0,
+ 0.0,0.0,1.0,0.0,
+ -0.25,0.0,0.5,1.0
+ ],"material":1,"ty":{"Cube":{"size":[1.0,1.0,0.5]}},"text":"memflow-win32"
+ },
+ {
+ "transform":[
+ 1.0,0.0,0.0,0.0,
+ 0.0,1.0,0.0,0.0,
+ 0.0,0.0,1.0,0.0,
+ 0.25,0.0,-0.5,1.0
+ ],"material":1,"ty":{"Cube":{"size":[1.0,1.0,0.5]}},"text":"memflow-qemu"
+ },
+ {
+ "transform":[
+ 1.0,0.0,0.0,0.0,
+ 0.0,1.0,0.0,0.0,
+ 0.0,0.0,1.0,0.0,
+ 0.75,0.0,-1.5,1.0
+ ],"material":1,"ty":{"Cube":{"size":[1.0,1.0,0.5]}},"text":"memflow-win32"
+ }
+ ],
+ "bg":{"color":[0.0,0.0,0.0]},
+ "dithering":{"count_frames":false,"frame_cnt":4181}
+}
+```
+
+### 2. Stable ABI
+
+In 0.1, the Connectors were turned into plugins through use of Rust trait objects. This was an okay
+solution at the time, however, we knew that it was not a safe one - changes in Rust versions could
+change the layout of those trait objects, leading to crashes or other misbehavior, in case of
+mismatch of plugin's `rustc` version and the one of the user's code. While the layout has remained
+stable most of the time, the tides started to shift a few years ago, as more effort was put into
+trait objects on the compiler front.
+
+For 0.2, we knew we could not keep the status quo, so, we built `cglue`. The crate allows for
+simple and flexible ABI safe code generation, suited for the needs of `memflow`. Throughout the
+(very long) beta period, we received 0 crash reports stemming from ABI instability, while 0.1 had
+such cases. Therefore, we can conclude that it was a good investment that already made memflow more
+stable.
+
+In `0.2.0-betaX` series, you may have encountered "invalid ABI" errors, well, fear not, because in
+stable series, we commit to not breaking the ABI across entirety of `0.2` series, so this problem
+should be a thing of the past for most users.
+
+### 3. Memory constrained vtop
+
+memflow 0.2 introduces the most scalable virtual address translation backend, period. The backend
+is able to walk entire page tree in milliseconds, targeting any modern memory architecture (x86 and
+ARM support out-of-the box, sufficient building blocks for RISC-V). In addition, compared to 0.1,
+the new backend uses fixed-size buffers, meaning RAM usage will no longer blow up on large
+translation ranges.
+
+### 4. 64-bit and 128-bit address spaces, on all architectures
+
+We now support analyzing 64-bit operating systems on 32-bit machines. In addition, if there was a
+theoretical 128-bit architecture, we would support that as well. However, it's more of a PoC and we
+do not expect this to be needed in the foreseeable future.
+
+The support can be toggled through `64_bit_mem` (default) and `128_bit_mem` features. Do note that
+these feature toggles do change memflow's ABI and it should not be possible to mix the plugin
+features.
+
+### 5. Shared `MemoryView`
+
+In 0.1, we have had a split between physical and virtual memory. The reason for the split is
+caching - we wish minimize latency by caching read-only memory in high-latency scenarios.
+However, to tell the cache what mode the memory is in (readable/writeable/executable), you must add
+metadata with each request. Meanwhile, this metadata may only be filled in by the virtual address
+translation backend.
+
+If user submits an I/O operation - they can't possibly know whether the request is going to a
+read-only, or a writeable page, therefore they just submit `UNKNOWN` page flags. This is
+complicated, therefore, we have lowered the gap between virtual and physical memory access through
+use of `MemoryView` trait. This trait not only removes the need for the user to explicitly submit
+the page flags, but also brings all I/O helpers that existed in virtual memory contexts. To use
+`MemoryView` on physical memory, just use the `phys_view` function:
+
+```rust
+use memflow::prelude::v1::*;
+
+fn main() -> Result<()> {
+ let inventory = Inventory::scan();
+ let mut conn = inventory.create_connector("dummy", None, None)?;
+
+ // Create a physical memory view
+ let mut view = conn.phys_view();
+
+ // Read from phys addr 0
+ let value: u64 = view.read(0.into())?;
+
+ Ok(())
+}
+```
+
+### 6. C and C++ are now first-class citizen
+
+The FFI is now automatically generated using `cbindgen` and `cglue-bindgen`. It may initially seem
+like a downgrade, however, this way we can ensure entirety of memflow's plugin-focused API surface
+can be both accessed, and implemented by foreign languages, such as C and C++.
+
+The key to using the new FFI, is reading Rust documentation and examples, and then finding the
+function equivalents in the headers. There are a few quirks here and there, but after understanding
+them, using the FFI should not be hard. For inspiration, see the following:
+
+- [C examples](https://github.com/memflow/memflow/tree/0.2.0/memflow-ffi/examples/c)
+- [C++ examples](https://github.com/memflow/memflow/tree/0.2.0/memflow-ffi/examples/cpp)
+- [CMake template](https://github.com/memflow/memflow-cmake-example)
+
+## Side projects
+
+`memflow` is as useful as the projects utilizing it. To get started with the new version faster,
+you may want to have a look at some of them. Here's the list of first-party releases:
+
+- [`reflow`](https://github.com/memflow/reflow) - execute code on top of virtual memory.
+- [`scanflow`](https://github.com/memflow/scanflow) - basic CheatEngine features in a command line
+ interface.
+- [`cloudflow`](https://github.com/memflow/cloudflow) (WIP) - flexible filesystem based way to
+ interact with memflow.
+- [`memflow-py`](https://github.com/memflow/memflow-py) - python bindings for memflow (courtesy of
+ emesare).
+
+## Reflection
+
+0.2 took way longer than we originally anticipated. This is mostly due to changing living
+conditions and the fact that both ko1N and I are only working on the project in hobbyist capacity.
+In addition, we pushed for perfection from documentation and implementation front - a feat
+infeasible at the current point. We do believe memflow is the framework that is going to bring the
+most empowerement to users, however, there are still ways to go.
+
+## Next up - Async Metamorphosis
+
+Next, we will work towards integrating [`mfio`](https://github.com/memflow/mfio) into memflow,
+which will enable higher scalability and simplicity. The key change is going to be transition from
+synchronous to asynchronous API. There are still a lot of open questions regarding this, such as
+FFI handling, how much the individual pieces of memflow's code will have to change, and how
+multithreading needs to be handled. However, we are confident those questions are not impossible
+to solve. Once the metamorphosis is done, we can consider the structure of memflow done. What comes
+afterwards, is rapid feature development. It will definitely be an exciting time to be alive. So
+let's just get there, shall we?
+
+\- h33p
diff --git a/src/quick_start.md b/src/quick_start.md
index e1117b7..fcfa705 100644
--- a/src/quick_start.md
+++ b/src/quick_start.md
@@ -31,9 +31,9 @@ After setting up cargo properly you can install memflowup via our install script
Alternatively you can install memflowup via cargo:
```
-> cargo install memflowup --force --version "=0.1.0-beta11"
+> cargo install memflowup --force
...
-Installed package `memflowup v0.1.0-beta11` (executable `memflowup.exe`)
+Installed package `memflowup v0.1.0` (executable `memflowup.exe`)
```
#### Note
@@ -41,7 +41,7 @@ memflowup should __not__ be installed or ran as root or via sudo. By default rus
### 2. Installing plugins
-When running `memflowup` for the first time it is recommended to use the interactive mode and install memflow from the 0.2.0-beta branch (development).
+When running `memflowup` for the first time it is recommended to use the interactive mode and install memflow from the stable branch.
Installing packages system-wide will place all plugins in `/usr/local/lib/memflow`.\
Installing packages per user will place all plugins in `$HOME/.local/lib/memflow`.
@@ -99,11 +99,11 @@ In case you installed the plugins like in the example above you can simply use t
### 3. Verify your installation and run an example
To test if everything is working properly the easiest method is to simply
-use one of the [examples](https://github.com/memflow/memflow/tree/0.2.0-beta11/memflow/examples) provided in memflow.
+use one of the [examples](https://github.com/memflow/memflow/tree/stable/memflow/examples) provided in memflow.
To run the examples simply check out the memflow repo with the appropiate version:
```
-> git clone --depth 1 --branch 0.2.0-beta11 https://github.com/memflow/memflow
+> git clone --depth 1 --branch stable https://github.com/memflow/memflow
> cd memflow
```
@@ -147,14 +147,14 @@ info: cleaning up downloads & tmp directories
After setting up cargo properly you can install memflowup via cargo:
```
-> cargo install memflowup --force --version "=0.1.0-beta11"
+> cargo install memflowup --force
...
-Installed package `memflowup v0.1.0-beta11` (executable `memflowup.exe`)
+Installed package `memflowup v0.1.0` (executable `memflowup.exe`)
```
### 2. Installing plugins
-When running `memflowup` for the first time it is recommended to use the interactive mode and install memflow from the 0.2.0-beta branch (development).
+When running `memflowup` for the first time it is recommended to use the interactive mode and install memflow from the stable branch.
Installing packages system-wide will place all plugins in `%ProgramFiles%\memflow\`.\
Installing packages per user will place all plugins in `%UserProfile%\Documents\memflow\`.
@@ -210,11 +210,11 @@ In case you installed the plugins like in the example above you can simply use t
### 3. Verify your installation and run an example
To test if everything is working properly the easiest method is to simply
-use one of the [examples](https://github.com/memflow/memflow/tree/0.2.0-beta11/memflow/examples) provided in memflow.
+use one of the [examples](https://github.com/memflow/memflow/tree/stable/memflow/examples) provided in memflow.
To run the examples simply check out the memflow repo with the appropiate version:
```
-> git clone --depth 1 --branch 0.2.0-beta11 https://github.com/memflow/memflow
+> git clone --depth 1 --branch stable https://github.com/memflow/memflow
> cd memflow
```
@@ -242,4 +242,4 @@ If everything went well you should see a list of all open processes:
1484 x86_64 x86_64 services.exe () (Alive)
...
-```
\ No newline at end of file
+```
diff --git a/src/static/js/asciirend/asciirend.js b/src/static/js/asciirend/asciirend.js
new file mode 100644
index 0000000..02e16ae
--- /dev/null
+++ b/src/static/js/asciirend/asciirend.js
@@ -0,0 +1,640 @@
+let wasm;
+
+const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
+
+if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
+
+let cachedUint8Memory0 = null;
+
+function getUint8Memory0() {
+ if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
+ cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+ }
+ return cachedUint8Memory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+ ptr = ptr >>> 0;
+ return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
+}
+/**
+* @returns {number}
+*/
+export function new_scene() {
+ const ret = wasm.new_scene();
+ return ret >>> 0;
+}
+
+/**
+* @param {number} scene
+*/
+export function remove_scene(scene) {
+ wasm.remove_scene(scene);
+}
+
+let cachedInt32Memory0 = null;
+
+function getInt32Memory0() {
+ if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
+ cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
+ }
+ return cachedInt32Memory0;
+}
+/**
+* @param {number} scene
+* @returns {string}
+*/
+export function scene_to_json(scene) {
+ let deferred1_0;
+ let deferred1_1;
+ try {
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+ wasm.scene_to_json(retptr, scene);
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
+ deferred1_0 = r0;
+ deferred1_1 = r1;
+ return getStringFromWasm0(r0, r1);
+ } finally {
+ wasm.__wbindgen_add_to_stack_pointer(16);
+ wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+ }
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
+
+const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
+ ? function (arg, view) {
+ return cachedTextEncoder.encodeInto(arg, view);
+}
+ : function (arg, view) {
+ const buf = cachedTextEncoder.encode(arg);
+ view.set(buf);
+ return {
+ read: arg.length,
+ written: buf.length
+ };
+});
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+ if (realloc === undefined) {
+ const buf = cachedTextEncoder.encode(arg);
+ const ptr = malloc(buf.length, 1) >>> 0;
+ getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
+ WASM_VECTOR_LEN = buf.length;
+ return ptr;
+ }
+
+ let len = arg.length;
+ let ptr = malloc(len, 1) >>> 0;
+
+ const mem = getUint8Memory0();
+
+ let offset = 0;
+
+ for (; offset < len; offset++) {
+ const code = arg.charCodeAt(offset);
+ if (code > 0x7F) break;
+ mem[ptr + offset] = code;
+ }
+
+ if (offset !== len) {
+ if (offset !== 0) {
+ arg = arg.slice(offset);
+ }
+ ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+ const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
+ const ret = encodeString(arg, view);
+
+ offset += ret.written;
+ }
+
+ WASM_VECTOR_LEN = offset;
+ return ptr;
+}
+/**
+* @param {string} scene
+* @returns {number}
+*/
+export function scene_from_json(scene) {
+ const ptr0 = passStringToWasm0(scene, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ const len0 = WASM_VECTOR_LEN;
+ const ret = wasm.scene_from_json(ptr0, len0);
+ return ret >>> 0;
+}
+
+/**
+* @param {number} x
+* @param {number} y
+* @param {number} z
+* @returns {Vec3}
+*/
+export function vec3(x, y, z) {
+ const ret = wasm.vec3(x, y, z);
+ return Vec3.__wrap(ret);
+}
+
+/**
+* @param {TermColorMode} colors
+* @returns {ColorConvParams}
+*/
+export function color_conv(colors) {
+ const ret = wasm.color_conv(colors);
+ return ColorConvParams.__wrap(ret);
+}
+
+function _assertClass(instance, klass) {
+ if (!(instance instanceof klass)) {
+ throw new Error(`expected instance of ${klass.name}`);
+ }
+ return instance.ptr;
+}
+/**
+* @param {number} scene
+* @param {number} obj
+* @param {Vec3} pos
+* @param {Vec3} rot
+* @param {Vec3} scale
+*/
+export function set_obj_transform(scene, obj, pos, rot, scale) {
+ _assertClass(pos, Vec3);
+ var ptr0 = pos.__destroy_into_raw();
+ _assertClass(rot, Vec3);
+ var ptr1 = rot.__destroy_into_raw();
+ _assertClass(scale, Vec3);
+ var ptr2 = scale.__destroy_into_raw();
+ wasm.set_obj_transform(scene, obj, ptr0, ptr1, ptr2);
+}
+
+function isLikeNone(x) {
+ return x === undefined || x === null;
+}
+/**
+* @param {number} scene
+* @param {StandardMaterial} material
+* @param {Vec3} size
+* @param {string | undefined} [text]
+* @returns {number | undefined}
+*/
+export function add_cube(scene, material, size, text) {
+ try {
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+ _assertClass(size, Vec3);
+ var ptr0 = size.__destroy_into_raw();
+ var ptr1 = isLikeNone(text) ? 0 : passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ var len1 = WASM_VECTOR_LEN;
+ wasm.add_cube(retptr, scene, material, ptr0, ptr1, len1);
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
+ return r0 === 0 ? undefined : r1 >>> 0;
+ } finally {
+ wasm.__wbindgen_add_to_stack_pointer(16);
+ }
+}
+
+/**
+* @param {number} scene
+* @param {StandardMaterial} material
+* @param {Vec3} start
+* @param {Vec3} end
+* @param {string | undefined} [text]
+* @returns {number | undefined}
+*/
+export function add_line(scene, material, start, end, text) {
+ try {
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+ _assertClass(start, Vec3);
+ var ptr0 = start.__destroy_into_raw();
+ _assertClass(end, Vec3);
+ var ptr1 = end.__destroy_into_raw();
+ var ptr2 = isLikeNone(text) ? 0 : passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ var len2 = WASM_VECTOR_LEN;
+ wasm.add_line(retptr, scene, material, ptr0, ptr1, ptr2, len2);
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
+ return r0 === 0 ? undefined : r1 >>> 0;
+ } finally {
+ wasm.__wbindgen_add_to_stack_pointer(16);
+ }
+}
+
+/**
+* @param {number} scene
+* @param {number} object
+* @param {string | undefined} [text]
+*/
+export function set_text(scene, object, text) {
+ var ptr0 = isLikeNone(text) ? 0 : passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ var len0 = WASM_VECTOR_LEN;
+ wasm.set_text(scene, object, ptr0, len0);
+}
+
+/**
+* @param {number} scene
+* @param {number} obj
+* @param {Vec3} start
+* @param {Vec3} end
+*/
+export function set_line_points(scene, obj, start, end) {
+ _assertClass(start, Vec3);
+ var ptr0 = start.__destroy_into_raw();
+ _assertClass(end, Vec3);
+ var ptr1 = end.__destroy_into_raw();
+ wasm.set_line_points(scene, obj, ptr0, ptr1);
+}
+
+let cachedUint32Memory0 = null;
+
+function getUint32Memory0() {
+ if (cachedUint32Memory0 === null || cachedUint32Memory0.byteLength === 0) {
+ cachedUint32Memory0 = new Uint32Array(wasm.memory.buffer);
+ }
+ return cachedUint32Memory0;
+}
+
+const heap = new Array(128).fill(undefined);
+
+heap.push(undefined, null, true, false);
+
+function getObject(idx) { return heap[idx]; }
+
+let heap_next = heap.length;
+
+function dropObject(idx) {
+ if (idx < 132) return;
+ heap[idx] = heap_next;
+ heap_next = idx;
+}
+
+function takeObject(idx) {
+ const ret = getObject(idx);
+ dropObject(idx);
+ return ret;
+}
+
+function getArrayJsValueFromWasm0(ptr, len) {
+ ptr = ptr >>> 0;
+ const mem = getUint32Memory0();
+ const slice = mem.subarray(ptr / 4, ptr / 4 + len);
+ const result = [];
+ for (let i = 0; i < slice.length; i++) {
+ result.push(takeObject(slice[i]));
+ }
+ return result;
+}
+/**
+* Renders a scene into RgbPixel slice.
+* @param {number} scene
+* @param {ColorConvParams} color_conv
+* @param {number} w
+* @param {number} h
+* @param {number} elapsed
+* @returns {(RgbPixel)[]}
+*/
+export function render(scene, color_conv, w, h, elapsed) {
+ try {
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+ _assertClass(color_conv, ColorConvParams);
+ wasm.render(retptr, scene, color_conv.__wbg_ptr, w, h, elapsed);
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
+ var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+ wasm.__wbindgen_free(r0, r1 * 4, 4);
+ return v1;
+ } finally {
+ wasm.__wbindgen_add_to_stack_pointer(16);
+ }
+}
+
+/**
+* @param {number} scene
+* @param {number} aspect_ratio
+*/
+export function set_camera_aspect(scene, aspect_ratio) {
+ wasm.set_camera_aspect(scene, aspect_ratio);
+}
+
+/**
+* @param {number} scene
+* @param {number} w
+* @param {number} h
+*/
+export function new_frame(scene, w, h) {
+ wasm.new_frame(scene, w, h);
+}
+
+/**
+* @param {number} scene
+* @param {boolean} focused
+*/
+export function event_focus(scene, focused) {
+ wasm.event_focus(scene, focused);
+}
+
+/**
+* @param {number} scene
+* @param {number} x
+* @param {number} y
+*/
+export function event_mouse_pos(scene, x, y) {
+ wasm.event_mouse_pos(scene, x, y);
+}
+
+/**
+* @param {number} scene
+*/
+export function event_mouse_pos_clear(scene) {
+ wasm.event_mouse_pos_clear(scene);
+}
+
+/**
+* @param {number} scene
+* @param {boolean} down
+* @param {boolean} primary
+*/
+export function event_mouse_button_state(scene, down, primary) {
+ wasm.event_mouse_button_state(scene, down, primary);
+}
+
+/**
+* @param {number} scene
+* @param {number} x
+* @param {number} y
+*/
+export function event_scroll(scene, x, y) {
+ wasm.event_scroll(scene, x, y);
+}
+
+/**
+* @param {number} scene
+* @param {Vec3} col
+*/
+export function set_bg_color(scene, col) {
+ _assertClass(col, Vec3);
+ var ptr0 = col.__destroy_into_raw();
+ wasm.set_bg_color(scene, ptr0);
+}
+
+/**
+* @param {number} scene
+* @param {boolean} count_frames
+*/
+export function set_dither_count_frames(scene, count_frames) {
+ wasm.set_dither_count_frames(scene, count_frames);
+}
+
+function addHeapObject(obj) {
+ if (heap_next === heap.length) heap.push(heap.length + 1);
+ const idx = heap_next;
+ heap_next = heap[idx];
+
+ heap[idx] = obj;
+ return idx;
+}
+/**
+*/
+export const TermColorMode = Object.freeze({ SingleCol:0,"0":"SingleCol",Col16:1,"1":"Col16",Col256:2,"2":"Col256",Rgb:3,"3":"Rgb", });
+/**
+*/
+export const ProjectionMode = Object.freeze({ Perspective:0,"0":"Perspective",Orthographic:1,"1":"Orthographic", });
+/**
+*/
+export const StandardMaterial = Object.freeze({ Unlit:0,"0":"Unlit",Diffuse:1,"1":"Diffuse",UiText:2,"2":"UiText", });
+/**
+*/
+export class ColorConvParams {
+
+ static __wrap(ptr) {
+ ptr = ptr >>> 0;
+ const obj = Object.create(ColorConvParams.prototype);
+ obj.__wbg_ptr = ptr;
+
+ return obj;
+ }
+
+ __destroy_into_raw() {
+ const ptr = this.__wbg_ptr;
+ this.__wbg_ptr = 0;
+
+ return ptr;
+ }
+
+ free() {
+ const ptr = this.__destroy_into_raw();
+ wasm.__wbg_colorconvparams_free(ptr);
+ }
+ /**
+ * @returns {TermColorMode}
+ */
+ get colors() {
+ const ret = wasm.__wbg_get_colorconvparams_colors(this.__wbg_ptr);
+ return ret;
+ }
+ /**
+ * @param {TermColorMode} arg0
+ */
+ set colors(arg0) {
+ wasm.__wbg_set_colorconvparams_colors(this.__wbg_ptr, arg0);
+ }
+}
+/**
+*/
+export class RgbPixel {
+
+ static __wrap(ptr) {
+ ptr = ptr >>> 0;
+ const obj = Object.create(RgbPixel.prototype);
+ obj.__wbg_ptr = ptr;
+
+ return obj;
+ }
+
+ __destroy_into_raw() {
+ const ptr = this.__wbg_ptr;
+ this.__wbg_ptr = 0;
+
+ return ptr;
+ }
+
+ free() {
+ const ptr = this.__destroy_into_raw();
+ wasm.__wbg_rgbpixel_free(ptr);
+ }
+ /**
+ * @returns {number}
+ */
+ get r() {
+ const ret = wasm.__wbg_get_rgbpixel_r(this.__wbg_ptr);
+ return ret;
+ }
+ /**
+ * @param {number} arg0
+ */
+ set r(arg0) {
+ wasm.__wbg_set_rgbpixel_r(this.__wbg_ptr, arg0);
+ }
+ /**
+ * @returns {number}
+ */
+ get g() {
+ const ret = wasm.__wbg_get_rgbpixel_g(this.__wbg_ptr);
+ return ret;
+ }
+ /**
+ * @param {number} arg0
+ */
+ set g(arg0) {
+ wasm.__wbg_set_rgbpixel_g(this.__wbg_ptr, arg0);
+ }
+ /**
+ * @returns {number}
+ */
+ get b() {
+ const ret = wasm.__wbg_get_rgbpixel_b(this.__wbg_ptr);
+ return ret;
+ }
+ /**
+ * @param {number} arg0
+ */
+ set b(arg0) {
+ wasm.__wbg_set_rgbpixel_b(this.__wbg_ptr, arg0);
+ }
+ /**
+ * @returns {number}
+ */
+ get c() {
+ const ret = wasm.__wbg_get_rgbpixel_c(this.__wbg_ptr);
+ return ret;
+ }
+ /**
+ * @param {number} arg0
+ */
+ set c(arg0) {
+ wasm.__wbg_set_rgbpixel_c(this.__wbg_ptr, arg0);
+ }
+}
+/**
+*/
+export class Vec3 {
+
+ static __wrap(ptr) {
+ ptr = ptr >>> 0;
+ const obj = Object.create(Vec3.prototype);
+ obj.__wbg_ptr = ptr;
+
+ return obj;
+ }
+
+ __destroy_into_raw() {
+ const ptr = this.__wbg_ptr;
+ this.__wbg_ptr = 0;
+
+ return ptr;
+ }
+
+ free() {
+ const ptr = this.__destroy_into_raw();
+ wasm.__wbg_vec3_free(ptr);
+ }
+}
+
+async function __wbg_load(module, imports) {
+ if (typeof Response === 'function' && module instanceof Response) {
+ if (typeof WebAssembly.instantiateStreaming === 'function') {
+ try {
+ return await WebAssembly.instantiateStreaming(module, imports);
+
+ } catch (e) {
+ if (module.headers.get('Content-Type') != 'application/wasm') {
+ console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+ } else {
+ throw e;
+ }
+ }
+ }
+
+ const bytes = await module.arrayBuffer();
+ return await WebAssembly.instantiate(bytes, imports);
+
+ } else {
+ const instance = await WebAssembly.instantiate(module, imports);
+
+ if (instance instanceof WebAssembly.Instance) {
+ return { instance, module };
+
+ } else {
+ return instance;
+ }
+ }
+}
+
+function __wbg_get_imports() {
+ const imports = {};
+ imports.wbg = {};
+ imports.wbg.__wbg_rgbpixel_new = function(arg0) {
+ const ret = RgbPixel.__wrap(arg0);
+ return addHeapObject(ret);
+ };
+ imports.wbg.__wbindgen_throw = function(arg0, arg1) {
+ throw new Error(getStringFromWasm0(arg0, arg1));
+ };
+
+ return imports;
+}
+
+function __wbg_init_memory(imports, maybe_memory) {
+
+}
+
+function __wbg_finalize_init(instance, module) {
+ wasm = instance.exports;
+ __wbg_init.__wbindgen_wasm_module = module;
+ cachedInt32Memory0 = null;
+ cachedUint32Memory0 = null;
+ cachedUint8Memory0 = null;
+
+
+ return wasm;
+}
+
+function initSync(module) {
+ if (wasm !== undefined) return wasm;
+
+ const imports = __wbg_get_imports();
+
+ __wbg_init_memory(imports);
+
+ if (!(module instanceof WebAssembly.Module)) {
+ module = new WebAssembly.Module(module);
+ }
+
+ const instance = new WebAssembly.Instance(module, imports);
+
+ return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(input) {
+ if (wasm !== undefined) return wasm;
+
+ if (typeof input === 'undefined') {
+ input = new URL('asciirend_bg.wasm', import.meta.url);
+ }
+ const imports = __wbg_get_imports();
+
+ if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) {
+ input = fetch(input);
+ }
+
+ __wbg_init_memory(imports);
+
+ const { instance, module } = await __wbg_load(await input, imports);
+
+ return __wbg_finalize_init(instance, module);
+}
+
+export { initSync }
+export default __wbg_init;
diff --git a/src/static/js/asciirend/asciirend_bg.wasm b/src/static/js/asciirend/asciirend_bg.wasm
new file mode 100644
index 0000000000000000000000000000000000000000..e4e5272f94bfdd282cf6b4353b86d630b09c27c4
GIT binary patch
literal 193097
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