diff options
297 files changed, 28972 insertions, 36 deletions
diff --git a/2026/framing/dist/index.html b/2026/framing/dist/index.html index ae8ba12..71d55b3 100644 --- a/2026/framing/dist/index.html +++ b/2026/framing/dist/index.html @@ -23,7 +23,7 @@ dispatchEvent(new CustomEvent("TrunkApplicationStarted", {detail: {wasm}})); <link rel="icon" href="data:;base64,iVBORw0KGgo="> <link rel="stylesheet" href="/framing/dist/index-1e3cd2ca0ba4d1ec.css" integrity="sha384-1q3UDTmLdOyf9/QxW+Imap//HWhTWNfvn7j2iwuUap3HSD6IOGG7pDS9VJMk7nKv"/> <title>TODO TITLE</title> - <link rel="modulepreload" href="/framing/dist/game_lib-a509343dd3244dc8.js" crossorigin="anonymous" integrity="sha384-kETWGSRk6mu21Pl7hsEBpB7eWp9Jg8dJ0WfMsHTslM4gPgB1ny4BccJxZQiG/rOL"><link rel="modulepreload" href="/framing/dist/snippets/game_lib-09da6449fcb9d06e/src/bindings.js" crossorigin="anonymous" integrity="sha384-OqSoI1U/qGAdOIY23X7G4HXgi2h6nb8jbT8RiF1LDHgJg7UPDyGz1ZQ/rgmUg4ue"><link rel="modulepreload" href="/framing/dist/snippets/teleia-727bf4351691f1c8/src/helpers.js" crossorigin="anonymous" integrity="sha384-HhtEY2WfGmhyPUSRWKZvqsRxYsdT/DLEdFUqWyDZt6G6lrNHmE1zMlw4BJ3RycRd"><link rel="preload" href="/framing/dist/game_lib-a509343dd3244dc8_bg.wasm" crossorigin="anonymous" integrity="sha384-mznY6+bfU5XIP79YSpHzuNd37ePGUT6ozIc4RfEodpnBunxBglkgO6wq31LV8Ddq" as="fetch" type="application/wasm"></head> + <link rel="modulepreload" href="/framing/dist/game_lib-a509343dd3244dc8.js" crossorigin="anonymous" integrity="sha384-kETWGSRk6mu21Pl7hsEBpB7eWp9Jg8dJ0WfMsHTslM4gPgB1ny4BccJxZQiG/rOL"><link rel="modulepreload" href="/framing/dist/snippets/teleia-727bf4351691f1c8/src/helpers.js" crossorigin="anonymous" integrity="sha384-HhtEY2WfGmhyPUSRWKZvqsRxYsdT/DLEdFUqWyDZt6G6lrNHmE1zMlw4BJ3RycRd"><link rel="modulepreload" href="/framing/dist/snippets/game_lib-09da6449fcb9d06e/src/bindings.js" crossorigin="anonymous" integrity="sha384-OqSoI1U/qGAdOIY23X7G4HXgi2h6nb8jbT8RiF1LDHgJg7UPDyGz1ZQ/rgmUg4ue"><link rel="preload" href="/framing/dist/game_lib-a509343dd3244dc8_bg.wasm" crossorigin="anonymous" integrity="sha384-mznY6+bfU5XIP79YSpHzuNd37ePGUT6ozIc4RfEodpnBunxBglkgO6wq31LV8Ddq" as="fetch" type="application/wasm"></head> <body> <script type="module"> window.addEventListener("TrunkApplicationStarted", async (event) => { diff --git a/2026/games/just__jane/.clang-format b/2026/games/just__jane/.clang-format new file mode 100644 index 0000000..d7dc6ec --- /dev/null +++ b/2026/games/just__jane/.clang-format @@ -0,0 +1,23 @@ +BasedOnStyle: LLVM +ColumnLimit: 120 + +BinPackArguments: false +BinPackParameters: false +AlignAfterOpenBracket: AlwaysBreak + +AllowAllArgumentsOnNextLine: false +AllowAllParametersOfDeclarationOnNextLine: false + +BreakBeforeBinaryOperators: NonAssignment +BreakBeforeTernaryOperators: true +BreakStringLiterals: true + +# Make breaking lines "cheap" +PenaltyBreakBeforeFirstCallParameter: 1 +PenaltyBreakAssignment: 2 +PenaltyBreakComment: 300 +PenaltyBreakFirstLessLess: 0 +PenaltyBreakOpenParenthesis: 0 +PenaltyBreakString: 1 + +PenaltyExcessCharacter: 1000000 diff --git a/2026/games/just__jane/.gitignore b/2026/games/just__jane/.gitignore new file mode 100644 index 0000000..6de1189 --- /dev/null +++ b/2026/games/just__jane/.gitignore @@ -0,0 +1,4 @@ +sakura_samura.js +sakura_samura.html +sakura_samura.data +sakura_samura.wasm diff --git a/2026/games/just__jane/Makefile b/2026/games/just__jane/Makefile new file mode 100644 index 0000000..c9b8c8e --- /dev/null +++ b/2026/games/just__jane/Makefile @@ -0,0 +1,39 @@ +CXX := em++ + +TARGET := sakura_samurai.html + +SRC_DIR := src +OBJ_DIR := build/web + +# RAYLIB_DIR := ../just-packages/raylib-web/raylib +RAYLIB_DIR := ../../examples/example_raylib + +CPPFLAGS := \ + -I$(SRC_DIR) \ + -isystem $(RAYLIB_DIR)/raylib/src \ + -Iinclude + +CXXFLAGS := -std=c++23 -Wall -Wextra -O2 -DPLATFORM_WEB -Wno-unused-parameter -Wno-unused-argument -sFETCH + +LDFLAGS := \ + $(RAYLIB_DIR)/libraylib.a \ + -s USE_GLFW=3 \ + -s ASYNCIFY \ + -s ALLOW_MEMORY_GROWTH=1 \ + -s ASSERTIONS=1 \ + --preload-file assets + +APP_SRCS := $(shell find $(SRC_DIR) -name '*.cpp') + +all: $(TARGET) + +$(TARGET): $(APP_SRCS) + $(CXX) $(CPPFLAGS) $(CXXFLAGS) -o $@ $^ $(LDFLAGS) + +clean: + rm -rf $(OBJ_DIR) $(TARGET) sakura_samurai.js sakura_samurai.wasm sakura_samurai.data .cache + +serve: $(TARGET) + emrun --no_browser --port 8080 . + +.PHONY: all clean serve diff --git a/2026/games/just__jane/README.md b/2026/games/just__jane/README.md new file mode 100644 index 0000000..b1473f3 --- /dev/null +++ b/2026/games/just__jane/README.md @@ -0,0 +1,3 @@ +source ~/installing/emsdk/emsdk_env.sh +make +emrun index.html diff --git a/2026/games/just__jane/assets/background.png b/2026/games/just__jane/assets/background.png Binary files differnew file mode 100644 index 0000000..866a5f6 --- /dev/null +++ b/2026/games/just__jane/assets/background.png diff --git a/2026/games/just__jane/assets/frame-v2.aseprite b/2026/games/just__jane/assets/frame-v2.aseprite Binary files differnew file mode 100644 index 0000000..cab5269 --- /dev/null +++ b/2026/games/just__jane/assets/frame-v2.aseprite diff --git a/2026/games/just__jane/assets/frame-v2.png b/2026/games/just__jane/assets/frame-v2.png Binary files differnew file mode 100644 index 0000000..5dba8b0 --- /dev/null +++ b/2026/games/just__jane/assets/frame-v2.png diff --git a/2026/games/just__jane/assets/frame.aseprite b/2026/games/just__jane/assets/frame.aseprite Binary files differnew file mode 100644 index 0000000..052f910 --- /dev/null +++ b/2026/games/just__jane/assets/frame.aseprite diff --git a/2026/games/just__jane/assets/pedals/0.png b/2026/games/just__jane/assets/pedals/0.png Binary files differnew file mode 100644 index 0000000..3d506bb --- /dev/null +++ b/2026/games/just__jane/assets/pedals/0.png diff --git a/2026/games/just__jane/assets/pedals/1.png b/2026/games/just__jane/assets/pedals/1.png Binary files differnew file mode 100644 index 0000000..54a3c83 --- /dev/null +++ b/2026/games/just__jane/assets/pedals/1.png diff --git a/2026/games/just__jane/assets/pedals/2.png b/2026/games/just__jane/assets/pedals/2.png Binary files differnew file mode 100644 index 0000000..993c7e9 --- /dev/null +++ b/2026/games/just__jane/assets/pedals/2.png diff --git a/2026/games/just__jane/assets/pedals/cut_pedal.png b/2026/games/just__jane/assets/pedals/cut_pedal.png Binary files differnew file mode 100644 index 0000000..c7a0a19 --- /dev/null +++ b/2026/games/just__jane/assets/pedals/cut_pedal.png diff --git a/2026/games/just__jane/assets/ronin.png b/2026/games/just__jane/assets/ronin.png Binary files differnew file mode 100644 index 0000000..9c78953 --- /dev/null +++ b/2026/games/just__jane/assets/ronin.png diff --git a/2026/games/just__jane/assets/slash.wav b/2026/games/just__jane/assets/slash.wav Binary files differnew file mode 100644 index 0000000..b82b476 --- /dev/null +++ b/2026/games/just__jane/assets/slash.wav diff --git a/2026/games/just__jane/compile_commands.json b/2026/games/just__jane/compile_commands.json new file mode 100644 index 0000000..802ac1c --- /dev/null +++ b/2026/games/just__jane/compile_commands.json @@ -0,0 +1,37 @@ +[ + { + "arguments": [ + "/home/jane/installing/emsdk/upstream/bin/clang++", + "-target", + "wasm32-unknown-emscripten", + "-fignore-exceptions", + "-mllvm", + "-combiner-global-alias-analysis=false", + "-mllvm", + "-enable-emscripten-sjlj", + "-mllvm", + "-disable-lsr", + "--sysroot=/home/jane/installing/emsdk/upstream/emscripten/cache/sysroot", + "-DEMSCRIPTEN", + "-Xclang", + "-iwithsysroot/include/fakesdl", + "-Xclang", + "-iwithsysroot/include/compat", + "-Isrc", + "-I../just-packages/raylib-web/raylib//src", + "-Iinclude", + "-std=c++23", + "-Wall", + "-Wextra", + "-O2", + "-DPLATFORM_WEB", + "-c", + "-o", + "/tmp/emscripten_temp_w6rb7jfq/main.o", + "src/main.cpp" + ], + "directory": "/home/jane/just-stream/just-cpp/just-jam", + "file": "/home/jane/just-stream/just-cpp/just-jam/src/main.cpp", + "output": "/tmp/emscripten_temp_w6rb7jfq/main.o" + } +] diff --git a/2026/games/just__jane/include/clock.hpp b/2026/games/just__jane/include/clock.hpp new file mode 100644 index 0000000..41bec56 --- /dev/null +++ b/2026/games/just__jane/include/clock.hpp @@ -0,0 +1,24 @@ +#pragma once + +#include <raymath.h> + +class Clock { +private: + float radius_; + long frame_total_; + long current_frame_; + Vector2 center_position_; + +public: + Clock(float radius, Vector2 center, int total) { + radius_ = radius; + frame_total_ = total; + current_frame_ = total; + center_position_ = center; + } + + void Update(); + void Draw(); + bool TimeIsUp(); + void Reset(); +}; diff --git a/2026/games/just__jane/include/cut.hpp b/2026/games/just__jane/include/cut.hpp new file mode 100644 index 0000000..0804e86 --- /dev/null +++ b/2026/games/just__jane/include/cut.hpp @@ -0,0 +1,18 @@ +#pragma once + +#include "raylib.h" + +class Cut { +private: + Vector2 start_; + Vector2 end_; + float current_step_; + + Sound slash_; + +public: + Cut(Vector2 start, Vector2 end); + void Draw(); + void Update(); + bool its_joever = false; +}; diff --git a/2026/games/just__jane/include/game_loop.hpp b/2026/games/just__jane/include/game_loop.hpp new file mode 100644 index 0000000..d2b537c --- /dev/null +++ b/2026/games/just__jane/include/game_loop.hpp @@ -0,0 +1,14 @@ +#pragma once + +#include <raylib.h> + +constexpr int GAME_WIDTH = 120; +constexpr int GAME_HEIGHT = 80; +constexpr int SCALE = 2; + +struct ScorePetal { + Vector2 Position; + Texture2D Texture; +}; + +void UpdateDrawFrame(); diff --git a/2026/games/just__jane/include/petal.hpp b/2026/games/just__jane/include/petal.hpp new file mode 100644 index 0000000..c85d227 --- /dev/null +++ b/2026/games/just__jane/include/petal.hpp @@ -0,0 +1,185 @@ +#pragma once + +#include "raylib.h" +#include <cstdlib> +#include <format> +#include <optional> +#include <random> + +struct PetalThing { + Texture2D texture; + bool direction; + Vector2 position; +}; + +class Petal { +private: + PetalThing thing_; + Vector2 size_; + Color color_; + std::mt19937 generator_; + std::uniform_real_distribution<float> change_direction_; + std::optional<Vector2> prev_mouse_position; + Texture2D cut_texture_; + std::vector<PetalThing> petal_things_; + long frame_count_ = 0; + Rectangle window_; + float fall_speed_; + + void update_position(PetalThing *thing) { + if (change_direction_(generator_) > 0.95) { + thing->direction = !thing->direction; + } + + float next_position = thing->direction ? thing->position.x - 2 : thing->position.x + 2; + if (next_position <= 0 - (thing->texture.width / 3.0f)) { + thing->direction = false; // we want to go right, right is false, clearly + next_position += 4; + } + + if (next_position >= window_.width - (thing->texture.width / 3.0f)) { + thing->direction = true; + next_position -= 4; + } + + thing->position.x = next_position; + + thing->position.y += fall_speed_; + } + + bool cut_internal(Vector2 start, Vector2 end) { + Rectangle rect = { + .x = thing_.position.x - 2, + .y = thing_.position.y - 2, + .width = size_.x + 4, + .height = size_.y + 4, + }; + + if (CheckCollisionPointRec(start, rect)) { + return true; + } + + if (CheckCollisionPointRec(end, rect)) { + return true; + } + + Vector2 tl = thing_.position; + Vector2 tr = {.x = rect.x + rect.width, .y = rect.y}; + Vector2 bl = {.x = rect.x, .y = rect.y + rect.height}; + Vector2 br = {.x = rect.x + rect.width, .y = rect.y + rect.height}; + + Vector2 collision_point; + + if (CheckCollisionLines(start, end, tl, tr, &collision_point)) { + return true; + } + + if (CheckCollisionLines(start, end, tl, bl, &collision_point)) { + return true; + } + + if (CheckCollisionLines(start, end, bl, br, &collision_point)) { + return true; + } + + if (CheckCollisionLines(start, end, br, tr, &collision_point)) { + return true; + } + + return false; + } + +public: + ~Petal() = default; + Petal(Rectangle window, unsigned seed) : window_(window) { + generator_ = std::mt19937(seed); + std::uniform_int_distribution<int> speed(0, 80); + std::uniform_int_distribution<int> x(0, window_.width); + auto pedal_thing = std::uniform_int_distribution<int>(0, 2); + int pedal = pedal_thing(generator_); + std::string file_path = std::format("assets/pedals/{}.png", pedal); + cut_texture_ = LoadTexture("assets/pedals/cut_pedal.png"); + thing_.texture = LoadTexture(file_path.c_str()); + thing_.position.x = x(generator_); + thing_.position.y = -thing_.texture.height; + size_ = {(float)thing_.texture.width, (float)thing_.texture.height}; + color_ = {0xFF, 0xFF, 0xFF, 0xFF}; + fall_speed_ = speed(generator_) / 100.0f; + } + + Petal(Rectangle window, Vector2 position, int p, float speed = 0.6) : window_(window) { + std::random_device rd; + generator_ = std::mt19937(rd()); + change_direction_ = std::uniform_real_distribution<float>(); + thing_.position = position; + thing_.texture = LoadTexture(std::format("assets/pedals/{}.png", p).c_str()); + cut_texture_ = LoadTexture("assets/pedals/cut_pedal.png"); + size_ = {(float)thing_.texture.width, (float)thing_.texture.height}; + fall_speed_ = speed; + color_ = {0xFF, 0xFF, 0xFF, 0xFF}; + } + + bool IsCut = false; + + void Cut() { + IsCut = true; + petal_things_.push_back( + PetalThing{ + .texture = cut_texture_, + .direction = true, + .position = Vector2{thing_.position.x - 1, thing_.position.y - 1}}); + + petal_things_.push_back( + PetalThing{ + .texture = cut_texture_, + .direction = false, + .position = Vector2{thing_.position.x + 1, thing_.position.y - 1}}); + + petal_things_.push_back( + PetalThing{ + .texture = cut_texture_, + .direction = true, + .position = Vector2{thing_.position.x - 1, thing_.position.y + 1}}); + + petal_things_.push_back( + PetalThing{ + .texture = cut_texture_, + .direction = false, + .position = Vector2{thing_.position.x + 1, thing_.position.y + 1}}); + } + + void Cut(Vector2 start, Vector2 end) { + + if (cut_internal(start, end)) { + Cut(); + } + } + + void Update() { + frame_count_ += 1; + if (frame_count_ % 2 != 0) { + return; + } + + if (IsCut) { + for (PetalThing &thing : petal_things_) { + update_position(&thing); + } + + } else { + update_position(&thing_); + } + } + + void Draw() { + if (IsCut) { + for (auto petal : petal_things_) { + DrawTextureEx(petal.texture, petal.position, 0, 1, color_); + } + } else { + DrawTextureEx(thing_.texture, thing_.position, 0, 1, color_); + } + } + + Vector2 GetPosition() { return thing_.position; } +}; diff --git a/2026/games/just__jane/include/score.hpp b/2026/games/just__jane/include/score.hpp new file mode 100644 index 0000000..20424ba --- /dev/null +++ b/2026/games/just__jane/include/score.hpp @@ -0,0 +1,8 @@ +#pragma once + +#include <cstring> +#include <emscripten/fetch.h> + +void on_success(emscripten_fetch_t *fetch); +void on_error(emscripten_fetch_t *fetch); +void post_score(int score); diff --git a/2026/games/just__jane/index.html b/2026/games/just__jane/index.html new file mode 100644 index 0000000..73f18d3 --- /dev/null +++ b/2026/games/just__jane/index.html @@ -0,0 +1,191 @@ +<!doctype html> +<html lang="en-us"> + <head> + <meta charset="utf-8"> + <meta http-equiv="Content-Type" content="text/html; charset=utf-8"> + <title>Sakura Samurai</title> + <style>body { + background-color: rgba(0.2, 0.2, 0.2, 1.0); + font-family: arial; + margin: 0; + padding: none; +} + +.emscripten { position: absolute; top: 0px; left: 0px; width: 100vw; height: 100vh; } +div.emscripten { text-align: center; } +div.emscripten_border { border: 1px solid black; } +/* the canvas *must not* have any border or padding, or mouse coords will be wrong */ +canvas.emscripten { border: 0px none; background-color: black; } + +#emscripten_logo { + display: inline-block; + margin: 0; + padding: 6px; + width: 265px; +} + +.spinner { + height: 30px; + width: 30px; + margin: 0; + margin-top: 20px; + margin-left: 20px; + display: inline-block; + vertical-align: top; + + -webkit-animation: rotation .8s linear infinite; + -moz-animation: rotation .8s linear infinite; + -o-animation: rotation .8s linear infinite; + animation: rotation 0.8s linear infinite; + + border-left: 5px solid rgb(235, 235, 235); + border-right: 5px solid rgb(235, 235, 235); + border-bottom: 5px solid rgb(235, 235, 235); + border-top: 5px solid rgb(120, 120, 120); + + border-radius: 100%; + background-color: rgb(189, 215, 46); +} + +@-webkit-keyframes rotation { + from {-webkit-transform: rotate(0deg);} + to {-webkit-transform: rotate(360deg);} +} +@-moz-keyframes rotation { + from {-moz-transform: rotate(0deg);} + to {-moz-transform: rotate(360deg);} +} +@-o-keyframes rotation { + from {-o-transform: rotate(0deg);} + to {-o-transform: rotate(360deg);} +} +@keyframes rotation { + from {transform: rotate(0deg);} + to {transform: rotate(360deg);} +} + +#status { + display: inline-block; + vertical-align: top; + margin-top: 30px; + margin-left: 20px; + font-weight: bold; + color: rgb(120, 120, 120); +} + +#progress { + height: 20px; + width: 300px; +} + +#controls { + display: inline-block; + float: right; + vertical-align: top; + margin-top: 30px; + margin-right: 20px; +} + +#output { + width: 100%; + height: 200px; + margin: 0 auto; + margin-top: 10px; + border-left: 0px; + border-right: 0px; + padding-left: 0px; + padding-right: 0px; + display: block; + background-color: black; + color: white; + font-family: 'Lucida Console', Monaco, monospace; + outline: none; +} +</style> + </head> + <body> + + <div class="spinner" id='spinner'></div> + <div class="emscripten" id="status">Downloading...</div> + + <div class="emscripten"> + <progress value="0" max="100" id="progress" hidden=1></progress> + </div> + + <canvas class="emscripten" id="canvas" oncontextmenu="event.preventDefault()" tabindex=-1></canvas> + + <script type='text/javascript'> + var statusElement = document.getElementById('status'); + var progressElement = document.getElementById('progress'); + var spinnerElement = document.getElementById('spinner'); + var canvasElement = document.getElementById('canvas'); + var outputElement = document.getElementById('output'); + if (outputElement) outputElement.value = ''; // clear browser cache + + // As a default initial behavior, pop up an alert when webgl context is lost. To make your + // application robust, you may want to override this behavior before shipping! + // See http://www.khronos.org/registry/webgl/specs/latest/1.0/#5.15.2 + canvasElement.addEventListener('webglcontextlost', (e) => { + alert('WebGL context lost. You will need to reload the page.'); + e.preventDefault(); + }, false); + + var setStatus = (text) => { + if (!setStatus.last) setStatus.last = { time: Date.now(), text: '' }; + if (text === setStatus.last.text) return; + var m = text.match(/([^(]+)\((\d+(\.\d+)?)\/(\d+)\)/); + var now = Date.now(); + // if this is a progress update, skip it if too soon + if (m && now - setStatus.last.time < 30) return; + setStatus.last.time = now; + setStatus.last.text = text; + if (m) { + text = m[1]; + progressElement.value = parseInt(m[2])*100; + progressElement.max = parseInt(m[4])*100; + progressElement.hidden = false; + spinnerElement.hidden = false; + } else { + progressElement.value = null; + progressElement.max = null; + progressElement.hidden = true; + if (!text) spinnerElement.style.display = 'none'; + } + statusElement.innerHTML = text; + }; + + var Module = { + print(...args) { + console.log(...args); + // These replacements are necessary if you render to raw HTML + //text = text.replace(/&/g, "&"); + //text = text.replace(/</g, "<"); + //text = text.replace(/>/g, ">"); + //text = text.replace('\n', '<br>', 'g'); + if (outputElement) { + var text = args.join(' '); + outputElement.value += text + "\n"; + outputElement.scrollTop = outputElement.scrollHeight; // focus on bottom + } + }, + canvas: canvasElement, + setStatus: setStatus, + totalDependencies: 0, + monitorRunDependencies(left) { + this.totalDependencies = Math.max(this.totalDependencies, left); + setStatus(left ? 'Preparing... (' + (this.totalDependencies-left) + '/' + this.totalDependencies + ')' : 'All downloads complete.'); + } + }; + setStatus('Downloading...'); + window.onerror = (event) => { + // TODO: do not warn on ok events like simulating an infinite loop or exitStatus + setStatus('Exception thrown, see JavaScript console'); + spinnerElement.style.display = 'none'; + setStatus = (text) => { + if (text) console.error('[post-exception status] ' + text); + }; + }; + </script> + <script async type="text/javascript" src="sakura_samurai.js"></script> + </body> +</html> diff --git a/2026/games/just__jane/sakura_samurai.data b/2026/games/just__jane/sakura_samurai.data Binary files differnew file mode 100644 index 0000000..5deda93 --- /dev/null +++ b/2026/games/just__jane/sakura_samurai.data diff --git a/2026/games/just__jane/sakura_samurai.html b/2026/games/just__jane/sakura_samurai.html new file mode 100644 index 0000000..1182fb6 --- /dev/null +++ b/2026/games/just__jane/sakura_samurai.html @@ -0,0 +1,202 @@ +<!doctype html> +<html lang="en-us"> + <head> + <meta charset="utf-8"> + <meta http-equiv="Content-Type" content="text/html; charset=utf-8"> + <title>Emscripten-Generated Code</title> + <style>body { + font-family: arial; + margin: 0; + padding: none; +} + +.emscripten { padding-right: 0; margin-left: auto; margin-right: auto; display: block; } +div.emscripten { text-align: center; } +div.emscripten_border { border: 1px solid black; } +/* the canvas *must not* have any border or padding, or mouse coords will be wrong */ +canvas.emscripten { border: 0px none; background-color: black; } + +#emscripten_logo { + display: inline-block; + margin: 0; + padding: 6px; + width: 265px; +} + +.spinner { + height: 30px; + width: 30px; + margin: 0; + margin-top: 20px; + margin-left: 20px; + display: inline-block; + vertical-align: top; + + -webkit-animation: rotation .8s linear infinite; + -moz-animation: rotation .8s linear infinite; + -o-animation: rotation .8s linear infinite; + animation: rotation 0.8s linear infinite; + + border-left: 5px solid rgb(235, 235, 235); + border-right: 5px solid rgb(235, 235, 235); + border-bottom: 5px solid rgb(235, 235, 235); + border-top: 5px solid rgb(120, 120, 120); + + border-radius: 100%; + background-color: rgb(189, 215, 46); +} + +@-webkit-keyframes rotation { + from {-webkit-transform: rotate(0deg);} + to {-webkit-transform: rotate(360deg);} +} +@-moz-keyframes rotation { + from {-moz-transform: rotate(0deg);} + to {-moz-transform: rotate(360deg);} +} +@-o-keyframes rotation { + from {-o-transform: rotate(0deg);} + to {-o-transform: rotate(360deg);} +} +@keyframes rotation { + from {transform: rotate(0deg);} + to {transform: rotate(360deg);} +} + +#status { + display: inline-block; + vertical-align: top; + margin-top: 30px; + margin-left: 20px; + font-weight: bold; + color: rgb(120, 120, 120); +} + +#progress { + height: 20px; + width: 300px; +} + +#controls { + display: inline-block; + float: right; + vertical-align: top; + margin-top: 30px; + margin-right: 20px; +} + +#output { + width: 100%; + height: 200px; + margin: 0 auto; + margin-top: 10px; + border-left: 0px; + border-right: 0px; + padding-left: 0px; + padding-right: 0px; + display: block; + background-color: black; + color: white; + font-family: 'Lucida Console', Monaco, monospace; + outline: none; +} +</style> + </head> + <body> + <a href="http://emscripten.org"><img id="emscripten_logo" src="data:image/png;base64,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"></a> + + <div class="spinner" id='spinner'></div> + <div class="emscripten" id="status">Downloading...</div> + + <span id='controls'> + <span><input type="checkbox" id="resize">Resize canvas</span> + <span><input type="checkbox" id="pointerLock" checked>Lock/hide mouse pointer </span> + <span><input type="button" value="Fullscreen" onclick="Module.requestFullscreen(document.getElementById('pointerLock').checked, + document.getElementById('resize').checked)"> + </span> + </span> + + <div class="emscripten"> + <progress value="0" max="100" id="progress" hidden=1></progress> + </div> + + <div class="emscripten_border"> + <canvas class="emscripten" id="canvas" oncontextmenu="event.preventDefault()" tabindex=-1></canvas> + </div> + <textarea id="output" rows="8"></textarea> + + <script type='text/javascript'> + var statusElement = document.getElementById('status'); + var progressElement = document.getElementById('progress'); + var spinnerElement = document.getElementById('spinner'); + var canvasElement = document.getElementById('canvas'); + var outputElement = document.getElementById('output'); + if (outputElement) outputElement.value = ''; // clear browser cache + + // As a default initial behavior, pop up an alert when webgl context is lost. To make your + // application robust, you may want to override this behavior before shipping! + // See http://www.khronos.org/registry/webgl/specs/latest/1.0/#5.15.2 + canvasElement.addEventListener('webglcontextlost', (e) => { + alert('WebGL context lost. You will need to reload the page.'); + e.preventDefault(); + }, false); + + var setStatus = (text) => { + if (!setStatus.last) setStatus.last = { time: Date.now(), text: '' }; + if (text === setStatus.last.text) return; + var m = text.match(/([^(]+)\((\d+(\.\d+)?)\/(\d+)\)/); + var now = Date.now(); + // if this is a progress update, skip it if too soon + if (m && now - setStatus.last.time < 30) return; + setStatus.last.time = now; + setStatus.last.text = text; + if (m) { + text = m[1]; + progressElement.value = parseInt(m[2])*100; + progressElement.max = parseInt(m[4])*100; + progressElement.hidden = false; + spinnerElement.hidden = false; + } else { + progressElement.value = null; + progressElement.max = null; + progressElement.hidden = true; + if (!text) spinnerElement.style.display = 'none'; + } + statusElement.innerHTML = text; + }; + + var Module = { + print(...args) { + console.log(...args); + // These replacements are necessary if you render to raw HTML + //text = text.replace(/&/g, "&"); + //text = text.replace(/</g, "<"); + //text = text.replace(/>/g, ">"); + //text = text.replace('\n', '<br>', 'g'); + if (outputElement) { + var text = args.join(' '); + outputElement.value += text + "\n"; + outputElement.scrollTop = outputElement.scrollHeight; // focus on bottom + } + }, + canvas: canvasElement, + setStatus: setStatus, + totalDependencies: 0, + monitorRunDependencies(left) { + this.totalDependencies = Math.max(this.totalDependencies, left); + setStatus(left ? 'Preparing... (' + (this.totalDependencies-left) + '/' + this.totalDependencies + ')' : 'All downloads complete.'); + } + }; + setStatus('Downloading...'); + window.onerror = (event) => { + // TODO: do not warn on ok events like simulating an infinite loop or exitStatus + setStatus('Exception thrown, see JavaScript console'); + spinnerElement.style.display = 'none'; + setStatus = (text) => { + if (text) console.error('[post-exception status] ' + text); + }; + }; + </script> + <script async type="text/javascript" src="sakura_samurai.js"></script> + </body> +</html> diff --git a/2026/games/just__jane/sakura_samurai.js b/2026/games/just__jane/sakura_samurai.js new file mode 100644 index 0000000..b47e1e1 --- /dev/null +++ b/2026/games/just__jane/sakura_samurai.js @@ -0,0 +1 @@ +(function(){function humanReadableVersionToPacked(str){str=str.split("-")[0];var vers=str.split(".").slice(0,3);while(vers.length<3)vers.push("00");vers=vers.map((n,i,arr)=>n.padStart(2,"0"));return vers.join("")}var packedVersionToHumanReadable=n=>[n/1e4|0,(n/100|0)%100,n%100].join(".");var TARGET_NOT_SUPPORTED=2147483647;var currentNodeVersion=typeof process!=="undefined"&&process.versions?.node?humanReadableVersionToPacked(process.versions.node):TARGET_NOT_SUPPORTED;if(currentNodeVersion<180300){throw new Error(`This emscripten-generated code requires node v${packedVersionToHumanReadable(180300)} (detected v${packedVersionToHumanReadable(currentNodeVersion)})`)}var userAgent=typeof navigator!=="undefined"&&navigator.userAgent;if(!userAgent){return}var currentSafariVersion=userAgent.includes("Safari/")&&!userAgent.includes("Chrome/")&&userAgent.match(/Version\/(\d+\.?\d*\.?\d*)/)?humanReadableVersionToPacked(userAgent.match(/Version\/(\d+\.?\d*\.?\d*)/)[1]):TARGET_NOT_SUPPORTED;if(currentSafariVersion<15e4){throw new Error(`This emscripten-generated code requires Safari v${packedVersionToHumanReadable(15e4)} (detected v${currentSafariVersion})`)}var currentFirefoxVersion=userAgent.match(/Firefox\/(\d+(?:\.\d+)?)/)?parseFloat(userAgent.match(/Firefox\/(\d+(?:\.\d+)?)/)[1]):TARGET_NOT_SUPPORTED;if(currentFirefoxVersion<79){throw new Error(`This emscripten-generated code requires Firefox v79 (detected v${currentFirefoxVersion})`)}var currentChromeVersion=userAgent.match(/Chrome\/(\d+(?:\.\d+)?)/)?parseFloat(userAgent.match(/Chrome\/(\d+(?:\.\d+)?)/)[1]):TARGET_NOT_SUPPORTED;if(currentChromeVersion<85){throw new Error(`This emscripten-generated code requires Chrome v85 (detected v${currentChromeVersion})`)}})();var Module=typeof Module!="undefined"?Module:{};var ENVIRONMENT_IS_WEB=!!globalThis.window;var ENVIRONMENT_IS_WORKER=!!globalThis.WorkerGlobalScope;var ENVIRONMENT_IS_NODE=globalThis.process?.versions?.node&&globalThis.process?.type!="renderer";var ENVIRONMENT_IS_SHELL=!ENVIRONMENT_IS_WEB&&!ENVIRONMENT_IS_NODE&&!ENVIRONMENT_IS_WORKER;if(!Module["expectedDataFileDownloads"])Module["expectedDataFileDownloads"]=0;Module["expectedDataFileDownloads"]++;(()=>{var isPthread=typeof ENVIRONMENT_IS_PTHREAD!="undefined"&&ENVIRONMENT_IS_PTHREAD;var isWasmWorker=typeof ENVIRONMENT_IS_WASM_WORKER!="undefined"&&ENVIRONMENT_IS_WASM_WORKER;if(isPthread||isWasmWorker)return;var isNode=globalThis.process&&globalThis.process.versions&&globalThis.process.versions.node&&globalThis.process.type!="renderer";async function loadPackage(metadata){var PACKAGE_PATH="";if(typeof window==="object"){PACKAGE_PATH=window["encodeURIComponent"](window.location.pathname.substring(0,window.location.pathname.lastIndexOf("/"))+"/")}else if(typeof process==="undefined"&&typeof location!=="undefined"){PACKAGE_PATH=encodeURIComponent(location.pathname.substring(0,location.pathname.lastIndexOf("/"))+"/")}var PACKAGE_NAME="sakura_samurai.data";var REMOTE_PACKAGE_BASE="sakura_samurai.data";var REMOTE_PACKAGE_NAME=Module["locateFile"]?Module["locateFile"](REMOTE_PACKAGE_BASE,""):REMOTE_PACKAGE_BASE;var REMOTE_PACKAGE_SIZE=metadata["remote_package_size"];async function fetchRemotePackage(packageName,packageSize){if(isNode){var contents=require("fs").readFileSync(packageName);return new Uint8Array(contents).buffer}if(!Module["dataFileDownloads"])Module["dataFileDownloads"]={};try{var response=await fetch(packageName)}catch(e){throw new Error(`Network Error: ${packageName}`,{e})}if(!response.ok){throw new Error(`${response.status}: ${response.url}`)}const chunks=[];const headers=response.headers;const total=Number(headers.get("Content-Length")||packageSize);let loaded=0;Module["setStatus"]&&Module["setStatus"]("Downloading data...");const reader=response.body.getReader();while(1){var{done,value}=await reader.read();if(done)break;chunks.push(value);loaded+=value.length;Module["dataFileDownloads"][packageName]={loaded,total};let totalLoaded=0;let totalSize=0;for(const download of Object.values(Module["dataFileDownloads"])){totalLoaded+=download.loaded;totalSize+=download.total}Module["setStatus"]&&Module["setStatus"](`Downloading data... (${totalLoaded}/${totalSize})`)}const packageData=new Uint8Array(chunks.map(c=>c.length).reduce((a,b)=>a+b,0));let offset=0;for(const chunk of chunks){packageData.set(chunk,offset);offset+=chunk.length}return packageData.buffer}var fetchPromise;var fetched=Module["getPreloadedPackage"]&&Module["getPreloadedPackage"](REMOTE_PACKAGE_NAME,REMOTE_PACKAGE_SIZE);if(!fetched){fetchPromise=fetchRemotePackage(REMOTE_PACKAGE_NAME,REMOTE_PACKAGE_SIZE)}async function runWithFS(Module){function assert(check,msg){if(!check)throw new Error(msg)}Module["FS_createPath"]("/","assets",true,true);Module["FS_createPath"]("/assets","pedals",true,true);for(var file of metadata["files"]){var name=file["filename"];Module["addRunDependency"](`fp ${name}`)}async function processPackageData(arrayBuffer){assert(arrayBuffer,"Loading data file failed.");assert(arrayBuffer.constructor.name===ArrayBuffer.name,"bad input to processPackageData "+arrayBuffer.constructor.name);var byteArray=new Uint8Array(arrayBuffer);for(var file of metadata["files"]){var name=file["filename"];var data=byteArray.subarray(file["start"],file["end"]);Module["FS_createDataFile"](name,null,data,true,true,true);Module["removeRunDependency"](`fp ${name}`)}Module["removeRunDependency"]("datafile_sakura_samurai.data")}Module["addRunDependency"]("datafile_sakura_samurai.data");if(!Module["preloadResults"])Module["preloadResults"]={};Module["preloadResults"][PACKAGE_NAME]={fromCache:false};if(!fetched){fetched=await fetchPromise}processPackageData(fetched)}if(Module["calledRun"]){runWithFS(Module)}else{if(!Module["preRun"])Module["preRun"]=[];Module["preRun"].push(runWithFS)}}loadPackage({files:[{filename:"/assets/background.png",start:0,end:1533},{filename:"/assets/frame-v2.aseprite",start:1533,end:3630},{filename:"/assets/frame-v2.png",start:3630,end:5968},{filename:"/assets/frame.aseprite",start:5968,end:7287},{filename:"/assets/pedals/0.png",start:7287,end:7443},{filename:"/assets/pedals/1.png",start:7443,end:7586},{filename:"/assets/pedals/2.png",start:7586,end:7758},{filename:"/assets/pedals/cut_pedal.png",start:7758,end:7854},{filename:"/assets/ronin.png",start:7854,end:10934},{filename:"/assets/slash.wav",start:10934,end:823830}],remote_package_size:823830})})();if(typeof ENVIRONMENT_IS_WASM_WORKER!="undefined"&&ENVIRONMENT_IS_WASM_WORKER||typeof ENVIRONMENT_IS_PTHREAD!="undefined"&&ENVIRONMENT_IS_PTHREAD||typeof ENVIRONMENT_IS_AUDIO_WORKLET!="undefined"&&ENVIRONMENT_IS_AUDIO_WORKLET)Module["preRun"]=[];var necessaryPreJSTasks=Module["preRun"].slice();if(!Module["preRun"])throw"Module.preRun should exist because file support used it; did a pre-js delete it?";necessaryPreJSTasks.forEach(task=>{if(Module["preRun"].indexOf(task)<0)throw"All preRun tasks that exist before user pre-js code should remain after; did you replace Module or modify Module.preRun?"});var arguments_=[];var thisProgram="./this.program";var quit_=(status,toThrow)=>{throw toThrow};var _scriptName=globalThis.document?.currentScript?.src;if(typeof __filename!="undefined"){_scriptName=__filename}else if(ENVIRONMENT_IS_WORKER){_scriptName=self.location.href}var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var readAsync,readBinary;if(ENVIRONMENT_IS_NODE){const isNode=globalThis.process?.versions?.node&&globalThis.process?.type!="renderer";if(!isNode)throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");var fs=require("node:fs");scriptDirectory=__dirname+"/";readBinary=filename=>{filename=isFileURI(filename)?new URL(filename):filename;var ret=fs.readFileSync(filename);assert(Buffer.isBuffer(ret));return ret};readAsync=async(filename,binary=true)=>{filename=isFileURI(filename)?new URL(filename):filename;var ret=fs.readFileSync(filename,binary?undefined:"utf8");assert(binary?Buffer.isBuffer(ret):typeof ret=="string");return ret};if(process.argv.length>1){thisProgram=process.argv[1].replace(/\\/g,"/")}arguments_=process.argv.slice(2);if(typeof module!="undefined"){module["exports"]=Module}quit_=(status,toThrow)=>{process.exitCode=status;throw toThrow}}else if(ENVIRONMENT_IS_SHELL){}else if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){try{scriptDirectory=new URL(".",_scriptName).href}catch{}if(!(globalThis.window||globalThis.WorkerGlobalScope))throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");{if(ENVIRONMENT_IS_WORKER){readBinary=url=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)}}readAsync=async url=>{if(isFileURI(url)){return new Promise((resolve,reject)=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,true);xhr.responseType="arraybuffer";xhr.onload=()=>{if(xhr.status==200||xhr.status==0&&xhr.response){resolve(xhr.response);return}reject(xhr.status)};xhr.onerror=reject;xhr.send(null)})}var response=await fetch(url,{credentials:"same-origin"});if(response.ok){return response.arrayBuffer()}throw new Error(response.status+" : "+response.url)}}}else{throw new Error("environment detection error")}var out=console.log.bind(console);var err=console.error.bind(console);assert(!ENVIRONMENT_IS_SHELL,"shell environment detected but not enabled at build time (add `shell` to `-sENVIRONMENT` to enable)");var wasmBinary;if(!globalThis.WebAssembly){err("no native wasm support detected")}var ABORT=false;var EXITSTATUS;function assert(condition,text){if(!condition){abort("Assertion failed"+(text?": "+text:""))}}var isFileURI=filename=>filename.startsWith("file://");function writeStackCookie(){var max=_emscripten_stack_get_end();assert((max&3)==0);if(max==0){max+=4}HEAPU32[max>>2]=34821223;HEAPU32[max+4>>2]=2310721022;HEAPU32[0>>2]=1668509029}function checkStackCookie(){if(ABORT)return;var max=_emscripten_stack_get_end();if(max==0){max+=4}var cookie1=HEAPU32[max>>2];var cookie2=HEAPU32[max+4>>2];if(cookie1!=34821223||cookie2!=2310721022){abort(`Stack overflow! Stack cookie has been overwritten at ${ptrToString(max)}, expected hex dwords 0x89BACDFE and 0x2135467, but received ${ptrToString(cookie2)} ${ptrToString(cookie1)}`)}if(HEAPU32[0>>2]!=1668509029){abort("Runtime error: The application has corrupted its heap memory area (address zero)!")}}class EmscriptenEH{}class EmscriptenSjLj extends EmscriptenEH{}var runtimeDebug=true;(()=>{var h16=new Int16Array(1);var h8=new Int8Array(h16.buffer);h16[0]=25459;if(h8[0]!==115||h8[1]!==99)abort("Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)")})();function consumedModuleProp(prop){if(!Object.getOwnPropertyDescriptor(Module,prop)){Object.defineProperty(Module,prop,{configurable:true,set(){abort(`Attempt to set \`Module.${prop}\` after it has already been processed. This can happen, for example, when code is injected via '--post-js' rather than '--pre-js'`)}})}}function makeInvalidEarlyAccess(name){return()=>assert(false,`call to '${name}' via reference taken before Wasm module initialization`)}function ignoredModuleProp(prop){if(Object.getOwnPropertyDescriptor(Module,prop)){abort(`\`Module.${prop}\` was supplied but \`${prop}\` not included in INCOMING_MODULE_JS_API`)}}function isExportedByForceFilesystem(name){return name==="FS_createPath"||name==="FS_createDataFile"||name==="FS_createPreloadedFile"||name==="FS_preloadFile"||name==="FS_unlink"||name==="addRunDependency"||name==="FS_createLazyFile"||name==="FS_createDevice"||name==="removeRunDependency"}function hookGlobalSymbolAccess(sym,func){if(!Object.getOwnPropertyDescriptor(globalThis,sym)){Object.defineProperty(globalThis,sym,{configurable:true,get(){func();return undefined}})}}function missingGlobal(sym,msg){hookGlobalSymbolAccess(sym,()=>{warnOnce(`\`${sym}\` is no longer defined by emscripten. ${msg}`)})}missingGlobal("buffer","Please use HEAP8.buffer or wasmMemory.buffer");missingGlobal("asm","Please use wasmExports instead");function missingLibrarySymbol(sym){hookGlobalSymbolAccess(sym,()=>{var msg=`\`${sym}\` is a library symbol and not included by default; add it to your library.js __deps or to DEFAULT_LIBRARY_FUNCS_TO_INCLUDE on the command line`;var librarySymbol=sym;if(!librarySymbol.startsWith("_")){librarySymbol="$"+sym}msg+=` (e.g. -sDEFAULT_LIBRARY_FUNCS_TO_INCLUDE='${librarySymbol}')`;if(isExportedByForceFilesystem(sym)){msg+=". Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you"}warnOnce(msg)});unexportedRuntimeSymbol(sym)}function unexportedRuntimeSymbol(sym){if(!Object.getOwnPropertyDescriptor(Module,sym)){Object.defineProperty(Module,sym,{configurable:true,get(){var msg=`'${sym}' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the Emscripten FAQ)`;if(isExportedByForceFilesystem(sym)){msg+=". Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you"}abort(msg)}})}}var runtimeInitialized=false;function updateMemoryViews(){var b=wasmMemory.buffer;HEAP8=new Int8Array(b);HEAP16=new Int16Array(b);HEAPU8=new Uint8Array(b);HEAPU16=new Uint16Array(b);HEAP32=new Int32Array(b);HEAPU32=new Uint32Array(b);HEAPF32=new Float32Array(b);HEAPF64=new Float64Array(b);HEAP64=new BigInt64Array(b);HEAPU64=new BigUint64Array(b)}assert(globalThis.Int32Array&&globalThis.Float64Array&&Int32Array.prototype.subarray&&Int32Array.prototype.set,"JS engine does not provide full typed array support");function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift())}}consumedModuleProp("preRun");callRuntimeCallbacks(onPreRuns)}function initRuntime(){assert(!runtimeInitialized);runtimeInitialized=true;checkStackCookie();if(!Module["noFSInit"]&&!FS.initialized)FS.init();TTY.init();wasmExports["__wasm_call_ctors"]();FS.ignorePermissions=false}function preMain(){checkStackCookie()}function postRun(){checkStackCookie();if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift())}}consumedModuleProp("postRun");callRuntimeCallbacks(onPostRuns)}function abort(what){Module["onAbort"]?.(what);what=`Aborted(${what})`;err(what);ABORT=true;if(what.search(/RuntimeError: [Uu]nreachable/)>=0){what+='. "unreachable" may be due to ASYNCIFY_STACK_SIZE not being large enough (try increasing it)'}var e=new WebAssembly.RuntimeError(what);throw e}function createExportWrapper(name,nargs){return(...args)=>{assert(runtimeInitialized,`native function \`${name}\` called before runtime initialization`);var f=wasmExports[name];assert(f,`exported native function \`${name}\` not found`);assert(args.length<=nargs,`native function \`${name}\` called with ${args.length} args but expects ${nargs}`);return f(...args)}}var wasmBinaryFile;function findWasmBinary(){return locateFile("sakura_samurai.wasm")}function getBinarySync(file){if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}if(readBinary){return readBinary(file)}throw"both async and sync fetching of the wasm failed"}async function getWasmBinary(binaryFile){if(!wasmBinary){try{var response=await readAsync(binaryFile);return new Uint8Array(response)}catch{}}return getBinarySync(binaryFile)}async function instantiateArrayBuffer(binaryFile,imports){try{var binary=await getWasmBinary(binaryFile);var instance=await WebAssembly.instantiate(binary,imports);return instance}catch(reason){err(`failed to asynchronously prepare wasm: ${reason}`);if(isFileURI(binaryFile)){err(`warning: Loading from a file URI (${binaryFile}) is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing`)}abort(reason)}}async function instantiateAsync(binary,binaryFile,imports){if(!binary&&!isFileURI(binaryFile)&&!ENVIRONMENT_IS_NODE){try{var response=fetch(binaryFile,{credentials:"same-origin"});var instantiationResult=await WebAssembly.instantiateStreaming(response,imports);return instantiationResult}catch(reason){err(`wasm streaming compile failed: ${reason}`);err("falling back to ArrayBuffer instantiation")}}return instantiateArrayBuffer(binaryFile,imports)}function getWasmImports(){Asyncify.instrumentWasmImports(wasmImports);var imports={env:wasmImports,wasi_snapshot_preview1:wasmImports};return imports}async function createWasm(){function receiveInstance(instance,module){wasmExports=instance.exports;wasmExports=Asyncify.instrumentWasmExports(wasmExports);assignWasmExports(wasmExports);updateMemoryViews();removeRunDependency("wasm-instantiate");return wasmExports}addRunDependency("wasm-instantiate");var trueModule=Module;function receiveInstantiationResult(result){assert(Module===trueModule,"the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?");trueModule=null;return receiveInstance(result["instance"])}var info=getWasmImports();if(Module["instantiateWasm"]){return new Promise((resolve,reject)=>{try{Module["instantiateWasm"](info,(inst,mod)=>{resolve(receiveInstance(inst,mod))})}catch(e){err(`Module.instantiateWasm callback failed with error: ${e}`);reject(e)}})}wasmBinaryFile??=findWasmBinary();var result=await instantiateAsync(wasmBinary,wasmBinaryFile,info);var exports=receiveInstantiationResult(result);return exports}class ExitStatus{name="ExitStatus";constructor(status){this.message=`Program terminated with exit(${status})`;this.status=status}}var HEAP16;var HEAP32;var HEAP64;var HEAP8;var HEAPF32;var HEAPF64;var HEAPU16;var HEAPU32;var HEAPU64;var HEAPU8;var callRuntimeCallbacks=callbacks=>{while(callbacks.length>0){callbacks.shift()(Module)}};var onPostRuns=[];var addOnPostRun=cb=>onPostRuns.push(cb);var onPreRuns=[];var addOnPreRun=cb=>onPreRuns.push(cb);var runDependencies=0;var dependenciesFulfilled=null;var runDependencyTracking={};var runDependencyWatcher=null;var removeRunDependency=id=>{runDependencies--;Module["monitorRunDependencies"]?.(runDependencies);assert(id,"removeRunDependency requires an ID");assert(runDependencyTracking[id]);delete runDependencyTracking[id];if(runDependencies==0){if(runDependencyWatcher!==null){clearInterval(runDependencyWatcher);runDependencyWatcher=null}if(dependenciesFulfilled){var callback=dependenciesFulfilled;dependenciesFulfilled=null;callback()}}};var addRunDependency=id=>{runDependencies++;Module["monitorRunDependencies"]?.(runDependencies);assert(id,"addRunDependency requires an ID");assert(!runDependencyTracking[id]);runDependencyTracking[id]=1;if(runDependencyWatcher===null&&globalThis.setInterval){runDependencyWatcher=setInterval(()=>{if(ABORT){clearInterval(runDependencyWatcher);runDependencyWatcher=null;return}var shown=false;for(var dep in runDependencyTracking){if(!shown){shown=true;err("still waiting on run dependencies:")}err(`dependency: ${dep}`)}if(shown){err("(end of list)")}},1e4);runDependencyWatcher.unref?.()}};var dynCalls={};var dynCallLegacy=(sig,ptr,args)=>{sig=sig.replace(/p/g,"i");assert(sig in dynCalls,`bad function pointer type - sig is not in dynCalls: '${sig}'`);if(args?.length){assert(args.length===sig.length-1)}else{assert(sig.length==1)}var f=dynCalls[sig];return f(ptr,...args)};var noExitRuntime=true;function ptrToString(ptr){assert(typeof ptr==="number",`ptrToString expects a number, got ${typeof ptr}`);ptr>>>=0;return"0x"+ptr.toString(16).padStart(8,"0")}function setValue(ptr,value,type="i8"){if(type.endsWith("*"))type="*";switch(type){case"i1":HEAP8[ptr]=value;break;case"i8":HEAP8[ptr]=value;break;case"i16":HEAP16[ptr>>1]=value;break;case"i32":HEAP32[ptr>>2]=value;break;case"i64":HEAP64[ptr>>3]=BigInt(value);break;case"float":HEAPF32[ptr>>2]=value;break;case"double":HEAPF64[ptr>>3]=value;break;case"*":HEAPU32[ptr>>2]=value;break;default:abort(`invalid type for setValue: ${type}`)}}var warnOnce=text=>{warnOnce.shown||={};if(!warnOnce.shown[text]){warnOnce.shown[text]=1;if(ENVIRONMENT_IS_NODE)text="warning: "+text;err(text)}};var UTF8Decoder=globalThis.TextDecoder&&new TextDecoder;var findStringEnd=(heapOrArray,idx,maxBytesToRead,ignoreNul)=>{var maxIdx=idx+maxBytesToRead;if(ignoreNul)return maxIdx;while(heapOrArray[idx]&&!(idx>=maxIdx))++idx;return idx};var UTF8ArrayToString=(heapOrArray,idx=0,maxBytesToRead,ignoreNul)=>{var endPtr=findStringEnd(heapOrArray,idx,maxBytesToRead,ignoreNul);if(endPtr-idx>16&&heapOrArray.buffer&&UTF8Decoder){return UTF8Decoder.decode(heapOrArray.subarray(idx,endPtr))}var str="";while(idx<endPtr){var u0=heapOrArray[idx++];if(!(u0&128)){str+=String.fromCharCode(u0);continue}var u1=heapOrArray[idx++]&63;if((u0&224)==192){str+=String.fromCharCode((u0&31)<<6|u1);continue}var u2=heapOrArray[idx++]&63;if((u0&240)==224){u0=(u0&15)<<12|u1<<6|u2}else{if((u0&248)!=240)warnOnce(`Invalid UTF-8 leading byte ${ptrToString(u0)} encountered when deserializing a UTF-8 string in wasm memory to a JS string!`);u0=(u0&7)<<18|u1<<12|u2<<6|heapOrArray[idx++]&63}if(u0<65536){str+=String.fromCharCode(u0)}else{var ch=u0-65536;str+=String.fromCharCode(55296|ch>>10,56320|ch&1023)}}return str};var UTF8ToString=(ptr,maxBytesToRead,ignoreNul)=>{assert(typeof ptr=="number",`UTF8ToString expects a number (got ${typeof ptr})`);return ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead,ignoreNul):""};var ___assert_fail=(condition,filename,line,func)=>abort(`Assertion failed: ${UTF8ToString(condition)}, at: `+[filename?UTF8ToString(filename):"unknown filename",line,func?UTF8ToString(func):"unknown function"]);class ExceptionInfo{constructor(excPtr){this.excPtr=excPtr;this.ptr=excPtr-24}set_type(type){HEAPU32[this.ptr+4>>2]=type}get_type(){return HEAPU32[this.ptr+4>>2]}set_destructor(destructor){HEAPU32[this.ptr+8>>2]=destructor}get_destructor(){return HEAPU32[this.ptr+8>>2]}set_caught(caught){caught=caught?1:0;HEAP8[this.ptr+12]=caught}get_caught(){return HEAP8[this.ptr+12]!=0}set_rethrown(rethrown){rethrown=rethrown?1:0;HEAP8[this.ptr+13]=rethrown}get_rethrown(){return HEAP8[this.ptr+13]!=0}init(type,destructor){this.set_adjusted_ptr(0);this.set_type(type);this.set_destructor(destructor)}set_adjusted_ptr(adjustedPtr){HEAPU32[this.ptr+16>>2]=adjustedPtr}get_adjusted_ptr(){return HEAPU32[this.ptr+16>>2]}}var uncaughtExceptionCount=0;var ___cxa_throw=(ptr,type,destructor)=>{var info=new ExceptionInfo(ptr);info.init(type,destructor);uncaughtExceptionCount++;assert(false,"Exception thrown, but exception catching is not enabled. Compile with -sNO_DISABLE_EXCEPTION_CATCHING or -sEXCEPTION_CATCHING_ALLOWED=[..] to catch.")};var PATH={isAbs:path=>path.charAt(0)==="/",splitPath:filename=>{var splitPathRe=/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;return splitPathRe.exec(filename).slice(1)},normalizeArray:(parts,allowAboveRoot)=>{var up=0;for(var i=parts.length-1;i>=0;i--){var last=parts[i];if(last==="."){parts.splice(i,1)}else if(last===".."){parts.splice(i,1);up++}else if(up){parts.splice(i,1);up--}}if(allowAboveRoot){for(;up;up--){parts.unshift("..")}}return parts},normalize:path=>{var isAbsolute=PATH.isAbs(path),trailingSlash=path.slice(-1)==="/";path=PATH.normalizeArray(path.split("/").filter(p=>!!p),!isAbsolute).join("/");if(!path&&!isAbsolute){path="."}if(path&&trailingSlash){path+="/"}return(isAbsolute?"/":"")+path},dirname:path=>{var result=PATH.splitPath(path),root=result[0],dir=result[1];if(!root&&!dir){return"."}if(dir){dir=dir.slice(0,-1)}return root+dir},basename:path=>path&&path.match(/([^\/]+|\/)\/*$/)[1],join:(...paths)=>PATH.normalize(paths.join("/")),join2:(l,r)=>PATH.normalize(l+"/"+r)};var initRandomFill=()=>{if(ENVIRONMENT_IS_NODE){var nodeCrypto=require("node:crypto");return view=>nodeCrypto.randomFillSync(view)}return view=>(crypto.getRandomValues(view),0)};var randomFill=view=>(randomFill=initRandomFill())(view);var PATH_FS={resolve:(...args)=>{var resolvedPath="",resolvedAbsolute=false;for(var i=args.length-1;i>=-1&&!resolvedAbsolute;i--){var path=i>=0?args[i]:FS.cwd();if(typeof path!="string"){throw new TypeError("Arguments to path.resolve must be strings")}else if(!path){return""}resolvedPath=path+"/"+resolvedPath;resolvedAbsolute=PATH.isAbs(path)}resolvedPath=PATH.normalizeArray(resolvedPath.split("/").filter(p=>!!p),!resolvedAbsolute).join("/");return(resolvedAbsolute?"/":"")+resolvedPath||"."},relative:(from,to)=>{from=PATH_FS.resolve(from).slice(1);to=PATH_FS.resolve(to).slice(1);function trim(arr){var start=0;for(;start<arr.length;start++){if(arr[start]!=="")break}var end=arr.length-1;for(;end>=0;end--){if(arr[end]!=="")break}if(start>end)return[];return arr.slice(start,end-start+1)}var fromParts=trim(from.split("/"));var toParts=trim(to.split("/"));var length=Math.min(fromParts.length,toParts.length);var samePartsLength=length;for(var i=0;i<length;i++){if(fromParts[i]!==toParts[i]){samePartsLength=i;break}}var outputParts=[];for(var i=samePartsLength;i<fromParts.length;i++){outputParts.push("..")}outputParts=outputParts.concat(toParts.slice(samePartsLength));return outputParts.join("/")}};var FS_stdin_getChar_buffer=[];var lengthBytesUTF8=str=>{var len=0;for(var i=0;i<str.length;++i){var c=str.charCodeAt(i);if(c<=127){len++}else if(c<=2047){len+=2}else if(c>=55296&&c<=57343){len+=4;++i}else{len+=3}}return len};var stringToUTF8Array=(str,heap,outIdx,maxBytesToWrite)=>{assert(typeof str==="string",`stringToUTF8Array expects a string (got ${typeof str})`);if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i<str.length;++i){var u=str.codePointAt(i);if(u<=127){if(outIdx>=endIdx)break;heap[outIdx++]=u}else if(u<=2047){if(outIdx+1>=endIdx)break;heap[outIdx++]=192|u>>6;heap[outIdx++]=128|u&63}else if(u<=65535){if(outIdx+2>=endIdx)break;heap[outIdx++]=224|u>>12;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}else{if(outIdx+3>=endIdx)break;if(u>1114111)warnOnce(`Invalid Unicode code point ${ptrToString(u)} encountered when serializing a JS string to a UTF-8 string in wasm memory! (Valid unicode code points should be in range 0-0x10FFFF).`);heap[outIdx++]=240|u>>18;heap[outIdx++]=128|u>>12&63;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63;i++}}heap[outIdx]=0;return outIdx-startIdx};var intArrayFromString=(stringy,dontAddNull,length)=>{var len=length>0?length:lengthBytesUTF8(stringy)+1;var u8array=new Array(len);var numBytesWritten=stringToUTF8Array(stringy,u8array,0,u8array.length);if(dontAddNull)u8array.length=numBytesWritten;return u8array};var FS_stdin_getChar=()=>{if(!FS_stdin_getChar_buffer.length){var result=null;if(ENVIRONMENT_IS_NODE){var BUFSIZE=256;var buf=Buffer.alloc(BUFSIZE);var bytesRead=0;var fd=process.stdin.fd;try{bytesRead=fs.readSync(fd,buf,0,BUFSIZE)}catch(e){if(e.toString().includes("EOF"))bytesRead=0;else throw e}if(bytesRead>0){result=buf.slice(0,bytesRead).toString("utf-8")}}else if(globalThis.window?.prompt){result=window.prompt("Input: ");if(result!==null){result+="\n"}}else{}if(!result){return null}FS_stdin_getChar_buffer=intArrayFromString(result,true)}return FS_stdin_getChar_buffer.shift()};var TTY={ttys:[],init(){},shutdown(){},register(dev,ops){TTY.ttys[dev]={input:[],output:[],ops};FS.registerDevice(dev,TTY.stream_ops)},stream_ops:{open(stream){var tty=TTY.ttys[stream.node.rdev];if(!tty){throw new FS.ErrnoError(43)}stream.tty=tty;stream.seekable=false},close(stream){stream.tty.ops.fsync(stream.tty)},fsync(stream){stream.tty.ops.fsync(stream.tty)},read(stream,buffer,offset,length,pos){if(!stream.tty||!stream.tty.ops.get_char){throw new FS.ErrnoError(60)}var bytesRead=0;for(var i=0;i<length;i++){var result;try{result=stream.tty.ops.get_char(stream.tty)}catch(e){throw new FS.ErrnoError(29)}if(result===undefined&&bytesRead===0){throw new FS.ErrnoError(6)}if(result===null||result===undefined)break;bytesRead++;buffer[offset+i]=result}if(bytesRead){stream.node.atime=Date.now()}return bytesRead},write(stream,buffer,offset,length,pos){if(!stream.tty||!stream.tty.ops.put_char){throw new FS.ErrnoError(60)}try{for(var i=0;i<length;i++){stream.tty.ops.put_char(stream.tty,buffer[offset+i])}}catch(e){throw new FS.ErrnoError(29)}if(length){stream.node.mtime=stream.node.ctime=Date.now()}return i}},default_tty_ops:{get_char(tty){return FS_stdin_getChar()},put_char(tty,val){if(val===null||val===10){out(UTF8ArrayToString(tty.output));tty.output=[]}else{if(val!=0)tty.output.push(val)}},fsync(tty){if(tty.output?.length>0){out(UTF8ArrayToString(tty.output));tty.output=[]}},ioctl_tcgets(tty){return{c_iflag:25856,c_oflag:5,c_cflag:191,c_lflag:35387,c_cc:[3,28,127,21,4,0,1,0,17,19,26,0,18,15,23,22,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},ioctl_tcsets(tty,optional_actions,data){return 0},ioctl_tiocgwinsz(tty){return[24,80]}},default_tty1_ops:{put_char(tty,val){if(val===null||val===10){err(UTF8ArrayToString(tty.output));tty.output=[]}else{if(val!=0)tty.output.push(val)}},fsync(tty){if(tty.output?.length>0){err(UTF8ArrayToString(tty.output));tty.output=[]}}}};var mmapAlloc=size=>{abort("internal error: mmapAlloc called but `emscripten_builtin_memalign` native symbol not exported")};var MEMFS={ops_table:null,mount(mount){return MEMFS.createNode(null,"/",16895,0)},createNode(parent,name,mode,dev){if(FS.isBlkdev(mode)||FS.isFIFO(mode)){throw new FS.ErrnoError(63)}MEMFS.ops_table||={dir:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr,lookup:MEMFS.node_ops.lookup,mknod:MEMFS.node_ops.mknod,rename:MEMFS.node_ops.rename,unlink:MEMFS.node_ops.unlink,rmdir:MEMFS.node_ops.rmdir,readdir:MEMFS.node_ops.readdir,symlink:MEMFS.node_ops.symlink},stream:{llseek:MEMFS.stream_ops.llseek}},file:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr},stream:{llseek:MEMFS.stream_ops.llseek,read:MEMFS.stream_ops.read,write:MEMFS.stream_ops.write,mmap:MEMFS.stream_ops.mmap,msync:MEMFS.stream_ops.msync}},link:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr,readlink:MEMFS.node_ops.readlink},stream:{}},chrdev:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr},stream:FS.chrdev_stream_ops}};var node=FS.createNode(parent,name,mode,dev);if(FS.isDir(node.mode)){node.node_ops=MEMFS.ops_table.dir.node;node.stream_ops=MEMFS.ops_table.dir.stream;node.contents={}}else if(FS.isFile(node.mode)){node.node_ops=MEMFS.ops_table.file.node;node.stream_ops=MEMFS.ops_table.file.stream;node.usedBytes=0;node.contents=MEMFS.emptyFileContents??=new Uint8Array(0)}else if(FS.isLink(node.mode)){node.node_ops=MEMFS.ops_table.link.node;node.stream_ops=MEMFS.ops_table.link.stream}else if(FS.isChrdev(node.mode)){node.node_ops=MEMFS.ops_table.chrdev.node;node.stream_ops=MEMFS.ops_table.chrdev.stream}node.atime=node.mtime=node.ctime=Date.now();if(parent){parent.contents[name]=node;parent.atime=parent.mtime=parent.ctime=node.atime}return node},getFileDataAsTypedArray(node){assert(FS.isFile(node.mode),"getFileDataAsTypedArray called on non-file");return node.contents.subarray(0,node.usedBytes)},expandFileStorage(node,newCapacity){var prevCapacity=node.contents.length;if(prevCapacity>=newCapacity)return;var CAPACITY_DOUBLING_MAX=1024*1024;newCapacity=Math.max(newCapacity,prevCapacity*(prevCapacity<CAPACITY_DOUBLING_MAX?2:1.125)>>>0);if(prevCapacity)newCapacity=Math.max(newCapacity,256);var oldContents=MEMFS.getFileDataAsTypedArray(node);node.contents=new Uint8Array(newCapacity);node.contents.set(oldContents)},resizeFileStorage(node,newSize){if(node.usedBytes==newSize)return;var oldContents=node.contents;node.contents=new Uint8Array(newSize);node.contents.set(oldContents.subarray(0,Math.min(newSize,node.usedBytes)));node.usedBytes=newSize},node_ops:{getattr(node){var attr={};attr.dev=FS.isChrdev(node.mode)?node.id:1;attr.ino=node.id;attr.mode=node.mode;attr.nlink=1;attr.uid=0;attr.gid=0;attr.rdev=node.rdev;if(FS.isDir(node.mode)){attr.size=4096}else if(FS.isFile(node.mode)){attr.size=node.usedBytes}else if(FS.isLink(node.mode)){attr.size=node.link.length}else{attr.size=0}attr.atime=new Date(node.atime);attr.mtime=new Date(node.mtime);attr.ctime=new Date(node.ctime);attr.blksize=4096;attr.blocks=Math.ceil(attr.size/attr.blksize);return attr},setattr(node,attr){for(const key of["mode","atime","mtime","ctime"]){if(attr[key]!=null){node[key]=attr[key]}}if(attr.size!==undefined){MEMFS.resizeFileStorage(node,attr.size)}},lookup(parent,name){throw new FS.ErrnoError(44)},mknod(parent,name,mode,dev){return MEMFS.createNode(parent,name,mode,dev)},rename(old_node,new_dir,new_name){var new_node;try{new_node=FS.lookupNode(new_dir,new_name)}catch(e){}if(new_node){if(FS.isDir(old_node.mode)){for(var i in new_node.contents){throw new FS.ErrnoError(55)}}FS.hashRemoveNode(new_node)}delete old_node.parent.contents[old_node.name];new_dir.contents[new_name]=old_node;old_node.name=new_name;new_dir.ctime=new_dir.mtime=old_node.parent.ctime=old_node.parent.mtime=Date.now()},unlink(parent,name){delete parent.contents[name];parent.ctime=parent.mtime=Date.now()},rmdir(parent,name){var node=FS.lookupNode(parent,name);for(var i in node.contents){throw new FS.ErrnoError(55)}delete parent.contents[name];parent.ctime=parent.mtime=Date.now()},readdir(node){return[".","..",...Object.keys(node.contents)]},symlink(parent,newname,oldpath){var node=MEMFS.createNode(parent,newname,511|40960,0);node.link=oldpath;return node},readlink(node){if(!FS.isLink(node.mode)){throw new FS.ErrnoError(28)}return node.link}},stream_ops:{read(stream,buffer,offset,length,position){var contents=stream.node.contents;if(position>=stream.node.usedBytes)return 0;var size=Math.min(stream.node.usedBytes-position,length);assert(size>=0);buffer.set(contents.subarray(position,position+size),offset);return size},write(stream,buffer,offset,length,position,canOwn){assert(buffer.subarray,"FS.write expects a TypedArray");if(buffer.buffer===HEAP8.buffer){canOwn=false}if(!length)return 0;var node=stream.node;node.mtime=node.ctime=Date.now();if(canOwn){assert(position===0,"canOwn must imply no weird position inside the file");node.contents=buffer.subarray(offset,offset+length);node.usedBytes=length}else if(node.usedBytes===0&&position===0){node.contents=buffer.slice(offset,offset+length);node.usedBytes=length}else{MEMFS.expandFileStorage(node,position+length);node.contents.set(buffer.subarray(offset,offset+length),position);node.usedBytes=Math.max(node.usedBytes,position+length)}return length},llseek(stream,offset,whence){var position=offset;if(whence===1){position+=stream.position}else if(whence===2){if(FS.isFile(stream.node.mode)){position+=stream.node.usedBytes}}if(position<0){throw new FS.ErrnoError(28)}return position},mmap(stream,length,position,prot,flags){if(!FS.isFile(stream.node.mode)){throw new FS.ErrnoError(43)}var ptr;var allocated;var contents=stream.node.contents;if(!(flags&2)&&contents.buffer===HEAP8.buffer){allocated=false;ptr=contents.byteOffset}else{allocated=true;ptr=mmapAlloc(length);if(!ptr){throw new FS.ErrnoError(48)}if(contents){if(position>0||position+length<contents.length){if(contents.subarray){contents=contents.subarray(position,position+length)}else{contents=Array.prototype.slice.call(contents,position,position+length)}}HEAP8.set(contents,ptr)}}return{ptr,allocated}},msync(stream,buffer,offset,length,mmapFlags){MEMFS.stream_ops.write(stream,buffer,0,length,offset,false);return 0}}};var FS_modeStringToFlags=str=>{if(typeof str!="string")return str;var flagModes={r:0,"r+":2,w:512|64|1,"w+":512|64|2,a:1024|64|1,"a+":1024|64|2};var flags=flagModes[str];if(typeof flags=="undefined"){throw new Error(`Unknown file open mode: ${str}`)}return flags};var FS_fileDataToTypedArray=data=>{if(typeof data=="string"){data=intArrayFromString(data,true)}if(!data.subarray){data=new Uint8Array(data)}return data};var FS_getMode=(canRead,canWrite)=>{var mode=0;if(canRead)mode|=292|73;if(canWrite)mode|=146;return mode};var strError=errno=>UTF8ToString(_strerror(errno));var ERRNO_CODES={EPERM:63,ENOENT:44,ESRCH:71,EINTR:27,EIO:29,ENXIO:60,E2BIG:1,ENOEXEC:45,EBADF:8,ECHILD:12,EAGAIN:6,EWOULDBLOCK:6,ENOMEM:48,EACCES:2,EFAULT:21,ENOTBLK:105,EBUSY:10,EEXIST:20,EXDEV:75,ENODEV:43,ENOTDIR:54,EISDIR:31,EINVAL:28,ENFILE:41,EMFILE:33,ENOTTY:59,ETXTBSY:74,EFBIG:22,ENOSPC:51,ESPIPE:70,EROFS:69,EMLINK:34,EPIPE:64,EDOM:18,ERANGE:68,ENOMSG:49,EIDRM:24,ECHRNG:106,EL2NSYNC:156,EL3HLT:107,EL3RST:108,ELNRNG:109,EUNATCH:110,ENOCSI:111,EL2HLT:112,EDEADLK:16,ENOLCK:46,EBADE:113,EBADR:114,EXFULL:115,ENOANO:104,EBADRQC:103,EBADSLT:102,EDEADLOCK:16,EBFONT:101,ENOSTR:100,ENODATA:116,ETIME:117,ENOSR:118,ENONET:119,ENOPKG:120,EREMOTE:121,ENOLINK:47,EADV:122,ESRMNT:123,ECOMM:124,EPROTO:65,EMULTIHOP:36,EDOTDOT:125,EBADMSG:9,ENOTUNIQ:126,EBADFD:127,EREMCHG:128,ELIBACC:129,ELIBBAD:130,ELIBSCN:131,ELIBMAX:132,ELIBEXEC:133,ENOSYS:52,ENOTEMPTY:55,ENAMETOOLONG:37,ELOOP:32,EOPNOTSUPP:138,EPFNOSUPPORT:139,ECONNRESET:15,ENOBUFS:42,EAFNOSUPPORT:5,EPROTOTYPE:67,ENOTSOCK:57,ENOPROTOOPT:50,ESHUTDOWN:140,ECONNREFUSED:14,EADDRINUSE:3,ECONNABORTED:13,ENETUNREACH:40,ENETDOWN:38,ETIMEDOUT:73,EHOSTDOWN:142,EHOSTUNREACH:23,EINPROGRESS:26,EALREADY:7,EDESTADDRREQ:17,EMSGSIZE:35,EPROTONOSUPPORT:66,ESOCKTNOSUPPORT:137,EADDRNOTAVAIL:4,ENETRESET:39,EISCONN:30,ENOTCONN:53,ETOOMANYREFS:141,EUSERS:136,EDQUOT:19,ESTALE:72,ENOTSUP:138,ENOMEDIUM:148,EILSEQ:25,EOVERFLOW:61,ECANCELED:11,ENOTRECOVERABLE:56,EOWNERDEAD:62,ESTRPIPE:135};var asyncLoad=async url=>{var arrayBuffer=await readAsync(url);assert(arrayBuffer,`Loading data file "${url}" failed (no arrayBuffer).`);return new Uint8Array(arrayBuffer)};var FS_createDataFile=(...args)=>FS.createDataFile(...args);var getUniqueRunDependency=id=>{var orig=id;while(1){if(!runDependencyTracking[id])return id;id=orig+Math.random()}};var preloadPlugins=[];var FS_handledByPreloadPlugin=async(byteArray,fullname)=>{if(typeof Browser!="undefined")Browser.init();for(var plugin of preloadPlugins){if(plugin["canHandle"](fullname)){assert(plugin["handle"].constructor.name==="AsyncFunction","Filesystem plugin handlers must be async functions (See #24914)");return plugin["handle"](byteArray,fullname)}}return byteArray};var FS_preloadFile=async(parent,name,url,canRead,canWrite,dontCreateFile,canOwn,preFinish)=>{var fullname=name?PATH_FS.resolve(PATH.join2(parent,name)):parent;var dep=getUniqueRunDependency(`cp ${fullname}`);addRunDependency(dep);try{var byteArray=url;if(typeof url=="string"){byteArray=await asyncLoad(url)}byteArray=await FS_handledByPreloadPlugin(byteArray,fullname);preFinish?.();if(!dontCreateFile){FS_createDataFile(parent,name,byteArray,canRead,canWrite,canOwn)}}finally{removeRunDependency(dep)}};var FS_createPreloadedFile=(parent,name,url,canRead,canWrite,onload,onerror,dontCreateFile,canOwn,preFinish)=>{FS_preloadFile(parent,name,url,canRead,canWrite,dontCreateFile,canOwn,preFinish).then(onload).catch(onerror)};var FS={root:null,mounts:[],devices:{},streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,filesystems:null,syncFSRequests:0,ErrnoError:class extends Error{name="ErrnoError";constructor(errno){super(runtimeInitialized?strError(errno):"");this.errno=errno;for(var key in ERRNO_CODES){if(ERRNO_CODES[key]===errno){this.code=key;break}}}},FSStream:class{shared={};get object(){return this.node}set object(val){this.node=val}get isRead(){return(this.flags&2097155)!==1}get isWrite(){return(this.flags&2097155)!==0}get isAppend(){return this.flags&1024}get flags(){return this.shared.flags}set flags(val){this.shared.flags=val}get position(){return this.shared.position}set position(val){this.shared.position=val}},FSNode:class{node_ops={};stream_ops={};readMode=292|73;writeMode=146;mounted=null;constructor(parent,name,mode,rdev){if(!parent){parent=this}this.parent=parent;this.mount=parent.mount;this.id=FS.nextInode++;this.name=name;this.mode=mode;this.rdev=rdev;this.atime=this.mtime=this.ctime=Date.now()}get read(){return(this.mode&this.readMode)===this.readMode}set read(val){val?this.mode|=this.readMode:this.mode&=~this.readMode}get write(){return(this.mode&this.writeMode)===this.writeMode}set write(val){val?this.mode|=this.writeMode:this.mode&=~this.writeMode}get isFolder(){return FS.isDir(this.mode)}get isDevice(){return FS.isChrdev(this.mode)}},lookupPath(path,opts={}){if(!path){throw new FS.ErrnoError(44)}opts.follow_mount??=true;if(!PATH.isAbs(path)){path=FS.cwd()+"/"+path}linkloop:for(var nlinks=0;nlinks<40;nlinks++){var parts=path.split("/").filter(p=>!!p);var current=FS.root;var current_path="/";for(var i=0;i<parts.length;i++){var islast=i===parts.length-1;if(islast&&opts.parent){break}if(parts[i]==="."){continue}if(parts[i]===".."){current_path=PATH.dirname(current_path);if(FS.isRoot(current)){path=current_path+"/"+parts.slice(i+1).join("/");nlinks--;continue linkloop}else{current=current.parent}continue}current_path=PATH.join2(current_path,parts[i]);try{current=FS.lookupNode(current,parts[i])}catch(e){if(e?.errno===44&&islast&&opts.noent_okay){return{path:current_path}}throw e}if(FS.isMountpoint(current)&&(!islast||opts.follow_mount)){current=current.mounted.root}if(FS.isLink(current.mode)&&(!islast||opts.follow)){if(!current.node_ops.readlink){throw new FS.ErrnoError(52)}var link=current.node_ops.readlink(current);if(!PATH.isAbs(link)){link=PATH.dirname(current_path)+"/"+link}path=link+"/"+parts.slice(i+1).join("/");continue linkloop}}return{path:current_path,node:current}}throw new FS.ErrnoError(32)},getPath(node){var path;while(true){if(FS.isRoot(node)){var mount=node.mount.mountpoint;if(!path)return mount;return mount[mount.length-1]!=="/"?`${mount}/${path}`:mount+path}path=path?`${node.name}/${path}`:node.name;node=node.parent}},hashName(parentid,name){var hash=0;for(var i=0;i<name.length;i++){hash=(hash<<5)-hash+name.charCodeAt(i)|0}return(parentid+hash>>>0)%FS.nameTable.length},hashAddNode(node){var hash=FS.hashName(node.parent.id,node.name);node.name_next=FS.nameTable[hash];FS.nameTable[hash]=node},hashRemoveNode(node){var hash=FS.hashName(node.parent.id,node.name);if(FS.nameTable[hash]===node){FS.nameTable[hash]=node.name_next}else{var current=FS.nameTable[hash];while(current){if(current.name_next===node){current.name_next=node.name_next;break}current=current.name_next}}},lookupNode(parent,name){var errCode=FS.mayLookup(parent);if(errCode){throw new FS.ErrnoError(errCode)}var hash=FS.hashName(parent.id,name);for(var node=FS.nameTable[hash];node;node=node.name_next){var nodeName=node.name;if(node.parent.id===parent.id&&nodeName===name){return node}}return FS.lookup(parent,name)},createNode(parent,name,mode,rdev){assert(typeof parent=="object");var node=new FS.FSNode(parent,name,mode,rdev);FS.hashAddNode(node);return node},destroyNode(node){FS.hashRemoveNode(node)},isRoot(node){return node===node.parent},isMountpoint(node){return!!node.mounted},isFile(mode){return(mode&61440)===32768},isDir(mode){return(mode&61440)===16384},isLink(mode){return(mode&61440)===40960},isChrdev(mode){return(mode&61440)===8192},isBlkdev(mode){return(mode&61440)===24576},isFIFO(mode){return(mode&61440)===4096},isSocket(mode){return(mode&49152)===49152},flagsToPermissionString(flag){var perms=["r","w","rw"][flag&3];if(flag&512){perms+="w"}return perms},nodePermissions(node,perms){if(FS.ignorePermissions){return 0}if(perms.includes("r")&&!(node.mode&292)){return 2}if(perms.includes("w")&&!(node.mode&146)){return 2}if(perms.includes("x")&&!(node.mode&73)){return 2}return 0},mayLookup(dir){if(!FS.isDir(dir.mode))return 54;var errCode=FS.nodePermissions(dir,"x");if(errCode)return errCode;if(!dir.node_ops.lookup)return 2;return 0},mayCreate(dir,name){if(!FS.isDir(dir.mode)){return 54}try{var node=FS.lookupNode(dir,name);return 20}catch(e){}return FS.nodePermissions(dir,"wx")},mayDelete(dir,name,isdir){var node;try{node=FS.lookupNode(dir,name)}catch(e){return e.errno}var errCode=FS.nodePermissions(dir,"wx");if(errCode){return errCode}if(isdir){if(!FS.isDir(node.mode)){return 54}if(FS.isRoot(node)||FS.getPath(node)===FS.cwd()){return 10}}else if(FS.isDir(node.mode)){return 31}return 0},mayOpen(node,flags){if(!node){return 44}if(FS.isLink(node.mode)){return 32}var mode=FS.flagsToPermissionString(flags);if(FS.isDir(node.mode)){if(mode!=="r"||flags&(512|64)){return 31}}return FS.nodePermissions(node,mode)},checkOpExists(op,err){if(!op){throw new FS.ErrnoError(err)}return op},MAX_OPEN_FDS:4096,nextfd(){for(var fd=0;fd<=FS.MAX_OPEN_FDS;fd++){if(!FS.streams[fd]){return fd}}throw new FS.ErrnoError(33)},getStreamChecked(fd){var stream=FS.getStream(fd);if(!stream){throw new FS.ErrnoError(8)}return stream},getStream:fd=>FS.streams[fd],createStream(stream,fd=-1){assert(fd>=-1);stream=Object.assign(new FS.FSStream,stream);if(fd==-1){fd=FS.nextfd()}stream.fd=fd;FS.streams[fd]=stream;return stream},closeStream(fd){FS.streams[fd]=null},dupStream(origStream,fd=-1){var stream=FS.createStream(origStream,fd);stream.stream_ops?.dup?.(stream);return stream},doSetAttr(stream,node,attr){var setattr=stream?.stream_ops.setattr;var arg=setattr?stream:node;setattr??=node.node_ops.setattr;FS.checkOpExists(setattr,63);try{setattr(arg,attr)}catch(e){if(e instanceof RangeError){throw new FS.ErrnoError(22)}throw e}},chrdev_stream_ops:{open(stream){var device=FS.getDevice(stream.node.rdev);stream.stream_ops=device.stream_ops;stream.stream_ops.open?.(stream)},llseek(){throw new FS.ErrnoError(70)}},major:dev=>dev>>8,minor:dev=>dev&255,makedev:(ma,mi)=>ma<<8|mi,registerDevice(dev,ops){FS.devices[dev]={stream_ops:ops}},getDevice:dev=>FS.devices[dev],getMounts(mount){var mounts=[];var check=[mount];while(check.length){var m=check.pop();mounts.push(m);check.push(...m.mounts)}return mounts},syncfs(populate,callback){if(typeof populate=="function"){callback=populate;populate=false}FS.syncFSRequests++;if(FS.syncFSRequests>1){err(`warning: ${FS.syncFSRequests} FS.syncfs operations in flight at once, probably just doing extra work`)}var mounts=FS.getMounts(FS.root.mount);var completed=0;function doCallback(errCode){assert(FS.syncFSRequests>0);FS.syncFSRequests--;return callback(errCode)}function done(errCode){if(errCode){if(!done.errored){done.errored=true;return doCallback(errCode)}return}if(++completed>=mounts.length){doCallback(null)}}for(var mount of mounts){if(mount.type.syncfs){mount.type.syncfs(mount,populate,done)}else{done(null)}}},mount(type,opts,mountpoint){if(typeof type=="string"){throw type}var root=mountpoint==="/";var pseudo=!mountpoint;var node;if(root&&FS.root){throw new FS.ErrnoError(10)}else if(!root&&!pseudo){var lookup=FS.lookupPath(mountpoint,{follow_mount:false});mountpoint=lookup.path;node=lookup.node;if(FS.isMountpoint(node)){throw new FS.ErrnoError(10)}if(!FS.isDir(node.mode)){throw new FS.ErrnoError(54)}}var mount={type,opts,mountpoint,mounts:[]};var mountRoot=type.mount(mount);mountRoot.mount=mount;mount.root=mountRoot;if(root){FS.root=mountRoot}else if(node){node.mounted=mount;if(node.mount){node.mount.mounts.push(mount)}}return mountRoot},unmount(mountpoint){var lookup=FS.lookupPath(mountpoint,{follow_mount:false});if(!FS.isMountpoint(lookup.node)){throw new FS.ErrnoError(28)}var node=lookup.node;var mount=node.mounted;var mounts=FS.getMounts(mount);for(var[hash,current]of Object.entries(FS.nameTable)){while(current){var next=current.name_next;if(mounts.includes(current.mount)){FS.destroyNode(current)}current=next}}node.mounted=null;var idx=node.mount.mounts.indexOf(mount);assert(idx!==-1);node.mount.mounts.splice(idx,1)},lookup(parent,name){return parent.node_ops.lookup(parent,name)},mknod(path,mode,dev){var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;var name=PATH.basename(path);if(!name){throw new FS.ErrnoError(28)}if(name==="."||name===".."){throw new FS.ErrnoError(20)}var errCode=FS.mayCreate(parent,name);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.mknod){throw new FS.ErrnoError(63)}return parent.node_ops.mknod(parent,name,mode,dev)},statfs(path){return FS.statfsNode(FS.lookupPath(path,{follow:true}).node)},statfsStream(stream){return FS.statfsNode(stream.node)},statfsNode(node){var rtn={bsize:4096,frsize:4096,blocks:1e6,bfree:5e5,bavail:5e5,files:FS.nextInode,ffree:FS.nextInode-1,fsid:42,flags:2,namelen:255};if(node.node_ops.statfs){Object.assign(rtn,node.node_ops.statfs(node.mount.opts.root))}return rtn},create(path,mode=438){mode&=4095;mode|=32768;return FS.mknod(path,mode,0)},mkdir(path,mode=511){mode&=511|512;mode|=16384;return FS.mknod(path,mode,0)},mkdirTree(path,mode){var dirs=path.split("/");var d="";for(var dir of dirs){if(!dir)continue;if(d||PATH.isAbs(path))d+="/";d+=dir;try{FS.mkdir(d,mode)}catch(e){if(e.errno!=20)throw e}}},mkdev(path,mode,dev){if(typeof dev=="undefined"){dev=mode;mode=438}mode|=8192;return FS.mknod(path,mode,dev)},symlink(oldpath,newpath){if(!PATH_FS.resolve(oldpath)){throw new FS.ErrnoError(44)}var lookup=FS.lookupPath(newpath,{parent:true});var parent=lookup.node;if(!parent){throw new FS.ErrnoError(44)}var newname=PATH.basename(newpath);var errCode=FS.mayCreate(parent,newname);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.symlink){throw new FS.ErrnoError(63)}return parent.node_ops.symlink(parent,newname,oldpath)},rename(old_path,new_path){var old_dirname=PATH.dirname(old_path);var new_dirname=PATH.dirname(new_path);var old_name=PATH.basename(old_path);var new_name=PATH.basename(new_path);var lookup,old_dir,new_dir;lookup=FS.lookupPath(old_path,{parent:true});old_dir=lookup.node;lookup=FS.lookupPath(new_path,{parent:true});new_dir=lookup.node;if(!old_dir||!new_dir)throw new FS.ErrnoError(44);if(old_dir.mount!==new_dir.mount){throw new FS.ErrnoError(75)}var old_node=FS.lookupNode(old_dir,old_name);var relative=PATH_FS.relative(old_path,new_dirname);if(relative.charAt(0)!=="."){throw new FS.ErrnoError(28)}relative=PATH_FS.relative(new_path,old_dirname);if(relative.charAt(0)!=="."){throw new FS.ErrnoError(55)}var new_node;try{new_node=FS.lookupNode(new_dir,new_name)}catch(e){}if(old_node===new_node){return}var isdir=FS.isDir(old_node.mode);var errCode=FS.mayDelete(old_dir,old_name,isdir);if(errCode){throw new FS.ErrnoError(errCode)}errCode=new_node?FS.mayDelete(new_dir,new_name,isdir):FS.mayCreate(new_dir,new_name);if(errCode){throw new FS.ErrnoError(errCode)}if(!old_dir.node_ops.rename){throw new FS.ErrnoError(63)}if(FS.isMountpoint(old_node)||new_node&&FS.isMountpoint(new_node)){throw new FS.ErrnoError(10)}if(new_dir!==old_dir){errCode=FS.nodePermissions(old_dir,"w");if(errCode){throw new FS.ErrnoError(errCode)}}FS.hashRemoveNode(old_node);try{old_dir.node_ops.rename(old_node,new_dir,new_name);old_node.parent=new_dir}catch(e){throw e}finally{FS.hashAddNode(old_node)}},rmdir(path){var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;var name=PATH.basename(path);var node=FS.lookupNode(parent,name);var errCode=FS.mayDelete(parent,name,true);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.rmdir){throw new FS.ErrnoError(63)}if(FS.isMountpoint(node)){throw new FS.ErrnoError(10)}parent.node_ops.rmdir(parent,name);FS.destroyNode(node)},readdir(path){var lookup=FS.lookupPath(path,{follow:true});var node=lookup.node;var readdir=FS.checkOpExists(node.node_ops.readdir,54);return readdir(node)},unlink(path){var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;if(!parent){throw new FS.ErrnoError(44)}var name=PATH.basename(path);var node=FS.lookupNode(parent,name);var errCode=FS.mayDelete(parent,name,false);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.unlink){throw new FS.ErrnoError(63)}if(FS.isMountpoint(node)){throw new FS.ErrnoError(10)}parent.node_ops.unlink(parent,name);FS.destroyNode(node)},readlink(path){var lookup=FS.lookupPath(path);var link=lookup.node;if(!link){throw new FS.ErrnoError(44)}if(!link.node_ops.readlink){throw new FS.ErrnoError(28)}return link.node_ops.readlink(link)},stat(path,dontFollow){var lookup=FS.lookupPath(path,{follow:!dontFollow});var node=lookup.node;var getattr=FS.checkOpExists(node.node_ops.getattr,63);return getattr(node)},fstat(fd){var stream=FS.getStreamChecked(fd);var node=stream.node;var getattr=stream.stream_ops.getattr;var arg=getattr?stream:node;getattr??=node.node_ops.getattr;FS.checkOpExists(getattr,63);return getattr(arg)},lstat(path){return FS.stat(path,true)},doChmod(stream,node,mode,dontFollow){FS.doSetAttr(stream,node,{mode:mode&4095|node.mode&~4095,ctime:Date.now(),dontFollow})},chmod(path,mode,dontFollow){var node;if(typeof path=="string"){var lookup=FS.lookupPath(path,{follow:!dontFollow});node=lookup.node}else{node=path}FS.doChmod(null,node,mode,dontFollow)},lchmod(path,mode){FS.chmod(path,mode,true)},fchmod(fd,mode){var stream=FS.getStreamChecked(fd);FS.doChmod(stream,stream.node,mode,false)},doChown(stream,node,dontFollow){FS.doSetAttr(stream,node,{timestamp:Date.now(),dontFollow})},chown(path,uid,gid,dontFollow){var node;if(typeof path=="string"){var lookup=FS.lookupPath(path,{follow:!dontFollow});node=lookup.node}else{node=path}FS.doChown(null,node,dontFollow)},lchown(path,uid,gid){FS.chown(path,uid,gid,true)},fchown(fd,uid,gid){var stream=FS.getStreamChecked(fd);FS.doChown(stream,stream.node,false)},doTruncate(stream,node,len){if(FS.isDir(node.mode)){throw new FS.ErrnoError(31)}if(!FS.isFile(node.mode)){throw new FS.ErrnoError(28)}var errCode=FS.nodePermissions(node,"w");if(errCode){throw new FS.ErrnoError(errCode)}FS.doSetAttr(stream,node,{size:len,timestamp:Date.now()})},truncate(path,len){if(len<0){throw new FS.ErrnoError(28)}var node;if(typeof path=="string"){var lookup=FS.lookupPath(path,{follow:true});node=lookup.node}else{node=path}FS.doTruncate(null,node,len)},ftruncate(fd,len){var stream=FS.getStreamChecked(fd);if(len<0||(stream.flags&2097155)===0){throw new FS.ErrnoError(28)}FS.doTruncate(stream,stream.node,len)},utime(path,atime,mtime){var lookup=FS.lookupPath(path,{follow:true});var node=lookup.node;var setattr=FS.checkOpExists(node.node_ops.setattr,63);setattr(node,{atime,mtime})},open(path,flags,mode=438){if(path===""){throw new FS.ErrnoError(44)}flags=FS_modeStringToFlags(flags);if(flags&64){mode=mode&4095|32768}else{mode=0}var node;var isDirPath;if(typeof path=="object"){node=path}else{isDirPath=path.endsWith("/");var lookup=FS.lookupPath(path,{follow:!(flags&131072),noent_okay:true});node=lookup.node;path=lookup.path}var created=false;if(flags&64){if(node){if(flags&128){throw new FS.ErrnoError(20)}}else if(isDirPath){throw new FS.ErrnoError(31)}else{node=FS.mknod(path,mode|511,0);created=true}}if(!node){throw new FS.ErrnoError(44)}if(FS.isChrdev(node.mode)){flags&=~512}if(flags&65536&&!FS.isDir(node.mode)){throw new FS.ErrnoError(54)}if(!created){var errCode=FS.mayOpen(node,flags);if(errCode){throw new FS.ErrnoError(errCode)}}if(flags&512&&!created){FS.truncate(node,0)}flags&=~(128|512|131072);var stream=FS.createStream({node,path:FS.getPath(node),flags,seekable:true,position:0,stream_ops:node.stream_ops,ungotten:[],error:false});if(stream.stream_ops.open){stream.stream_ops.open(stream)}if(created){FS.chmod(node,mode&511)}return stream},close(stream){if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if(stream.getdents)stream.getdents=null;try{if(stream.stream_ops.close){stream.stream_ops.close(stream)}}catch(e){throw e}finally{FS.closeStream(stream.fd)}stream.fd=null},isClosed(stream){return stream.fd===null},llseek(stream,offset,whence){if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if(!stream.seekable||!stream.stream_ops.llseek){throw new FS.ErrnoError(70)}if(whence!=0&&whence!=1&&whence!=2){throw new FS.ErrnoError(28)}stream.position=stream.stream_ops.llseek(stream,offset,whence);stream.ungotten=[];return stream.position},read(stream,buffer,offset,length,position){assert(offset>=0);if(length<0||position<0){throw new FS.ErrnoError(28)}if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if((stream.flags&2097155)===1){throw new FS.ErrnoError(8)}if(FS.isDir(stream.node.mode)){throw new FS.ErrnoError(31)}if(!stream.stream_ops.read){throw new FS.ErrnoError(28)}var seeking=typeof position!="undefined";if(!seeking){position=stream.position}else if(!stream.seekable){throw new FS.ErrnoError(70)}var bytesRead=stream.stream_ops.read(stream,buffer,offset,length,position);if(!seeking)stream.position+=bytesRead;return bytesRead},write(stream,buffer,offset,length,position,canOwn){assert(offset>=0);assert(buffer.subarray,"FS.write expects a TypedArray");if(length<0||position<0){throw new FS.ErrnoError(28)}if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if((stream.flags&2097155)===0){throw new FS.ErrnoError(8)}if(FS.isDir(stream.node.mode)){throw new FS.ErrnoError(31)}if(!stream.stream_ops.write){throw new FS.ErrnoError(28)}if(stream.seekable&&stream.flags&1024){FS.llseek(stream,0,2)}var seeking=typeof position!="undefined";if(!seeking){position=stream.position}else if(!stream.seekable){throw new FS.ErrnoError(70)}var bytesWritten=stream.stream_ops.write(stream,buffer,offset,length,position,canOwn);if(!seeking)stream.position+=bytesWritten;return bytesWritten},mmap(stream,length,position,prot,flags){if((prot&2)!==0&&(flags&2)===0&&(stream.flags&2097155)!==2){throw new FS.ErrnoError(2)}if((stream.flags&2097155)===1){throw new FS.ErrnoError(2)}if(!stream.stream_ops.mmap){throw new FS.ErrnoError(43)}if(!length){throw new FS.ErrnoError(28)}return stream.stream_ops.mmap(stream,length,position,prot,flags)},msync(stream,buffer,offset,length,mmapFlags){assert(offset>=0);if(!stream.stream_ops.msync){return 0}return stream.stream_ops.msync(stream,buffer,offset,length,mmapFlags)},ioctl(stream,cmd,arg){if(!stream.stream_ops.ioctl){throw new FS.ErrnoError(59)}return stream.stream_ops.ioctl(stream,cmd,arg)},readFile(path,opts={}){opts.flags=opts.flags||0;opts.encoding=opts.encoding||"binary";if(opts.encoding!=="utf8"&&opts.encoding!=="binary"){abort(`Invalid encoding type "${opts.encoding}"`)}var stream=FS.open(path,opts.flags);var stat=FS.stat(path);var length=stat.size;var buf=new Uint8Array(length);FS.read(stream,buf,0,length,0);if(opts.encoding==="utf8"){buf=UTF8ArrayToString(buf)}FS.close(stream);return buf},writeFile(path,data,opts={}){opts.flags=opts.flags||577;var stream=FS.open(path,opts.flags,opts.mode);data=FS_fileDataToTypedArray(data);FS.write(stream,data,0,data.byteLength,undefined,opts.canOwn);FS.close(stream)},cwd:()=>FS.currentPath,chdir(path){var lookup=FS.lookupPath(path,{follow:true});if(lookup.node===null){throw new FS.ErrnoError(44)}if(!FS.isDir(lookup.node.mode)){throw new FS.ErrnoError(54)}var errCode=FS.nodePermissions(lookup.node,"x");if(errCode){throw new FS.ErrnoError(errCode)}FS.currentPath=lookup.path},createDefaultDirectories(){FS.mkdir("/tmp");FS.mkdir("/home");FS.mkdir("/home/web_user")},createDefaultDevices(){FS.mkdir("/dev");FS.registerDevice(FS.makedev(1,3),{read:()=>0,write:(stream,buffer,offset,length,pos)=>length,llseek:()=>0});FS.mkdev("/dev/null",FS.makedev(1,3));TTY.register(FS.makedev(5,0),TTY.default_tty_ops);TTY.register(FS.makedev(6,0),TTY.default_tty1_ops);FS.mkdev("/dev/tty",FS.makedev(5,0));FS.mkdev("/dev/tty1",FS.makedev(6,0));var randomBuffer=new Uint8Array(1024),randomLeft=0;var randomByte=()=>{if(randomLeft===0){randomFill(randomBuffer);randomLeft=randomBuffer.byteLength}return randomBuffer[--randomLeft]};FS.createDevice("/dev","random",randomByte);FS.createDevice("/dev","urandom",randomByte);FS.mkdir("/dev/shm");FS.mkdir("/dev/shm/tmp")},createSpecialDirectories(){FS.mkdir("/proc");var proc_self=FS.mkdir("/proc/self");FS.mkdir("/proc/self/fd");FS.mount({mount(){var node=FS.createNode(proc_self,"fd",16895,73);node.stream_ops={llseek:MEMFS.stream_ops.llseek};node.node_ops={lookup(parent,name){var fd=+name;var stream=FS.getStreamChecked(fd);var ret={parent:null,mount:{mountpoint:"fake"},node_ops:{readlink:()=>stream.path},id:fd+1};ret.parent=ret;return ret},readdir(){return Array.from(FS.streams.entries()).filter(([k,v])=>v).map(([k,v])=>k.toString())}};return node}},{},"/proc/self/fd")},createStandardStreams(input,output,error){if(input){FS.createDevice("/dev","stdin",input)}else{FS.symlink("/dev/tty","/dev/stdin")}if(output){FS.createDevice("/dev","stdout",null,output)}else{FS.symlink("/dev/tty","/dev/stdout")}if(error){FS.createDevice("/dev","stderr",null,error)}else{FS.symlink("/dev/tty1","/dev/stderr")}var stdin=FS.open("/dev/stdin",0);var stdout=FS.open("/dev/stdout",1);var stderr=FS.open("/dev/stderr",1);assert(stdin.fd===0,`invalid handle for stdin (${stdin.fd})`);assert(stdout.fd===1,`invalid handle for stdout (${stdout.fd})`);assert(stderr.fd===2,`invalid handle for stderr (${stderr.fd})`)},staticInit(){FS.nameTable=new Array(4096);FS.mount(MEMFS,{},"/");FS.createDefaultDirectories();FS.createDefaultDevices();FS.createSpecialDirectories();FS.filesystems={MEMFS}},init(input,output,error){assert(!FS.initialized,"FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)");FS.initialized=true;input??=Module["stdin"];output??=Module["stdout"];error??=Module["stderr"];FS.createStandardStreams(input,output,error)},quit(){FS.initialized=false;_fflush(0);for(var stream of FS.streams){if(stream){FS.close(stream)}}},findObject(path,dontResolveLastLink){var ret=FS.analyzePath(path,dontResolveLastLink);if(!ret.exists){return null}return ret.object},analyzePath(path,dontResolveLastLink){try{var lookup=FS.lookupPath(path,{follow:!dontResolveLastLink});path=lookup.path}catch(e){}var ret={isRoot:false,exists:false,error:0,name:null,path:null,object:null,parentExists:false,parentPath:null,parentObject:null};try{var lookup=FS.lookupPath(path,{parent:true});ret.parentExists=true;ret.parentPath=lookup.path;ret.parentObject=lookup.node;ret.name=PATH.basename(path);lookup=FS.lookupPath(path,{follow:!dontResolveLastLink});ret.exists=true;ret.path=lookup.path;ret.object=lookup.node;ret.name=lookup.node.name;ret.isRoot=lookup.path==="/"}catch(e){ret.error=e.errno}return ret},createPath(parent,path,canRead,canWrite){parent=typeof parent=="string"?parent:FS.getPath(parent);var parts=path.split("/").reverse();while(parts.length){var part=parts.pop();if(!part)continue;var current=PATH.join2(parent,part);try{FS.mkdir(current)}catch(e){if(e.errno!=20)throw e}parent=current}return current},createFile(parent,name,properties,canRead,canWrite){var path=PATH.join2(typeof parent=="string"?parent:FS.getPath(parent),name);var mode=FS_getMode(canRead,canWrite);return FS.create(path,mode)},createDataFile(parent,name,data,canRead,canWrite,canOwn){var path=name;if(parent){parent=typeof parent=="string"?parent:FS.getPath(parent);path=name?PATH.join2(parent,name):parent}var mode=FS_getMode(canRead,canWrite);var node=FS.create(path,mode);if(data){data=FS_fileDataToTypedArray(data);FS.chmod(node,mode|146);var stream=FS.open(node,577);FS.write(stream,data,0,data.length,0,canOwn);FS.close(stream);FS.chmod(node,mode)}},createDevice(parent,name,input,output){var path=PATH.join2(typeof parent=="string"?parent:FS.getPath(parent),name);var mode=FS_getMode(!!input,!!output);FS.createDevice.major??=64;var dev=FS.makedev(FS.createDevice.major++,0);FS.registerDevice(dev,{open(stream){stream.seekable=false},close(stream){if(output?.buffer?.length){output(10)}},read(stream,buffer,offset,length,pos){var bytesRead=0;for(var i=0;i<length;i++){var result;try{result=input()}catch(e){throw new FS.ErrnoError(29)}if(result===undefined&&bytesRead===0){throw new FS.ErrnoError(6)}if(result===null||result===undefined)break;bytesRead++;buffer[offset+i]=result}if(bytesRead){stream.node.atime=Date.now()}return bytesRead},write(stream,buffer,offset,length,pos){for(var i=0;i<length;i++){try{output(buffer[offset+i])}catch(e){throw new FS.ErrnoError(29)}}if(length){stream.node.mtime=stream.node.ctime=Date.now()}return i}});return FS.mkdev(path,mode,dev)},forceLoadFile(obj){if(obj.isDevice||obj.isFolder||obj.link||obj.contents)return true;if(globalThis.XMLHttpRequest){abort("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.")}else{try{obj.contents=readBinary(obj.url)}catch(e){throw new FS.ErrnoError(29)}}},createLazyFile(parent,name,url,canRead,canWrite){class LazyUint8Array{lengthKnown=false;chunks=[];get(idx){if(idx>this.length-1||idx<0){return undefined}var chunkOffset=idx%this.chunkSize;var chunkNum=idx/this.chunkSize|0;return this.getter(chunkNum)[chunkOffset]}setDataGetter(getter){this.getter=getter}cacheLength(){var xhr=new XMLHttpRequest;xhr.open("HEAD",url,false);xhr.send(null);if(!(xhr.status>=200&&xhr.status<300||xhr.status===304))abort("Couldn't load "+url+". Status: "+xhr.status);var datalength=Number(xhr.getResponseHeader("Content-length"));var header;var hasByteServing=(header=xhr.getResponseHeader("Accept-Ranges"))&&header==="bytes";var usesGzip=(header=xhr.getResponseHeader("Content-Encoding"))&&header==="gzip";var chunkSize=1024*1024;if(!hasByteServing)chunkSize=datalength;var doXHR=(from,to)=>{if(from>to)abort("invalid range ("+from+", "+to+") or no bytes requested!");if(to>datalength-1)abort("only "+datalength+" bytes available! programmer error!");var xhr=new XMLHttpRequest;xhr.open("GET",url,false);if(datalength!==chunkSize)xhr.setRequestHeader("Range","bytes="+from+"-"+to);xhr.responseType="arraybuffer";if(xhr.overrideMimeType){xhr.overrideMimeType("text/plain; charset=x-user-defined")}xhr.send(null);if(!(xhr.status>=200&&xhr.status<300||xhr.status===304))abort("Couldn't load "+url+". Status: "+xhr.status);if(xhr.response!==undefined){return new Uint8Array(xhr.response||[])}return intArrayFromString(xhr.responseText||"",true)};var lazyArray=this;lazyArray.setDataGetter(chunkNum=>{var start=chunkNum*chunkSize;var end=(chunkNum+1)*chunkSize-1;end=Math.min(end,datalength-1);if(typeof lazyArray.chunks[chunkNum]=="undefined"){lazyArray.chunks[chunkNum]=doXHR(start,end)}if(typeof lazyArray.chunks[chunkNum]=="undefined")abort("doXHR failed!");return lazyArray.chunks[chunkNum]});if(usesGzip||!datalength){chunkSize=datalength=1;datalength=this.getter(0).length;chunkSize=datalength;out("LazyFiles on gzip forces download of the whole file when length is accessed")}this._length=datalength;this._chunkSize=chunkSize;this.lengthKnown=true}get length(){if(!this.lengthKnown){this.cacheLength()}return this._length}get chunkSize(){if(!this.lengthKnown){this.cacheLength()}return this._chunkSize}}if(globalThis.XMLHttpRequest){if(!ENVIRONMENT_IS_WORKER)abort("Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc");var lazyArray=new LazyUint8Array;var properties={isDevice:false,contents:lazyArray}}else{var properties={isDevice:false,url}}var node=FS.createFile(parent,name,properties,canRead,canWrite);if(properties.contents){node.contents=properties.contents}else if(properties.url){node.contents=null;node.url=properties.url}Object.defineProperties(node,{usedBytes:{get:function(){return this.contents.length}}});var stream_ops={};for(const[key,fn]of Object.entries(node.stream_ops)){stream_ops[key]=(...args)=>{FS.forceLoadFile(node);return fn(...args)}}function writeChunks(stream,buffer,offset,length,position){var contents=stream.node.contents;if(position>=contents.length)return 0;var size=Math.min(contents.length-position,length);assert(size>=0);if(contents.slice){for(var i=0;i<size;i++){buffer[offset+i]=contents[position+i]}}else{for(var i=0;i<size;i++){buffer[offset+i]=contents.get(position+i)}}return size}stream_ops.read=(stream,buffer,offset,length,position)=>{FS.forceLoadFile(node);return writeChunks(stream,buffer,offset,length,position)};stream_ops.mmap=(stream,length,position,prot,flags)=>{FS.forceLoadFile(node);var ptr=mmapAlloc(length);if(!ptr){throw new FS.ErrnoError(48)}writeChunks(stream,HEAP8,ptr,length,position);return{ptr,allocated:true}};node.stream_ops=stream_ops;return node}};var SYSCALLS={currentUmask:18,calculateAt(dirfd,path,allowEmpty){if(PATH.isAbs(path)){return path}var dir;if(dirfd===-100){dir=FS.cwd()}else{var dirstream=SYSCALLS.getStreamFromFD(dirfd);dir=dirstream.path}if(path.length==0){if(!allowEmpty){throw new FS.ErrnoError(44)}return dir}return dir+"/"+path},writeStat(buf,stat){HEAPU32[buf>>2]=stat.dev;HEAPU32[buf+4>>2]=stat.mode;HEAPU32[buf+8>>2]=stat.nlink;HEAPU32[buf+12>>2]=stat.uid;HEAPU32[buf+16>>2]=stat.gid;HEAPU32[buf+20>>2]=stat.rdev;HEAP64[buf+24>>3]=BigInt(stat.size);HEAP32[buf+32>>2]=4096;HEAP32[buf+36>>2]=stat.blocks;var atime=stat.atime.getTime();var mtime=stat.mtime.getTime();var ctime=stat.ctime.getTime();HEAP64[buf+40>>3]=BigInt(Math.floor(atime/1e3));HEAPU32[buf+48>>2]=atime%1e3*1e3*1e3;HEAP64[buf+56>>3]=BigInt(Math.floor(mtime/1e3));HEAPU32[buf+64>>2]=mtime%1e3*1e3*1e3;HEAP64[buf+72>>3]=BigInt(Math.floor(ctime/1e3));HEAPU32[buf+80>>2]=ctime%1e3*1e3*1e3;HEAP64[buf+88>>3]=BigInt(stat.ino);return 0},writeStatFs(buf,stats){HEAPU32[buf+4>>2]=stats.bsize;HEAPU32[buf+60>>2]=stats.bsize;HEAP64[buf+8>>3]=BigInt(stats.blocks);HEAP64[buf+16>>3]=BigInt(stats.bfree);HEAP64[buf+24>>3]=BigInt(stats.bavail);HEAP64[buf+32>>3]=BigInt(stats.files);HEAP64[buf+40>>3]=BigInt(stats.ffree);HEAPU32[buf+48>>2]=stats.fsid;HEAPU32[buf+64>>2]=stats.flags;HEAPU32[buf+56>>2]=stats.namelen},doMsync(addr,stream,len,flags,offset){if(!FS.isFile(stream.node.mode)){throw new FS.ErrnoError(43)}if(flags&2){return 0}var buffer=HEAPU8.slice(addr,addr+len);FS.msync(stream,buffer,offset,len,flags)},getStreamFromFD(fd){var stream=FS.getStreamChecked(fd);return stream},varargs:undefined,getStr(ptr){var ret=UTF8ToString(ptr);return ret}};function ___syscall_faccessat(dirfd,path,amode,flags){try{path=SYSCALLS.getStr(path);assert(!flags||flags==512);path=SYSCALLS.calculateAt(dirfd,path);if(amode&~7){return-28}var lookup=FS.lookupPath(path,{follow:true});var node=lookup.node;if(!node){return-44}var perms="";if(amode&4)perms+="r";if(amode&2)perms+="w";if(amode&1)perms+="x";if(perms&&FS.nodePermissions(node,perms)){return-2}return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}var syscallGetVarargI=()=>{assert(SYSCALLS.varargs!=undefined);var ret=HEAP32[+SYSCALLS.varargs>>2];SYSCALLS.varargs+=4;return ret};var syscallGetVarargP=syscallGetVarargI;function ___syscall_fcntl64(fd,cmd,varargs){SYSCALLS.varargs=varargs;try{var stream=SYSCALLS.getStreamFromFD(fd);switch(cmd){case 0:{var arg=syscallGetVarargI();if(arg<0){return-28}while(FS.streams[arg]){arg++}var newStream;newStream=FS.dupStream(stream,arg);return newStream.fd}case 1:case 2:return 0;case 3:return stream.flags;case 4:{var arg=syscallGetVarargI();var mask=289792;stream.flags=stream.flags&~mask|arg&mask;return 0}case 12:{var arg=syscallGetVarargP();var offset=0;HEAP16[arg+offset>>1]=2;return 0}case 13:case 14:return 0}return-28}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}var stringToUTF8=(str,outPtr,maxBytesToWrite)=>{assert(typeof maxBytesToWrite=="number","stringToUTF8 requires a third parameter that specifies the length of the output buffer");return stringToUTF8Array(str,HEAPU8,outPtr,maxBytesToWrite)};function ___syscall_getcwd(buf,size){try{if(size===0)return-28;var cwd=FS.cwd();var cwdLengthInBytes=lengthBytesUTF8(cwd)+1;if(size<cwdLengthInBytes)return-68;stringToUTF8(cwd,buf,size);return cwdLengthInBytes}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_ioctl(fd,op,varargs){SYSCALLS.varargs=varargs;try{var stream=SYSCALLS.getStreamFromFD(fd);switch(op){case 21509:{if(!stream.tty)return-59;return 0}case 21505:{if(!stream.tty)return-59;if(stream.tty.ops.ioctl_tcgets){var termios=stream.tty.ops.ioctl_tcgets(stream);var argp=syscallGetVarargP();HEAP32[argp>>2]=termios.c_iflag||0;HEAP32[argp+4>>2]=termios.c_oflag||0;HEAP32[argp+8>>2]=termios.c_cflag||0;HEAP32[argp+12>>2]=termios.c_lflag||0;for(var i=0;i<32;i++){HEAP8[argp+i+17]=termios.c_cc[i]||0}return 0}return 0}case 21510:case 21511:case 21512:{if(!stream.tty)return-59;return 0}case 21506:case 21507:case 21508:{if(!stream.tty)return-59;if(stream.tty.ops.ioctl_tcsets){var argp=syscallGetVarargP();var c_iflag=HEAP32[argp>>2];var c_oflag=HEAP32[argp+4>>2];var c_cflag=HEAP32[argp+8>>2];var c_lflag=HEAP32[argp+12>>2];var c_cc=[];for(var i=0;i<32;i++){c_cc.push(HEAP8[argp+i+17])}return stream.tty.ops.ioctl_tcsets(stream.tty,op,{c_iflag,c_oflag,c_cflag,c_lflag,c_cc})}return 0}case 21519:{if(!stream.tty)return-59;var argp=syscallGetVarargP();HEAP32[argp>>2]=0;return 0}case 21520:{if(!stream.tty)return-59;return-28}case 21537:case 21531:{var argp=syscallGetVarargP();return FS.ioctl(stream,op,argp)}case 21523:{if(!stream.tty)return-59;if(stream.tty.ops.ioctl_tiocgwinsz){var winsize=stream.tty.ops.ioctl_tiocgwinsz(stream.tty);var argp=syscallGetVarargP();HEAP16[argp>>1]=winsize[0];HEAP16[argp+2>>1]=winsize[1]}return 0}case 21524:{if(!stream.tty)return-59;return 0}case 21515:{if(!stream.tty)return-59;return 0}default:return-28}}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_openat(dirfd,path,flags,varargs){SYSCALLS.varargs=varargs;try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);var mode=varargs?syscallGetVarargI():0;if(flags&64){mode&=~SYSCALLS.currentUmask}return FS.open(path,flags,mode).fd}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}var __abort_js=()=>abort("native code called abort()");var __tzset_js=(timezone,daylight,std_name,dst_name)=>{var currentYear=(new Date).getFullYear();var winter=new Date(currentYear,0,1);var summer=new Date(currentYear,6,1);var winterOffset=winter.getTimezoneOffset();var summerOffset=summer.getTimezoneOffset();var stdTimezoneOffset=Math.max(winterOffset,summerOffset);HEAPU32[timezone>>2]=stdTimezoneOffset*60;HEAP32[daylight>>2]=Number(winterOffset!=summerOffset);var extractZone=timezoneOffset=>{var sign=timezoneOffset>=0?"-":"+";var absOffset=Math.abs(timezoneOffset);var hours=String(Math.floor(absOffset/60)).padStart(2,"0");var minutes=String(absOffset%60).padStart(2,"0");return`UTC${sign}${hours}${minutes}`};var winterName=extractZone(winterOffset);var summerName=extractZone(summerOffset);assert(winterName);assert(summerName);assert(lengthBytesUTF8(winterName)<=16,`timezone name truncated to fit in TZNAME_MAX (${winterName})`);assert(lengthBytesUTF8(summerName)<=16,`timezone name truncated to fit in TZNAME_MAX (${summerName})`);if(summerOffset<winterOffset){stringToUTF8(winterName,std_name,17);stringToUTF8(summerName,dst_name,17)}else{stringToUTF8(winterName,dst_name,17);stringToUTF8(summerName,std_name,17)}};var _emscripten_get_now=()=>performance.now();var _emscripten_date_now=()=>Date.now();var nowIsMonotonic=1;var checkWasiClock=clock_id=>clock_id>=0&&clock_id<=3;var INT53_MAX=9007199254740992;var INT53_MIN=-9007199254740992;var bigintToI53Checked=num=>num<INT53_MIN||num>INT53_MAX?NaN:Number(num);function _clock_time_get(clk_id,ignored_precision,ptime){ignored_precision=bigintToI53Checked(ignored_precision);if(!checkWasiClock(clk_id)){return 28}var now;if(clk_id===0){now=_emscripten_date_now()}else if(nowIsMonotonic){now=_emscripten_get_now()}else{return 52}var nsec=Math.round(now*1e3*1e3);HEAP64[ptime>>3]=BigInt(nsec);return 0}var readEmAsmArgsArray=[];var readEmAsmArgs=(sigPtr,buf)=>{assert(Array.isArray(readEmAsmArgsArray));assert(buf%16==0);readEmAsmArgsArray.length=0;var ch;while(ch=HEAPU8[sigPtr++]){var chr=String.fromCharCode(ch);var validChars=["d","f","i","p"];validChars.push("j");assert(validChars.includes(chr),`Invalid character ${ch}("${chr}") in readEmAsmArgs! Use only [${validChars}], and do not specify "v" for void return argument.`);var wide=ch!=105;wide&=ch!=112;buf+=wide&&buf%8?4:0;readEmAsmArgsArray.push(ch==112?HEAPU32[buf>>2]:ch==106?HEAP64[buf>>3]:ch==105?HEAP32[buf>>2]:HEAPF64[buf>>3]);buf+=wide?8:4}return readEmAsmArgsArray};var runEmAsmFunction=(code,sigPtr,argbuf)=>{var args=readEmAsmArgs(sigPtr,argbuf);assert(ASM_CONSTS.hasOwnProperty(code),`No EM_ASM constant found at address ${code}. The loaded WebAssembly file is likely out of sync with the generated JavaScript.`);return ASM_CONSTS[code](...args)};var _emscripten_asm_const_double=(code,sigPtr,argbuf)=>runEmAsmFunction(code,sigPtr,argbuf);var _emscripten_asm_const_int=(code,sigPtr,argbuf)=>runEmAsmFunction(code,sigPtr,argbuf);function _emscripten_fetch_free(id){if(Fetch.xhrs.has(id)){var xhr=Fetch.xhrs.get(id);Fetch.xhrs.free(id);if(xhr.readyState>0&&xhr.readyState<4){xhr.abort()}}}var maybeCStringToJsString=cString=>cString>2?UTF8ToString(cString):cString;var specialHTMLTargets=[0,globalThis.document??0,globalThis.window??0];var findEventTarget=target=>{target=maybeCStringToJsString(target);var domElement=specialHTMLTargets[target]||globalThis.document?.querySelector(target);return domElement};var getBoundingClientRect=e=>specialHTMLTargets.indexOf(e)<0?e.getBoundingClientRect():{left:0,top:0};var _emscripten_get_element_css_size=(target,width,height)=>{target=findEventTarget(target);if(!target)return-4;var rect=getBoundingClientRect(target);HEAPF64[width>>3]=rect.width;HEAPF64[height>>3]=rect.height;return 0};var onExits=[];var JSEvents={removeAllEventListeners(){while(JSEvents.eventHandlers.length){JSEvents._removeHandler(JSEvents.eventHandlers.length-1)}JSEvents.deferredCalls=[]},inEventHandler:0,deferredCalls:[],deferCall(targetFunction,precedence,argsList){function arraysHaveEqualContent(arrA,arrB){if(arrA.length!=arrB.length)return false;for(var i in arrA){if(arrA[i]!=arrB[i])return false}return true}for(var call of JSEvents.deferredCalls){if(call.targetFunction==targetFunction&&arraysHaveEqualContent(call.argsList,argsList)){return}}JSEvents.deferredCalls.push({targetFunction,precedence,argsList});JSEvents.deferredCalls.sort((x,y)=>x.precedence-y.precedence)},removeDeferredCalls(targetFunction){JSEvents.deferredCalls=JSEvents.deferredCalls.filter(call=>call.targetFunction!=targetFunction)},canPerformEventHandlerRequests(){if(navigator.userActivation){return navigator.userActivation.isActive}return JSEvents.inEventHandler&&JSEvents.currentEventHandler.allowsDeferredCalls},runDeferredCalls(){if(!JSEvents.canPerformEventHandlerRequests()){return}var deferredCalls=JSEvents.deferredCalls;JSEvents.deferredCalls=[];for(var call of deferredCalls){call.targetFunction(...call.argsList)}},eventHandlers:[],removeAllHandlersOnTarget:(target,eventTypeString)=>{for(var i=0;i<JSEvents.eventHandlers.length;++i){if(JSEvents.eventHandlers[i].target==target&&(!eventTypeString||eventTypeString==JSEvents.eventHandlers[i].eventTypeString)){JSEvents._removeHandler(i--)}}},_removeHandler(i){var h=JSEvents.eventHandlers[i];h.target.removeEventListener(h.eventTypeString,h.eventListenerFunc,h.useCapture);JSEvents.eventHandlers.splice(i,1)},registerOrRemoveHandler(eventHandler){if(!eventHandler.target){err("registerOrRemoveHandler: the target element for event handler registration does not exist, when processing the following event handler registration:");console.dir(eventHandler);return-4}if(eventHandler.callbackfunc){eventHandler.eventListenerFunc=function(event){++JSEvents.inEventHandler;JSEvents.currentEventHandler=eventHandler;JSEvents.runDeferredCalls();eventHandler.handlerFunc(event);JSEvents.runDeferredCalls();--JSEvents.inEventHandler};eventHandler.target.addEventListener(eventHandler.eventTypeString,eventHandler.eventListenerFunc,eventHandler.useCapture);JSEvents.eventHandlers.push(eventHandler)}else{for(var i=0;i<JSEvents.eventHandlers.length;++i){if(JSEvents.eventHandlers[i].target==eventHandler.target&&JSEvents.eventHandlers[i].eventTypeString==eventHandler.eventTypeString){JSEvents._removeHandler(i--)}}}return 0},removeSingleHandler(eventHandler){let success=false;for(let i=0;i<JSEvents.eventHandlers.length;++i){const handler=JSEvents.eventHandlers[i];if(handler.target===eventHandler.target&&handler.eventTypeId===eventHandler.eventTypeId&&handler.callbackfunc===eventHandler.callbackfunc&&handler.userData===eventHandler.userData){JSEvents._removeHandler(i--);success=true}}return success?0:-5},getNodeNameForTarget(target){if(!target)return"";if(target==window)return"#window";if(target==screen)return"#screen";return target?.nodeName||""},fullscreenEnabled(){return document.fullscreenEnabled||document.webkitFullscreenEnabled}};var fillGamepadEventData=(eventStruct,e)=>{HEAPF64[eventStruct>>3]=e.timestamp;for(var i=0;i<e.axes.length;++i){HEAPF64[eventStruct+i*8+16>>3]=e.axes[i]}for(var i=0;i<e.buttons.length;++i){if(typeof e.buttons[i]=="object"){HEAPF64[eventStruct+i*8+528>>3]=e.buttons[i].value}else{HEAPF64[eventStruct+i*8+528>>3]=e.buttons[i]}}for(var i=0;i<e.buttons.length;++i){if(typeof e.buttons[i]=="object"){HEAP8[eventStruct+i+1040]=e.buttons[i].pressed}else{HEAP8[eventStruct+i+1040]=e.buttons[i]==1}}HEAP8[eventStruct+1104]=e.connected;HEAP32[eventStruct+1108>>2]=e.index;HEAP32[eventStruct+8>>2]=e.axes.length;HEAP32[eventStruct+12>>2]=e.buttons.length;stringToUTF8(e.id,eventStruct+1112,64);stringToUTF8(e.mapping,eventStruct+1176,64)};var _emscripten_get_gamepad_status=(index,gamepadState)=>{assert(JSEvents.lastGamepadState,"emscripten_get_gamepad_status() called before emscripten_sample_gamepad_data()");if(index<0||index>=JSEvents.lastGamepadState.length)return-5;if(!JSEvents.lastGamepadState[index])return-7;fillGamepadEventData(gamepadState,JSEvents.lastGamepadState[index]);return 0};var _emscripten_get_num_gamepads=()=>{assert(JSEvents.lastGamepadState,"emscripten_get_num_gamepads() called before emscripten_sample_gamepad_data()");return JSEvents.lastGamepadState.length};var GLctx;var webgl_enable_ANGLE_instanced_arrays=ctx=>{var ext=ctx.getExtension("ANGLE_instanced_arrays");if(ext){ctx["vertexAttribDivisor"]=(index,divisor)=>ext["vertexAttribDivisorANGLE"](index,divisor);ctx["drawArraysInstanced"]=(mode,first,count,primcount)=>ext["drawArraysInstancedANGLE"](mode,first,count,primcount);ctx["drawElementsInstanced"]=(mode,count,type,indices,primcount)=>ext["drawElementsInstancedANGLE"](mode,count,type,indices,primcount);return 1}};var webgl_enable_OES_vertex_array_object=ctx=>{var ext=ctx.getExtension("OES_vertex_array_object");if(ext){ctx["createVertexArray"]=()=>ext["createVertexArrayOES"]();ctx["deleteVertexArray"]=vao=>ext["deleteVertexArrayOES"](vao);ctx["bindVertexArray"]=vao=>ext["bindVertexArrayOES"](vao);ctx["isVertexArray"]=vao=>ext["isVertexArrayOES"](vao);return 1}};var webgl_enable_WEBGL_draw_buffers=ctx=>{var ext=ctx.getExtension("WEBGL_draw_buffers");if(ext){ctx["drawBuffers"]=(n,bufs)=>ext["drawBuffersWEBGL"](n,bufs);return 1}};var webgl_enable_EXT_polygon_offset_clamp=ctx=>!!(ctx.extPolygonOffsetClamp=ctx.getExtension("EXT_polygon_offset_clamp"));var webgl_enable_EXT_clip_control=ctx=>!!(ctx.extClipControl=ctx.getExtension("EXT_clip_control"));var webgl_enable_WEBGL_polygon_mode=ctx=>!!(ctx.webglPolygonMode=ctx.getExtension("WEBGL_polygon_mode"));var webgl_enable_WEBGL_multi_draw=ctx=>!!(ctx.multiDrawWebgl=ctx.getExtension("WEBGL_multi_draw"));var getEmscriptenSupportedExtensions=ctx=>{var supportedExtensions=["ANGLE_instanced_arrays","EXT_blend_minmax","EXT_disjoint_timer_query","EXT_frag_depth","EXT_shader_texture_lod","EXT_sRGB","OES_element_index_uint","OES_fbo_render_mipmap","OES_standard_derivatives","OES_texture_float","OES_texture_half_float","OES_texture_half_float_linear","OES_vertex_array_object","WEBGL_color_buffer_float","WEBGL_depth_texture","WEBGL_draw_buffers","EXT_clip_control","EXT_color_buffer_half_float","EXT_depth_clamp","EXT_float_blend","EXT_polygon_offset_clamp","EXT_texture_compression_bptc","EXT_texture_compression_rgtc","EXT_texture_filter_anisotropic","KHR_parallel_shader_compile","OES_texture_float_linear","WEBGL_blend_func_extended","WEBGL_compressed_texture_astc","WEBGL_compressed_texture_etc","WEBGL_compressed_texture_etc1","WEBGL_compressed_texture_s3tc","WEBGL_compressed_texture_s3tc_srgb","WEBGL_debug_renderer_info","WEBGL_debug_shaders","WEBGL_lose_context","WEBGL_multi_draw","WEBGL_polygon_mode"];return(ctx.getSupportedExtensions()||[]).filter(ext=>supportedExtensions.includes(ext))};var GL={counter:1,buffers:[],programs:[],framebuffers:[],renderbuffers:[],textures:[],shaders:[],vaos:[],contexts:[],offscreenCanvases:{},queries:[],stringCache:{},unpackAlignment:4,unpackRowLength:0,recordError:errorCode=>{if(!GL.lastError){GL.lastError=errorCode}},getNewId:table=>{var ret=GL.counter++;for(var i=table.length;i<ret;i++){table[i]=null}return ret},genObject:(n,buffers,createFunction,objectTable)=>{for(var i=0;i<n;i++){var buffer=GLctx[createFunction]();var id=buffer&&GL.getNewId(objectTable);if(buffer){buffer.name=id;objectTable[id]=buffer}else{GL.recordError(1282)}HEAP32[buffers+i*4>>2]=id}},getSource:(shader,count,string,length)=>{var source="";for(var i=0;i<count;++i){var len=length?HEAPU32[length+i*4>>2]:undefined;source+=UTF8ToString(HEAPU32[string+i*4>>2],len)}return source},createContext:(canvas,webGLContextAttributes)=>{if(!canvas.getContextSafariWebGL2Fixed){canvas.getContextSafariWebGL2Fixed=canvas.getContext;function fixedGetContext(ver,attrs){var gl=canvas.getContextSafariWebGL2Fixed(ver,attrs);return ver=="webgl"==gl instanceof WebGLRenderingContext?gl:null}canvas.getContext=fixedGetContext}var ctx=canvas.getContext("webgl",webGLContextAttributes);if(!ctx)return 0;var handle=GL.registerContext(ctx,webGLContextAttributes);return handle},registerContext:(ctx,webGLContextAttributes)=>{var handle=GL.getNewId(GL.contexts);var context={handle,attributes:webGLContextAttributes,version:webGLContextAttributes.majorVersion,GLctx:ctx};if(ctx.canvas)ctx.canvas.GLctxObject=context;GL.contexts[handle]=context;if(typeof webGLContextAttributes.enableExtensionsByDefault=="undefined"||webGLContextAttributes.enableExtensionsByDefault){GL.initExtensions(context)}return handle},makeContextCurrent:contextHandle=>{GL.currentContext=GL.contexts[contextHandle];Module["ctx"]=GLctx=GL.currentContext?.GLctx;return!(contextHandle&&!GLctx)},getContext:contextHandle=>GL.contexts[contextHandle],deleteContext:contextHandle=>{if(GL.currentContext===GL.contexts[contextHandle]){GL.currentContext=null}if(typeof JSEvents=="object"){JSEvents.removeAllHandlersOnTarget(GL.contexts[contextHandle].GLctx.canvas)}if(GL.contexts[contextHandle]?.GLctx.canvas){GL.contexts[contextHandle].GLctx.canvas.GLctxObject=undefined}GL.contexts[contextHandle]=null},initExtensions:context=>{context||=GL.currentContext;if(context.initExtensionsDone)return;context.initExtensionsDone=true;var GLctx=context.GLctx;webgl_enable_WEBGL_multi_draw(GLctx);webgl_enable_EXT_polygon_offset_clamp(GLctx);webgl_enable_EXT_clip_control(GLctx);webgl_enable_WEBGL_polygon_mode(GLctx);webgl_enable_ANGLE_instanced_arrays(GLctx);webgl_enable_OES_vertex_array_object(GLctx);webgl_enable_WEBGL_draw_buffers(GLctx);{GLctx.disjointTimerQueryExt=GLctx.getExtension("EXT_disjoint_timer_query")}for(var ext of getEmscriptenSupportedExtensions(GLctx)){if(!ext.includes("lose_context")&&!ext.includes("debug")){GLctx.getExtension(ext)}}}};var _emscripten_glActiveTexture=x0=>GLctx.activeTexture(x0);var _emscripten_glAttachShader=(program,shader)=>{GLctx.attachShader(GL.programs[program],GL.shaders[shader])};var _emscripten_glBeginQueryEXT=(target,id)=>{GLctx.disjointTimerQueryExt["beginQueryEXT"](target,GL.queries[id])};var _emscripten_glBindAttribLocation=(program,index,name)=>{GLctx.bindAttribLocation(GL.programs[program],index,UTF8ToString(name))};var _emscripten_glBindBuffer=(target,buffer)=>{GLctx.bindBuffer(target,GL.buffers[buffer])};var _emscripten_glBindFramebuffer=(target,framebuffer)=>{GLctx.bindFramebuffer(target,GL.framebuffers[framebuffer])};var _emscripten_glBindRenderbuffer=(target,renderbuffer)=>{GLctx.bindRenderbuffer(target,GL.renderbuffers[renderbuffer])};var _emscripten_glBindTexture=(target,texture)=>{GLctx.bindTexture(target,GL.textures[texture])};var _emscripten_glBindVertexArray=vao=>{GLctx.bindVertexArray(GL.vaos[vao])};var _glBindVertexArray=_emscripten_glBindVertexArray;var _emscripten_glBindVertexArrayOES=_glBindVertexArray;var _emscripten_glBlendColor=(x0,x1,x2,x3)=>GLctx.blendColor(x0,x1,x2,x3);var _emscripten_glBlendEquation=x0=>GLctx.blendEquation(x0);var _emscripten_glBlendEquationSeparate=(x0,x1)=>GLctx.blendEquationSeparate(x0,x1);var _emscripten_glBlendFunc=(x0,x1)=>GLctx.blendFunc(x0,x1);var _emscripten_glBlendFuncSeparate=(x0,x1,x2,x3)=>GLctx.blendFuncSeparate(x0,x1,x2,x3);var _emscripten_glBufferData=(target,size,data,usage)=>{GLctx.bufferData(target,data?HEAPU8.subarray(data,data+size):size,usage)};var _emscripten_glBufferSubData=(target,offset,size,data)=>{GLctx.bufferSubData(target,offset,HEAPU8.subarray(data,data+size))};var _emscripten_glCheckFramebufferStatus=x0=>GLctx.checkFramebufferStatus(x0);var _emscripten_glClear=x0=>GLctx.clear(x0);var _emscripten_glClearColor=(x0,x1,x2,x3)=>GLctx.clearColor(x0,x1,x2,x3);var _emscripten_glClearDepthf=x0=>GLctx.clearDepth(x0);var _emscripten_glClearStencil=x0=>GLctx.clearStencil(x0);var _emscripten_glClipControlEXT=(origin,depth)=>{GLctx.extClipControl["clipControlEXT"](origin,depth)};var _emscripten_glColorMask=(red,green,blue,alpha)=>{GLctx.colorMask(!!red,!!green,!!blue,!!alpha)};var _emscripten_glCompileShader=shader=>{GLctx.compileShader(GL.shaders[shader])};var _emscripten_glCompressedTexImage2D=(target,level,internalFormat,width,height,border,imageSize,data)=>{GLctx.compressedTexImage2D(target,level,internalFormat,width,height,border,HEAPU8.subarray(data,data+imageSize))};var _emscripten_glCompressedTexSubImage2D=(target,level,xoffset,yoffset,width,height,format,imageSize,data)=>{GLctx.compressedTexSubImage2D(target,level,xoffset,yoffset,width,height,format,HEAPU8.subarray(data,data+imageSize))};var _emscripten_glCopyTexImage2D=(x0,x1,x2,x3,x4,x5,x6,x7)=>GLctx.copyTexImage2D(x0,x1,x2,x3,x4,x5,x6,x7);var _emscripten_glCopyTexSubImage2D=(x0,x1,x2,x3,x4,x5,x6,x7)=>GLctx.copyTexSubImage2D(x0,x1,x2,x3,x4,x5,x6,x7);var _emscripten_glCreateProgram=()=>{var id=GL.getNewId(GL.programs);var program=GLctx.createProgram();program.name=id;program.maxUniformLength=program.maxAttributeLength=program.maxUniformBlockNameLength=0;program.uniformIdCounter=1;GL.programs[id]=program;return id};var _emscripten_glCreateShader=shaderType=>{var id=GL.getNewId(GL.shaders);GL.shaders[id]=GLctx.createShader(shaderType);return id};var _emscripten_glCullFace=x0=>GLctx.cullFace(x0);var _emscripten_glDeleteBuffers=(n,buffers)=>{for(var i=0;i<n;i++){var id=HEAP32[buffers+i*4>>2];var buffer=GL.buffers[id];if(!buffer)continue;GLctx.deleteBuffer(buffer);buffer.name=0;GL.buffers[id]=null}};var _emscripten_glDeleteFramebuffers=(n,framebuffers)=>{for(var i=0;i<n;++i){var id=HEAP32[framebuffers+i*4>>2];var framebuffer=GL.framebuffers[id];if(!framebuffer)continue;GLctx.deleteFramebuffer(framebuffer);framebuffer.name=0;GL.framebuffers[id]=null}};var _emscripten_glDeleteProgram=id=>{if(!id)return;var program=GL.programs[id];if(!program){GL.recordError(1281);return}GLctx.deleteProgram(program);program.name=0;GL.programs[id]=null};var _emscripten_glDeleteQueriesEXT=(n,ids)=>{for(var i=0;i<n;i++){var id=HEAP32[ids+i*4>>2];var query=GL.queries[id];if(!query)continue;GLctx.disjointTimerQueryExt["deleteQueryEXT"](query);GL.queries[id]=null}};var _emscripten_glDeleteRenderbuffers=(n,renderbuffers)=>{for(var i=0;i<n;i++){var id=HEAP32[renderbuffers+i*4>>2];var renderbuffer=GL.renderbuffers[id];if(!renderbuffer)continue;GLctx.deleteRenderbuffer(renderbuffer);renderbuffer.name=0;GL.renderbuffers[id]=null}};var _emscripten_glDeleteShader=id=>{if(!id)return;var shader=GL.shaders[id];if(!shader){GL.recordError(1281);return}GLctx.deleteShader(shader);GL.shaders[id]=null};var _emscripten_glDeleteTextures=(n,textures)=>{for(var i=0;i<n;i++){var id=HEAP32[textures+i*4>>2];var texture=GL.textures[id];if(!texture)continue;GLctx.deleteTexture(texture);texture.name=0;GL.textures[id]=null}};var _emscripten_glDeleteVertexArrays=(n,vaos)=>{for(var i=0;i<n;i++){var id=HEAP32[vaos+i*4>>2];GLctx.deleteVertexArray(GL.vaos[id]);GL.vaos[id]=null}};var _glDeleteVertexArrays=_emscripten_glDeleteVertexArrays;var _emscripten_glDeleteVertexArraysOES=_glDeleteVertexArrays;var _emscripten_glDepthFunc=x0=>GLctx.depthFunc(x0);var _emscripten_glDepthMask=flag=>{GLctx.depthMask(!!flag)};var _emscripten_glDepthRangef=(x0,x1)=>GLctx.depthRange(x0,x1);var _emscripten_glDetachShader=(program,shader)=>{GLctx.detachShader(GL.programs[program],GL.shaders[shader])};var _emscripten_glDisable=x0=>GLctx.disable(x0);var _emscripten_glDisableVertexAttribArray=index=>{GLctx.disableVertexAttribArray(index)};var _emscripten_glDrawArrays=(mode,first,count)=>{GLctx.drawArrays(mode,first,count)};var _emscripten_glDrawArraysInstanced=(mode,first,count,primcount)=>{GLctx.drawArraysInstanced(mode,first,count,primcount)};var _glDrawArraysInstanced=_emscripten_glDrawArraysInstanced;var _emscripten_glDrawArraysInstancedANGLE=_glDrawArraysInstanced;var tempFixedLengthArray=[];var _emscripten_glDrawBuffers=(n,bufs)=>{var bufArray=tempFixedLengthArray[n];for(var i=0;i<n;i++){bufArray[i]=HEAP32[bufs+i*4>>2]}GLctx.drawBuffers(bufArray)};var _glDrawBuffers=_emscripten_glDrawBuffers;var _emscripten_glDrawBuffersWEBGL=_glDrawBuffers;var _emscripten_glDrawElements=(mode,count,type,indices)=>{GLctx.drawElements(mode,count,type,indices)};var _emscripten_glDrawElementsInstanced=(mode,count,type,indices,primcount)=>{GLctx.drawElementsInstanced(mode,count,type,indices,primcount)};var _glDrawElementsInstanced=_emscripten_glDrawElementsInstanced;var _emscripten_glDrawElementsInstancedANGLE=_glDrawElementsInstanced;var _emscripten_glEnable=x0=>GLctx.enable(x0);var _emscripten_glEnableVertexAttribArray=index=>{GLctx.enableVertexAttribArray(index)};var _emscripten_glEndQueryEXT=target=>{GLctx.disjointTimerQueryExt["endQueryEXT"](target)};var _emscripten_glFinish=()=>GLctx.finish();var _emscripten_glFlush=()=>GLctx.flush();var _emscripten_glFramebufferRenderbuffer=(target,attachment,renderbuffertarget,renderbuffer)=>{GLctx.framebufferRenderbuffer(target,attachment,renderbuffertarget,GL.renderbuffers[renderbuffer])};var _emscripten_glFramebufferTexture2D=(target,attachment,textarget,texture,level)=>{GLctx.framebufferTexture2D(target,attachment,textarget,GL.textures[texture],level)};var _emscripten_glFrontFace=x0=>GLctx.frontFace(x0);var _emscripten_glGenBuffers=(n,buffers)=>{GL.genObject(n,buffers,"createBuffer",GL.buffers)};var _emscripten_glGenFramebuffers=(n,ids)=>{GL.genObject(n,ids,"createFramebuffer",GL.framebuffers)};var _emscripten_glGenQueriesEXT=(n,ids)=>{for(var i=0;i<n;i++){var query=GLctx.disjointTimerQueryExt["createQueryEXT"]();if(!query){GL.recordError(1282);while(i<n)HEAP32[ids+i++*4>>2]=0;return}var id=GL.getNewId(GL.queries);query.name=id;GL.queries[id]=query;HEAP32[ids+i*4>>2]=id}};var _emscripten_glGenRenderbuffers=(n,renderbuffers)=>{GL.genObject(n,renderbuffers,"createRenderbuffer",GL.renderbuffers)};var _emscripten_glGenTextures=(n,textures)=>{GL.genObject(n,textures,"createTexture",GL.textures)};var _emscripten_glGenVertexArrays=(n,arrays)=>{GL.genObject(n,arrays,"createVertexArray",GL.vaos)};var _glGenVertexArrays=_emscripten_glGenVertexArrays;var _emscripten_glGenVertexArraysOES=_glGenVertexArrays;var _emscripten_glGenerateMipmap=x0=>GLctx.generateMipmap(x0);var __glGetActiveAttribOrUniform=(funcName,program,index,bufSize,length,size,type,name)=>{program=GL.programs[program];var info=GLctx[funcName](program,index);if(info){var numBytesWrittenExclNull=name&&stringToUTF8(info.name,name,bufSize);if(length)HEAP32[length>>2]=numBytesWrittenExclNull;if(size)HEAP32[size>>2]=info.size;if(type)HEAP32[type>>2]=info.type}};var _emscripten_glGetActiveAttrib=(program,index,bufSize,length,size,type,name)=>__glGetActiveAttribOrUniform("getActiveAttrib",program,index,bufSize,length,size,type,name);var _emscripten_glGetActiveUniform=(program,index,bufSize,length,size,type,name)=>__glGetActiveAttribOrUniform("getActiveUniform",program,index,bufSize,length,size,type,name);var _emscripten_glGetAttachedShaders=(program,maxCount,count,shaders)=>{var result=GLctx.getAttachedShaders(GL.programs[program]);var len=result.length;if(len>maxCount){len=maxCount}HEAP32[count>>2]=len;for(var i=0;i<len;++i){var id=GL.shaders.indexOf(result[i]);HEAP32[shaders+i*4>>2]=id}};var _emscripten_glGetAttribLocation=(program,name)=>GLctx.getAttribLocation(GL.programs[program],UTF8ToString(name));var readI53FromI64=ptr=>HEAPU32[ptr>>2]+HEAP32[ptr+4>>2]*4294967296;var readI53FromU64=ptr=>HEAPU32[ptr>>2]+HEAPU32[ptr+4>>2]*4294967296;var writeI53ToI64=(ptr,num)=>{HEAPU32[ptr>>2]=num;var lower=HEAPU32[ptr>>2];HEAPU32[ptr+4>>2]=(num-lower)/4294967296;var deserialized=num>=0?readI53FromU64(ptr):readI53FromI64(ptr);var offset=ptr>>2;if(deserialized!=num)warnOnce(`writeI53ToI64() out of range: serialized JS Number ${num} to Wasm heap as bytes lo=${ptrToString(HEAPU32[offset])}, hi=${ptrToString(HEAPU32[offset+1])}, which deserializes back to ${deserialized} instead!`)};var emscriptenWebGLGet=(name_,p,type)=>{if(!p){GL.recordError(1281);return}var ret=undefined;switch(name_){case 36346:ret=1;break;case 36344:if(type!=0&&type!=1){GL.recordError(1280)}return;case 36345:ret=0;break;case 34466:var formats=GLctx.getParameter(34467);ret=formats?formats.length:0;break}if(ret===undefined){var result=GLctx.getParameter(name_);switch(typeof result){case"number":ret=result;break;case"boolean":ret=result?1:0;break;case"string":GL.recordError(1280);return;case"object":if(result===null){switch(name_){case 34964:case 35725:case 34965:case 36006:case 36007:case 32873:case 34229:case 34068:{ret=0;break}default:{GL.recordError(1280);return}}}else if(result instanceof Float32Array||result instanceof Uint32Array||result instanceof Int32Array||result instanceof Array){for(var i=0;i<result.length;++i){switch(type){case 0:HEAP32[p+i*4>>2]=result[i];break;case 2:HEAPF32[p+i*4>>2]=result[i];break;case 4:HEAP8[p+i]=result[i]?1:0;break}}return}else{try{ret=result.name|0}catch(e){GL.recordError(1280);err(`GL_INVALID_ENUM in glGet${type}v: Unknown object returned from WebGL getParameter(${name_})! (error: ${e})`);return}}break;default:GL.recordError(1280);err(`GL_INVALID_ENUM in glGet${type}v: Native code calling glGet${type}v(${name_}) and it returns ${result} of type ${typeof result}!`);return}}switch(type){case 1:writeI53ToI64(p,ret);break;case 0:HEAP32[p>>2]=ret;break;case 2:HEAPF32[p>>2]=ret;break;case 4:HEAP8[p]=ret?1:0;break}};var _emscripten_glGetBooleanv=(name_,p)=>emscriptenWebGLGet(name_,p,4);var _emscripten_glGetBufferParameteriv=(target,value,data)=>{if(!data){GL.recordError(1281);return}HEAP32[data>>2]=GLctx.getBufferParameter(target,value)};var _emscripten_glGetError=()=>{var error=GLctx.getError()||GL.lastError;GL.lastError=0;return error};var _emscripten_glGetFloatv=(name_,p)=>emscriptenWebGLGet(name_,p,2);var _emscripten_glGetFramebufferAttachmentParameteriv=(target,attachment,pname,params)=>{var result=GLctx.getFramebufferAttachmentParameter(target,attachment,pname);if(result instanceof WebGLRenderbuffer||result instanceof WebGLTexture){result=result.name|0}HEAP32[params>>2]=result};var _emscripten_glGetIntegerv=(name_,p)=>emscriptenWebGLGet(name_,p,0);var _emscripten_glGetProgramInfoLog=(program,maxLength,length,infoLog)=>{var log=GLctx.getProgramInfoLog(GL.programs[program]);if(log===null)log="(unknown error)";var numBytesWrittenExclNull=maxLength>0&&infoLog?stringToUTF8(log,infoLog,maxLength):0;if(length)HEAP32[length>>2]=numBytesWrittenExclNull};var _emscripten_glGetProgramiv=(program,pname,p)=>{if(!p){GL.recordError(1281);return}if(program>=GL.counter){GL.recordError(1281);return}program=GL.programs[program];if(pname==35716){var log=GLctx.getProgramInfoLog(program);if(log===null)log="(unknown error)";HEAP32[p>>2]=log.length+1}else if(pname==35719){if(!program.maxUniformLength){var numActiveUniforms=GLctx.getProgramParameter(program,35718);for(var i=0;i<numActiveUniforms;++i){program.maxUniformLength=Math.max(program.maxUniformLength,GLctx.getActiveUniform(program,i).name.length+1)}}HEAP32[p>>2]=program.maxUniformLength}else if(pname==35722){if(!program.maxAttributeLength){var numActiveAttributes=GLctx.getProgramParameter(program,35721);for(var i=0;i<numActiveAttributes;++i){program.maxAttributeLength=Math.max(program.maxAttributeLength,GLctx.getActiveAttrib(program,i).name.length+1)}}HEAP32[p>>2]=program.maxAttributeLength}else if(pname==35381){if(!program.maxUniformBlockNameLength){var numActiveUniformBlocks=GLctx.getProgramParameter(program,35382);for(var i=0;i<numActiveUniformBlocks;++i){program.maxUniformBlockNameLength=Math.max(program.maxUniformBlockNameLength,GLctx.getActiveUniformBlockName(program,i).length+1)}}HEAP32[p>>2]=program.maxUniformBlockNameLength}else{HEAP32[p>>2]=GLctx.getProgramParameter(program,pname)}};var _emscripten_glGetQueryObjecti64vEXT=(id,pname,params)=>{if(!params){GL.recordError(1281);return}var query=GL.queries[id];var param;{param=GLctx.disjointTimerQueryExt["getQueryObjectEXT"](query,pname)}var ret;if(typeof param=="boolean"){ret=param?1:0}else{ret=param}writeI53ToI64(params,ret)};var _emscripten_glGetQueryObjectivEXT=(id,pname,params)=>{if(!params){GL.recordError(1281);return}var query=GL.queries[id];var param=GLctx.disjointTimerQueryExt["getQueryObjectEXT"](query,pname);var ret;if(typeof param=="boolean"){ret=param?1:0}else{ret=param}HEAP32[params>>2]=ret};var _glGetQueryObjecti64vEXT=_emscripten_glGetQueryObjecti64vEXT;var _emscripten_glGetQueryObjectui64vEXT=_glGetQueryObjecti64vEXT;var _glGetQueryObjectivEXT=_emscripten_glGetQueryObjectivEXT;var _emscripten_glGetQueryObjectuivEXT=_glGetQueryObjectivEXT;var _emscripten_glGetQueryivEXT=(target,pname,params)=>{if(!params){GL.recordError(1281);return}HEAP32[params>>2]=GLctx.disjointTimerQueryExt["getQueryEXT"](target,pname)};var _emscripten_glGetRenderbufferParameteriv=(target,pname,params)=>{if(!params){GL.recordError(1281);return}HEAP32[params>>2]=GLctx.getRenderbufferParameter(target,pname)};var _emscripten_glGetShaderInfoLog=(shader,maxLength,length,infoLog)=>{var log=GLctx.getShaderInfoLog(GL.shaders[shader]);if(log===null)log="(unknown error)";var numBytesWrittenExclNull=maxLength>0&&infoLog?stringToUTF8(log,infoLog,maxLength):0;if(length)HEAP32[length>>2]=numBytesWrittenExclNull};var _emscripten_glGetShaderPrecisionFormat=(shaderType,precisionType,range,precision)=>{var result=GLctx.getShaderPrecisionFormat(shaderType,precisionType);HEAP32[range>>2]=result.rangeMin;HEAP32[range+4>>2]=result.rangeMax;HEAP32[precision>>2]=result.precision};var _emscripten_glGetShaderSource=(shader,bufSize,length,source)=>{var result=GLctx.getShaderSource(GL.shaders[shader]);if(!result)return;var numBytesWrittenExclNull=bufSize>0&&source?stringToUTF8(result,source,bufSize):0;if(length)HEAP32[length>>2]=numBytesWrittenExclNull};var _emscripten_glGetShaderiv=(shader,pname,p)=>{if(!p){GL.recordError(1281);return}if(pname==35716){var log=GLctx.getShaderInfoLog(GL.shaders[shader]);if(log===null)log="(unknown error)";var logLength=log?log.length+1:0;HEAP32[p>>2]=logLength}else if(pname==35720){var source=GLctx.getShaderSource(GL.shaders[shader]);var sourceLength=source?source.length+1:0;HEAP32[p>>2]=sourceLength}else{HEAP32[p>>2]=GLctx.getShaderParameter(GL.shaders[shader],pname)}};var stringToNewUTF8=str=>{var size=lengthBytesUTF8(str)+1;var ret=_malloc(size);if(ret)stringToUTF8(str,ret,size);return ret};var webglGetExtensions=()=>{var exts=getEmscriptenSupportedExtensions(GLctx);exts=exts.concat(exts.map(e=>"GL_"+e));return exts};var _emscripten_glGetString=name_=>{var ret=GL.stringCache[name_];if(!ret){switch(name_){case 7939:ret=stringToNewUTF8(webglGetExtensions().join(" "));break;case 7936:case 7937:case 37445:case 37446:var s=GLctx.getParameter(name_);if(!s){GL.recordError(1280)}ret=s?stringToNewUTF8(s):0;break;case 7938:var webGLVersion=GLctx.getParameter(7938);var glVersion=`OpenGL ES 2.0 (${webGLVersion})`;ret=stringToNewUTF8(glVersion);break;case 35724:var glslVersion=GLctx.getParameter(35724);var ver_re=/^WebGL GLSL ES ([0-9]\.[0-9][0-9]?)(?:$| .*)/;var ver_num=glslVersion.match(ver_re);if(ver_num!==null){if(ver_num[1].length==3)ver_num[1]=ver_num[1]+"0";glslVersion=`OpenGL ES GLSL ES ${ver_num[1]} (${glslVersion})`}ret=stringToNewUTF8(glslVersion);break;default:GL.recordError(1280)}GL.stringCache[name_]=ret}return ret};var _emscripten_glGetTexParameterfv=(target,pname,params)=>{if(!params){GL.recordError(1281);return}HEAPF32[params>>2]=GLctx.getTexParameter(target,pname)};var _emscripten_glGetTexParameteriv=(target,pname,params)=>{if(!params){GL.recordError(1281);return}HEAP32[params>>2]=GLctx.getTexParameter(target,pname)};var jstoi_q=str=>parseInt(str);var webglGetLeftBracePos=name=>name.slice(-1)=="]"&&name.lastIndexOf("[");var webglPrepareUniformLocationsBeforeFirstUse=program=>{var uniformLocsById=program.uniformLocsById,uniformSizeAndIdsByName=program.uniformSizeAndIdsByName,i,j;if(!uniformLocsById){program.uniformLocsById=uniformLocsById={};program.uniformArrayNamesById={};var numActiveUniforms=GLctx.getProgramParameter(program,35718);for(i=0;i<numActiveUniforms;++i){var u=GLctx.getActiveUniform(program,i);var nm=u.name;var sz=u.size;var lb=webglGetLeftBracePos(nm);var arrayName=lb>0?nm.slice(0,lb):nm;var id=program.uniformIdCounter;program.uniformIdCounter+=sz;uniformSizeAndIdsByName[arrayName]=[sz,id];for(j=0;j<sz;++j){uniformLocsById[id]=j;program.uniformArrayNamesById[id++]=arrayName}}}};var _emscripten_glGetUniformLocation=(program,name)=>{name=UTF8ToString(name);if(program=GL.programs[program]){webglPrepareUniformLocationsBeforeFirstUse(program);var uniformLocsById=program.uniformLocsById;var arrayIndex=0;var uniformBaseName=name;var leftBrace=webglGetLeftBracePos(name);if(leftBrace>0){arrayIndex=jstoi_q(name.slice(leftBrace+1))>>>0;uniformBaseName=name.slice(0,leftBrace)}var sizeAndId=program.uniformSizeAndIdsByName[uniformBaseName];if(sizeAndId&&arrayIndex<sizeAndId[0]){arrayIndex+=sizeAndId[1];if(uniformLocsById[arrayIndex]=uniformLocsById[arrayIndex]||GLctx.getUniformLocation(program,name)){return arrayIndex}}}else{GL.recordError(1281)}return-1};var webglGetUniformLocation=location=>{var p=GLctx.currentProgram;if(p){var webglLoc=p.uniformLocsById[location];if(typeof webglLoc=="number"){p.uniformLocsById[location]=webglLoc=GLctx.getUniformLocation(p,p.uniformArrayNamesById[location]+(webglLoc>0?`[${webglLoc}]`:""))}return webglLoc}else{GL.recordError(1282)}};var emscriptenWebGLGetUniform=(program,location,params,type)=>{if(!params){GL.recordError(1281);return}program=GL.programs[program];webglPrepareUniformLocationsBeforeFirstUse(program);var data=GLctx.getUniform(program,webglGetUniformLocation(location));if(typeof data=="number"||typeof data=="boolean"){switch(type){case 0:HEAP32[params>>2]=data;break;case 2:HEAPF32[params>>2]=data;break}}else{for(var i=0;i<data.length;i++){switch(type){case 0:HEAP32[params+i*4>>2]=data[i];break;case 2:HEAPF32[params+i*4>>2]=data[i];break}}}};var _emscripten_glGetUniformfv=(program,location,params)=>{emscriptenWebGLGetUniform(program,location,params,2)};var _emscripten_glGetUniformiv=(program,location,params)=>{emscriptenWebGLGetUniform(program,location,params,0)};var _emscripten_glGetVertexAttribPointerv=(index,pname,pointer)=>{if(!pointer){GL.recordError(1281);return}HEAP32[pointer>>2]=GLctx.getVertexAttribOffset(index,pname)};var emscriptenWebGLGetVertexAttrib=(index,pname,params,type)=>{if(!params){GL.recordError(1281);return}var data=GLctx.getVertexAttrib(index,pname);if(pname==34975){HEAP32[params>>2]=data&&data["name"]}else if(typeof data=="number"||typeof data=="boolean"){switch(type){case 0:HEAP32[params>>2]=data;break;case 2:HEAPF32[params>>2]=data;break;case 5:HEAP32[params>>2]=Math.fround(data);break}}else{for(var i=0;i<data.length;i++){switch(type){case 0:HEAP32[params+i*4>>2]=data[i];break;case 2:HEAPF32[params+i*4>>2]=data[i];break;case 5:HEAP32[params+i*4>>2]=Math.fround(data[i]);break}}}};var _emscripten_glGetVertexAttribfv=(index,pname,params)=>{emscriptenWebGLGetVertexAttrib(index,pname,params,2)};var _emscripten_glGetVertexAttribiv=(index,pname,params)=>{emscriptenWebGLGetVertexAttrib(index,pname,params,5)};var _emscripten_glHint=(x0,x1)=>GLctx.hint(x0,x1);var _emscripten_glIsBuffer=buffer=>{var b=GL.buffers[buffer];if(!b)return 0;return GLctx.isBuffer(b)};var _emscripten_glIsEnabled=x0=>GLctx.isEnabled(x0);var _emscripten_glIsFramebuffer=framebuffer=>{var fb=GL.framebuffers[framebuffer];if(!fb)return 0;return GLctx.isFramebuffer(fb)};var _emscripten_glIsProgram=program=>{program=GL.programs[program];if(!program)return 0;return GLctx.isProgram(program)};var _emscripten_glIsQueryEXT=id=>{var query=GL.queries[id];if(!query)return 0;return GLctx.disjointTimerQueryExt["isQueryEXT"](query)};var _emscripten_glIsRenderbuffer=renderbuffer=>{var rb=GL.renderbuffers[renderbuffer];if(!rb)return 0;return GLctx.isRenderbuffer(rb)};var _emscripten_glIsShader=shader=>{var s=GL.shaders[shader];if(!s)return 0;return GLctx.isShader(s)};var _emscripten_glIsTexture=id=>{var texture=GL.textures[id];if(!texture)return 0;return GLctx.isTexture(texture)};var _emscripten_glIsVertexArray=array=>{var vao=GL.vaos[array];if(!vao)return 0;return GLctx.isVertexArray(vao)};var _glIsVertexArray=_emscripten_glIsVertexArray;var _emscripten_glIsVertexArrayOES=_glIsVertexArray;var _emscripten_glLineWidth=x0=>GLctx.lineWidth(x0);var _emscripten_glLinkProgram=program=>{program=GL.programs[program];GLctx.linkProgram(program);program.uniformLocsById=0;program.uniformSizeAndIdsByName={}};var _emscripten_glPixelStorei=(pname,param)=>{if(pname==3317){GL.unpackAlignment=param}else if(pname==3314){GL.unpackRowLength=param}GLctx.pixelStorei(pname,param)};var _emscripten_glPolygonModeWEBGL=(face,mode)=>{GLctx.webglPolygonMode["polygonModeWEBGL"](face,mode)};var _emscripten_glPolygonOffset=(x0,x1)=>GLctx.polygonOffset(x0,x1);var _emscripten_glPolygonOffsetClampEXT=(factor,units,clamp)=>{GLctx.extPolygonOffsetClamp["polygonOffsetClampEXT"](factor,units,clamp)};var _emscripten_glQueryCounterEXT=(id,target)=>{GLctx.disjointTimerQueryExt["queryCounterEXT"](GL.queries[id],target)};var computeUnpackAlignedImageSize=(width,height,sizePerPixel)=>{function roundedToNextMultipleOf(x,y){return x+y-1&-y}var plainRowSize=(GL.unpackRowLength||width)*sizePerPixel;var alignedRowSize=roundedToNextMultipleOf(plainRowSize,GL.unpackAlignment);return height*alignedRowSize};var colorChannelsInGlTextureFormat=format=>{var colorChannels={5:3,6:4,8:2,29502:3,29504:4};return colorChannels[format-6402]||1};var heapObjectForWebGLType=type=>{type-=5120;if(type==1)return HEAPU8;if(type==4)return HEAP32;if(type==6)return HEAPF32;if(type==5||type==28922)return HEAPU32;return HEAPU16};var toTypedArrayIndex=(pointer,heap)=>pointer>>>31-Math.clz32(heap.BYTES_PER_ELEMENT);var emscriptenWebGLGetTexPixelData=(type,format,width,height,pixels,internalFormat)=>{var heap=heapObjectForWebGLType(type);var sizePerPixel=colorChannelsInGlTextureFormat(format)*heap.BYTES_PER_ELEMENT;var bytes=computeUnpackAlignedImageSize(width,height,sizePerPixel);return heap.subarray(toTypedArrayIndex(pixels,heap),toTypedArrayIndex(pixels+bytes,heap))};var _emscripten_glReadPixels=(x,y,width,height,format,type,pixels)=>{var pixelData=emscriptenWebGLGetTexPixelData(type,format,width,height,pixels,format);if(!pixelData){GL.recordError(1280);return}GLctx.readPixels(x,y,width,height,format,type,pixelData)};var _emscripten_glReleaseShaderCompiler=()=>{};var _emscripten_glRenderbufferStorage=(x0,x1,x2,x3)=>GLctx.renderbufferStorage(x0,x1,x2,x3);var _emscripten_glSampleCoverage=(value,invert)=>{GLctx.sampleCoverage(value,!!invert)};var _emscripten_glScissor=(x0,x1,x2,x3)=>GLctx.scissor(x0,x1,x2,x3);var _emscripten_glShaderBinary=(count,shaders,binaryformat,binary,length)=>{GL.recordError(1280)};var _emscripten_glShaderSource=(shader,count,string,length)=>{var source=GL.getSource(shader,count,string,length);GLctx.shaderSource(GL.shaders[shader],source)};var _emscripten_glStencilFunc=(x0,x1,x2)=>GLctx.stencilFunc(x0,x1,x2);var _emscripten_glStencilFuncSeparate=(x0,x1,x2,x3)=>GLctx.stencilFuncSeparate(x0,x1,x2,x3);var _emscripten_glStencilMask=x0=>GLctx.stencilMask(x0);var _emscripten_glStencilMaskSeparate=(x0,x1)=>GLctx.stencilMaskSeparate(x0,x1);var _emscripten_glStencilOp=(x0,x1,x2)=>GLctx.stencilOp(x0,x1,x2);var _emscripten_glStencilOpSeparate=(x0,x1,x2,x3)=>GLctx.stencilOpSeparate(x0,x1,x2,x3);var _emscripten_glTexImage2D=(target,level,internalFormat,width,height,border,format,type,pixels)=>{var pixelData=pixels?emscriptenWebGLGetTexPixelData(type,format,width,height,pixels,internalFormat):null;GLctx.texImage2D(target,level,internalFormat,width,height,border,format,type,pixelData)};var _emscripten_glTexParameterf=(x0,x1,x2)=>GLctx.texParameterf(x0,x1,x2);var _emscripten_glTexParameterfv=(target,pname,params)=>{var param=HEAPF32[params>>2];GLctx.texParameterf(target,pname,param)};var _emscripten_glTexParameteri=(x0,x1,x2)=>GLctx.texParameteri(x0,x1,x2);var _emscripten_glTexParameteriv=(target,pname,params)=>{var param=HEAP32[params>>2];GLctx.texParameteri(target,pname,param)};var _emscripten_glTexSubImage2D=(target,level,xoffset,yoffset,width,height,format,type,pixels)=>{var pixelData=pixels?emscriptenWebGLGetTexPixelData(type,format,width,height,pixels,0):null;GLctx.texSubImage2D(target,level,xoffset,yoffset,width,height,format,type,pixelData)};var _emscripten_glUniform1f=(location,v0)=>{GLctx.uniform1f(webglGetUniformLocation(location),v0)};var miniTempWebGLFloatBuffers=[];var _emscripten_glUniform1fv=(location,count,value)=>{if(count<=288){var view=miniTempWebGLFloatBuffers[count];for(var i=0;i<count;++i){view[i]=HEAPF32[value+4*i>>2]}}else{var view=HEAPF32.subarray(value>>2,value+count*4>>2)}GLctx.uniform1fv(webglGetUniformLocation(location),view)};var _emscripten_glUniform1i=(location,v0)=>{GLctx.uniform1i(webglGetUniformLocation(location),v0)};var miniTempWebGLIntBuffers=[];var _emscripten_glUniform1iv=(location,count,value)=>{if(count<=288){var view=miniTempWebGLIntBuffers[count];for(var i=0;i<count;++i){view[i]=HEAP32[value+4*i>>2]}}else{var view=HEAP32.subarray(value>>2,value+count*4>>2)}GLctx.uniform1iv(webglGetUniformLocation(location),view)};var _emscripten_glUniform2f=(location,v0,v1)=>{GLctx.uniform2f(webglGetUniformLocation(location),v0,v1)};var _emscripten_glUniform2fv=(location,count,value)=>{if(count<=144){count*=2;var view=miniTempWebGLFloatBuffers[count];for(var i=0;i<count;i+=2){view[i]=HEAPF32[value+4*i>>2];view[i+1]=HEAPF32[value+(4*i+4)>>2]}}else{var view=HEAPF32.subarray(value>>2,value+count*8>>2)}GLctx.uniform2fv(webglGetUniformLocation(location),view)};var _emscripten_glUniform2i=(location,v0,v1)=>{GLctx.uniform2i(webglGetUniformLocation(location),v0,v1)};var _emscripten_glUniform2iv=(location,count,value)=>{if(count<=144){count*=2;var view=miniTempWebGLIntBuffers[count];for(var i=0;i<count;i+=2){view[i]=HEAP32[value+4*i>>2];view[i+1]=HEAP32[value+(4*i+4)>>2]}}else{var view=HEAP32.subarray(value>>2,value+count*8>>2)}GLctx.uniform2iv(webglGetUniformLocation(location),view)};var _emscripten_glUniform3f=(location,v0,v1,v2)=>{GLctx.uniform3f(webglGetUniformLocation(location),v0,v1,v2)};var _emscripten_glUniform3fv=(location,count,value)=>{if(count<=96){count*=3;var view=miniTempWebGLFloatBuffers[count];for(var i=0;i<count;i+=3){view[i]=HEAPF32[value+4*i>>2];view[i+1]=HEAPF32[value+(4*i+4)>>2];view[i+2]=HEAPF32[value+(4*i+8)>>2]}}else{var view=HEAPF32.subarray(value>>2,value+count*12>>2)}GLctx.uniform3fv(webglGetUniformLocation(location),view)};var _emscripten_glUniform3i=(location,v0,v1,v2)=>{GLctx.uniform3i(webglGetUniformLocation(location),v0,v1,v2)};var _emscripten_glUniform3iv=(location,count,value)=>{if(count<=96){count*=3;var view=miniTempWebGLIntBuffers[count];for(var i=0;i<count;i+=3){view[i]=HEAP32[value+4*i>>2];view[i+1]=HEAP32[value+(4*i+4)>>2];view[i+2]=HEAP32[value+(4*i+8)>>2]}}else{var view=HEAP32.subarray(value>>2,value+count*12>>2)}GLctx.uniform3iv(webglGetUniformLocation(location),view)};var _emscripten_glUniform4f=(location,v0,v1,v2,v3)=>{GLctx.uniform4f(webglGetUniformLocation(location),v0,v1,v2,v3)};var _emscripten_glUniform4fv=(location,count,value)=>{if(count<=72){var view=miniTempWebGLFloatBuffers[4*count];var heap=HEAPF32;value=value>>2;count*=4;for(var i=0;i<count;i+=4){var dst=value+i;view[i]=heap[dst];view[i+1]=heap[dst+1];view[i+2]=heap[dst+2];view[i+3]=heap[dst+3]}}else{var view=HEAPF32.subarray(value>>2,value+count*16>>2)}GLctx.uniform4fv(webglGetUniformLocation(location),view)};var _emscripten_glUniform4i=(location,v0,v1,v2,v3)=>{GLctx.uniform4i(webglGetUniformLocation(location),v0,v1,v2,v3)};var _emscripten_glUniform4iv=(location,count,value)=>{if(count<=72){count*=4;var view=miniTempWebGLIntBuffers[count];for(var i=0;i<count;i+=4){view[i]=HEAP32[value+4*i>>2];view[i+1]=HEAP32[value+(4*i+4)>>2];view[i+2]=HEAP32[value+(4*i+8)>>2];view[i+3]=HEAP32[value+(4*i+12)>>2]}}else{var view=HEAP32.subarray(value>>2,value+count*16>>2)}GLctx.uniform4iv(webglGetUniformLocation(location),view)};var _emscripten_glUniformMatrix2fv=(location,count,transpose,value)=>{if(count<=72){count*=4;var view=miniTempWebGLFloatBuffers[count];for(var i=0;i<count;i+=4){view[i]=HEAPF32[value+4*i>>2];view[i+1]=HEAPF32[value+(4*i+4)>>2];view[i+2]=HEAPF32[value+(4*i+8)>>2];view[i+3]=HEAPF32[value+(4*i+12)>>2]}}else{var view=HEAPF32.subarray(value>>2,value+count*16>>2)}GLctx.uniformMatrix2fv(webglGetUniformLocation(location),!!transpose,view)};var _emscripten_glUniformMatrix3fv=(location,count,transpose,value)=>{if(count<=32){count*=9;var view=miniTempWebGLFloatBuffers[count];for(var i=0;i<count;i+=9){view[i]=HEAPF32[value+4*i>>2];view[i+1]=HEAPF32[value+(4*i+4)>>2];view[i+2]=HEAPF32[value+(4*i+8)>>2];view[i+3]=HEAPF32[value+(4*i+12)>>2];view[i+4]=HEAPF32[value+(4*i+16)>>2];view[i+5]=HEAPF32[value+(4*i+20)>>2];view[i+6]=HEAPF32[value+(4*i+24)>>2];view[i+7]=HEAPF32[value+(4*i+28)>>2];view[i+8]=HEAPF32[value+(4*i+32)>>2]}}else{var view=HEAPF32.subarray(value>>2,value+count*36>>2)}GLctx.uniformMatrix3fv(webglGetUniformLocation(location),!!transpose,view)};var _emscripten_glUniformMatrix4fv=(location,count,transpose,value)=>{if(count<=18){var view=miniTempWebGLFloatBuffers[16*count];var heap=HEAPF32;value=value>>2;count*=16;for(var i=0;i<count;i+=16){var dst=value+i;view[i]=heap[dst];view[i+1]=heap[dst+1];view[i+2]=heap[dst+2];view[i+3]=heap[dst+3];view[i+4]=heap[dst+4];view[i+5]=heap[dst+5];view[i+6]=heap[dst+6];view[i+7]=heap[dst+7];view[i+8]=heap[dst+8];view[i+9]=heap[dst+9];view[i+10]=heap[dst+10];view[i+11]=heap[dst+11];view[i+12]=heap[dst+12];view[i+13]=heap[dst+13];view[i+14]=heap[dst+14];view[i+15]=heap[dst+15]}}else{var view=HEAPF32.subarray(value>>2,value+count*64>>2)}GLctx.uniformMatrix4fv(webglGetUniformLocation(location),!!transpose,view)};var _emscripten_glUseProgram=program=>{program=GL.programs[program];GLctx.useProgram(program);GLctx.currentProgram=program};var _emscripten_glValidateProgram=program=>{GLctx.validateProgram(GL.programs[program])};var _emscripten_glVertexAttrib1f=(x0,x1)=>GLctx.vertexAttrib1f(x0,x1);var _emscripten_glVertexAttrib1fv=(index,v)=>{GLctx.vertexAttrib1f(index,HEAPF32[v>>2])};var _emscripten_glVertexAttrib2f=(x0,x1,x2)=>GLctx.vertexAttrib2f(x0,x1,x2);var _emscripten_glVertexAttrib2fv=(index,v)=>{GLctx.vertexAttrib2f(index,HEAPF32[v>>2],HEAPF32[v+4>>2])};var _emscripten_glVertexAttrib3f=(x0,x1,x2,x3)=>GLctx.vertexAttrib3f(x0,x1,x2,x3);var _emscripten_glVertexAttrib3fv=(index,v)=>{GLctx.vertexAttrib3f(index,HEAPF32[v>>2],HEAPF32[v+4>>2],HEAPF32[v+8>>2])};var _emscripten_glVertexAttrib4f=(x0,x1,x2,x3,x4)=>GLctx.vertexAttrib4f(x0,x1,x2,x3,x4);var _emscripten_glVertexAttrib4fv=(index,v)=>{GLctx.vertexAttrib4f(index,HEAPF32[v>>2],HEAPF32[v+4>>2],HEAPF32[v+8>>2],HEAPF32[v+12>>2])};var _emscripten_glVertexAttribDivisor=(index,divisor)=>{GLctx.vertexAttribDivisor(index,divisor)};var _glVertexAttribDivisor=_emscripten_glVertexAttribDivisor;var _emscripten_glVertexAttribDivisorANGLE=_glVertexAttribDivisor;var _emscripten_glVertexAttribPointer=(index,size,type,normalized,stride,ptr)=>{GLctx.vertexAttribPointer(index,size,type,!!normalized,stride,ptr)};var _emscripten_glViewport=(x0,x1,x2,x3)=>GLctx.viewport(x0,x1,x2,x3);var _emscripten_is_main_browser_thread=()=>!ENVIRONMENT_IS_WORKER;var getHeapMax=()=>2147483648;var alignMemory=(size,alignment)=>{assert(alignment,"alignment argument is required");return Math.ceil(size/alignment)*alignment};var growMemory=size=>{var oldHeapSize=wasmMemory.buffer.byteLength;var pages=(size-oldHeapSize+65535)/65536|0;try{wasmMemory.grow(pages);updateMemoryViews();return 1}catch(e){err(`growMemory: Attempted to grow heap from ${oldHeapSize} bytes to ${size} bytes, but got error: ${e}`)}};var _emscripten_resize_heap=requestedSize=>{var oldSize=HEAPU8.length;requestedSize>>>=0;assert(requestedSize>oldSize);var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){err(`Cannot enlarge memory, requested ${requestedSize} bytes, but the limit is ${maxHeapSize} bytes!`);return false}for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignMemory(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=growMemory(newSize);if(replacement){return true}}err(`Failed to grow the heap from ${oldSize} bytes to ${newSize} bytes, not enough memory!`);return false};var _emscripten_run_script=ptr=>{eval(UTF8ToString(ptr))};var _emscripten_sample_gamepad_data=()=>{try{if(navigator.getGamepads)return(JSEvents.lastGamepadState=navigator.getGamepads())?0:-1}catch(e){err(`navigator.getGamepads() exists, but failed to execute with exception ${e}. Disabling Gamepad access.`);navigator.getGamepads=null}return-1};var registerFocusEventCallback=(target,userData,useCapture,callbackfunc,eventTypeId,eventTypeString,targetThread)=>{var eventSize=256;JSEvents.focusEvent||=_malloc(eventSize);var focusEventHandlerFunc=e=>{var nodeName=JSEvents.getNodeNameForTarget(e.target);var id=e.target.id?e.target.id:"";var focusEvent=JSEvents.focusEvent;stringToUTF8(nodeName,focusEvent+0,128);stringToUTF8(id,focusEvent+128,128);if(((a1,a2,a3)=>dynCall_iiii(callbackfunc,a1,a2,a3))(eventTypeId,focusEvent,userData))e.preventDefault()};var eventHandler={target:findEventTarget(target),eventTypeString,eventTypeId,userData,callbackfunc,handlerFunc:focusEventHandlerFunc,useCapture};return JSEvents.registerOrRemoveHandler(eventHandler)};var _emscripten_set_blur_callback_on_thread=(target,userData,useCapture,callbackfunc,targetThread)=>registerFocusEventCallback(target,userData,useCapture,callbackfunc,12,"blur",targetThread);var findCanvasEventTarget=findEventTarget;var _emscripten_set_canvas_element_size=(target,width,height)=>{var canvas=findCanvasEventTarget(target);if(!canvas)return-4;canvas.width=width;canvas.height=height;return 0};var fillMouseEventData=(eventStruct,e,target)=>{assert(eventStruct%4==0);HEAPF64[eventStruct>>3]=e.timeStamp;var idx=eventStruct>>2;HEAP32[idx+2]=e.screenX;HEAP32[idx+3]=e.screenY;HEAP32[idx+4]=e.clientX;HEAP32[idx+5]=e.clientY;HEAP8[eventStruct+24]=e.ctrlKey;HEAP8[eventStruct+25]=e.shiftKey;HEAP8[eventStruct+26]=e.altKey;HEAP8[eventStruct+27]=e.metaKey;HEAP16[idx*2+14]=e.button;HEAP16[idx*2+15]=e.buttons;HEAP32[idx+8]=e["movementX"];HEAP32[idx+9]=e["movementY"];var rect=getBoundingClientRect(target);HEAP32[idx+10]=e.clientX-(rect.left|0);HEAP32[idx+11]=e.clientY-(rect.top|0)};var registerMouseEventCallback=(target,userData,useCapture,callbackfunc,eventTypeId,eventTypeString,targetThread)=>{var eventSize=64;JSEvents.mouseEvent||=_malloc(eventSize);target=findEventTarget(target);var mouseEventHandlerFunc=e=>{fillMouseEventData(JSEvents.mouseEvent,e,target);if(((a1,a2,a3)=>dynCall_iiii(callbackfunc,a1,a2,a3))(eventTypeId,JSEvents.mouseEvent,userData))e.preventDefault()};var eventHandler={target,allowsDeferredCalls:eventTypeString!="mousemove"&&eventTypeString!="mouseenter"&&eventTypeString!="mouseleave",eventTypeString,eventTypeId,userData,callbackfunc,handlerFunc:mouseEventHandlerFunc,useCapture};return JSEvents.registerOrRemoveHandler(eventHandler)};var _emscripten_set_click_callback_on_thread=(target,userData,useCapture,callbackfunc,targetThread)=>registerMouseEventCallback(target,userData,useCapture,callbackfunc,4,"click",targetThread);var _emscripten_set_focus_callback_on_thread=(target,userData,useCapture,callbackfunc,targetThread)=>registerFocusEventCallback(target,userData,useCapture,callbackfunc,13,"focus",targetThread);function getFullscreenElement(){return document.fullscreenElement||document.mozFullScreenElement||document.webkitFullscreenElement||document.webkitCurrentFullScreenElement||document.msFullscreenElement}var fillFullscreenChangeEventData=eventStruct=>{var fullscreenElement=getFullscreenElement();var isFullscreen=!!fullscreenElement;HEAP8[eventStruct]=isFullscreen;HEAP8[eventStruct+1]=JSEvents.fullscreenEnabled();var reportedElement=isFullscreen?fullscreenElement:JSEvents.previousFullscreenElement;var nodeName=JSEvents.getNodeNameForTarget(reportedElement);var id=reportedElement?.id||"";stringToUTF8(nodeName,eventStruct+2,128);stringToUTF8(id,eventStruct+130,128);HEAP32[eventStruct+260>>2]=reportedElement?reportedElement.clientWidth:0;HEAP32[eventStruct+264>>2]=reportedElement?reportedElement.clientHeight:0;HEAP32[eventStruct+268>>2]=screen.width;HEAP32[eventStruct+272>>2]=screen.height;if(isFullscreen){JSEvents.previousFullscreenElement=fullscreenElement}};var registerFullscreenChangeEventCallback=(target,userData,useCapture,callbackfunc,eventTypeId,eventTypeString,targetThread)=>{var eventSize=276;JSEvents.fullscreenChangeEvent||=_malloc(eventSize);var fullscreenChangeEventHandlerFunc=e=>{var fullscreenChangeEvent=JSEvents.fullscreenChangeEvent;fillFullscreenChangeEventData(fullscreenChangeEvent);if(((a1,a2,a3)=>dynCall_iiii(callbackfunc,a1,a2,a3))(eventTypeId,fullscreenChangeEvent,userData))e.preventDefault()};var eventHandler={target,eventTypeString,eventTypeId,userData,callbackfunc,handlerFunc:fullscreenChangeEventHandlerFunc,useCapture};return JSEvents.registerOrRemoveHandler(eventHandler)};var _emscripten_set_fullscreenchange_callback_on_thread=(target,userData,useCapture,callbackfunc,targetThread)=>{if(!JSEvents.fullscreenEnabled())return-1;target=findEventTarget(target);if(!target)return-4;registerFullscreenChangeEventCallback(target,userData,useCapture,callbackfunc,19,"webkitfullscreenchange",targetThread);return registerFullscreenChangeEventCallback(target,userData,useCapture,callbackfunc,19,"fullscreenchange",targetThread)};var registerGamepadEventCallback=(target,userData,useCapture,callbackfunc,eventTypeId,eventTypeString,targetThread)=>{var eventSize=1240;JSEvents.gamepadEvent||=_malloc(eventSize);var gamepadEventHandlerFunc=e=>{var gamepadEvent=JSEvents.gamepadEvent;fillGamepadEventData(gamepadEvent,e["gamepad"]);if(((a1,a2,a3)=>dynCall_iiii(callbackfunc,a1,a2,a3))(eventTypeId,gamepadEvent,userData))e.preventDefault()};var eventHandler={target:findEventTarget(target),allowsDeferredCalls:true,eventTypeString,eventTypeId,userData,callbackfunc,handlerFunc:gamepadEventHandlerFunc,useCapture};return JSEvents.registerOrRemoveHandler(eventHandler)};var _emscripten_set_gamepadconnected_callback_on_thread=(userData,useCapture,callbackfunc,targetThread)=>{if(_emscripten_sample_gamepad_data())return-1;return registerGamepadEventCallback(2,userData,useCapture,callbackfunc,26,"gamepadconnected",targetThread)};var _emscripten_set_gamepaddisconnected_callback_on_thread=(userData,useCapture,callbackfunc,targetThread)=>{if(_emscripten_sample_gamepad_data())return-1;return registerGamepadEventCallback(2,userData,useCapture,callbackfunc,27,"gamepaddisconnected",targetThread)};var handleException=e=>{if(e instanceof ExitStatus||e=="unwind"){return EXITSTATUS}checkStackCookie();if(e instanceof WebAssembly.RuntimeError){if(_emscripten_stack_get_current()<=0){err("Stack overflow detected. You can try increasing -sSTACK_SIZE (currently set to 65536)")}}quit_(1,e)};var runtimeKeepaliveCounter=0;var keepRuntimeAlive=()=>noExitRuntime||runtimeKeepaliveCounter>0;var _proc_exit=code=>{EXITSTATUS=code;if(!keepRuntimeAlive()){Module["onExit"]?.(code);ABORT=true}quit_(code,new ExitStatus(code))};var exitJS=(status,implicit)=>{EXITSTATUS=status;checkUnflushedContent();if(keepRuntimeAlive()&&!implicit){var msg=`program exited (with status: ${status}), but keepRuntimeAlive() is set (counter=${runtimeKeepaliveCounter}) due to an async operation, so halting execution but not exiting the runtime or preventing further async execution (you can use emscripten_force_exit, if you want to force a true shutdown)`;err(msg)}_proc_exit(status)};var _exit=exitJS;var maybeExit=()=>{if(!keepRuntimeAlive()){try{_exit(EXITSTATUS)}catch(e){handleException(e)}}};var callUserCallback=func=>{if(ABORT){err("user callback triggered after runtime exited or application aborted. Ignoring.");return}try{return func()}catch(e){handleException(e)}finally{maybeExit()}};var _emscripten_set_main_loop_timing=(mode,value)=>{MainLoop.timingMode=mode;MainLoop.timingValue=value;if(!MainLoop.func){err("emscripten_set_main_loop_timing: Cannot set timing mode for main loop since a main loop does not exist! Call emscripten_set_main_loop first to set one up.");return 1}if(!MainLoop.running){MainLoop.running=true}if(mode==0){MainLoop.scheduler=function MainLoop_scheduler_setTimeout(){var timeUntilNextTick=Math.max(0,MainLoop.tickStartTime+value-_emscripten_get_now())|0;setTimeout(MainLoop.runner,timeUntilNextTick)}}else if(mode==1){MainLoop.scheduler=function MainLoop_scheduler_rAF(){MainLoop.requestAnimationFrame(MainLoop.runner)}}else{assert(mode==2);if(!MainLoop.setImmediate){if(globalThis.setImmediate){MainLoop.setImmediate=setImmediate}else{var setImmediates=[];var emscriptenMainLoopMessageId="setimmediate";var MainLoop_setImmediate_messageHandler=event=>{if(event.data===emscriptenMainLoopMessageId||event.data.target===emscriptenMainLoopMessageId){event.stopPropagation();setImmediates.shift()()}};addEventListener("message",MainLoop_setImmediate_messageHandler,true);MainLoop.setImmediate=func=>{setImmediates.push(func);if(ENVIRONMENT_IS_WORKER){Module["setImmediates"]??=[];Module["setImmediates"].push(func);postMessage({target:emscriptenMainLoopMessageId})}else postMessage(emscriptenMainLoopMessageId,"*")}}}MainLoop.scheduler=function MainLoop_scheduler_setImmediate(){MainLoop.setImmediate(MainLoop.runner)}}return 0};var MainLoop={running:false,scheduler:null,currentlyRunningMainloop:0,func:null,arg:0,timingMode:0,timingValue:0,currentFrameNumber:0,queue:[],preMainLoop:[],postMainLoop:[],pause(){MainLoop.scheduler=null;MainLoop.currentlyRunningMainloop++},resume(){MainLoop.currentlyRunningMainloop++;var timingMode=MainLoop.timingMode;var timingValue=MainLoop.timingValue;var func=MainLoop.func;MainLoop.func=null;setMainLoop(func,0,false,MainLoop.arg,true);_emscripten_set_main_loop_timing(timingMode,timingValue);MainLoop.scheduler()},updateStatus(){if(Module["setStatus"]){var message=Module["statusMessage"]||"Please wait...";var remaining=MainLoop.remainingBlockers??0;var expected=MainLoop.expectedBlockers??0;if(remaining){if(remaining<expected){Module["setStatus"](`{message} ({expected - remaining}/{expected})`)}else{Module["setStatus"](message)}}else{Module["setStatus"]("")}}},init(){Module["preMainLoop"]&&MainLoop.preMainLoop.push(Module["preMainLoop"]);Module["postMainLoop"]&&MainLoop.postMainLoop.push(Module["postMainLoop"])},runIter(func){if(ABORT)return;for(var pre of MainLoop.preMainLoop){if(pre()===false){return}}callUserCallback(func);for(var post of MainLoop.postMainLoop){post()}checkStackCookie()},nextRAF:0,fakeRequestAnimationFrame(func){var now=Date.now();if(MainLoop.nextRAF===0){MainLoop.nextRAF=now+1e3/60}else{while(now+2>=MainLoop.nextRAF){MainLoop.nextRAF+=1e3/60}}var delay=Math.max(MainLoop.nextRAF-now,0);setTimeout(func,delay)},requestAnimationFrame(func){if(globalThis.requestAnimationFrame){requestAnimationFrame(func)}else{MainLoop.fakeRequestAnimationFrame(func)}}};var setMainLoop=(iterFunc,fps,simulateInfiniteLoop,arg,noSetTiming)=>{assert(!MainLoop.func,"emscripten_set_main_loop: there can only be one main loop function at once");MainLoop.func=iterFunc;MainLoop.arg=arg;var thisMainLoopId=MainLoop.currentlyRunningMainloop;function checkIsRunning(){if(thisMainLoopId<MainLoop.currentlyRunningMainloop){maybeExit();return false}return true}MainLoop.running=false;MainLoop.runner=function MainLoop_runner(){if(ABORT)return;if(MainLoop.queue.length>0){var start=Date.now();var blocker=MainLoop.queue.shift();blocker.func(blocker.arg);if(MainLoop.remainingBlockers){var remaining=MainLoop.remainingBlockers;var next=remaining%1==0?remaining-1:Math.floor(remaining);if(blocker.counted){MainLoop.remainingBlockers=next}else{next=next+.5;MainLoop.remainingBlockers=(8*remaining+next)/9}}MainLoop.updateStatus();if(!checkIsRunning())return;setTimeout(MainLoop.runner,0);return}if(!checkIsRunning())return;MainLoop.currentFrameNumber=MainLoop.currentFrameNumber+1|0;if(MainLoop.timingMode==1&&MainLoop.timingValue>1&&MainLoop.currentFrameNumber%MainLoop.timingValue!=0){MainLoop.scheduler();return}else if(MainLoop.timingMode==0){MainLoop.tickStartTime=_emscripten_get_now();if(Module["ctx"]){warnOnce("Looks like you are rendering without using requestAnimationFrame for the main loop. You should use 0 for the frame rate in emscripten_set_main_loop in order to use requestAnimationFrame, as that can greatly improve your frame rates!")}}MainLoop.runIter(iterFunc);if(!checkIsRunning())return;MainLoop.scheduler()};if(!noSetTiming){if(fps>0){_emscripten_set_main_loop_timing(0,1e3/fps)}else{_emscripten_set_main_loop_timing(1,1)}MainLoop.scheduler()}if(simulateInfiniteLoop){throw"unwind"}};var _emscripten_set_main_loop=(func,fps,simulateInfiniteLoop)=>{var iterFunc=()=>dynCall_v(func);setMainLoop(iterFunc,fps,simulateInfiniteLoop)};var _emscripten_set_mousedown_callback_on_thread=(target,userData,useCapture,callbackfunc,targetThread)=>registerMouseEventCallback(target,userData,useCapture,callbackfunc,5,"mousedown",targetThread);var _emscripten_set_mousemove_callback_on_thread=(target,userData,useCapture,callbackfunc,targetThread)=>registerMouseEventCallback(target,userData,useCapture,callbackfunc,8,"mousemove",targetThread);var _emscripten_set_mouseup_callback_on_thread=(target,userData,useCapture,callbackfunc,targetThread)=>registerMouseEventCallback(target,userData,useCapture,callbackfunc,6,"mouseup",targetThread);var fillPointerlockChangeEventData=eventStruct=>{var pointerLockElement=document.pointerLockElement;var isPointerlocked=!!pointerLockElement;HEAP8[eventStruct]=isPointerlocked;var nodeName=JSEvents.getNodeNameForTarget(pointerLockElement);var id=pointerLockElement?.id||"";stringToUTF8(nodeName,eventStruct+1,128);stringToUTF8(id,eventStruct+129,128)};var registerPointerlockChangeEventCallback=(target,userData,useCapture,callbackfunc,eventTypeId,eventTypeString,targetThread)=>{var eventSize=257;JSEvents.pointerlockChangeEvent||=_malloc(eventSize);var pointerlockChangeEventHandlerFunc=e=>{var pointerlockChangeEvent=JSEvents.pointerlockChangeEvent;fillPointerlockChangeEventData(pointerlockChangeEvent);if(((a1,a2,a3)=>dynCall_iiii(callbackfunc,a1,a2,a3))(eventTypeId,pointerlockChangeEvent,userData))e.preventDefault()};var eventHandler={target,eventTypeString,eventTypeId,userData,callbackfunc,handlerFunc:pointerlockChangeEventHandlerFunc,useCapture};return JSEvents.registerOrRemoveHandler(eventHandler)};var _emscripten_set_pointerlockchange_callback_on_thread=(target,userData,useCapture,callbackfunc,targetThread)=>{if(!document.body?.requestPointerLock){return-1}target=findEventTarget(target);if(!target)return-4;return registerPointerlockChangeEventCallback(target,userData,useCapture,callbackfunc,20,"pointerlockchange",targetThread)};var registerUiEventCallback=(target,userData,useCapture,callbackfunc,eventTypeId,eventTypeString,targetThread)=>{var eventSize=36;JSEvents.uiEvent||=_malloc(eventSize);target=findEventTarget(target);var uiEventHandlerFunc=e=>{if(e.target!=target){return}var b=document.body;if(!b){return}var uiEvent=JSEvents.uiEvent;HEAP32[uiEvent>>2]=0;HEAP32[uiEvent+4>>2]=b.clientWidth;HEAP32[uiEvent+8>>2]=b.clientHeight;HEAP32[uiEvent+12>>2]=innerWidth;HEAP32[uiEvent+16>>2]=innerHeight;HEAP32[uiEvent+20>>2]=outerWidth;HEAP32[uiEvent+24>>2]=outerHeight;HEAP32[uiEvent+28>>2]=pageXOffset|0;HEAP32[uiEvent+32>>2]=pageYOffset|0;if(((a1,a2,a3)=>dynCall_iiii(callbackfunc,a1,a2,a3))(eventTypeId,uiEvent,userData))e.preventDefault()};var eventHandler={target,eventTypeString,eventTypeId,userData,callbackfunc,handlerFunc:uiEventHandlerFunc,useCapture};return JSEvents.registerOrRemoveHandler(eventHandler)};var _emscripten_set_resize_callback_on_thread=(target,userData,useCapture,callbackfunc,targetThread)=>registerUiEventCallback(target,userData,useCapture,callbackfunc,10,"resize",targetThread);var registerTouchEventCallback=(target,userData,useCapture,callbackfunc,eventTypeId,eventTypeString,targetThread)=>{var eventSize=1552;JSEvents.touchEvent||=_malloc(eventSize);target=findEventTarget(target);var touchEventHandlerFunc=e=>{assert(e);var t,touches={},et=e.touches;for(let t of et){t.isChanged=t.onTarget=0;touches[t.identifier]=t}for(let t of e.changedTouches){t.isChanged=1;touches[t.identifier]=t}for(let t of e.targetTouches){touches[t.identifier].onTarget=1}var touchEvent=JSEvents.touchEvent;HEAPF64[touchEvent>>3]=e.timeStamp;HEAP8[touchEvent+12]=e.ctrlKey;HEAP8[touchEvent+13]=e.shiftKey;HEAP8[touchEvent+14]=e.altKey;HEAP8[touchEvent+15]=e.metaKey;var idx=touchEvent+16;var targetRect=getBoundingClientRect(target);var numTouches=0;for(let t of Object.values(touches)){var idx32=idx>>2;HEAP32[idx32+0]=t.identifier;HEAP32[idx32+1]=t.screenX;HEAP32[idx32+2]=t.screenY;HEAP32[idx32+3]=t.clientX;HEAP32[idx32+4]=t.clientY;HEAP32[idx32+5]=t.pageX;HEAP32[idx32+6]=t.pageY;HEAP8[idx+28]=t.isChanged;HEAP8[idx+29]=t.onTarget;HEAP32[idx32+8]=t.clientX-(targetRect.left|0);HEAP32[idx32+9]=t.clientY-(targetRect.top|0);idx+=48;if(++numTouches>31){break}}HEAP32[touchEvent+8>>2]=numTouches;if(((a1,a2,a3)=>dynCall_iiii(callbackfunc,a1,a2,a3))(eventTypeId,touchEvent,userData))e.preventDefault()};var eventHandler={target,allowsDeferredCalls:eventTypeString=="touchstart"||eventTypeString=="touchend",eventTypeString,eventTypeId,userData,callbackfunc,handlerFunc:touchEventHandlerFunc,useCapture};return JSEvents.registerOrRemoveHandler(eventHandler)};var _emscripten_set_touchcancel_callback_on_thread=(target,userData,useCapture,callbackfunc,targetThread)=>registerTouchEventCallback(target,userData,useCapture,callbackfunc,25,"touchcancel",targetThread);var _emscripten_set_touchend_callback_on_thread=(target,userData,useCapture,callbackfunc,targetThread)=>registerTouchEventCallback(target,userData,useCapture,callbackfunc,23,"touchend",targetThread);var _emscripten_set_touchmove_callback_on_thread=(target,userData,useCapture,callbackfunc,targetThread)=>registerTouchEventCallback(target,userData,useCapture,callbackfunc,24,"touchmove",targetThread);var _emscripten_set_touchstart_callback_on_thread=(target,userData,useCapture,callbackfunc,targetThread)=>registerTouchEventCallback(target,userData,useCapture,callbackfunc,22,"touchstart",targetThread);var fillVisibilityChangeEventData=eventStruct=>{var visibilityStates=["hidden","visible","prerender","unloaded"];var visibilityState=visibilityStates.indexOf(document.visibilityState);HEAP8[eventStruct]=document.hidden;HEAP32[eventStruct+4>>2]=visibilityState};var registerVisibilityChangeEventCallback=(target,userData,useCapture,callbackfunc,eventTypeId,eventTypeString,targetThread)=>{var eventSize=8;JSEvents.visibilityChangeEvent||=_malloc(eventSize);var visibilityChangeEventHandlerFunc=e=>{var visibilityChangeEvent=JSEvents.visibilityChangeEvent;fillVisibilityChangeEventData(visibilityChangeEvent);if(((a1,a2,a3)=>dynCall_iiii(callbackfunc,a1,a2,a3))(eventTypeId,visibilityChangeEvent,userData))e.preventDefault()};var eventHandler={target,eventTypeString,eventTypeId,userData,callbackfunc,handlerFunc:visibilityChangeEventHandlerFunc,useCapture};return JSEvents.registerOrRemoveHandler(eventHandler)};var _emscripten_set_visibilitychange_callback_on_thread=(userData,useCapture,callbackfunc,targetThread)=>{if(!specialHTMLTargets[1]){return-4}return registerVisibilityChangeEventCallback(specialHTMLTargets[1],userData,useCapture,callbackfunc,21,"visibilitychange",targetThread)};var safeSetTimeout=(func,timeout)=>setTimeout(()=>{callUserCallback(func)},timeout);var Browser={useWebGL:false,isFullscreen:false,pointerLock:false,moduleContextCreatedCallbacks:[],workers:[],preloadedImages:{},preloadedAudios:{},getCanvas:()=>Module["canvas"],init(){if(Browser.initted)return;Browser.initted=true;var imagePlugin={};imagePlugin["canHandle"]=name=>!Module["noImageDecoding"]&&/\.(jpg|jpeg|png|bmp|webp)$/i.test(name);imagePlugin["handle"]=async(byteArray,name)=>{var b=new Blob([byteArray],{type:Browser.getMimetype(name)});if(b.size!==byteArray.length){b=new Blob([new Uint8Array(byteArray).buffer],{type:Browser.getMimetype(name)})}var url=URL.createObjectURL(b);return new Promise((resolve,reject)=>{var img=new Image;img.onload=()=>{assert(img.complete,`Image ${name} could not be decoded`);var canvas=document.createElement("canvas");canvas.width=img.width;canvas.height=img.height;var ctx=canvas.getContext("2d");ctx.drawImage(img,0,0);Browser.preloadedImages[name]=canvas;URL.revokeObjectURL(url);resolve(byteArray)};img.onerror=event=>{err(`Image ${url} could not be decoded`);reject()};img.src=url})};preloadPlugins.push(imagePlugin);var audioPlugin={};audioPlugin["canHandle"]=name=>!Module["noAudioDecoding"]&&name.slice(-4)in{".ogg":1,".wav":1,".mp3":1};audioPlugin["handle"]=async(byteArray,name)=>new Promise((resolve,reject)=>{var done=false;function finish(audio){if(done)return;done=true;Browser.preloadedAudios[name]=audio;resolve(byteArray)}var b=new Blob([byteArray],{type:Browser.getMimetype(name)});var url=URL.createObjectURL(b);var audio=new Audio;audio.addEventListener("canplaythrough",()=>finish(audio),false);audio.onerror=event=>{if(done)return;err(`warning: browser could not fully decode audio ${name}, trying slower base64 approach`);function encode64(data){var BASE="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";var PAD="=";var ret="";var leftchar=0;var leftbits=0;for(var i=0;i<data.length;i++){leftchar=leftchar<<8|data[i];leftbits+=8;while(leftbits>=6){var curr=leftchar>>leftbits-6&63;leftbits-=6;ret+=BASE[curr]}}if(leftbits==2){ret+=BASE[(leftchar&3)<<4];ret+=PAD+PAD}else if(leftbits==4){ret+=BASE[(leftchar&15)<<2];ret+=PAD}return ret}audio.src="data:audio/x-"+name.slice(-3)+";base64,"+encode64(byteArray);finish(audio)};audio.src=url;safeSetTimeout(()=>{finish(audio)},1e4)});preloadPlugins.push(audioPlugin);function pointerLockChange(){var canvas=Browser.getCanvas();Browser.pointerLock=document.pointerLockElement===canvas}var canvas=Browser.getCanvas();if(canvas){document.addEventListener("pointerlockchange",pointerLockChange,false);if(Module["elementPointerLock"]){canvas.addEventListener("click",ev=>{if(!Browser.pointerLock&&Browser.getCanvas().requestPointerLock){Browser.getCanvas().requestPointerLock();ev.preventDefault()}},false)}}},createContext(canvas,useWebGL,setInModule,webGLContextAttributes){if(useWebGL&&Module["ctx"]&&canvas==Browser.getCanvas())return Module["ctx"];var ctx;var contextHandle;if(useWebGL){var contextAttributes={antialias:false,alpha:false,majorVersion:1};if(webGLContextAttributes){for(var attribute in webGLContextAttributes){contextAttributes[attribute]=webGLContextAttributes[attribute]}}if(typeof GL!="undefined"){contextHandle=GL.createContext(canvas,contextAttributes);if(contextHandle){ctx=GL.getContext(contextHandle).GLctx}}}else{ctx=canvas.getContext("2d")}if(!ctx)return null;if(setInModule){if(!useWebGL)assert(typeof GLctx=="undefined","cannot set in module if GLctx is used, but we are a non-GL context that would replace it");Module["ctx"]=ctx;if(useWebGL)GL.makeContextCurrent(contextHandle);Browser.useWebGL=useWebGL;Browser.moduleContextCreatedCallbacks.forEach(callback=>callback());Browser.init()}return ctx},fullscreenHandlersInstalled:false,lockPointer:undefined,resizeCanvas:undefined,requestFullscreen(lockPointer,resizeCanvas){Browser.lockPointer=lockPointer;Browser.resizeCanvas=resizeCanvas;if(typeof Browser.lockPointer=="undefined")Browser.lockPointer=true;if(typeof Browser.resizeCanvas=="undefined")Browser.resizeCanvas=false;var canvas=Browser.getCanvas();function fullscreenChange(){Browser.isFullscreen=false;var canvasContainer=canvas.parentNode;if(getFullscreenElement()===canvasContainer){canvas.exitFullscreen=Browser.exitFullscreen;if(Browser.lockPointer)canvas.requestPointerLock();Browser.isFullscreen=true;if(Browser.resizeCanvas){Browser.setFullscreenCanvasSize()}else{Browser.updateCanvasDimensions(canvas)}}else{canvasContainer.parentNode.insertBefore(canvas,canvasContainer);canvasContainer.parentNode.removeChild(canvasContainer);if(Browser.resizeCanvas){Browser.setWindowedCanvasSize()}else{Browser.updateCanvasDimensions(canvas)}}Module["onFullScreen"]?.(Browser.isFullscreen);Module["onFullscreen"]?.(Browser.isFullscreen)}if(!Browser.fullscreenHandlersInstalled){Browser.fullscreenHandlersInstalled=true;document.addEventListener("fullscreenchange",fullscreenChange,false);document.addEventListener("mozfullscreenchange",fullscreenChange,false);document.addEventListener("webkitfullscreenchange",fullscreenChange,false);document.addEventListener("MSFullscreenChange",fullscreenChange,false)}var canvasContainer=document.createElement("div");canvas.parentNode.insertBefore(canvasContainer,canvas);canvasContainer.appendChild(canvas);canvasContainer.requestFullscreen=canvasContainer["requestFullscreen"]||canvasContainer["mozRequestFullScreen"]||canvasContainer["msRequestFullscreen"]||(canvasContainer["webkitRequestFullscreen"]?()=>canvasContainer["webkitRequestFullscreen"](Element["ALLOW_KEYBOARD_INPUT"]):null)||(canvasContainer["webkitRequestFullScreen"]?()=>canvasContainer["webkitRequestFullScreen"](Element["ALLOW_KEYBOARD_INPUT"]):null);canvasContainer.requestFullscreen()},requestFullScreen(){abort("Module.requestFullScreen has been replaced by Module.requestFullscreen (without a capital S)")},exitFullscreen(){if(!Browser.isFullscreen){return false}var CFS=document["exitFullscreen"]||document["cancelFullScreen"]||document["mozCancelFullScreen"]||document["msExitFullscreen"]||document["webkitCancelFullScreen"]||(()=>{});CFS.apply(document,[]);return true},safeSetTimeout(func,timeout){return safeSetTimeout(func,timeout)},getMimetype(name){return{jpg:"image/jpeg",jpeg:"image/jpeg",png:"image/png",bmp:"image/bmp",ogg:"audio/ogg",wav:"audio/wav",mp3:"audio/mpeg"}[name.slice(name.lastIndexOf(".")+1)]},getUserMedia(func){window.getUserMedia||=navigator["getUserMedia"]||navigator["mozGetUserMedia"];window.getUserMedia(func)},getMovementX(event){return event["movementX"]||event["mozMovementX"]||event["webkitMovementX"]||0},getMovementY(event){return event["movementY"]||event["mozMovementY"]||event["webkitMovementY"]||0},getMouseWheelDelta(event){var delta=0;switch(event.type){case"DOMMouseScroll":delta=event.detail/3;break;case"mousewheel":delta=event.wheelDelta/120;break;case"wheel":delta=event.deltaY;switch(event.deltaMode){case 0:delta/=100;break;case 1:delta/=3;break;case 2:delta*=80;break;default:abort("unrecognized mouse wheel delta mode: "+event.deltaMode)}break;default:abort("unrecognized mouse wheel event: "+event.type)}return delta},mouseX:0,mouseY:0,mouseMovementX:0,mouseMovementY:0,touches:{},lastTouches:{},calculateMouseCoords(pageX,pageY){var canvas=Browser.getCanvas();var rect=canvas.getBoundingClientRect();var adjustedX=pageX-(window.scrollX+rect.left);var adjustedY=pageY-(window.scrollY+rect.top);adjustedX=adjustedX*(canvas.width/rect.width);adjustedY=adjustedY*(canvas.height/rect.height);return{x:adjustedX,y:adjustedY}},setMouseCoords(pageX,pageY){const{x,y}=Browser.calculateMouseCoords(pageX,pageY);Browser.mouseMovementX=x-Browser.mouseX;Browser.mouseMovementY=y-Browser.mouseY;Browser.mouseX=x;Browser.mouseY=y},calculateMouseEvent(event){if(Browser.pointerLock){if(event.type!="mousemove"&&"mozMovementX"in event){Browser.mouseMovementX=Browser.mouseMovementY=0}else{Browser.mouseMovementX=Browser.getMovementX(event);Browser.mouseMovementY=Browser.getMovementY(event)}Browser.mouseX+=Browser.mouseMovementX;Browser.mouseY+=Browser.mouseMovementY}else{if(event.type==="touchstart"||event.type==="touchend"||event.type==="touchmove"){var touch=event.touch;if(touch===undefined){return}var coords=Browser.calculateMouseCoords(touch.pageX,touch.pageY);if(event.type==="touchstart"){Browser.lastTouches[touch.identifier]=coords;Browser.touches[touch.identifier]=coords}else if(event.type==="touchend"||event.type==="touchmove"){var last=Browser.touches[touch.identifier];last||=coords;Browser.lastTouches[touch.identifier]=last;Browser.touches[touch.identifier]=coords}return}Browser.setMouseCoords(event.pageX,event.pageY)}},resizeListeners:[],updateResizeListeners(){var canvas=Browser.getCanvas();Browser.resizeListeners.forEach(listener=>listener(canvas.width,canvas.height))},setCanvasSize(width,height,noUpdates){var canvas=Browser.getCanvas();Browser.updateCanvasDimensions(canvas,width,height);if(!noUpdates)Browser.updateResizeListeners()},windowedWidth:0,windowedHeight:0,setFullscreenCanvasSize(){if(typeof SDL!="undefined"){var flags=HEAPU32[SDL.screen>>2];flags=flags|8388608;HEAP32[SDL.screen>>2]=flags}Browser.updateCanvasDimensions(Browser.getCanvas());Browser.updateResizeListeners()},setWindowedCanvasSize(){if(typeof SDL!="undefined"){var flags=HEAPU32[SDL.screen>>2];flags=flags&~8388608;HEAP32[SDL.screen>>2]=flags}Browser.updateCanvasDimensions(Browser.getCanvas());Browser.updateResizeListeners()},updateCanvasDimensions(canvas,wNative,hNative){if(wNative&&hNative){canvas.widthNative=wNative;canvas.heightNative=hNative}else{wNative=canvas.widthNative;hNative=canvas.heightNative}var w=wNative;var h=hNative;if(Module["forcedAspectRatio"]>0){if(w/h<Module["forcedAspectRatio"]){w=Math.round(h*Module["forcedAspectRatio"])}else{h=Math.round(w/Module["forcedAspectRatio"])}}if(getFullscreenElement()===canvas.parentNode&&typeof screen!="undefined"){var factor=Math.min(screen.width/w,screen.height/h);w=Math.round(w*factor);h=Math.round(h*factor)}if(Browser.resizeCanvas){if(canvas.width!=w)canvas.width=w;if(canvas.height!=h)canvas.height=h;if(typeof canvas.style!="undefined"){canvas.style.removeProperty("width");canvas.style.removeProperty("height")}}else{if(canvas.width!=wNative)canvas.width=wNative;if(canvas.height!=hNative)canvas.height=hNative;if(typeof canvas.style!="undefined"){if(w!=wNative||h!=hNative){canvas.style.setProperty("width",w+"px","important");canvas.style.setProperty("height",h+"px","important")}else{canvas.style.removeProperty("width");canvas.style.removeProperty("height")}}}}};var _emscripten_set_window_title=title=>document.title=UTF8ToString(title);class HandleAllocator{allocated=[undefined];freelist=[];get(id){assert(this.allocated[id]!==undefined,`invalid handle: ${id}`);return this.allocated[id]}has(id){return this.allocated[id]!==undefined}allocate(handle){var id=this.freelist.pop()||this.allocated.length;this.allocated[id]=handle;return id}free(id){assert(this.allocated[id]!==undefined);this.allocated[id]=undefined;this.freelist.push(id)}}var Fetch={async openDatabase(dbname,dbversion){return new Promise((resolve,reject)=>{try{var openRequest=indexedDB.open(dbname,dbversion)}catch(e){return reject(e)}openRequest.onupgradeneeded=event=>{var db=event.target.result;if(db.objectStoreNames.contains("FILES")){db.deleteObjectStore("FILES")}db.createObjectStore("FILES")};openRequest.onsuccess=event=>resolve(event.target.result);openRequest.onerror=reject})},async init(){Fetch.xhrs=new HandleAllocator;addRunDependency("library_fetch_init");try{var db=await Fetch.openDatabase("emscripten_filesystem",1);Fetch.dbInstance=db}catch(e){Fetch.dbInstance=false}finally{removeRunDependency("library_fetch_init")}}};function fetchXHR(fetch,onsuccess,onerror,onprogress,onreadystatechange){var url=HEAPU32[fetch+8>>2];if(!url){onerror(fetch,"no url specified!");return}var url_=UTF8ToString(url);var fetch_attr=fetch+108;var requestMethod=UTF8ToString(fetch_attr+0);requestMethod||="GET";var timeoutMsecs=HEAPU32[fetch_attr+56>>2];var userName=HEAPU32[fetch_attr+68>>2];var password=HEAPU32[fetch_attr+72>>2];var requestHeaders=HEAPU32[fetch_attr+76>>2];var overriddenMimeType=HEAPU32[fetch_attr+80>>2];var dataPtr=HEAPU32[fetch_attr+84>>2];var dataLength=HEAPU32[fetch_attr+88>>2];var fetchAttributes=HEAPU32[fetch_attr+52>>2];var fetchAttrLoadToMemory=!!(fetchAttributes&1);var fetchAttrStreamData=!!(fetchAttributes&2);var fetchAttrSynchronous=!!(fetchAttributes&64);var userNameStr=userName?UTF8ToString(userName):undefined;var passwordStr=password?UTF8ToString(password):undefined;var xhr=new XMLHttpRequest;xhr.withCredentials=!!HEAPU8[fetch_attr+60];xhr._streamData=fetchAttrStreamData;xhr.open(requestMethod,url_,!fetchAttrSynchronous,userNameStr,passwordStr);if(!fetchAttrSynchronous)xhr.timeout=timeoutMsecs;xhr.url_=url_;assert(!fetchAttrStreamData,"streaming is only supported when FETCH_STREAMING is enabled");xhr.responseType="arraybuffer";if(overriddenMimeType){var overriddenMimeTypeStr=UTF8ToString(overriddenMimeType);xhr.overrideMimeType(overriddenMimeTypeStr)}if(requestHeaders){for(;;){var key=HEAPU32[requestHeaders>>2];if(!key)break;var value=HEAPU32[requestHeaders+4>>2];if(!value)break;requestHeaders+=8;var keyStr=UTF8ToString(key);var valueStr=UTF8ToString(value);xhr.setRequestHeader(keyStr,valueStr)}}var id=Fetch.xhrs.allocate(xhr);HEAPU32[fetch>>2]=id;var data=dataPtr&&dataLength?HEAPU8.slice(dataPtr,dataPtr+dataLength):null;function saveResponseAndStatus(){var ptr=0;var ptrLen=0;if(xhr.response&&fetchAttrLoadToMemory&&HEAPU32[fetch+12>>2]===0){ptrLen=xhr.response.byteLength}if(ptrLen>0){ptr=_realloc(HEAPU32[fetch+12>>2],ptrLen);HEAPU8.set(new Uint8Array(xhr.response),ptr)}HEAPU32[fetch+12>>2]=ptr;writeI53ToI64(fetch+16,ptrLen);writeI53ToI64(fetch+24,0);var len=xhr.response?xhr.response.byteLength:0;if(len){writeI53ToI64(fetch+32,len)}HEAP16[fetch+40>>1]=xhr.readyState;HEAP16[fetch+42>>1]=xhr.status;if(xhr.statusText)stringToUTF8(xhr.statusText,fetch+44,64);if(fetchAttrSynchronous){var ruPtr=stringToNewUTF8(xhr.responseURL);HEAPU32[fetch+200>>2]=ruPtr}}xhr.onload=e=>{if(!Fetch.xhrs.has(id)){return}saveResponseAndStatus();if(xhr.status>=200&&xhr.status<300){if(fetchAttrStreamData){assert(xhr.response===null)}onsuccess(fetch,xhr,e)}else{onerror(fetch,e)}};xhr.onerror=e=>{if(!Fetch.xhrs.has(id)){return}saveResponseAndStatus();onerror(fetch,e)};xhr.ontimeout=e=>{if(!Fetch.xhrs.has(id)){return}onerror(fetch,e)};xhr.onprogress=e=>{if(!Fetch.xhrs.has(id)){return}var ptrLen=fetchAttrLoadToMemory&&fetchAttrStreamData&&xhr.response?xhr.response.byteLength:0;var ptr=0;if(ptrLen>0&&fetchAttrLoadToMemory&&fetchAttrStreamData){assert(onprogress,"streaming fetch requires an onprogress handler");ptr=_realloc(HEAPU32[fetch+12>>2],ptrLen);HEAPU8.set(new Uint8Array(xhr.response),ptr)}HEAPU32[fetch+12>>2]=ptr;writeI53ToI64(fetch+16,ptrLen);writeI53ToI64(fetch+24,e.loaded-ptrLen);writeI53ToI64(fetch+32,e.total);HEAP16[fetch+40>>1]=xhr.readyState;var status=xhr.status;if(xhr.readyState>=3&&xhr.status===0&&e.loaded>0)status=200;HEAP16[fetch+42>>1]=status;if(xhr.statusText)stringToUTF8(xhr.statusText,fetch+44,64);onprogress(fetch,e)};xhr.onreadystatechange=e=>{if(!Fetch.xhrs.has(id)){return}HEAP16[fetch+40>>1]=xhr.readyState;if(xhr.readyState>=2){HEAP16[fetch+42>>1]=xhr.status}if(!fetchAttrSynchronous&&(xhr.readyState===2&&xhr.responseURL.length>0)){var ruPtr=stringToNewUTF8(xhr.responseURL);HEAPU32[fetch+200>>2]=ruPtr}onreadystatechange(fetch,e)};try{xhr.send(data)}catch(e){onerror(fetch,e)}}function fetchCacheData(db,fetch,data,onsuccess,onerror){if(!db){onerror(fetch,0,"IndexedDB not available!");return}var fetch_attr=fetch+108;var destinationPath=HEAPU32[fetch_attr+64>>2];destinationPath||=HEAPU32[fetch+8>>2];var destinationPathStr=UTF8ToString(destinationPath);try{var transaction=db.transaction(["FILES"],"readwrite");var packages=transaction.objectStore("FILES");var putRequest=packages.put(data,destinationPathStr);putRequest.onsuccess=event=>{HEAP16[fetch+40>>1]=4;HEAP16[fetch+42>>1]=200;stringToUTF8("OK",fetch+44,64);onsuccess(fetch,0,destinationPathStr)};putRequest.onerror=error=>{HEAP16[fetch+40>>1]=4;HEAP16[fetch+42>>1]=413;stringToUTF8("Payload Too Large",fetch+44,64);onerror(fetch,0,error)}}catch(e){onerror(fetch,0,e)}}function fetchLoadCachedData(db,fetch,onsuccess,onerror){if(!db){onerror(fetch,0,"IndexedDB not available!");return}var fetch_attr=fetch+108;var path=HEAPU32[fetch_attr+64>>2];path||=HEAPU32[fetch+8>>2];var pathStr=UTF8ToString(path);try{var transaction=db.transaction(["FILES"],"readonly");var packages=transaction.objectStore("FILES");var getRequest=packages.get(pathStr);getRequest.onsuccess=event=>{if(event.target.result){var value=event.target.result;var len=value.byteLength||value.length;var ptr=_malloc(len);HEAPU8.set(new Uint8Array(value),ptr);HEAPU32[fetch+12>>2]=ptr;writeI53ToI64(fetch+16,len);writeI53ToI64(fetch+24,0);writeI53ToI64(fetch+32,len);HEAP16[fetch+40>>1]=4;HEAP16[fetch+42>>1]=200;stringToUTF8("OK",fetch+44,64);onsuccess(fetch,0,value)}else{HEAP16[fetch+40>>1]=4;HEAP16[fetch+42>>1]=404;stringToUTF8("Not Found",fetch+44,64);onerror(fetch,0,"no data")}};getRequest.onerror=error=>{HEAP16[fetch+40>>1]=4;HEAP16[fetch+42>>1]=404;stringToUTF8("Not Found",fetch+44,64);onerror(fetch,0,error)}}catch(e){onerror(fetch,0,e)}}function fetchDeleteCachedData(db,fetch,onsuccess,onerror){if(!db){onerror(fetch,0,"IndexedDB not available!");return}var fetch_attr=fetch+108;var path=HEAPU32[fetch_attr+64>>2];path||=HEAPU32[fetch+8>>2];var pathStr=UTF8ToString(path);try{var transaction=db.transaction(["FILES"],"readwrite");var packages=transaction.objectStore("FILES");var request=packages.delete(pathStr);request.onsuccess=event=>{var value=event.target.result;HEAPU32[fetch+12>>2]=0;writeI53ToI64(fetch+16,0);writeI53ToI64(fetch+24,0);writeI53ToI64(fetch+32,0);HEAP16[fetch+40>>1]=4;HEAP16[fetch+42>>1]=200;stringToUTF8("OK",fetch+44,64);onsuccess(fetch,0,value)};request.onerror=error=>{HEAP16[fetch+40>>1]=4;HEAP16[fetch+42>>1]=404;stringToUTF8("Not Found",fetch+44,64);onerror(fetch,0,error)}}catch(e){onerror(fetch,0,e)}}function _emscripten_start_fetch(fetch,successcb,errorcb,progresscb,readystatechangecb){var fetch_attr=fetch+108;var onsuccess=HEAPU32[fetch_attr+36>>2];var onerror=HEAPU32[fetch_attr+40>>2];var onprogress=HEAPU32[fetch_attr+44>>2];var onreadystatechange=HEAPU32[fetch_attr+48>>2];var fetchAttributes=HEAPU32[fetch_attr+52>>2];var fetchAttrSynchronous=!!(fetchAttributes&64);function doCallback(f){if(fetchAttrSynchronous){f()}else{callUserCallback(f)}}var reportSuccess=(fetch,xhr,e)=>{doCallback(()=>{if(onsuccess)(a1=>dynCall_vi(onsuccess,a1))(fetch);else successcb?.(fetch)})};var reportProgress=(fetch,e)=>{doCallback(()=>{if(onprogress)(a1=>dynCall_vi(onprogress,a1))(fetch);else progresscb?.(fetch)})};var reportError=(fetch,e)=>{doCallback(()=>{if(onerror)(a1=>dynCall_vi(onerror,a1))(fetch);else errorcb?.(fetch)})};var reportReadyStateChange=(fetch,e)=>{doCallback(()=>{if(onreadystatechange)(a1=>dynCall_vi(onreadystatechange,a1))(fetch);else readystatechangecb?.(fetch)})};var performUncachedXhr=(fetch,xhr,e)=>{fetchXHR(fetch,reportSuccess,reportError,reportProgress,reportReadyStateChange)};var cacheResultAndReportSuccess=(fetch,xhr,e)=>{var storeSuccess=(fetch,xhr,e)=>{doCallback(()=>{if(onsuccess)(a1=>dynCall_vi(onsuccess,a1))(fetch);else successcb?.(fetch)})};var storeError=(fetch,xhr,e)=>{doCallback(()=>{if(onsuccess)(a1=>dynCall_vi(onsuccess,a1))(fetch);else successcb?.(fetch)})};fetchCacheData(Fetch.dbInstance,fetch,xhr.response,storeSuccess,storeError)};var performCachedXhr=(fetch,xhr,e)=>{fetchXHR(fetch,cacheResultAndReportSuccess,reportError,reportProgress,reportReadyStateChange)};var requestMethod=UTF8ToString(fetch_attr+0);var fetchAttrReplace=!!(fetchAttributes&16);var fetchAttrPersistFile=!!(fetchAttributes&4);var fetchAttrNoDownload=!!(fetchAttributes&32);if(requestMethod==="EM_IDB_STORE"){var ptr=HEAPU32[fetch_attr+84>>2];var size=HEAPU32[fetch_attr+88>>2];fetchCacheData(Fetch.dbInstance,fetch,HEAPU8.slice(ptr,ptr+size),reportSuccess,reportError)}else if(requestMethod==="EM_IDB_DELETE"){fetchDeleteCachedData(Fetch.dbInstance,fetch,reportSuccess,reportError)}else if(!fetchAttrReplace){fetchLoadCachedData(Fetch.dbInstance,fetch,reportSuccess,fetchAttrNoDownload?reportError:fetchAttrPersistFile?performCachedXhr:performUncachedXhr)}else if(!fetchAttrNoDownload){fetchXHR(fetch,fetchAttrPersistFile?cacheResultAndReportSuccess:reportSuccess,reportError,reportProgress,reportReadyStateChange)}else{return 0}return fetch}var ENV={};var getExecutableName=()=>thisProgram||"./this.program";var getEnvStrings=()=>{if(!getEnvStrings.strings){var lang=(globalThis.navigator?.language??"C").replace("-","_")+".UTF-8";var env={USER:"web_user",LOGNAME:"web_user",PATH:"/",PWD:"/",HOME:"/home/web_user",LANG:lang,_:getExecutableName()};for(var x in ENV){if(ENV[x]===undefined)delete env[x];else env[x]=ENV[x]}var strings=[];for(var x in env){strings.push(`${x}=${env[x]}`)}getEnvStrings.strings=strings}return getEnvStrings.strings};var _environ_get=(__environ,environ_buf)=>{var bufSize=0;var envp=0;for(var string of getEnvStrings()){var ptr=environ_buf+bufSize;HEAPU32[__environ+envp>>2]=ptr;bufSize+=stringToUTF8(string,ptr,Infinity)+1;envp+=4}return 0};var _environ_sizes_get=(penviron_count,penviron_buf_size)=>{var strings=getEnvStrings();HEAPU32[penviron_count>>2]=strings.length;var bufSize=0;for(var string of strings){bufSize+=lengthBytesUTF8(string)+1}HEAPU32[penviron_buf_size>>2]=bufSize;return 0};function _fd_close(fd){try{var stream=SYSCALLS.getStreamFromFD(fd);FS.close(stream);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}var doReadv=(stream,iov,iovcnt,offset)=>{var ret=0;for(var i=0;i<iovcnt;i++){var ptr=HEAPU32[iov>>2];var len=HEAPU32[iov+4>>2];iov+=8;var curr=FS.read(stream,HEAP8,ptr,len,offset);if(curr<0)return-1;ret+=curr;if(curr<len)break;if(typeof offset!="undefined"){offset+=curr}}return ret};function _fd_read(fd,iov,iovcnt,pnum){try{var stream=SYSCALLS.getStreamFromFD(fd);var num=doReadv(stream,iov,iovcnt);HEAPU32[pnum>>2]=num;return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}function _fd_seek(fd,offset,whence,newOffset){offset=bigintToI53Checked(offset);try{if(isNaN(offset))return 22;var stream=SYSCALLS.getStreamFromFD(fd);FS.llseek(stream,offset,whence);HEAP64[newOffset>>3]=BigInt(stream.position);if(stream.getdents&&offset===0&&whence===0)stream.getdents=null;return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}var doWritev=(stream,iov,iovcnt,offset)=>{var ret=0;for(var i=0;i<iovcnt;i++){var ptr=HEAPU32[iov>>2];var len=HEAPU32[iov+4>>2];iov+=8;var curr=FS.write(stream,HEAP8,ptr,len,offset);if(curr<0)return-1;ret+=curr;if(curr<len){break}if(typeof offset!="undefined"){offset+=curr}}return ret};function _fd_write(fd,iov,iovcnt,pnum){try{var stream=SYSCALLS.getStreamFromFD(fd);var num=doWritev(stream,iov,iovcnt);HEAPU32[pnum>>2]=num;return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}var _glActiveTexture=_emscripten_glActiveTexture;var _glAttachShader=_emscripten_glAttachShader;var _glBindAttribLocation=_emscripten_glBindAttribLocation;var _glBindBuffer=_emscripten_glBindBuffer;var _glBindFramebuffer=_emscripten_glBindFramebuffer;var _glBindRenderbuffer=_emscripten_glBindRenderbuffer;var _glBindTexture=_emscripten_glBindTexture;var _glBlendFunc=_emscripten_glBlendFunc;var _glBufferData=_emscripten_glBufferData;var _glBufferSubData=_emscripten_glBufferSubData;var _glCheckFramebufferStatus=_emscripten_glCheckFramebufferStatus;var _glClear=_emscripten_glClear;var _glClearColor=_emscripten_glClearColor;var _glClearDepthf=_emscripten_glClearDepthf;var _glCompileShader=_emscripten_glCompileShader;var _glCompressedTexImage2D=_emscripten_glCompressedTexImage2D;var _glCreateProgram=_emscripten_glCreateProgram;var _glCreateShader=_emscripten_glCreateShader;var _glCullFace=_emscripten_glCullFace;var _glDeleteProgram=_emscripten_glDeleteProgram;var _glDeleteShader=_emscripten_glDeleteShader;var _glDepthFunc=_emscripten_glDepthFunc;var _glDisable=_emscripten_glDisable;var _glDrawArrays=_emscripten_glDrawArrays;var _glDrawElements=_emscripten_glDrawElements;var _glEnable=_emscripten_glEnable;var _glEnableVertexAttribArray=_emscripten_glEnableVertexAttribArray;var _glFramebufferRenderbuffer=_emscripten_glFramebufferRenderbuffer;var _glFramebufferTexture2D=_emscripten_glFramebufferTexture2D;var _glFrontFace=_emscripten_glFrontFace;var _glGenBuffers=_emscripten_glGenBuffers;var _glGenFramebuffers=_emscripten_glGenFramebuffers;var _glGenRenderbuffers=_emscripten_glGenRenderbuffers;var _glGenTextures=_emscripten_glGenTextures;var _glGetAttribLocation=_emscripten_glGetAttribLocation;var _glGetFloatv=_emscripten_glGetFloatv;var _glGetProgramInfoLog=_emscripten_glGetProgramInfoLog;var _glGetProgramiv=_emscripten_glGetProgramiv;var _glGetShaderInfoLog=_emscripten_glGetShaderInfoLog;var _glGetShaderiv=_emscripten_glGetShaderiv;var _glGetString=_emscripten_glGetString;var _glGetUniformLocation=_emscripten_glGetUniformLocation;var _glLinkProgram=_emscripten_glLinkProgram;var _glPixelStorei=_emscripten_glPixelStorei;var _glReadPixels=_emscripten_glReadPixels;var _glRenderbufferStorage=_emscripten_glRenderbufferStorage;var _glShaderSource=_emscripten_glShaderSource;var _glTexImage2D=_emscripten_glTexImage2D;var _glTexParameteri=_emscripten_glTexParameteri;var _glUniform1i=_emscripten_glUniform1i;var _glUniform4f=_emscripten_glUniform4f;var _glUniformMatrix4fv=_emscripten_glUniformMatrix4fv;var _glUseProgram=_emscripten_glUseProgram;var _glVertexAttribPointer=_emscripten_glVertexAttribPointer;var _glViewport=_emscripten_glViewport;function GLFW_Window(id,width,height,framebufferWidth,framebufferHeight,title,monitor,share){this.id=id;this.x=0;this.y=0;this.fullscreen=false;this.storedX=0;this.storedY=0;this.width=width;this.height=height;this.framebufferWidth=framebufferWidth;this.framebufferHeight=framebufferHeight;this.storedWidth=width;this.storedHeight=height;this.title=title;this.monitor=monitor;this.share=share;this.attributes={...GLFW.hints};this.inputModes={208897:212993,208898:0,208899:0};this.buttons=0;this.keys=new Array;this.domKeys=new Array;this.shouldClose=0;this.title=null;this.windowPosFunc=0;this.windowSizeFunc=0;this.windowCloseFunc=0;this.windowRefreshFunc=0;this.windowFocusFunc=0;this.windowIconifyFunc=0;this.windowMaximizeFunc=0;this.framebufferSizeFunc=0;this.windowContentScaleFunc=0;this.mouseButtonFunc=0;this.cursorPosFunc=0;this.cursorEnterFunc=0;this.scrollFunc=0;this.dropFunc=0;this.keyFunc=0;this.charFunc=0;this.userptr=0}var GLFW={WindowFromId:id=>{if(id<=0||!GLFW.windows)return null;return GLFW.windows[id-1]},joystickFunc:0,errorFunc:0,monitorFunc:0,active:null,scale:null,windows:null,monitors:null,monitorString:null,versionString:null,initialTime:null,extensions:null,devicePixelRatioMQL:null,hints:null,primaryTouchId:null,defaultHints:{131073:0,131074:0,131075:1,131076:1,131077:1,131082:0,135169:8,135170:8,135171:8,135172:8,135173:24,135174:8,135175:0,135176:0,135177:0,135178:0,135179:0,135180:0,135181:0,135182:0,135183:0,139265:196609,139266:1,139267:0,139268:0,139269:0,139270:0,139271:0,139272:0,139276:0},DOMToGLFWKeyCode:keycode=>{switch(keycode){case 32:return 32;case 222:return 39;case 188:return 44;case 173:return 45;case 189:return 45;case 190:return 46;case 191:return 47;case 48:return 48;case 49:return 49;case 50:return 50;case 51:return 51;case 52:return 52;case 53:return 53;case 54:return 54;case 55:return 55;case 56:return 56;case 57:return 57;case 59:return 59;case 61:return 61;case 187:return 61;case 65:return 65;case 66:return 66;case 67:return 67;case 68:return 68;case 69:return 69;case 70:return 70;case 71:return 71;case 72:return 72;case 73:return 73;case 74:return 74;case 75:return 75;case 76:return 76;case 77:return 77;case 78:return 78;case 79:return 79;case 80:return 80;case 81:return 81;case 82:return 82;case 83:return 83;case 84:return 84;case 85:return 85;case 86:return 86;case 87:return 87;case 88:return 88;case 89:return 89;case 90:return 90;case 219:return 91;case 220:return 92;case 221:return 93;case 192:return 96;case 27:return 256;case 13:return 257;case 9:return 258;case 8:return 259;case 45:return 260;case 46:return 261;case 39:return 262;case 37:return 263;case 40:return 264;case 38:return 265;case 33:return 266;case 34:return 267;case 36:return 268;case 35:return 269;case 20:return 280;case 145:return 281;case 144:return 282;case 44:return 283;case 19:return 284;case 112:return 290;case 113:return 291;case 114:return 292;case 115:return 293;case 116:return 294;case 117:return 295;case 118:return 296;case 119:return 297;case 120:return 298;case 121:return 299;case 122:return 300;case 123:return 301;case 124:return 302;case 125:return 303;case 126:return 304;case 127:return 305;case 128:return 306;case 129:return 307;case 130:return 308;case 131:return 309;case 132:return 310;case 133:return 311;case 134:return 312;case 135:return 313;case 136:return 314;case 96:return 320;case 97:return 321;case 98:return 322;case 99:return 323;case 100:return 324;case 101:return 325;case 102:return 326;case 103:return 327;case 104:return 328;case 105:return 329;case 110:return 330;case 111:return 331;case 106:return 332;case 109:return 333;case 107:return 334;case 16:return 340;case 17:return 341;case 18:return 342;case 91:return 343;case 224:return 343;case 93:return 348;default:return-1}},getModBits:win=>{var mod=0;if(win.keys[340])mod|=1;if(win.keys[341])mod|=2;if(win.keys[342])mod|=4;if(win.keys[343]||win.keys[348])mod|=8;return mod},onKeyPress:event=>{if(!GLFW.active||!GLFW.active.charFunc)return;if(event.ctrlKey||event.metaKey)return;var charCode=event.charCode;if(charCode==0||charCode>=0&&charCode<=31)return;((a1,a2)=>dynCall_vii(GLFW.active.charFunc,a1,a2))(GLFW.active.id,charCode)},onKeyChanged:(keyCode,status)=>{if(!GLFW.active)return;var key=GLFW.DOMToGLFWKeyCode(keyCode);if(key==-1)return;var repeat=status&&GLFW.active.keys[key];GLFW.active.keys[key]=status;GLFW.active.domKeys[keyCode]=status;if(GLFW.active.keyFunc){if(repeat)status=2;((a1,a2,a3,a4,a5)=>dynCall_viiiii(GLFW.active.keyFunc,a1,a2,a3,a4,a5))(GLFW.active.id,key,keyCode,status,GLFW.getModBits(GLFW.active))}},onGamepadConnected:event=>{GLFW.refreshJoysticks()},onGamepadDisconnected:event=>{GLFW.refreshJoysticks()},onKeydown:event=>{GLFW.onKeyChanged(event.keyCode,1);if(event.key=="Backspace"||event.key=="Tab"){event.preventDefault()}},onKeyup:event=>{GLFW.onKeyChanged(event.keyCode,0)},onBlur:event=>{if(!GLFW.active)return;for(var i=0;i<GLFW.active.domKeys.length;++i){if(GLFW.active.domKeys[i]){GLFW.onKeyChanged(i,0)}}},onMousemove:event=>{if(!GLFW.active)return;if(event.type==="touchmove"){event.preventDefault();let primaryChanged=false;for(let i of event.changedTouches){if(GLFW.primaryTouchId===i.identifier){Browser.setMouseCoords(i.pageX,i.pageY);primaryChanged=true;break}}if(!primaryChanged){return}}else{Browser.calculateMouseEvent(event)}if(event.target!=Browser.getCanvas()||!GLFW.active.cursorPosFunc)return;if(GLFW.active.cursorPosFunc){((a1,a2,a3)=>dynCall_vidd(GLFW.active.cursorPosFunc,a1,a2,a3))(GLFW.active.id,Browser.mouseX,Browser.mouseY)}},DOMToGLFWMouseButton:event=>{var eventButton=event["button"];if(eventButton>0){if(eventButton==1){eventButton=2}else{eventButton=1}}return eventButton},onMouseenter:event=>{if(!GLFW.active)return;if(event.target!=Browser.getCanvas())return;if(GLFW.active.cursorEnterFunc){((a1,a2)=>dynCall_vii(GLFW.active.cursorEnterFunc,a1,a2))(GLFW.active.id,1)}},onMouseleave:event=>{if(!GLFW.active)return;if(event.target!=Browser.getCanvas())return;if(GLFW.active.cursorEnterFunc){((a1,a2)=>dynCall_vii(GLFW.active.cursorEnterFunc,a1,a2))(GLFW.active.id,0)}},onMouseButtonChanged:(event,status)=>{if(!GLFW.active)return;if(event.target!=Browser.getCanvas())return;const isTouchType=event.type==="touchstart"||event.type==="touchend"||event.type==="touchcancel";let eventButton=0;if(isTouchType){event.preventDefault();let primaryChanged=false;if(GLFW.primaryTouchId===null&&event.type==="touchstart"&&event.targetTouches.length>0){const chosenTouch=event.targetTouches[0];GLFW.primaryTouchId=chosenTouch.identifier;Browser.setMouseCoords(chosenTouch.pageX,chosenTouch.pageY);primaryChanged=true}else if(event.type==="touchend"||event.type==="touchcancel"){for(let i of event.changedTouches){if(GLFW.primaryTouchId===i.identifier){GLFW.primaryTouchId=null;primaryChanged=true;break}}}if(!primaryChanged){return}}else{Browser.calculateMouseEvent(event);eventButton=GLFW.DOMToGLFWMouseButton(event)}if(status==1){GLFW.active.buttons|=1<<eventButton;try{event.target.setCapture()}catch(e){}}else{GLFW.active.buttons&=~(1<<eventButton)}if(GLFW.active.mouseButtonFunc){((a1,a2,a3,a4)=>dynCall_viiii(GLFW.active.mouseButtonFunc,a1,a2,a3,a4))(GLFW.active.id,eventButton,status,GLFW.getModBits(GLFW.active))}},onMouseButtonDown:event=>{if(!GLFW.active)return;GLFW.onMouseButtonChanged(event,1)},onMouseButtonUp:event=>{if(!GLFW.active)return;GLFW.onMouseButtonChanged(event,0)},onMouseWheel:event=>{var delta=-Browser.getMouseWheelDelta(event);delta=delta==0?0:delta>0?Math.max(delta,1):Math.min(delta,-1);GLFW.wheelPos+=delta;if(!GLFW.active||!GLFW.active.scrollFunc||event.target!=Browser.getCanvas())return;var sx=0;var sy=delta;if(event.type=="mousewheel"){sx=event.wheelDeltaX}else{sx=event.deltaX}((a1,a2,a3)=>dynCall_vidd(GLFW.active.scrollFunc,a1,a2,a3))(GLFW.active.id,sx,sy);event.preventDefault()},onCanvasResize:(width,height,framebufferWidth,framebufferHeight)=>{if(!GLFW.active)return;var resizeNeeded=false;if(getFullscreenElement()){if(!GLFW.active.fullscreen){resizeNeeded=width!=screen.width||height!=screen.height;GLFW.active.storedX=GLFW.active.x;GLFW.active.storedY=GLFW.active.y;GLFW.active.storedWidth=GLFW.active.width;GLFW.active.storedHeight=GLFW.active.height;GLFW.active.x=GLFW.active.y=0;GLFW.active.width=screen.width;GLFW.active.height=screen.height;GLFW.active.fullscreen=true}}else if(GLFW.active.fullscreen==true){resizeNeeded=width!=GLFW.active.storedWidth||height!=GLFW.active.storedHeight;GLFW.active.x=GLFW.active.storedX;GLFW.active.y=GLFW.active.storedY;GLFW.active.width=GLFW.active.storedWidth;GLFW.active.height=GLFW.active.storedHeight;GLFW.active.fullscreen=false}if(resizeNeeded){Browser.setCanvasSize(GLFW.active.width,GLFW.active.height)}else if(GLFW.active.width!=width||GLFW.active.height!=height||GLFW.active.framebufferWidth!=framebufferWidth||GLFW.active.framebufferHeight!=framebufferHeight){GLFW.active.width=width;GLFW.active.height=height;GLFW.active.framebufferWidth=framebufferWidth;GLFW.active.framebufferHeight=framebufferHeight;GLFW.onWindowSizeChanged();GLFW.onFramebufferSizeChanged()}},onWindowSizeChanged:()=>{if(!GLFW.active)return;if(GLFW.active.windowSizeFunc){((a1,a2,a3)=>dynCall_viii(GLFW.active.windowSizeFunc,a1,a2,a3))(GLFW.active.id,GLFW.active.width,GLFW.active.height)}},onFramebufferSizeChanged:()=>{if(!GLFW.active)return;if(GLFW.active.framebufferSizeFunc){((a1,a2,a3)=>dynCall_viii(GLFW.active.framebufferSizeFunc,a1,a2,a3))(GLFW.active.id,GLFW.active.framebufferWidth,GLFW.active.framebufferHeight)}},onWindowContentScaleChanged:scale=>{GLFW.scale=scale;if(!GLFW.active)return;if(GLFW.active.windowContentScaleFunc){((a1,a2,a3)=>dynCall_viff(GLFW.active.windowContentScaleFunc,a1,a2,a3))(GLFW.active.id,GLFW.scale,GLFW.scale)}},getTime:()=>_emscripten_get_now()/1e3,setWindowTitle:(winid,title)=>{var win=GLFW.WindowFromId(winid);if(!win)return;win.title=title;if(GLFW.active.id==win.id){_emscripten_set_window_title(title)}},setJoystickCallback:cbfun=>{var prevcbfun=GLFW.joystickFunc;GLFW.joystickFunc=cbfun;GLFW.refreshJoysticks();return prevcbfun},joys:{},lastGamepadState:[],lastGamepadStateFrame:null,refreshJoysticks:()=>{if(MainLoop.currentFrameNumber!==GLFW.lastGamepadStateFrame||!MainLoop.currentFrameNumber){GLFW.lastGamepadState=navigator.getGamepads?navigator.getGamepads():navigator.webkitGetGamepads||[];GLFW.lastGamepadStateFrame=MainLoop.currentFrameNumber;for(var joy=0;joy<GLFW.lastGamepadState.length;++joy){var gamepad=GLFW.lastGamepadState[joy];if(gamepad){if(!GLFW.joys[joy]){out("glfw joystick connected:",joy);GLFW.joys[joy]={id:stringToNewUTF8(gamepad.id),buttonsCount:gamepad.buttons.length,axesCount:gamepad.axes.length,buttons:_malloc(gamepad.buttons.length),axes:_malloc(gamepad.axes.length*4)};if(GLFW.joystickFunc){((a1,a2)=>dynCall_vii(GLFW.joystickFunc,a1,a2))(joy,262145)}}var data=GLFW.joys[joy];for(var i=0;i<gamepad.buttons.length;++i){HEAP8[data.buttons+i]=gamepad.buttons[i].pressed}for(var i=0;i<gamepad.axes.length;++i){HEAPF32[data.axes+i*4>>2]=gamepad.axes[i]}}else{if(GLFW.joys[joy]){out("glfw joystick disconnected",joy);if(GLFW.joystickFunc){((a1,a2)=>dynCall_vii(GLFW.joystickFunc,a1,a2))(joy,262146)}_free(GLFW.joys[joy].id);_free(GLFW.joys[joy].buttons);_free(GLFW.joys[joy].axes);delete GLFW.joys[joy]}}}}},setKeyCallback:(winid,cbfun)=>{var win=GLFW.WindowFromId(winid);if(!win)return null;var prevcbfun=win.keyFunc;win.keyFunc=cbfun;return prevcbfun},setCharCallback:(winid,cbfun)=>{var win=GLFW.WindowFromId(winid);if(!win)return null;var prevcbfun=win.charFunc;win.charFunc=cbfun;return prevcbfun},setMouseButtonCallback:(winid,cbfun)=>{var win=GLFW.WindowFromId(winid);if(!win)return null;var prevcbfun=win.mouseButtonFunc;win.mouseButtonFunc=cbfun;return prevcbfun},setCursorPosCallback:(winid,cbfun)=>{var win=GLFW.WindowFromId(winid);if(!win)return null;var prevcbfun=win.cursorPosFunc;win.cursorPosFunc=cbfun;return prevcbfun},setScrollCallback:(winid,cbfun)=>{var win=GLFW.WindowFromId(winid);if(!win)return null;var prevcbfun=win.scrollFunc;win.scrollFunc=cbfun;return prevcbfun},setDropCallback:(winid,cbfun)=>{var win=GLFW.WindowFromId(winid);if(!win)return null;var prevcbfun=win.dropFunc;win.dropFunc=cbfun;return prevcbfun},onDrop:event=>{if(!GLFW.active||!GLFW.active.dropFunc)return;if(!event.dataTransfer||!event.dataTransfer.files||event.dataTransfer.files.length==0)return;event.preventDefault();var drop_dir=".glfw_dropped_files";var filenames=_malloc(event.dataTransfer.files.length*4);var filenamesArray=[];for(var i=0;i<event.dataTransfer.files.length;++i){var path=`/${drop_dir}/${event.dataTransfer.files[i].name.replace(/\//g,"_")}`;var filename=stringToNewUTF8(path);filenamesArray.push(filename);HEAPU32[filenames+i*4>>2]=filename}var written=0;FS.createPath("/",drop_dir);function save(file,in_path,numfiles){var path="/"+drop_dir+in_path+"/"+file.name.replace(/\//g,"_");var reader=new FileReader;reader.onloadend=e=>{if(reader.readyState!=2){++written;err(`failed to read dropped file: ${in_path}/${file.name}: ${reader.error}`);return}var data=e.target.result;FS.writeFile(path,new Uint8Array(data));if(++written===numfiles){((a1,a2,a3)=>dynCall_viii(GLFW.active.dropFunc,a1,a2,a3))(GLFW.active.id,filenamesArray.length,filenames);for(var i=0;i<filenamesArray.length;++i){_free(filenamesArray[i])}_free(filenames)}};reader.readAsArrayBuffer(file)}let filesQ=[];function finalize(){var count=filesQ.length;for(var i=0;i<count;++i){save(filesQ[i].file,filesQ[i].path,count)}}if(DataTransferItem.prototype.webkitGetAsEntry){let entriesTree={};function markDone(fullpath,recursive){if(entriesTree[fullpath].subpaths.length!=0)return;delete entriesTree[fullpath];let parentpath=fullpath.substring(0,fullpath.lastIndexOf("/"));if(!entriesTree.hasOwnProperty(parentpath)){if(Object.keys(entriesTree).length==0)finalize();return}const fpIndex=entriesTree[parentpath].subpaths.indexOf(fullpath);if(fpIndex>-1)entriesTree[parentpath].subpaths.splice(fpIndex,1);if(recursive)markDone(parentpath,true);if(Object.keys(entriesTree).length==0)finalize()}function processEntry(entry){let fp=entry.fullPath;let pp=fp.substring(0,fp.lastIndexOf("/"));entriesTree[fp]={subpaths:[]};if(entry.isFile){entry.file(f=>{filesQ.push({file:f,path:pp});markDone(fp,false)})}else if(entry.isDirectory){if(entriesTree.hasOwnProperty(pp))entriesTree[pp].subpaths.push(fp);FS.createPath("/"+drop_dir+pp,entry.name);var reader=entry.createReader();var rRead=function(dirEntries){if(dirEntries.length==0){markDone(fp,true);return}for(const ent of dirEntries)processEntry(ent);reader.readEntries(rRead)};reader.readEntries(rRead)}}for(const item of event.dataTransfer.items){processEntry(item.webkitGetAsEntry())}}else{for(const file of event.dataTransfer.files){filesQ.push({file,path:""})}finalize()}return false},onDragover:event=>{if(!GLFW.active||!GLFW.active.dropFunc)return;event.preventDefault();return false},setWindowSizeCallback:(winid,cbfun)=>{var win=GLFW.WindowFromId(winid);if(!win)return null;var prevcbfun=win.windowSizeFunc;win.windowSizeFunc=cbfun;return prevcbfun},setWindowCloseCallback:(winid,cbfun)=>{var win=GLFW.WindowFromId(winid);if(!win)return null;var prevcbfun=win.windowCloseFunc;win.windowCloseFunc=cbfun;return prevcbfun},setWindowRefreshCallback:(winid,cbfun)=>{var win=GLFW.WindowFromId(winid);if(!win)return null;var prevcbfun=win.windowRefreshFunc;win.windowRefreshFunc=cbfun;return prevcbfun},onClickRequestPointerLock:e=>{var canvas=Browser.getCanvas();if(!Browser.pointerLock&&canvas.requestPointerLock){canvas.requestPointerLock();e.preventDefault()}},setInputMode:(winid,mode,value)=>{var win=GLFW.WindowFromId(winid);if(!win)return;switch(mode){case 208897:{var canvas=Browser.getCanvas();switch(value){case 212993:{win.inputModes[mode]=value;canvas.removeEventListener("click",GLFW.onClickRequestPointerLock,true);document.exitPointerLock();break}case 212994:{err("glfwSetInputMode called with GLFW_CURSOR_HIDDEN value not implemented");break}case 212995:{win.inputModes[mode]=value;canvas.addEventListener("click",GLFW.onClickRequestPointerLock,true);canvas.requestPointerLock();break}default:{err(`glfwSetInputMode called with unknown value parameter value: ${value}`);break}}break}case 208898:{err("glfwSetInputMode called with GLFW_STICKY_KEYS mode not implemented");break}case 208899:{err("glfwSetInputMode called with GLFW_STICKY_MOUSE_BUTTONS mode not implemented");break}case 208900:{err("glfwSetInputMode called with GLFW_LOCK_KEY_MODS mode not implemented");break}case 208901:{err("glfwSetInputMode called with GLFW_RAW_MOUSE_MOTION mode not implemented");break}default:{err(`glfwSetInputMode called with unknown mode parameter value: ${mode}`);break}}},getKey:(winid,key)=>{var win=GLFW.WindowFromId(winid);if(!win)return 0;return win.keys[key]},getMouseButton:(winid,button)=>{var win=GLFW.WindowFromId(winid);if(!win)return 0;return(win.buttons&1<<button)>0},getCursorPos:(winid,x,y)=>{HEAPF64[x>>3]=Browser.mouseX;HEAPF64[y>>3]=Browser.mouseY},getMousePos:(winid,x,y)=>{HEAP32[x>>2]=Browser.mouseX;HEAP32[y>>2]=Browser.mouseY},setCursorPos:(winid,x,y)=>{},getWindowPos:(winid,x,y)=>{var wx=0;var wy=0;var win=GLFW.WindowFromId(winid);if(win){wx=win.x;wy=win.y}if(x){HEAP32[x>>2]=wx}if(y){HEAP32[y>>2]=wy}},setWindowPos:(winid,x,y)=>{var win=GLFW.WindowFromId(winid);if(!win)return;win.x=x;win.y=y},getWindowSize:(winid,width,height)=>{var ww=0;var wh=0;var win=GLFW.WindowFromId(winid);if(win){ww=win.width;wh=win.height}if(width){HEAP32[width>>2]=ww}if(height){HEAP32[height>>2]=wh}},setWindowSize:(winid,width,height)=>{var win=GLFW.WindowFromId(winid);if(!win)return;if(GLFW.active.id==win.id){Browser.setCanvasSize(width,height)}},defaultWindowHints:()=>{GLFW.hints={...GLFW.defaultHints}},createWindow:(width,height,title,monitor,share)=>{var i,id;for(i=0;i<GLFW.windows.length&&GLFW.windows[i]!==null;i++){}if(i>0)abort("glfwCreateWindow only supports one window at time currently");id=i+1;if(width<=0||height<=0)return 0;if(monitor){Browser.requestFullscreen()}else{Browser.setCanvasSize(width,height)}for(i=0;i<GLFW.windows.length&&GLFW.windows[i]==null;i++){}const canvas=Browser.getCanvas();var useWebGL=GLFW.hints[139265]>0;if(i==GLFW.windows.length){if(useWebGL){var contextAttributes={antialias:GLFW.hints[135181]>1,depth:GLFW.hints[135173]>0,stencil:GLFW.hints[135174]>0,alpha:GLFW.hints[135172]>0};Browser.createContext(canvas,true,true,contextAttributes)}else{Browser.init()}}if(!Module["ctx"]&&useWebGL)return 0;var win=new GLFW_Window(id,width,height,canvas.width,canvas.height,title,monitor,share);if(id-1==GLFW.windows.length){GLFW.windows.push(win)}else{GLFW.windows[id-1]=win}GLFW.active=win;GLFW.adjustCanvasDimensions();return win.id},destroyWindow:winid=>{var win=GLFW.WindowFromId(winid);if(!win)return;if(win.windowCloseFunc){(a1=>dynCall_vi(win.windowCloseFunc,a1))(win.id)}GLFW.windows[win.id-1]=null;if(GLFW.active.id==win.id){GLFW.active=null}for(win of GLFW.windows){if(win!==null)return}delete Module["ctx"]},swapBuffers:winid=>{},requestFullscreen(lockPointer,resizeCanvas){Browser.lockPointer=lockPointer;Browser.resizeCanvas=resizeCanvas;if(typeof Browser.lockPointer=="undefined")Browser.lockPointer=true;if(typeof Browser.resizeCanvas=="undefined")Browser.resizeCanvas=false;var canvas=Browser.getCanvas();function fullscreenChange(){Browser.isFullscreen=false;var canvasContainer=canvas.parentNode;if(getFullscreenElement()===canvasContainer){canvas.exitFullscreen=Browser.exitFullscreen;if(Browser.lockPointer)canvas.requestPointerLock();Browser.isFullscreen=true;if(Browser.resizeCanvas){Browser.setFullscreenCanvasSize()}else{Browser.updateCanvasDimensions(canvas);Browser.updateResizeListeners()}}else{canvasContainer.parentNode.insertBefore(canvas,canvasContainer);canvasContainer.parentNode.removeChild(canvasContainer);if(Browser.resizeCanvas){Browser.setWindowedCanvasSize()}else{Browser.updateCanvasDimensions(canvas);Browser.updateResizeListeners()}}Module["onFullScreen"]?.(Browser.isFullscreen);Module["onFullscreen"]?.(Browser.isFullscreen)}if(!Browser.fullscreenHandlersInstalled){Browser.fullscreenHandlersInstalled=true;document.addEventListener("fullscreenchange",fullscreenChange,false);document.addEventListener("mozfullscreenchange",fullscreenChange,false);document.addEventListener("webkitfullscreenchange",fullscreenChange,false);document.addEventListener("MSFullscreenChange",fullscreenChange,false)}var canvasContainer=document.createElement("div");canvas.parentNode.insertBefore(canvasContainer,canvas);canvasContainer.appendChild(canvas);canvasContainer.requestFullscreen=canvasContainer["requestFullscreen"]||canvasContainer["mozRequestFullScreen"]||canvasContainer["msRequestFullscreen"]||(canvasContainer["webkitRequestFullscreen"]?()=>canvasContainer["webkitRequestFullscreen"](Element["ALLOW_KEYBOARD_INPUT"]):null)||(canvasContainer["webkitRequestFullScreen"]?()=>canvasContainer["webkitRequestFullScreen"](Element["ALLOW_KEYBOARD_INPUT"]):null);canvasContainer.requestFullscreen()},updateCanvasDimensions(canvas,wNative,hNative){const scale=GLFW.getHiDPIScale();if(wNative&&hNative){canvas.widthNative=wNative;canvas.heightNative=hNative}else{wNative=canvas.widthNative;hNative=canvas.heightNative}var w=wNative;var h=hNative;if(Module["forcedAspectRatio"]&&Module["forcedAspectRatio"]>0){if(w/h<Module["forcedAspectRatio"]){w=Math.round(h*Module["forcedAspectRatio"])}else{h=Math.round(w/Module["forcedAspectRatio"])}}if(getFullscreenElement()===canvas.parentNode&&typeof screen!="undefined"){var factor=Math.min(screen.width/w,screen.height/h);w=Math.round(w*factor);h=Math.round(h*factor)}if(Browser.resizeCanvas){wNative=w;hNative=h}const wNativeScaled=Math.floor(wNative*scale);const hNativeScaled=Math.floor(hNative*scale);if(canvas.width!=wNativeScaled)canvas.width=wNativeScaled;if(canvas.height!=hNativeScaled)canvas.height=hNativeScaled;if(typeof canvas.style!="undefined"){if(!GLFW.isCSSScalingEnabled()){canvas.style.setProperty("width",wNative+"px","important");canvas.style.setProperty("height",hNative+"px","important")}else{canvas.style.removeProperty("width");canvas.style.removeProperty("height")}}},calculateMouseCoords(pageX,pageY){const rect=Browser.getCanvas().getBoundingClientRect();var adjustedX=pageX-(window.scrollX+rect.left);var adjustedY=pageY-(window.scrollY+rect.top);if(GLFW.isCSSScalingEnabled()&&GLFW.active){adjustedX=adjustedX*(GLFW.active.width/rect.width);adjustedY=adjustedY*(GLFW.active.height/rect.height)}return{x:adjustedX,y:adjustedY}},setWindowAttrib:(winid,attrib,value)=>{var win=GLFW.WindowFromId(winid);if(!win)return;const isHiDPIAware=GLFW.isHiDPIAware();win.attributes[attrib]=value;if(isHiDPIAware!==GLFW.isHiDPIAware())GLFW.adjustCanvasDimensions()},getDevicePixelRatio(){return typeof devicePixelRatio=="number"&&devicePixelRatio||1},isHiDPIAware(){if(GLFW.active)return GLFW.active.attributes[139276]>0;else return false},isCSSScalingEnabled(){return!GLFW.isHiDPIAware()},adjustCanvasDimensions(){if(GLFW.active){Browser.updateCanvasDimensions(Browser.getCanvas(),GLFW.active.width,GLFW.active.height);Browser.updateResizeListeners()}},getHiDPIScale(){return GLFW.isHiDPIAware()?GLFW.scale:1},onDevicePixelRatioChange(){GLFW.onWindowContentScaleChanged(GLFW.getDevicePixelRatio());GLFW.adjustCanvasDimensions()},GLFW2ParamToGLFW3Param:param=>{var table={196609:0,196610:0,196611:0,196612:0,196613:0,196614:0,131073:0,131074:0,131075:0,131076:0,131077:135169,131078:135170,131079:135171,131080:135172,131081:135173,131082:135174,131083:135183,131084:135175,131085:135176,131086:135177,131087:135178,131088:135179,131089:135180,131090:0,131091:135181,131092:139266,131093:139267,131094:139270,131095:139271,131096:139272};return table[param]}};var _glfwCreateWindow=(width,height,title,monitor,share)=>GLFW.createWindow(width,height,title,monitor,share);var _glfwDefaultWindowHints=()=>GLFW.defaultWindowHints();var _glfwGetPrimaryMonitor=()=>1;var _glfwGetTime=()=>GLFW.getTime()-GLFW.initialTime;var _glfwGetVideoModes=(monitor,count)=>{HEAP32[count>>2]=0;return 0};var _glfwInit=()=>{if(GLFW.windows)return 1;GLFW.initialTime=GLFW.getTime();GLFW.defaultWindowHints();GLFW.windows=new Array;GLFW.active=null;GLFW.scale=GLFW.getDevicePixelRatio();window.addEventListener("gamepadconnected",GLFW.onGamepadConnected,true);window.addEventListener("gamepaddisconnected",GLFW.onGamepadDisconnected,true);window.addEventListener("keydown",GLFW.onKeydown,true);window.addEventListener("keypress",GLFW.onKeyPress,true);window.addEventListener("keyup",GLFW.onKeyup,true);window.addEventListener("blur",GLFW.onBlur,true);GLFW.devicePixelRatioMQL=window.matchMedia("(resolution: "+GLFW.getDevicePixelRatio()+"dppx)");GLFW.devicePixelRatioMQL.addEventListener("change",GLFW.onDevicePixelRatioChange);var canvas=Browser.getCanvas();canvas.addEventListener("touchmove",GLFW.onMousemove,true);canvas.addEventListener("touchstart",GLFW.onMouseButtonDown,true);canvas.addEventListener("touchcancel",GLFW.onMouseButtonUp,true);canvas.addEventListener("touchend",GLFW.onMouseButtonUp,true);canvas.addEventListener("mousemove",GLFW.onMousemove,true);canvas.addEventListener("mousedown",GLFW.onMouseButtonDown,true);canvas.addEventListener("mouseup",GLFW.onMouseButtonUp,true);canvas.addEventListener("wheel",GLFW.onMouseWheel,true);canvas.addEventListener("mousewheel",GLFW.onMouseWheel,true);canvas.addEventListener("mouseenter",GLFW.onMouseenter,true);canvas.addEventListener("mouseleave",GLFW.onMouseleave,true);canvas.addEventListener("drop",GLFW.onDrop,true);canvas.addEventListener("dragover",GLFW.onDragover,true);Browser.requestFullscreen=GLFW.requestFullscreen;Browser.calculateMouseCoords=GLFW.calculateMouseCoords;Browser.updateCanvasDimensions=GLFW.updateCanvasDimensions;Browser.resizeListeners.push((width,height)=>{if(GLFW.isHiDPIAware()){var canvas=Browser.getCanvas();GLFW.onCanvasResize(canvas.clientWidth,canvas.clientHeight,width,height)}else{GLFW.onCanvasResize(width,height,width,height)}});return 1};var _glfwMakeContextCurrent=winid=>0;var _glfwSetCharCallback=(winid,cbfun)=>GLFW.setCharCallback(winid,cbfun);var _glfwSetCursorEnterCallback=(winid,cbfun)=>{var win=GLFW.WindowFromId(winid);if(!win)return null;var prevcbfun=win.cursorEnterFunc;win.cursorEnterFunc=cbfun;return prevcbfun};var _glfwSetCursorPosCallback=(winid,cbfun)=>GLFW.setCursorPosCallback(winid,cbfun);var _glfwSetDropCallback=(winid,cbfun)=>GLFW.setDropCallback(winid,cbfun);var _glfwSetErrorCallback=cbfun=>{var prevcbfun=GLFW.errorFunc;GLFW.errorFunc=cbfun;return prevcbfun};var _glfwSetKeyCallback=(winid,cbfun)=>GLFW.setKeyCallback(winid,cbfun);var _glfwSetMouseButtonCallback=(winid,cbfun)=>GLFW.setMouseButtonCallback(winid,cbfun);var _glfwSetScrollCallback=(winid,cbfun)=>GLFW.setScrollCallback(winid,cbfun);var _glfwSetWindowContentScaleCallback=(winid,cbfun)=>{var win=GLFW.WindowFromId(winid);if(!win)return null;var prevcbfun=win.windowContentScaleFunc;win.windowContentScaleFunc=cbfun;return prevcbfun};var _glfwSetWindowFocusCallback=(winid,cbfun)=>{var win=GLFW.WindowFromId(winid);if(!win)return null;var prevcbfun=win.windowFocusFunc;win.windowFocusFunc=cbfun;return prevcbfun};var _glfwSetWindowIconifyCallback=(winid,cbfun)=>{var win=GLFW.WindowFromId(winid);if(!win)return null;var prevcbfun=win.windowIconifyFunc;win.windowIconifyFunc=cbfun;return prevcbfun};var _glfwSetWindowShouldClose=(winid,value)=>{var win=GLFW.WindowFromId(winid);if(!win)return;win.shouldClose=value};var _glfwSetWindowSize=(winid,width,height)=>GLFW.setWindowSize(winid,width,height);var _glfwSetWindowSizeCallback=(winid,cbfun)=>GLFW.setWindowSizeCallback(winid,cbfun);var _glfwSwapBuffers=winid=>GLFW.swapBuffers(winid);var _glfwTerminate=()=>{window.removeEventListener("gamepadconnected",GLFW.onGamepadConnected,true);window.removeEventListener("gamepaddisconnected",GLFW.onGamepadDisconnected,true);window.removeEventListener("keydown",GLFW.onKeydown,true);window.removeEventListener("keypress",GLFW.onKeyPress,true);window.removeEventListener("keyup",GLFW.onKeyup,true);window.removeEventListener("blur",GLFW.onBlur,true);var canvas=Browser.getCanvas();canvas.removeEventListener("touchmove",GLFW.onMousemove,true);canvas.removeEventListener("touchstart",GLFW.onMouseButtonDown,true);canvas.removeEventListener("touchcancel",GLFW.onMouseButtonUp,true);canvas.removeEventListener("touchend",GLFW.onMouseButtonUp,true);canvas.removeEventListener("mousemove",GLFW.onMousemove,true);canvas.removeEventListener("mousedown",GLFW.onMouseButtonDown,true);canvas.removeEventListener("mouseup",GLFW.onMouseButtonUp,true);canvas.removeEventListener("wheel",GLFW.onMouseWheel,true);canvas.removeEventListener("mousewheel",GLFW.onMouseWheel,true);canvas.removeEventListener("mouseenter",GLFW.onMouseenter,true);canvas.removeEventListener("mouseleave",GLFW.onMouseleave,true);canvas.removeEventListener("drop",GLFW.onDrop,true);canvas.removeEventListener("dragover",GLFW.onDragover,true);if(GLFW.devicePixelRatioMQL)GLFW.devicePixelRatioMQL.removeEventListener("change",GLFW.onDevicePixelRatioChange);canvas.width=canvas.height=1;GLFW.windows=null;GLFW.active=null};var _glfwWindowHint=(target,hint)=>{GLFW.hints[target]=hint};var _random_get=(buffer,size)=>randomFill(HEAPU8.subarray(buffer,buffer+size));var runAndAbortIfError=func=>{try{return func()}catch(e){abort(e)}};var createNamedFunction=(name,func)=>Object.defineProperty(func,"name",{value:name});var Asyncify={instrumentWasmImports(imports){var importPattern=/^(invoke_.*|__asyncjs__.*)$/;for(let[x,original]of Object.entries(imports)){if(typeof original=="function"){let isAsyncifyImport=original.isAsync||importPattern.test(x);imports[x]=(...args)=>{var originalAsyncifyState=Asyncify.state;try{return original(...args)}finally{var changedToDisabled=originalAsyncifyState===Asyncify.State.Normal&&Asyncify.state===Asyncify.State.Disabled;var ignoredInvoke=x.startsWith("invoke_")&&true;if(Asyncify.state!==originalAsyncifyState&&!isAsyncifyImport&&!changedToDisabled&&!ignoredInvoke){abort(`import ${x} was not in ASYNCIFY_IMPORTS, but changed the state`)}}}}}},instrumentFunction(original){var wrapper=(...args)=>{Asyncify.exportCallStack.push(original);try{return original(...args)}finally{if(!ABORT){var top=Asyncify.exportCallStack.pop();assert(top===original);Asyncify.maybeStopUnwind()}}};Asyncify.funcWrappers.set(original,wrapper);wrapper=createNamedFunction(`__asyncify_wrapper_${original.name}`,wrapper);return wrapper},instrumentWasmExports(exports){var ret={};for(let[x,original]of Object.entries(exports)){if(typeof original=="function"){var wrapper=Asyncify.instrumentFunction(original);ret[x]=wrapper}else{ret[x]=original}}return ret},State:{Normal:0,Unwinding:1,Rewinding:2,Disabled:3},state:0,StackSize:4096,currData:null,handleSleepReturnValue:0,exportCallStack:[],callstackFuncToId:new Map,callStackIdToFunc:new Map,funcWrappers:new Map,callStackId:0,asyncPromiseHandlers:null,sleepCallbacks:[],getCallStackId(func){assert(func);if(!Asyncify.callstackFuncToId.has(func)){var id=Asyncify.callStackId++;Asyncify.callstackFuncToId.set(func,id);Asyncify.callStackIdToFunc.set(id,func)}return Asyncify.callstackFuncToId.get(func)},maybeStopUnwind(){if(Asyncify.currData&&Asyncify.state===Asyncify.State.Unwinding&&Asyncify.exportCallStack.length===0){Asyncify.state=Asyncify.State.Normal;runAndAbortIfError(_asyncify_stop_unwind);if(typeof Fibers!="undefined"){Fibers.trampoline()}}},whenDone(){assert(Asyncify.currData,"tried to wait for an async operation when none is in progress");assert(!Asyncify.asyncPromiseHandlers,"cannot have multiple async operations in flight at once");return new Promise((resolve,reject)=>{Asyncify.asyncPromiseHandlers={resolve,reject}})},allocateData(){var ptr=_malloc(12+Asyncify.StackSize);Asyncify.setDataHeader(ptr,ptr+12,Asyncify.StackSize);Asyncify.setDataRewindFunc(ptr);return ptr},setDataHeader(ptr,stack,stackSize){HEAPU32[ptr>>2]=stack;HEAPU32[ptr+4>>2]=stack+stackSize},setDataRewindFunc(ptr){var bottomOfCallStack=Asyncify.exportCallStack[0];assert(bottomOfCallStack,"exportCallStack is empty");var rewindId=Asyncify.getCallStackId(bottomOfCallStack);HEAP32[ptr+8>>2]=rewindId},getDataRewindFunc(ptr){var id=HEAP32[ptr+8>>2];var func=Asyncify.callStackIdToFunc.get(id);assert(func,`id ${id} not found in callStackIdToFunc`);return func},doRewind(ptr){var original=Asyncify.getDataRewindFunc(ptr);var func=Asyncify.funcWrappers.get(original);assert(original);assert(func);return callUserCallback(func)},handleSleep(startAsync){assert(Asyncify.state!==Asyncify.State.Disabled,"handleSleep called after Asyncify was shut down");if(ABORT)return;if(Asyncify.state===Asyncify.State.Normal){var reachedCallback=false;var reachedAfterCallback=false;startAsync((handleSleepReturnValue=0)=>{assert(["undefined","number","boolean","bigint"].includes(typeof handleSleepReturnValue),`invalid type for handleSleepReturnValue: '${typeof handleSleepReturnValue}'`);if(ABORT)return;Asyncify.handleSleepReturnValue=handleSleepReturnValue;reachedCallback=true;if(!reachedAfterCallback){return}assert(!Asyncify.exportCallStack.length,"waking up (starting to rewind) must be done from JS, without compiled code on the stack");Asyncify.state=Asyncify.State.Rewinding;runAndAbortIfError(()=>_asyncify_start_rewind(Asyncify.currData));if(typeof MainLoop!="undefined"&&MainLoop.func){MainLoop.resume()}var asyncWasmReturnValue,isError=false;try{asyncWasmReturnValue=Asyncify.doRewind(Asyncify.currData)}catch(err){asyncWasmReturnValue=err;isError=true}var handled=false;if(!Asyncify.currData){var asyncPromiseHandlers=Asyncify.asyncPromiseHandlers;if(asyncPromiseHandlers){Asyncify.asyncPromiseHandlers=null;(isError?asyncPromiseHandlers.reject:asyncPromiseHandlers.resolve)(asyncWasmReturnValue);handled=true}}if(isError&&!handled){throw asyncWasmReturnValue}});reachedAfterCallback=true;if(!reachedCallback){Asyncify.state=Asyncify.State.Unwinding;Asyncify.currData=Asyncify.allocateData();if(typeof MainLoop!="undefined"&&MainLoop.func){MainLoop.pause()}runAndAbortIfError(()=>_asyncify_start_unwind(Asyncify.currData))}}else if(Asyncify.state===Asyncify.State.Rewinding){Asyncify.state=Asyncify.State.Normal;runAndAbortIfError(_asyncify_stop_rewind);_free(Asyncify.currData);Asyncify.currData=null;Asyncify.sleepCallbacks.forEach(callUserCallback)}else{abort(`invalid state: ${Asyncify.state}`)}return Asyncify.handleSleepReturnValue},handleAsync:startAsync=>Asyncify.handleSleep(async wakeUp=>{wakeUp(await startAsync())})};var requestFullscreen=Browser.requestFullscreen;var FS_createPath=(...args)=>FS.createPath(...args);var FS_unlink=(...args)=>FS.unlink(...args);var FS_createLazyFile=(...args)=>FS.createLazyFile(...args);var FS_createDevice=(...args)=>FS.createDevice(...args);FS.createPreloadedFile=FS_createPreloadedFile;FS.preloadFile=FS_preloadFile;FS.staticInit();for(let i=0;i<32;++i)tempFixedLengthArray.push(new Array(i));var miniTempWebGLFloatBuffersStorage=new Float32Array(288);for(var i=0;i<=288;++i){miniTempWebGLFloatBuffers[i]=miniTempWebGLFloatBuffersStorage.subarray(0,i)}var miniTempWebGLIntBuffersStorage=new Int32Array(288);for(var i=0;i<=288;++i){miniTempWebGLIntBuffers[i]=miniTempWebGLIntBuffersStorage.subarray(0,i)}Module["requestAnimationFrame"]=MainLoop.requestAnimationFrame;Module["pauseMainLoop"]=MainLoop.pause;Module["resumeMainLoop"]=MainLoop.resume;MainLoop.init();Fetch.init();{if(Module["noExitRuntime"])noExitRuntime=Module["noExitRuntime"];if(Module["preloadPlugins"])preloadPlugins=Module["preloadPlugins"];if(Module["print"])out=Module["print"];if(Module["printErr"])err=Module["printErr"];if(Module["wasmBinary"])wasmBinary=Module["wasmBinary"];checkIncomingModuleAPI();if(Module["arguments"])arguments_=Module["arguments"];if(Module["thisProgram"])thisProgram=Module["thisProgram"];assert(typeof Module["memoryInitializerPrefixURL"]=="undefined","Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead");assert(typeof Module["pthreadMainPrefixURL"]=="undefined","Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead");assert(typeof Module["cdInitializerPrefixURL"]=="undefined","Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead");assert(typeof Module["filePackagePrefixURL"]=="undefined","Module.filePackagePrefixURL option was removed, use Module.locateFile instead");assert(typeof Module["read"]=="undefined","Module.read option was removed");assert(typeof Module["readAsync"]=="undefined","Module.readAsync option was removed (modify readAsync in JS)");assert(typeof Module["readBinary"]=="undefined","Module.readBinary option was removed (modify readBinary in JS)");assert(typeof Module["setWindowTitle"]=="undefined","Module.setWindowTitle option was removed (modify emscripten_set_window_title in JS)");assert(typeof Module["TOTAL_MEMORY"]=="undefined","Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY");assert(typeof Module["ENVIRONMENT"]=="undefined","Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -sENVIRONMENT=web or -sENVIRONMENT=node)");assert(typeof Module["STACK_SIZE"]=="undefined","STACK_SIZE can no longer be set at runtime. Use -sSTACK_SIZE at link time");assert(typeof Module["wasmMemory"]=="undefined","Use of `wasmMemory` detected. Use -sIMPORTED_MEMORY to define wasmMemory externally");assert(typeof Module["INITIAL_MEMORY"]=="undefined","Detected runtime INITIAL_MEMORY setting. Use -sIMPORTED_MEMORY to define wasmMemory dynamically");if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].shift()()}}consumedModuleProp("preInit")}Module["addRunDependency"]=addRunDependency;Module["removeRunDependency"]=removeRunDependency;Module["requestFullscreen"]=requestFullscreen;Module["FS_preloadFile"]=FS_preloadFile;Module["FS_unlink"]=FS_unlink;Module["FS_createPath"]=FS_createPath;Module["FS_createDevice"]=FS_createDevice;Module["FS_createDataFile"]=FS_createDataFile;Module["FS_createLazyFile"]=FS_createLazyFile;var missingLibrarySymbols=["writeI53ToI64Clamped","writeI53ToI64Signaling","writeI53ToU64Clamped","writeI53ToU64Signaling","convertI32PairToI53","convertI32PairToI53Checked","convertU32PairToI53","stackAlloc","getTempRet0","setTempRet0","zeroMemory","withStackSave","inetPton4","inetNtop4","inetPton6","inetNtop6","readSockaddr","writeSockaddr","runMainThreadEmAsm","autoResumeAudioContext","getDynCaller","asmjsMangle","addOnInit","addOnPostCtor","addOnPreMain","STACK_SIZE","STACK_ALIGN","POINTER_SIZE","ASSERTIONS","ccall","cwrap","convertJsFunctionToWasm","getEmptyTableSlot","updateTableMap","getFunctionAddress","addFunction","removeFunction","intArrayToString","AsciiToString","stringToAscii","UTF16ToString","stringToUTF16","lengthBytesUTF16","UTF32ToString","stringToUTF32","lengthBytesUTF32","stringToUTF8OnStack","writeArrayToMemory","registerKeyEventCallback","registerWheelEventCallback","fillDeviceOrientationEventData","registerDeviceOrientationEventCallback","fillDeviceMotionEventData","registerDeviceMotionEventCallback","screenOrientation","fillOrientationChangeEventData","registerOrientationChangeEventCallback","JSEvents_requestFullscreen","JSEvents_resizeCanvasForFullscreen","registerRestoreOldStyle","hideEverythingExceptGivenElement","restoreHiddenElements","setLetterbox","softFullscreenResizeWebGLRenderTarget","doRequestFullscreen","registerPointerlockErrorEventCallback","requestPointerLock","registerBeforeUnloadEventCallback","fillBatteryEventData","registerBatteryEventCallback","setCanvasElementSize","getCanvasElementSize","jsStackTrace","getCallstack","convertPCtoSourceLocation","wasiRightsToMuslOFlags","wasiOFlagsToMuslOFlags","setImmediateWrapped","safeRequestAnimationFrame","clearImmediateWrapped","registerPostMainLoop","registerPreMainLoop","getPromise","makePromise","idsToPromises","makePromiseCallback","findMatchingCatch","incrementUncaughtExceptionCount","decrementUncaughtExceptionCount","Browser_asyncPrepareDataCounter","isLeapYear","ydayFromDate","arraySum","addDays","getSocketFromFD","getSocketAddress","FS_mkdirTree","_setNetworkCallback","writeGLArray","registerWebGlEventCallback","ALLOC_NORMAL","ALLOC_STACK","allocate","writeStringToMemory","writeAsciiToMemory","allocateUTF8","allocateUTF8OnStack","demangle","stackTrace","getNativeTypeSize"];missingLibrarySymbols.forEach(missingLibrarySymbol);var unexportedSymbols=["run","out","err","callMain","abort","wasmExports","writeStackCookie","checkStackCookie","writeI53ToI64","readI53FromI64","readI53FromU64","INT53_MAX","INT53_MIN","bigintToI53Checked","HEAP8","HEAPU8","HEAP16","HEAPU16","HEAP32","HEAPU32","HEAPF32","HEAPF64","HEAP64","HEAPU64","stackSave","stackRestore","createNamedFunction","ptrToString","exitJS","getHeapMax","growMemory","ENV","ERRNO_CODES","strError","DNS","Protocols","Sockets","timers","warnOnce","readEmAsmArgsArray","readEmAsmArgs","runEmAsmFunction","jstoi_q","getExecutableName","dynCallLegacy","dynCall","handleException","keepRuntimeAlive","runtimeKeepalivePush","runtimeKeepalivePop","callUserCallback","maybeExit","asyncLoad","alignMemory","mmapAlloc","HandleAllocator","wasmTable","wasmMemory","getUniqueRunDependency","noExitRuntime","addOnPreRun","addOnExit","addOnPostRun","freeTableIndexes","functionsInTableMap","setValue","getValue","PATH","PATH_FS","UTF8Decoder","UTF8ArrayToString","UTF8ToString","stringToUTF8Array","stringToUTF8","lengthBytesUTF8","intArrayFromString","UTF16Decoder","stringToNewUTF8","JSEvents","specialHTMLTargets","maybeCStringToJsString","findEventTarget","findCanvasEventTarget","getBoundingClientRect","fillMouseEventData","registerMouseEventCallback","registerUiEventCallback","registerFocusEventCallback","fillFullscreenChangeEventData","registerFullscreenChangeEventCallback","currentFullscreenStrategy","restoreOldWindowedStyle","fillPointerlockChangeEventData","registerPointerlockChangeEventCallback","fillVisibilityChangeEventData","registerVisibilityChangeEventCallback","registerTouchEventCallback","fillGamepadEventData","registerGamepadEventCallback","UNWIND_CACHE","ExitStatus","getEnvStrings","checkWasiClock","doReadv","doWritev","initRandomFill","randomFill","safeSetTimeout","emSetImmediate","emClearImmediate_deps","emClearImmediate","promiseMap","uncaughtExceptionCount","exceptionCaught","ExceptionInfo","Browser","requestFullScreen","setCanvasSize","getUserMedia","createContext","getPreloadedImageData__data","wget","MONTH_DAYS_REGULAR","MONTH_DAYS_LEAP","MONTH_DAYS_REGULAR_CUMULATIVE","MONTH_DAYS_LEAP_CUMULATIVE","SYSCALLS","preloadPlugins","FS_createPreloadedFile","FS_modeStringToFlags","FS_getMode","FS_fileDataToTypedArray","FS_stdin_getChar_buffer","FS_stdin_getChar","FS_readFile","FS","FS_root","FS_mounts","FS_devices","FS_streams","FS_nextInode","FS_nameTable","FS_currentPath","FS_initialized","FS_ignorePermissions","FS_filesystems","FS_syncFSRequests","FS_lookupPath","FS_getPath","FS_hashName","FS_hashAddNode","FS_hashRemoveNode","FS_lookupNode","FS_createNode","FS_destroyNode","FS_isRoot","FS_isMountpoint","FS_isFile","FS_isDir","FS_isLink","FS_isChrdev","FS_isBlkdev","FS_isFIFO","FS_isSocket","FS_flagsToPermissionString","FS_nodePermissions","FS_mayLookup","FS_mayCreate","FS_mayDelete","FS_mayOpen","FS_checkOpExists","FS_nextfd","FS_getStreamChecked","FS_getStream","FS_createStream","FS_closeStream","FS_dupStream","FS_doSetAttr","FS_chrdev_stream_ops","FS_major","FS_minor","FS_makedev","FS_registerDevice","FS_getDevice","FS_getMounts","FS_syncfs","FS_mount","FS_unmount","FS_lookup","FS_mknod","FS_statfs","FS_statfsStream","FS_statfsNode","FS_create","FS_mkdir","FS_mkdev","FS_symlink","FS_rename","FS_rmdir","FS_readdir","FS_readlink","FS_stat","FS_fstat","FS_lstat","FS_doChmod","FS_chmod","FS_lchmod","FS_fchmod","FS_doChown","FS_chown","FS_lchown","FS_fchown","FS_doTruncate","FS_truncate","FS_ftruncate","FS_utime","FS_open","FS_close","FS_isClosed","FS_llseek","FS_read","FS_write","FS_mmap","FS_msync","FS_ioctl","FS_writeFile","FS_cwd","FS_chdir","FS_createDefaultDirectories","FS_createDefaultDevices","FS_createSpecialDirectories","FS_createStandardStreams","FS_staticInit","FS_init","FS_quit","FS_findObject","FS_analyzePath","FS_createFile","FS_forceLoadFile","MEMFS","TTY","PIPEFS","SOCKFS","tempFixedLengthArray","miniTempWebGLFloatBuffers","miniTempWebGLIntBuffers","heapObjectForWebGLType","toTypedArrayIndex","webgl_enable_ANGLE_instanced_arrays","webgl_enable_OES_vertex_array_object","webgl_enable_WEBGL_draw_buffers","webgl_enable_WEBGL_multi_draw","webgl_enable_EXT_polygon_offset_clamp","webgl_enable_EXT_clip_control","webgl_enable_WEBGL_polygon_mode","GL","emscriptenWebGLGet","computeUnpackAlignedImageSize","colorChannelsInGlTextureFormat","emscriptenWebGLGetTexPixelData","emscriptenWebGLGetUniform","webglGetUniformLocation","webglPrepareUniformLocationsBeforeFirstUse","webglGetLeftBracePos","emscriptenWebGLGetVertexAttrib","__glGetActiveAttribOrUniform","AL","GLUT","EGL","GLEW","IDBStore","runAndAbortIfError","Asyncify","Fibers","SDL","SDL_gfx","GLFW_Window","GLFW","print","printErr","jstoi_s","Fetch","fetchDeleteCachedData","fetchLoadCachedData","fetchCacheData","fetchXHR"];unexportedSymbols.forEach(unexportedRuntimeSymbol);function checkIncomingModuleAPI(){ignoredModuleProp("fetchSettings");ignoredModuleProp("logReadFiles");ignoredModuleProp("loadSplitModule");ignoredModuleProp("onMalloc");ignoredModuleProp("onRealloc");ignoredModuleProp("onFree");ignoredModuleProp("onSbrkGrow")}var ASM_CONSTS={207094:()=>window.lcolonqJamStart||-1,207137:()=>{if(document.fullscreenElement)return 1},207183:()=>Module.canvas.width,207215:()=>parseInt(Module.canvas.style.width),207263:()=>{document.exitFullscreen()},207290:()=>{setTimeout(function(){Module.requestFullscreen(false,false)},100)},207362:()=>{if(document.fullscreenElement)return 1},207408:()=>Module.canvas.width,207440:()=>screen.width,207465:()=>{document.exitFullscreen()},207492:$0=>{const canvasId=UTF8ToString($0);setTimeout(function(){Module.requestFullscreen(false,true);setTimeout(function(){document.querySelector(canvasId).style.width="unset"},100)},100)},207686:()=>window.innerWidth,207712:()=>window.innerHeight,207739:()=>{if(document.fullscreenElement)return 1},207785:()=>Module.canvas.width,207817:()=>parseInt(Module.canvas.style.width),207865:()=>{if(document.fullscreenElement)return 1},207911:()=>Module.canvas.width,207943:()=>screen.width,207968:()=>window.innerWidth,207994:()=>window.innerHeight,208021:()=>{if(document.fullscreenElement)return 1},208067:()=>Module.canvas.width,208099:()=>screen.width,208124:()=>{document.exitFullscreen()},208151:()=>{if(document.fullscreenElement)return 1},208197:()=>Module.canvas.width,208229:()=>parseInt(Module.canvas.style.width),208277:()=>{document.exitFullscreen()},208304:$0=>{Module.canvas.style.opacity=$0},208342:()=>screen.width,208367:()=>screen.height,208393:()=>window.screenX,208420:()=>window.screenY,208447:()=>window.devicePixelRatio,208483:$0=>{navigator.clipboard.writeText(UTF8ToString($0))},208536:$0=>{Module.canvas.style.cursor=UTF8ToString($0)},208587:()=>{Module.canvas.style.cursor="none"},208624:($0,$1,$2,$3)=>{try{navigator.getGamepads()[$0].vibrationActuator.playEffect("dual-rumble",{startDelay:0,duration:$3,weakMagnitude:$1,strongMagnitude:$2})}catch(e){try{navigator.getGamepads()[$0].hapticActuators[0].pulse($2,$3)}catch(e){}}},208880:$0=>{Module.canvas.style.cursor=UTF8ToString($0)},208931:()=>{if(document.pointerLockElement)return 1},208978:()=>{if(document.fullscreenElement)return 1},209024:()=>window.innerWidth,209050:()=>window.innerHeight,209077:($0,$1,$2,$3,$4)=>{if(typeof window==="undefined"||(window.AudioContext||window.webkitAudioContext)===undefined){return 0}if(typeof window.miniaudio==="undefined"){window.miniaudio={referenceCount:0};window.miniaudio.device_type={};window.miniaudio.device_type.playback=$0;window.miniaudio.device_type.capture=$1;window.miniaudio.device_type.duplex=$2;window.miniaudio.device_state={};window.miniaudio.device_state.stopped=$3;window.miniaudio.device_state.started=$4;let miniaudio=window.miniaudio;miniaudio.devices=[];miniaudio.track_device=function(device){for(var iDevice=0;iDevice<miniaudio.devices.length;++iDevice){if(miniaudio.devices[iDevice]==null){miniaudio.devices[iDevice]=device;return iDevice}}miniaudio.devices.push(device);return miniaudio.devices.length-1};miniaudio.untrack_device_by_index=function(deviceIndex){miniaudio.devices[deviceIndex]=null;while(miniaudio.devices.length>0){if(miniaudio.devices[miniaudio.devices.length-1]==null){miniaudio.devices.pop()}else{break}}};miniaudio.untrack_device=function(device){for(var iDevice=0;iDevice<miniaudio.devices.length;++iDevice){if(miniaudio.devices[iDevice]==device){return miniaudio.untrack_device_by_index(iDevice)}}};miniaudio.get_device_by_index=function(deviceIndex){return miniaudio.devices[deviceIndex]};miniaudio.unlock_event_types=function(){return["touchend","click"]}();miniaudio.unlock=function(){for(var i=0;i<miniaudio.devices.length;++i){var device=miniaudio.devices[i];if(device!=null&&device.webaudio!=null&&device.state===miniaudio.device_state.started){device.webaudio.resume().then(()=>{_ma_device__on_notification_unlocked(device.pDevice)},error=>{console.error("Failed to resume audiocontext",error)})}}miniaudio.unlock_event_types.map(function(event_type){document.removeEventListener(event_type,miniaudio.unlock,true)})};miniaudio.unlock_event_types.map(function(event_type){document.addEventListener(event_type,miniaudio.unlock,true)})}window.miniaudio.referenceCount+=1;return 1},211255:()=>{if(typeof window.miniaudio!=="undefined"){window.miniaudio.unlock_event_types.map(function(event_type){document.removeEventListener(event_type,window.miniaudio.unlock,true)});window.miniaudio.referenceCount-=1;if(window.miniaudio.referenceCount===0){delete window.miniaudio}}},211559:()=>navigator.mediaDevices!==undefined&&navigator.mediaDevices.getUserMedia!==undefined,211663:()=>{try{var temp=new(window.AudioContext||window.webkitAudioContext);var sampleRate=temp.sampleRate;temp.close();return sampleRate}catch(e){return 0}},211834:($0,$1,$2,$3,$4,$5)=>{var deviceType=$0;var channels=$1;var sampleRate=$2;var bufferSize=$3;var pIntermediaryBuffer=$4;var pDevice=$5;if(typeof window.miniaudio==="undefined"){return-1}var device={};var audioContextOptions={};if(deviceType==window.miniaudio.device_type.playback&&sampleRate!=0){audioContextOptions.sampleRate=sampleRate}device.webaudio=new(window.AudioContext||window.webkitAudioContext)(audioContextOptions);device.webaudio.suspend();device.state=window.miniaudio.device_state.stopped;var channelCountIn=0;var channelCountOut=channels;if(deviceType!=window.miniaudio.device_type.playback){channelCountIn=channels}device.scriptNode=device.webaudio.createScriptProcessor(bufferSize,channelCountIn,channelCountOut);device.scriptNode.onaudioprocess=function(e){if(device.intermediaryBufferView==null||device.intermediaryBufferView.length==0){device.intermediaryBufferView=new Float32Array(HEAPF32.buffer,pIntermediaryBuffer,bufferSize*channels)}if(deviceType==window.miniaudio.device_type.capture||deviceType==window.miniaudio.device_type.duplex){for(var iChannel=0;iChannel<channels;iChannel+=1){var inputBuffer=e.inputBuffer.getChannelData(iChannel);var intermediaryBuffer=device.intermediaryBufferView;for(var iFrame=0;iFrame<bufferSize;iFrame+=1){intermediaryBuffer[iFrame*channels+iChannel]=inputBuffer[iFrame]}}_ma_device_process_pcm_frames_capture__webaudio(pDevice,bufferSize,pIntermediaryBuffer)}if(deviceType==window.miniaudio.device_type.playback||deviceType==window.miniaudio.device_type.duplex){_ma_device_process_pcm_frames_playback__webaudio(pDevice,bufferSize,pIntermediaryBuffer);for(var iChannel=0;iChannel<e.outputBuffer.numberOfChannels;++iChannel){var outputBuffer=e.outputBuffer.getChannelData(iChannel);var intermediaryBuffer=device.intermediaryBufferView;for(var iFrame=0;iFrame<bufferSize;iFrame+=1){outputBuffer[iFrame]=intermediaryBuffer[iFrame*channels+iChannel]}}}else{for(var iChannel=0;iChannel<e.outputBuffer.numberOfChannels;++iChannel){e.outputBuffer.getChannelData(iChannel).fill(0)}}};if(deviceType==window.miniaudio.device_type.capture||deviceType==window.miniaudio.device_type.duplex){navigator.mediaDevices.getUserMedia({audio:true,video:false}).then(function(stream){device.streamNode=device.webaudio.createMediaStreamSource(stream);device.streamNode.connect(device.scriptNode);device.scriptNode.connect(device.webaudio.destination)}).catch(function(error){console.log("Failed to get user media: "+error)})}if(deviceType==window.miniaudio.device_type.playback){device.scriptNode.connect(device.webaudio.destination)}device.pDevice=pDevice;return window.miniaudio.track_device(device)},214711:$0=>window.miniaudio.get_device_by_index($0).webaudio.sampleRate,214784:$0=>{var device=window.miniaudio.get_device_by_index($0);if(device.scriptNode!==undefined){device.scriptNode.onaudioprocess=function(e){};device.scriptNode.disconnect();device.scriptNode=undefined}if(device.streamNode!==undefined){device.streamNode.disconnect();device.streamNode=undefined}device.webaudio.close();device.webaudio=undefined;device.pDevice=undefined},215184:$0=>{window.miniaudio.untrack_device_by_index($0)},215234:$0=>{var device=window.miniaudio.get_device_by_index($0);device.webaudio.resume();device.state=window.miniaudio.device_state.started},215373:$0=>{var device=window.miniaudio.get_device_by_index($0);device.webaudio.suspend();device.state=window.miniaudio.device_state.stopped}};function get_cookie(name){const cookieName=UTF8ToString(name)+"=";const cookies=document.cookie.split(";");for(let c of cookies){c=c.trim();if(c.startsWith(cookieName)){const value=c.substring(cookieName.length);const len=lengthBytesUTF8(value)+1;const buffer=_malloc(len);stringToUTF8(value,buffer,len);return buffer}}return 0}function SetCanvasIdJs(out,outSize){var canvasId="#"+Module.canvas.id;stringToUTF8(canvasId,out,outSize)}var _free=makeInvalidEarlyAccess("_free");var _malloc=makeInvalidEarlyAccess("_malloc");var _main=Module["_main"]=makeInvalidEarlyAccess("_main");var _fflush=makeInvalidEarlyAccess("_fflush");var _realloc=makeInvalidEarlyAccess("_realloc");var _ma_device__on_notification_unlocked=Module["_ma_device__on_notification_unlocked"]=makeInvalidEarlyAccess("_ma_device__on_notification_unlocked");var _ma_malloc_emscripten=Module["_ma_malloc_emscripten"]=makeInvalidEarlyAccess("_ma_malloc_emscripten");var _ma_free_emscripten=Module["_ma_free_emscripten"]=makeInvalidEarlyAccess("_ma_free_emscripten");var _ma_device_process_pcm_frames_capture__webaudio=Module["_ma_device_process_pcm_frames_capture__webaudio"]=makeInvalidEarlyAccess("_ma_device_process_pcm_frames_capture__webaudio");var _ma_device_process_pcm_frames_playback__webaudio=Module["_ma_device_process_pcm_frames_playback__webaudio"]=makeInvalidEarlyAccess("_ma_device_process_pcm_frames_playback__webaudio");var _emscripten_stack_get_end=makeInvalidEarlyAccess("_emscripten_stack_get_end");var _emscripten_stack_get_base=makeInvalidEarlyAccess("_emscripten_stack_get_base");var _strerror=makeInvalidEarlyAccess("_strerror");var _emscripten_stack_init=makeInvalidEarlyAccess("_emscripten_stack_init");var _emscripten_stack_get_free=makeInvalidEarlyAccess("_emscripten_stack_get_free");var __emscripten_stack_restore=makeInvalidEarlyAccess("__emscripten_stack_restore");var __emscripten_stack_alloc=makeInvalidEarlyAccess("__emscripten_stack_alloc");var _emscripten_stack_get_current=makeInvalidEarlyAccess("_emscripten_stack_get_current");var dynCall_vii=makeInvalidEarlyAccess("dynCall_vii");var dynCall_vi=makeInvalidEarlyAccess("dynCall_vi");var dynCall_ii=makeInvalidEarlyAccess("dynCall_ii");var dynCall_v=makeInvalidEarlyAccess("dynCall_v");var dynCall_iiii=makeInvalidEarlyAccess("dynCall_iiii");var dynCall_viii=makeInvalidEarlyAccess("dynCall_viii");var dynCall_viff=makeInvalidEarlyAccess("dynCall_viff");var dynCall_viiiii=makeInvalidEarlyAccess("dynCall_viiiii");var dynCall_viiii=makeInvalidEarlyAccess("dynCall_viiii");var dynCall_vidd=makeInvalidEarlyAccess("dynCall_vidd");var dynCall_iii=makeInvalidEarlyAccess("dynCall_iii");var dynCall_iiiii=makeInvalidEarlyAccess("dynCall_iiiii");var dynCall_iiiji=makeInvalidEarlyAccess("dynCall_iiiji");var dynCall_iiiiiii=makeInvalidEarlyAccess("dynCall_iiiiiii");var dynCall_jii=makeInvalidEarlyAccess("dynCall_jii");var dynCall_vffff=makeInvalidEarlyAccess("dynCall_vffff");var dynCall_vf=makeInvalidEarlyAccess("dynCall_vf");var dynCall_viiiiiiii=makeInvalidEarlyAccess("dynCall_viiiiiiii");var dynCall_viiiiiiiii=makeInvalidEarlyAccess("dynCall_viiiiiiiii");var dynCall_i=makeInvalidEarlyAccess("dynCall_i");var dynCall_vff=makeInvalidEarlyAccess("dynCall_vff");var dynCall_viiiiiii=makeInvalidEarlyAccess("dynCall_viiiiiii");var dynCall_vfi=makeInvalidEarlyAccess("dynCall_vfi");var dynCall_viif=makeInvalidEarlyAccess("dynCall_viif");var dynCall_vif=makeInvalidEarlyAccess("dynCall_vif");var dynCall_vifff=makeInvalidEarlyAccess("dynCall_vifff");var dynCall_viffff=makeInvalidEarlyAccess("dynCall_viffff");var dynCall_viiiiii=makeInvalidEarlyAccess("dynCall_viiiiii");var dynCall_vfff=makeInvalidEarlyAccess("dynCall_vfff");var dynCall_jiji=makeInvalidEarlyAccess("dynCall_jiji");var dynCall_iidiiii=makeInvalidEarlyAccess("dynCall_iidiiii");var dynCall_viijii=makeInvalidEarlyAccess("dynCall_viijii");var dynCall_iiiiii=makeInvalidEarlyAccess("dynCall_iiiiii");var dynCall_iiiiiiiii=makeInvalidEarlyAccess("dynCall_iiiiiiiii");var dynCall_iiiiij=makeInvalidEarlyAccess("dynCall_iiiiij");var dynCall_iiiiid=makeInvalidEarlyAccess("dynCall_iiiiid");var dynCall_iiiiijj=makeInvalidEarlyAccess("dynCall_iiiiijj");var dynCall_iiiiiiii=makeInvalidEarlyAccess("dynCall_iiiiiiii");var dynCall_iiiiiijj=makeInvalidEarlyAccess("dynCall_iiiiiijj");var _asyncify_start_unwind=makeInvalidEarlyAccess("_asyncify_start_unwind");var _asyncify_stop_unwind=makeInvalidEarlyAccess("_asyncify_stop_unwind");var _asyncify_start_rewind=makeInvalidEarlyAccess("_asyncify_start_rewind");var _asyncify_stop_rewind=makeInvalidEarlyAccess("_asyncify_stop_rewind");var memory=makeInvalidEarlyAccess("memory");var __indirect_function_table=makeInvalidEarlyAccess("__indirect_function_table");var wasmMemory=makeInvalidEarlyAccess("wasmMemory");function assignWasmExports(wasmExports){assert(typeof wasmExports["free"]!="undefined","missing Wasm export: free");assert(typeof wasmExports["malloc"]!="undefined","missing Wasm export: malloc");assert(typeof wasmExports["main"]!="undefined","missing Wasm export: main");assert(typeof wasmExports["fflush"]!="undefined","missing Wasm export: fflush");assert(typeof wasmExports["realloc"]!="undefined","missing Wasm export: realloc");assert(typeof wasmExports["ma_device__on_notification_unlocked"]!="undefined","missing Wasm export: ma_device__on_notification_unlocked");assert(typeof wasmExports["ma_malloc_emscripten"]!="undefined","missing Wasm export: ma_malloc_emscripten");assert(typeof wasmExports["ma_free_emscripten"]!="undefined","missing Wasm export: ma_free_emscripten");assert(typeof wasmExports["ma_device_process_pcm_frames_capture__webaudio"]!="undefined","missing Wasm export: ma_device_process_pcm_frames_capture__webaudio");assert(typeof wasmExports["ma_device_process_pcm_frames_playback__webaudio"]!="undefined","missing Wasm export: ma_device_process_pcm_frames_playback__webaudio");assert(typeof wasmExports["emscripten_stack_get_end"]!="undefined","missing Wasm export: emscripten_stack_get_end");assert(typeof wasmExports["emscripten_stack_get_base"]!="undefined","missing Wasm export: emscripten_stack_get_base");assert(typeof wasmExports["strerror"]!="undefined","missing Wasm export: strerror");assert(typeof wasmExports["emscripten_stack_init"]!="undefined","missing Wasm export: emscripten_stack_init");assert(typeof wasmExports["emscripten_stack_get_free"]!="undefined","missing Wasm export: emscripten_stack_get_free");assert(typeof wasmExports["_emscripten_stack_restore"]!="undefined","missing Wasm export: _emscripten_stack_restore");assert(typeof wasmExports["_emscripten_stack_alloc"]!="undefined","missing Wasm export: _emscripten_stack_alloc");assert(typeof wasmExports["emscripten_stack_get_current"]!="undefined","missing Wasm export: emscripten_stack_get_current");assert(typeof wasmExports["dynCall_vii"]!="undefined","missing Wasm export: dynCall_vii");assert(typeof wasmExports["dynCall_vi"]!="undefined","missing Wasm export: dynCall_vi");assert(typeof wasmExports["dynCall_ii"]!="undefined","missing Wasm export: dynCall_ii");assert(typeof wasmExports["dynCall_v"]!="undefined","missing Wasm export: dynCall_v");assert(typeof wasmExports["dynCall_iiii"]!="undefined","missing Wasm export: dynCall_iiii");assert(typeof wasmExports["dynCall_viii"]!="undefined","missing Wasm export: dynCall_viii");assert(typeof wasmExports["dynCall_viff"]!="undefined","missing Wasm export: dynCall_viff");assert(typeof wasmExports["dynCall_viiiii"]!="undefined","missing Wasm export: dynCall_viiiii");assert(typeof wasmExports["dynCall_viiii"]!="undefined","missing Wasm export: dynCall_viiii");assert(typeof wasmExports["dynCall_vidd"]!="undefined","missing Wasm export: dynCall_vidd");assert(typeof wasmExports["dynCall_iii"]!="undefined","missing Wasm export: dynCall_iii");assert(typeof wasmExports["dynCall_iiiii"]!="undefined","missing Wasm export: dynCall_iiiii");assert(typeof wasmExports["dynCall_iiiji"]!="undefined","missing Wasm export: dynCall_iiiji");assert(typeof wasmExports["dynCall_iiiiiii"]!="undefined","missing Wasm export: dynCall_iiiiiii");assert(typeof wasmExports["dynCall_jii"]!="undefined","missing Wasm export: dynCall_jii");assert(typeof wasmExports["dynCall_vffff"]!="undefined","missing Wasm export: dynCall_vffff");assert(typeof wasmExports["dynCall_vf"]!="undefined","missing Wasm export: dynCall_vf");assert(typeof wasmExports["dynCall_viiiiiiii"]!="undefined","missing Wasm export: dynCall_viiiiiiii");assert(typeof wasmExports["dynCall_viiiiiiiii"]!="undefined","missing Wasm export: dynCall_viiiiiiiii");assert(typeof wasmExports["dynCall_i"]!="undefined","missing Wasm export: dynCall_i");assert(typeof wasmExports["dynCall_vff"]!="undefined","missing Wasm export: dynCall_vff");assert(typeof wasmExports["dynCall_viiiiiii"]!="undefined","missing Wasm export: dynCall_viiiiiii");assert(typeof wasmExports["dynCall_vfi"]!="undefined","missing Wasm export: dynCall_vfi");assert(typeof wasmExports["dynCall_viif"]!="undefined","missing Wasm export: dynCall_viif");assert(typeof wasmExports["dynCall_vif"]!="undefined","missing Wasm export: dynCall_vif");assert(typeof wasmExports["dynCall_vifff"]!="undefined","missing Wasm export: dynCall_vifff");assert(typeof wasmExports["dynCall_viffff"]!="undefined","missing Wasm export: dynCall_viffff");assert(typeof wasmExports["dynCall_viiiiii"]!="undefined","missing Wasm export: dynCall_viiiiii");assert(typeof wasmExports["dynCall_vfff"]!="undefined","missing Wasm export: dynCall_vfff");assert(typeof wasmExports["dynCall_jiji"]!="undefined","missing Wasm export: dynCall_jiji");assert(typeof wasmExports["dynCall_iidiiii"]!="undefined","missing Wasm export: dynCall_iidiiii");assert(typeof wasmExports["dynCall_viijii"]!="undefined","missing Wasm export: dynCall_viijii");assert(typeof wasmExports["dynCall_iiiiii"]!="undefined","missing Wasm export: dynCall_iiiiii");assert(typeof wasmExports["dynCall_iiiiiiiii"]!="undefined","missing Wasm export: dynCall_iiiiiiiii");assert(typeof wasmExports["dynCall_iiiiij"]!="undefined","missing Wasm export: dynCall_iiiiij");assert(typeof wasmExports["dynCall_iiiiid"]!="undefined","missing Wasm export: dynCall_iiiiid");assert(typeof wasmExports["dynCall_iiiiijj"]!="undefined","missing Wasm export: dynCall_iiiiijj");assert(typeof wasmExports["dynCall_iiiiiiii"]!="undefined","missing Wasm export: dynCall_iiiiiiii");assert(typeof wasmExports["dynCall_iiiiiijj"]!="undefined","missing Wasm export: dynCall_iiiiiijj");assert(typeof wasmExports["asyncify_start_unwind"]!="undefined","missing Wasm export: asyncify_start_unwind");assert(typeof wasmExports["asyncify_stop_unwind"]!="undefined","missing Wasm export: asyncify_stop_unwind");assert(typeof wasmExports["asyncify_start_rewind"]!="undefined","missing Wasm export: asyncify_start_rewind");assert(typeof wasmExports["asyncify_stop_rewind"]!="undefined","missing Wasm export: asyncify_stop_rewind");assert(typeof wasmExports["memory"]!="undefined","missing Wasm export: memory");assert(typeof wasmExports["__indirect_function_table"]!="undefined","missing Wasm export: __indirect_function_table");_free=createExportWrapper("free",1);_malloc=createExportWrapper("malloc",1);_main=Module["_main"]=createExportWrapper("main",2);_fflush=createExportWrapper("fflush",1);_realloc=createExportWrapper("realloc",2);_ma_device__on_notification_unlocked=Module["_ma_device__on_notification_unlocked"]=createExportWrapper("ma_device__on_notification_unlocked",1);_ma_malloc_emscripten=Module["_ma_malloc_emscripten"]=createExportWrapper("ma_malloc_emscripten",2);_ma_free_emscripten=Module["_ma_free_emscripten"]=createExportWrapper("ma_free_emscripten",2);_ma_device_process_pcm_frames_capture__webaudio=Module["_ma_device_process_pcm_frames_capture__webaudio"]=createExportWrapper("ma_device_process_pcm_frames_capture__webaudio",3);_ma_device_process_pcm_frames_playback__webaudio=Module["_ma_device_process_pcm_frames_playback__webaudio"]=createExportWrapper("ma_device_process_pcm_frames_playback__webaudio",3);_emscripten_stack_get_end=wasmExports["emscripten_stack_get_end"];_emscripten_stack_get_base=wasmExports["emscripten_stack_get_base"];_strerror=createExportWrapper("strerror",1);_emscripten_stack_init=wasmExports["emscripten_stack_init"];_emscripten_stack_get_free=wasmExports["emscripten_stack_get_free"];__emscripten_stack_restore=wasmExports["_emscripten_stack_restore"];__emscripten_stack_alloc=wasmExports["_emscripten_stack_alloc"];_emscripten_stack_get_current=wasmExports["emscripten_stack_get_current"];dynCall_vii=dynCalls["vii"]=createExportWrapper("dynCall_vii",3);dynCall_vi=dynCalls["vi"]=createExportWrapper("dynCall_vi",2);dynCall_ii=dynCalls["ii"]=createExportWrapper("dynCall_ii",2);dynCall_v=dynCalls["v"]=createExportWrapper("dynCall_v",1);dynCall_iiii=dynCalls["iiii"]=createExportWrapper("dynCall_iiii",4);dynCall_viii=dynCalls["viii"]=createExportWrapper("dynCall_viii",4);dynCall_viff=dynCalls["viff"]=createExportWrapper("dynCall_viff",4);dynCall_viiiii=dynCalls["viiiii"]=createExportWrapper("dynCall_viiiii",6);dynCall_viiii=dynCalls["viiii"]=createExportWrapper("dynCall_viiii",5);dynCall_vidd=dynCalls["vidd"]=createExportWrapper("dynCall_vidd",4);dynCall_iii=dynCalls["iii"]=createExportWrapper("dynCall_iii",3);dynCall_iiiii=dynCalls["iiiii"]=createExportWrapper("dynCall_iiiii",5);dynCall_iiiji=dynCalls["iiiji"]=createExportWrapper("dynCall_iiiji",5);dynCall_iiiiiii=dynCalls["iiiiiii"]=createExportWrapper("dynCall_iiiiiii",7);dynCall_jii=dynCalls["jii"]=createExportWrapper("dynCall_jii",3);dynCall_vffff=dynCalls["vffff"]=createExportWrapper("dynCall_vffff",5);dynCall_vf=dynCalls["vf"]=createExportWrapper("dynCall_vf",2);dynCall_viiiiiiii=dynCalls["viiiiiiii"]=createExportWrapper("dynCall_viiiiiiii",9);dynCall_viiiiiiiii=dynCalls["viiiiiiiii"]=createExportWrapper("dynCall_viiiiiiiii",10);dynCall_i=dynCalls["i"]=createExportWrapper("dynCall_i",1);dynCall_vff=dynCalls["vff"]=createExportWrapper("dynCall_vff",3);dynCall_viiiiiii=dynCalls["viiiiiii"]=createExportWrapper("dynCall_viiiiiii",8);dynCall_vfi=dynCalls["vfi"]=createExportWrapper("dynCall_vfi",3);dynCall_viif=dynCalls["viif"]=createExportWrapper("dynCall_viif",4);dynCall_vif=dynCalls["vif"]=createExportWrapper("dynCall_vif",3);dynCall_vifff=dynCalls["vifff"]=createExportWrapper("dynCall_vifff",5);dynCall_viffff=dynCalls["viffff"]=createExportWrapper("dynCall_viffff",6);dynCall_viiiiii=dynCalls["viiiiii"]=createExportWrapper("dynCall_viiiiii",7);dynCall_vfff=dynCalls["vfff"]=createExportWrapper("dynCall_vfff",4);dynCall_jiji=dynCalls["jiji"]=createExportWrapper("dynCall_jiji",4);dynCall_iidiiii=dynCalls["iidiiii"]=createExportWrapper("dynCall_iidiiii",7);dynCall_viijii=dynCalls["viijii"]=createExportWrapper("dynCall_viijii",6);dynCall_iiiiii=dynCalls["iiiiii"]=createExportWrapper("dynCall_iiiiii",6);dynCall_iiiiiiiii=dynCalls["iiiiiiiii"]=createExportWrapper("dynCall_iiiiiiiii",9);dynCall_iiiiij=dynCalls["iiiiij"]=createExportWrapper("dynCall_iiiiij",6);dynCall_iiiiid=dynCalls["iiiiid"]=createExportWrapper("dynCall_iiiiid",6);dynCall_iiiiijj=dynCalls["iiiiijj"]=createExportWrapper("dynCall_iiiiijj",7);dynCall_iiiiiiii=dynCalls["iiiiiiii"]=createExportWrapper("dynCall_iiiiiiii",8);dynCall_iiiiiijj=dynCalls["iiiiiijj"]=createExportWrapper("dynCall_iiiiiijj",8);_asyncify_start_unwind=createExportWrapper("asyncify_start_unwind",1);_asyncify_stop_unwind=createExportWrapper("asyncify_stop_unwind",0);_asyncify_start_rewind=createExportWrapper("asyncify_start_rewind",1);_asyncify_stop_rewind=createExportWrapper("asyncify_stop_rewind",0);memory=wasmMemory=wasmExports["memory"];__indirect_function_table=wasmExports["__indirect_function_table"]}var wasmImports={SetCanvasIdJs,__assert_fail:___assert_fail,__cxa_throw:___cxa_throw,__syscall_faccessat:___syscall_faccessat,__syscall_fcntl64:___syscall_fcntl64,__syscall_getcwd:___syscall_getcwd,__syscall_ioctl:___syscall_ioctl,__syscall_openat:___syscall_openat,_abort_js:__abort_js,_tzset_js:__tzset_js,clock_time_get:_clock_time_get,emscripten_asm_const_double:_emscripten_asm_const_double,emscripten_asm_const_int:_emscripten_asm_const_int,emscripten_date_now:_emscripten_date_now,emscripten_fetch_free:_emscripten_fetch_free,emscripten_get_element_css_size:_emscripten_get_element_css_size,emscripten_get_gamepad_status:_emscripten_get_gamepad_status,emscripten_get_now:_emscripten_get_now,emscripten_get_num_gamepads:_emscripten_get_num_gamepads,emscripten_glActiveTexture:_emscripten_glActiveTexture,emscripten_glAttachShader:_emscripten_glAttachShader,emscripten_glBeginQueryEXT:_emscripten_glBeginQueryEXT,emscripten_glBindAttribLocation:_emscripten_glBindAttribLocation,emscripten_glBindBuffer:_emscripten_glBindBuffer,emscripten_glBindFramebuffer:_emscripten_glBindFramebuffer,emscripten_glBindRenderbuffer:_emscripten_glBindRenderbuffer,emscripten_glBindTexture:_emscripten_glBindTexture,emscripten_glBindVertexArrayOES:_emscripten_glBindVertexArrayOES,emscripten_glBlendColor:_emscripten_glBlendColor,emscripten_glBlendEquation:_emscripten_glBlendEquation,emscripten_glBlendEquationSeparate:_emscripten_glBlendEquationSeparate,emscripten_glBlendFunc:_emscripten_glBlendFunc,emscripten_glBlendFuncSeparate:_emscripten_glBlendFuncSeparate,emscripten_glBufferData:_emscripten_glBufferData,emscripten_glBufferSubData:_emscripten_glBufferSubData,emscripten_glCheckFramebufferStatus:_emscripten_glCheckFramebufferStatus,emscripten_glClear:_emscripten_glClear,emscripten_glClearColor:_emscripten_glClearColor,emscripten_glClearDepthf:_emscripten_glClearDepthf,emscripten_glClearStencil:_emscripten_glClearStencil,emscripten_glClipControlEXT:_emscripten_glClipControlEXT,emscripten_glColorMask:_emscripten_glColorMask,emscripten_glCompileShader:_emscripten_glCompileShader,emscripten_glCompressedTexImage2D:_emscripten_glCompressedTexImage2D,emscripten_glCompressedTexSubImage2D:_emscripten_glCompressedTexSubImage2D,emscripten_glCopyTexImage2D:_emscripten_glCopyTexImage2D,emscripten_glCopyTexSubImage2D:_emscripten_glCopyTexSubImage2D,emscripten_glCreateProgram:_emscripten_glCreateProgram,emscripten_glCreateShader:_emscripten_glCreateShader,emscripten_glCullFace:_emscripten_glCullFace,emscripten_glDeleteBuffers:_emscripten_glDeleteBuffers,emscripten_glDeleteFramebuffers:_emscripten_glDeleteFramebuffers,emscripten_glDeleteProgram:_emscripten_glDeleteProgram,emscripten_glDeleteQueriesEXT:_emscripten_glDeleteQueriesEXT,emscripten_glDeleteRenderbuffers:_emscripten_glDeleteRenderbuffers,emscripten_glDeleteShader:_emscripten_glDeleteShader,emscripten_glDeleteTextures:_emscripten_glDeleteTextures,emscripten_glDeleteVertexArraysOES:_emscripten_glDeleteVertexArraysOES,emscripten_glDepthFunc:_emscripten_glDepthFunc,emscripten_glDepthMask:_emscripten_glDepthMask,emscripten_glDepthRangef:_emscripten_glDepthRangef,emscripten_glDetachShader:_emscripten_glDetachShader,emscripten_glDisable:_emscripten_glDisable,emscripten_glDisableVertexAttribArray:_emscripten_glDisableVertexAttribArray,emscripten_glDrawArrays:_emscripten_glDrawArrays,emscripten_glDrawArraysInstancedANGLE:_emscripten_glDrawArraysInstancedANGLE,emscripten_glDrawBuffersWEBGL:_emscripten_glDrawBuffersWEBGL,emscripten_glDrawElements:_emscripten_glDrawElements,emscripten_glDrawElementsInstancedANGLE:_emscripten_glDrawElementsInstancedANGLE,emscripten_glEnable:_emscripten_glEnable,emscripten_glEnableVertexAttribArray:_emscripten_glEnableVertexAttribArray,emscripten_glEndQueryEXT:_emscripten_glEndQueryEXT,emscripten_glFinish:_emscripten_glFinish,emscripten_glFlush:_emscripten_glFlush,emscripten_glFramebufferRenderbuffer:_emscripten_glFramebufferRenderbuffer,emscripten_glFramebufferTexture2D:_emscripten_glFramebufferTexture2D,emscripten_glFrontFace:_emscripten_glFrontFace,emscripten_glGenBuffers:_emscripten_glGenBuffers,emscripten_glGenFramebuffers:_emscripten_glGenFramebuffers,emscripten_glGenQueriesEXT:_emscripten_glGenQueriesEXT,emscripten_glGenRenderbuffers:_emscripten_glGenRenderbuffers,emscripten_glGenTextures:_emscripten_glGenTextures,emscripten_glGenVertexArraysOES:_emscripten_glGenVertexArraysOES,emscripten_glGenerateMipmap:_emscripten_glGenerateMipmap,emscripten_glGetActiveAttrib:_emscripten_glGetActiveAttrib,emscripten_glGetActiveUniform:_emscripten_glGetActiveUniform,emscripten_glGetAttachedShaders:_emscripten_glGetAttachedShaders,emscripten_glGetAttribLocation:_emscripten_glGetAttribLocation,emscripten_glGetBooleanv:_emscripten_glGetBooleanv,emscripten_glGetBufferParameteriv:_emscripten_glGetBufferParameteriv,emscripten_glGetError:_emscripten_glGetError,emscripten_glGetFloatv:_emscripten_glGetFloatv,emscripten_glGetFramebufferAttachmentParameteriv:_emscripten_glGetFramebufferAttachmentParameteriv,emscripten_glGetIntegerv:_emscripten_glGetIntegerv,emscripten_glGetProgramInfoLog:_emscripten_glGetProgramInfoLog,emscripten_glGetProgramiv:_emscripten_glGetProgramiv,emscripten_glGetQueryObjecti64vEXT:_emscripten_glGetQueryObjecti64vEXT,emscripten_glGetQueryObjectivEXT:_emscripten_glGetQueryObjectivEXT,emscripten_glGetQueryObjectui64vEXT:_emscripten_glGetQueryObjectui64vEXT,emscripten_glGetQueryObjectuivEXT:_emscripten_glGetQueryObjectuivEXT,emscripten_glGetQueryivEXT:_emscripten_glGetQueryivEXT,emscripten_glGetRenderbufferParameteriv:_emscripten_glGetRenderbufferParameteriv,emscripten_glGetShaderInfoLog:_emscripten_glGetShaderInfoLog,emscripten_glGetShaderPrecisionFormat:_emscripten_glGetShaderPrecisionFormat,emscripten_glGetShaderSource:_emscripten_glGetShaderSource,emscripten_glGetShaderiv:_emscripten_glGetShaderiv,emscripten_glGetString:_emscripten_glGetString,emscripten_glGetTexParameterfv:_emscripten_glGetTexParameterfv,emscripten_glGetTexParameteriv:_emscripten_glGetTexParameteriv,emscripten_glGetUniformLocation:_emscripten_glGetUniformLocation,emscripten_glGetUniformfv:_emscripten_glGetUniformfv,emscripten_glGetUniformiv:_emscripten_glGetUniformiv,emscripten_glGetVertexAttribPointerv:_emscripten_glGetVertexAttribPointerv,emscripten_glGetVertexAttribfv:_emscripten_glGetVertexAttribfv,emscripten_glGetVertexAttribiv:_emscripten_glGetVertexAttribiv,emscripten_glHint:_emscripten_glHint,emscripten_glIsBuffer:_emscripten_glIsBuffer,emscripten_glIsEnabled:_emscripten_glIsEnabled,emscripten_glIsFramebuffer:_emscripten_glIsFramebuffer,emscripten_glIsProgram:_emscripten_glIsProgram,emscripten_glIsQueryEXT:_emscripten_glIsQueryEXT,emscripten_glIsRenderbuffer:_emscripten_glIsRenderbuffer,emscripten_glIsShader:_emscripten_glIsShader,emscripten_glIsTexture:_emscripten_glIsTexture,emscripten_glIsVertexArrayOES:_emscripten_glIsVertexArrayOES,emscripten_glLineWidth:_emscripten_glLineWidth,emscripten_glLinkProgram:_emscripten_glLinkProgram,emscripten_glPixelStorei:_emscripten_glPixelStorei,emscripten_glPolygonModeWEBGL:_emscripten_glPolygonModeWEBGL,emscripten_glPolygonOffset:_emscripten_glPolygonOffset,emscripten_glPolygonOffsetClampEXT:_emscripten_glPolygonOffsetClampEXT,emscripten_glQueryCounterEXT:_emscripten_glQueryCounterEXT,emscripten_glReadPixels:_emscripten_glReadPixels,emscripten_glReleaseShaderCompiler:_emscripten_glReleaseShaderCompiler,emscripten_glRenderbufferStorage:_emscripten_glRenderbufferStorage,emscripten_glSampleCoverage:_emscripten_glSampleCoverage,emscripten_glScissor:_emscripten_glScissor,emscripten_glShaderBinary:_emscripten_glShaderBinary,emscripten_glShaderSource:_emscripten_glShaderSource,emscripten_glStencilFunc:_emscripten_glStencilFunc,emscripten_glStencilFuncSeparate:_emscripten_glStencilFuncSeparate,emscripten_glStencilMask:_emscripten_glStencilMask,emscripten_glStencilMaskSeparate:_emscripten_glStencilMaskSeparate,emscripten_glStencilOp:_emscripten_glStencilOp,emscripten_glStencilOpSeparate:_emscripten_glStencilOpSeparate,emscripten_glTexImage2D:_emscripten_glTexImage2D,emscripten_glTexParameterf:_emscripten_glTexParameterf,emscripten_glTexParameterfv:_emscripten_glTexParameterfv,emscripten_glTexParameteri:_emscripten_glTexParameteri,emscripten_glTexParameteriv:_emscripten_glTexParameteriv,emscripten_glTexSubImage2D:_emscripten_glTexSubImage2D,emscripten_glUniform1f:_emscripten_glUniform1f,emscripten_glUniform1fv:_emscripten_glUniform1fv,emscripten_glUniform1i:_emscripten_glUniform1i,emscripten_glUniform1iv:_emscripten_glUniform1iv,emscripten_glUniform2f:_emscripten_glUniform2f,emscripten_glUniform2fv:_emscripten_glUniform2fv,emscripten_glUniform2i:_emscripten_glUniform2i,emscripten_glUniform2iv:_emscripten_glUniform2iv,emscripten_glUniform3f:_emscripten_glUniform3f,emscripten_glUniform3fv:_emscripten_glUniform3fv,emscripten_glUniform3i:_emscripten_glUniform3i,emscripten_glUniform3iv:_emscripten_glUniform3iv,emscripten_glUniform4f:_emscripten_glUniform4f,emscripten_glUniform4fv:_emscripten_glUniform4fv,emscripten_glUniform4i:_emscripten_glUniform4i,emscripten_glUniform4iv:_emscripten_glUniform4iv,emscripten_glUniformMatrix2fv:_emscripten_glUniformMatrix2fv,emscripten_glUniformMatrix3fv:_emscripten_glUniformMatrix3fv,emscripten_glUniformMatrix4fv:_emscripten_glUniformMatrix4fv,emscripten_glUseProgram:_emscripten_glUseProgram,emscripten_glValidateProgram:_emscripten_glValidateProgram,emscripten_glVertexAttrib1f:_emscripten_glVertexAttrib1f,emscripten_glVertexAttrib1fv:_emscripten_glVertexAttrib1fv,emscripten_glVertexAttrib2f:_emscripten_glVertexAttrib2f,emscripten_glVertexAttrib2fv:_emscripten_glVertexAttrib2fv,emscripten_glVertexAttrib3f:_emscripten_glVertexAttrib3f,emscripten_glVertexAttrib3fv:_emscripten_glVertexAttrib3fv,emscripten_glVertexAttrib4f:_emscripten_glVertexAttrib4f,emscripten_glVertexAttrib4fv:_emscripten_glVertexAttrib4fv,emscripten_glVertexAttribDivisorANGLE:_emscripten_glVertexAttribDivisorANGLE,emscripten_glVertexAttribPointer:_emscripten_glVertexAttribPointer,emscripten_glViewport:_emscripten_glViewport,emscripten_is_main_browser_thread:_emscripten_is_main_browser_thread,emscripten_resize_heap:_emscripten_resize_heap,emscripten_run_script:_emscripten_run_script,emscripten_sample_gamepad_data:_emscripten_sample_gamepad_data,emscripten_set_blur_callback_on_thread:_emscripten_set_blur_callback_on_thread,emscripten_set_canvas_element_size:_emscripten_set_canvas_element_size,emscripten_set_click_callback_on_thread:_emscripten_set_click_callback_on_thread,emscripten_set_focus_callback_on_thread:_emscripten_set_focus_callback_on_thread,emscripten_set_fullscreenchange_callback_on_thread:_emscripten_set_fullscreenchange_callback_on_thread,emscripten_set_gamepadconnected_callback_on_thread:_emscripten_set_gamepadconnected_callback_on_thread,emscripten_set_gamepaddisconnected_callback_on_thread:_emscripten_set_gamepaddisconnected_callback_on_thread,emscripten_set_main_loop:_emscripten_set_main_loop,emscripten_set_mousedown_callback_on_thread:_emscripten_set_mousedown_callback_on_thread,emscripten_set_mousemove_callback_on_thread:_emscripten_set_mousemove_callback_on_thread,emscripten_set_mouseup_callback_on_thread:_emscripten_set_mouseup_callback_on_thread,emscripten_set_pointerlockchange_callback_on_thread:_emscripten_set_pointerlockchange_callback_on_thread,emscripten_set_resize_callback_on_thread:_emscripten_set_resize_callback_on_thread,emscripten_set_touchcancel_callback_on_thread:_emscripten_set_touchcancel_callback_on_thread,emscripten_set_touchend_callback_on_thread:_emscripten_set_touchend_callback_on_thread,emscripten_set_touchmove_callback_on_thread:_emscripten_set_touchmove_callback_on_thread,emscripten_set_touchstart_callback_on_thread:_emscripten_set_touchstart_callback_on_thread,emscripten_set_visibilitychange_callback_on_thread:_emscripten_set_visibilitychange_callback_on_thread,emscripten_set_window_title:_emscripten_set_window_title,emscripten_start_fetch:_emscripten_start_fetch,environ_get:_environ_get,environ_sizes_get:_environ_sizes_get,exit:_exit,fd_close:_fd_close,fd_read:_fd_read,fd_seek:_fd_seek,fd_write:_fd_write,get_cookie,glActiveTexture:_glActiveTexture,glAttachShader:_glAttachShader,glBindAttribLocation:_glBindAttribLocation,glBindBuffer:_glBindBuffer,glBindFramebuffer:_glBindFramebuffer,glBindRenderbuffer:_glBindRenderbuffer,glBindTexture:_glBindTexture,glBlendFunc:_glBlendFunc,glBufferData:_glBufferData,glBufferSubData:_glBufferSubData,glCheckFramebufferStatus:_glCheckFramebufferStatus,glClear:_glClear,glClearColor:_glClearColor,glClearDepthf:_glClearDepthf,glCompileShader:_glCompileShader,glCompressedTexImage2D:_glCompressedTexImage2D,glCreateProgram:_glCreateProgram,glCreateShader:_glCreateShader,glCullFace:_glCullFace,glDeleteProgram:_glDeleteProgram,glDeleteShader:_glDeleteShader,glDepthFunc:_glDepthFunc,glDisable:_glDisable,glDrawArrays:_glDrawArrays,glDrawElements:_glDrawElements,glEnable:_glEnable,glEnableVertexAttribArray:_glEnableVertexAttribArray,glFramebufferRenderbuffer:_glFramebufferRenderbuffer,glFramebufferTexture2D:_glFramebufferTexture2D,glFrontFace:_glFrontFace,glGenBuffers:_glGenBuffers,glGenFramebuffers:_glGenFramebuffers,glGenRenderbuffers:_glGenRenderbuffers,glGenTextures:_glGenTextures,glGetAttribLocation:_glGetAttribLocation,glGetFloatv:_glGetFloatv,glGetProgramInfoLog:_glGetProgramInfoLog,glGetProgramiv:_glGetProgramiv,glGetShaderInfoLog:_glGetShaderInfoLog,glGetShaderiv:_glGetShaderiv,glGetString:_glGetString,glGetUniformLocation:_glGetUniformLocation,glLinkProgram:_glLinkProgram,glPixelStorei:_glPixelStorei,glReadPixels:_glReadPixels,glRenderbufferStorage:_glRenderbufferStorage,glShaderSource:_glShaderSource,glTexImage2D:_glTexImage2D,glTexParameteri:_glTexParameteri,glUniform1i:_glUniform1i,glUniform4f:_glUniform4f,glUniformMatrix4fv:_glUniformMatrix4fv,glUseProgram:_glUseProgram,glVertexAttribPointer:_glVertexAttribPointer,glViewport:_glViewport,glfwCreateWindow:_glfwCreateWindow,glfwDefaultWindowHints:_glfwDefaultWindowHints,glfwGetPrimaryMonitor:_glfwGetPrimaryMonitor,glfwGetTime:_glfwGetTime,glfwGetVideoModes:_glfwGetVideoModes,glfwInit:_glfwInit,glfwMakeContextCurrent:_glfwMakeContextCurrent,glfwSetCharCallback:_glfwSetCharCallback,glfwSetCursorEnterCallback:_glfwSetCursorEnterCallback,glfwSetCursorPosCallback:_glfwSetCursorPosCallback,glfwSetDropCallback:_glfwSetDropCallback,glfwSetErrorCallback:_glfwSetErrorCallback,glfwSetKeyCallback:_glfwSetKeyCallback,glfwSetMouseButtonCallback:_glfwSetMouseButtonCallback,glfwSetScrollCallback:_glfwSetScrollCallback,glfwSetWindowContentScaleCallback:_glfwSetWindowContentScaleCallback,glfwSetWindowFocusCallback:_glfwSetWindowFocusCallback,glfwSetWindowIconifyCallback:_glfwSetWindowIconifyCallback,glfwSetWindowShouldClose:_glfwSetWindowShouldClose,glfwSetWindowSize:_glfwSetWindowSize,glfwSetWindowSizeCallback:_glfwSetWindowSizeCallback,glfwSwapBuffers:_glfwSwapBuffers,glfwTerminate:_glfwTerminate,glfwWindowHint:_glfwWindowHint,random_get:_random_get};var calledRun;function callMain(){assert(runDependencies==0,'cannot call main when async dependencies remain! (listen on Module["onRuntimeInitialized"])');assert(typeof onPreRuns==="undefined"||onPreRuns.length==0,"cannot call main when preRun functions remain to be called");var entryFunction=_main;var argc=0;var argv=0;try{var ret=entryFunction(argc,argv);exitJS(ret,true);return ret}catch(e){return handleException(e)}}function stackCheckInit(){_emscripten_stack_init();writeStackCookie()}function run(){if(runDependencies>0){dependenciesFulfilled=run;return}stackCheckInit();preRun();if(runDependencies>0){dependenciesFulfilled=run;return}function doRun(){assert(!calledRun);calledRun=true;Module["calledRun"]=true;if(ABORT)return;initRuntime();preMain();Module["onRuntimeInitialized"]?.();consumedModuleProp("onRuntimeInitialized");var noInitialRun=Module["noInitialRun"]||false;if(!noInitialRun)callMain();postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(()=>{setTimeout(()=>Module["setStatus"](""),1);doRun()},1)}else{doRun()}checkStackCookie()}function checkUnflushedContent(){var oldOut=out;var oldErr=err;var has=false;out=err=x=>{has=true};try{_fflush(0);for(var name of["stdout","stderr"]){var info=FS.analyzePath("/dev/"+name);if(!info)return;var stream=info.object;var rdev=stream.rdev;var tty=TTY.ttys[rdev];if(tty?.output?.length){has=true}}}catch(e){}out=oldOut;err=oldErr;if(has){warnOnce("stdio streams had content in them that was not flushed. you should set EXIT_RUNTIME to 1 (see the Emscripten FAQ), or make sure to emit a newline when you printf etc.")}}var wasmExports;createWasm();run(); diff --git a/2026/games/just__jane/sakura_samurai.wasm b/2026/games/just__jane/sakura_samurai.wasm Binary files differnew file mode 100755 index 0000000..5a2774e --- /dev/null +++ b/2026/games/just__jane/sakura_samurai.wasm diff --git a/2026/games/just__jane/src/clock.cpp b/2026/games/just__jane/src/clock.cpp new file mode 100644 index 0000000..fbe1dbb --- /dev/null +++ b/2026/games/just__jane/src/clock.cpp @@ -0,0 +1,19 @@ +#include "raylib.h" +#include <algorithm> +#include <clock.hpp> + +void Clock::Update() { current_frame_ = std::max(0.0f, (float)current_frame_ - 1); } +void Clock::Draw() { + + DrawCircle(center_position_.x, center_position_.y, radius_, {0x3c, 0x3a, 0x3a, 0xFF}); + DrawCircleSector( + center_position_, + radius_ - 2, + -90, + -90 + (-360 * (current_frame_ / (float)frame_total_)), + 36, + {0xDE, 0xAD, 0xFF, 0xFF}); +} + +bool Clock::TimeIsUp() { return current_frame_ <= 0; } +void Clock::Reset() { current_frame_ = frame_total_; } diff --git a/2026/games/just__jane/src/cut.cpp b/2026/games/just__jane/src/cut.cpp new file mode 100644 index 0000000..67e4c25 --- /dev/null +++ b/2026/games/just__jane/src/cut.cpp @@ -0,0 +1,37 @@ +#include "raylib.h" +#include "raymath.h" +#include <cut.hpp> + +Cut::Cut(Vector2 start, Vector2 end) { + InitAudioDevice(); + this->start_ = start; + this->end_ = end; + this->current_step_ = 0.0; + this->slash_ = LoadSound("assets/slash.wav"); +} + +void Cut::Draw() { + if (this->its_joever) { + return; + } + + Vector2 head = Vector2Lerp(start_, end_, current_step_); + DrawLineV(start_, head, {0x0F, 0x0F, 0x0F, 0x40}); +} + +void Cut::Update() { + if (this->its_joever) { + return; + } + + if (this->current_step_ == 0.0) { + PlaySound(slash_); + } + + if (this->current_step_ >= 1.0) { + this->its_joever = true; + return; + } + + this->current_step_ += (1.0 / 60.0); +} diff --git a/2026/games/just__jane/src/game_loop.cpp b/2026/games/just__jane/src/game_loop.cpp new file mode 100644 index 0000000..e95fc26 --- /dev/null +++ b/2026/games/just__jane/src/game_loop.cpp @@ -0,0 +1,425 @@ +#include "raylib.h" +#include <format> +#include <random> +#include <raymath.h> + +#include <emscripten/em_types.h> +#include <emscripten/emscripten.h> +#include <emscripten/html5.h> +#include <optional> + +#include <clock.hpp> +#include <cut.hpp> +#include <game_loop.hpp> +#include <petal.hpp> +#include <score.hpp> +#include <sstream> + +static std::uniform_real_distribution<float> rng_ = std::uniform_real_distribution<float>(); +std::mt19937 generator_; + +static bool initialized; +static bool game_over = false; +static int score; +static int score_to_win; + +static std::optional<Cut> the_cut; +static std::optional<Vector2> initial_point; +static std::optional<Vector2> terminal_point; + +static bool mouse_is_down; +static bool mouse_is_up; + +static Texture2D bg_texture_; +static Texture2D score_petal_texture; +static Texture2D ronin_textures; + +static RenderTexture2D draw_target; +static std::vector<Petal> petals; +static std::vector<Petal> tutorial_petals; + +static bool tutorial_is_running = true; +static long frame_counter; +static int ronin_anim_frame = 0; +static Vector2 ronin_position = {-40, GAME_HEIGHT - 30}; +constexpr Rectangle RONIN_FRAME = {0, 0, 44, 34}; + +static std::optional<bool> game_started; +static int TUTORIAL_END_FRAME = 90; +static int TUTORIAL_MOVE_START = 10; +static int TUTORIAL_CUT_FRAME = 50; +constexpr int TOTAL_GAME_TIME = 400; +static Clock game_clock(10, Vector2{GAME_WIDTH - 11, GAME_HEIGHT - 11}, TOTAL_GAME_TIME); + +static double difficulty = 0.0; + +static std::vector<ScorePetal> score_petals; + +void RenderFreezeFrames() { + BeginTextureMode(draw_target); + if (the_cut) { + the_cut->Draw(); + } + EndTextureMode(); +} + +void RenderDrawTarget() { + BeginTextureMode(draw_target); + Rectangle source = Rectangle{ + .x = 0, + .y = 0, + .width = (float)bg_texture_.width, + .height = (float)bg_texture_.height, + }; + + Rectangle dest = Rectangle{ + .x = 0, + .y = 0, + .width = GAME_WIDTH, + .height = GAME_HEIGHT, + }; + + DrawTexturePro(bg_texture_, source, dest, {0, 0}, 0, WHITE); + + for (Petal petal : petals) { + petal.Draw(); + } + + if (the_cut) { + the_cut->Draw(); + } + + game_clock.Draw(); + EndTextureMode(); +} + +EM_BOOL OnGlobalMouse(int event_type, const EmscriptenMouseEvent *mouse_event, void *user_data) { + if (event_type == EMSCRIPTEN_EVENT_MOUSEDOWN) { + mouse_is_down = true; + } else if (event_type == EMSCRIPTEN_EVENT_MOUSEUP) { + mouse_is_down = false; + mouse_is_up = true; + } + + return EM_FALSE; +} + +void StartNewGame(bool with_tutorial = true) { + game_clock.Reset(); + petals.clear(); + tutorial_petals.clear(); + score_petals.clear(); + + Rectangle window = Rectangle{.x = 0, .y = 0, .width = GAME_WIDTH, .height = GAME_HEIGHT}; + tutorial_petals.push_back(Petal(window, Vector2{10, -10}, 0)); + tutorial_petals.push_back(Petal(window, Vector2{50, -1}, 0)); + tutorial_petals.push_back(Petal(window, Vector2{70, -5}, 2)); + tutorial_petals.push_back(Petal(window, Vector2{98, 10}, 0, 0.9)); + tutorial_petals.push_back(Petal(window, Vector2{14, 7}, 1)); + tutorial_petals.push_back(Petal(window, Vector2{37, 5}, 1, 0.2)); + tutorial_petals.push_back(Petal(window, Vector2{19, 13}, 0)); + tutorial_petals.push_back(Petal(window, Vector2{39, 19}, 0)); + tutorial_petals.push_back(Petal(window, Vector2{65, 0}, 2, 0.8)); + tutorial_petals.push_back(Petal(window, Vector2{104, 5}, 1)); + tutorial_petals.push_back(Petal(window, Vector2{12, 4}, 0, 0.4)); + + game_over = false; + the_cut = std::nullopt; + initial_point = std::nullopt; + terminal_point = std::nullopt; + score = 0; + tutorial_is_running = with_tutorial; + frame_counter = 0; + ronin_anim_frame = 0; + ronin_position = {-40, GAME_HEIGHT - 44}; + game_started = true; + + std::random_device rd; + generator_ = std::mt19937(rd()); +} + +void InitializeAssets() { + score_petal_texture = LoadTexture("assets/petals/cut_petal.png"); + bg_texture_ = LoadTexture("assets/background.png"); + ronin_textures = LoadTexture("assets/ronin.png"); + + draw_target = LoadRenderTexture(GAME_WIDTH, GAME_HEIGHT); + + emscripten_set_mousedown_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, nullptr, EM_TRUE, OnGlobalMouse); + emscripten_set_mouseup_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, nullptr, EM_TRUE, OnGlobalMouse); + + initialized = true; +} + +void Draw() { + ClearBackground(RAYWHITE); + + if (the_cut.has_value() && !the_cut.value().its_joever) { + RenderFreezeFrames(); + } else { + RenderDrawTarget(); + } + + Rectangle target_src{ + .x = 0, + .y = 0, + .width = GAME_WIDTH, + .height = -GAME_HEIGHT, + }; + + Rectangle target_dest{ + .x = 0, + .y = 0, + .width = GAME_WIDTH * SCALE, + .height = GAME_HEIGHT * SCALE, + }; + + DrawTexturePro(draw_target.texture, target_src, target_dest, {0, 0}, 0, WHITE); +} + +void Update() { + if (!game_started) { + game_started = true; + } + + if (!game_over) { + game_clock.Update(); + if (game_clock.TimeIsUp() && !the_cut.has_value()) { + the_cut = Cut(Vector2{0, 0}, Vector2{0, 0}); + game_over = true; + } + + if (!game_over && the_cut.has_value() && !the_cut.value().its_joever) { + the_cut->Update(); + return; + } + + if (!game_over && the_cut.has_value() && the_cut->its_joever) { + for (Petal &petal : petals) { + petal.Cut(*initial_point, *terminal_point); + if (petal.IsCut) { + score += 1; + score_petals.push_back( + ScorePetal{ + .Position{.x = 20 + (float)score * (score_petal_texture.width + 3), .y = GAME_HEIGHT - 5}, + .Texture = score_petal_texture}); + } + } + post_score(score); + game_over = true; + } + + if (!initial_point.has_value() && mouse_is_down) { + initial_point = Vector2Scale(GetMousePosition(), 1.0f / SCALE); + } + + if (!terminal_point.has_value() && initial_point.has_value() && mouse_is_up) { + terminal_point = Vector2Scale(GetMousePosition(), 1.0f / SCALE); + } + + if (!the_cut.has_value() && initial_point.has_value() && terminal_point.has_value()) { + Vector2 direction = Vector2Normalize(Vector2Subtract(terminal_point.value(), initial_point.value())); + terminal_point = Vector2Add(initial_point.value(), Vector2Scale(direction, 70.0f)); + the_cut = Cut(*initial_point, *terminal_point); + } + } + + for (Petal &petal : petals) { + petal.Update(); + } + + if (petals.size() < 20 && rng_(generator_) > .90) { + std::random_device rd; + Rectangle window = Rectangle{.x = 0, .y = 0, .width = GAME_WIDTH, .height = GAME_HEIGHT}; + petals.push_back(Petal(window, rd())); + } + + petals.erase( + std::remove_if(petals.begin(), petals.end(), [](Petal petal) { return petal.GetPosition().y > GAME_HEIGHT; }), + petals.end()); +} + +void UpdateTutorial() { + for (auto &blossom : tutorial_petals) { + blossom.Update(); + } + + frame_counter += 1; + if (frame_counter % 2 != 0) { + return; + } + + if (frame_counter > TUTORIAL_END_FRAME) { + tutorial_is_running = false; + } + + if (frame_counter > TUTORIAL_MOVE_START) { + if (ronin_position.x < 10) { + ronin_position.x += 2; + return; + } + + if (ronin_anim_frame < 5) { + ronin_anim_frame += 1; + return; + } + } + + if (tutorial_petals.size() > 0 && !tutorial_petals[0].IsCut && frame_counter > TUTORIAL_CUT_FRAME) { + for (auto &blossom : tutorial_petals) { + blossom.Cut(); + } + } +} + +void RenderTutorialDrawTarget() { + BeginTextureMode(draw_target); + Rectangle source = Rectangle{ + .x = 0, + .y = 0, + .width = (float)bg_texture_.width, + .height = (float)bg_texture_.height, + }; + + Rectangle dest = Rectangle{ + .x = 0, + .y = 0, + .width = GAME_WIDTH, + .height = GAME_HEIGHT, + }; + + DrawTexturePro(bg_texture_, source, dest, {0, 0}, 0, WHITE); + + Rectangle src = Rectangle{ + .x = RONIN_FRAME.width * ronin_anim_frame, + .y = 0, + .width = RONIN_FRAME.width, + .height = RONIN_FRAME.height}; + + Rectangle ronin_dest = + Rectangle{.x = ronin_position.x, .y = ronin_position.y, .width = RONIN_FRAME.width, .height = RONIN_FRAME.height}; + + DrawTexturePro(ronin_textures, src, ronin_dest, {0, 0}, 0, WHITE); + + for (auto blossom : tutorial_petals) { + blossom.Draw(); + } + + EndTextureMode(); +} + +void DrawTutorial() { + ClearBackground(RAYWHITE); + + RenderTutorialDrawTarget(); + + Rectangle target_src{ + .x = 0, + .y = 0, + .width = GAME_WIDTH, + .height = -GAME_HEIGHT, + }; + + Rectangle target_dest{ + .x = 0, + .y = 0, + .width = GAME_WIDTH * SCALE, + .height = GAME_HEIGHT * SCALE, + }; + + Color c = WHITE; + DrawTexturePro(draw_target.texture, target_src, target_dest, {0, 0}, 0, c); +} + +static bool user_started_game = false; +void UpdateStart() { + if (IsMouseButtonReleased(MOUSE_BUTTON_LEFT)) { + InitAudioDevice(); + SetAudioStreamBufferSizeDefault(4096); + user_started_game = true; + } +} + +void DrawStart() { + ClearBackground(WHITE); + DrawText("click to start", GAME_WIDTH / 2 - 20, GAME_HEIGHT / 2 - 5, 20, BLACK); +} + +void UpdateGameOver() { + static int counter = 0; + Update(); + if (counter++ > 120) { + counter = 0; + if (score > difficulty) { + emscripten_run_script("window.parent.postMessage({op: \"done\", win: true});"); + } else { + emscripten_run_script("window.parent.postMessage({op: \"done\", win: false});"); + } + initialized = false; + StartNewGame(false); + } +} + +void DrawGameOver() { + ClearBackground(WHITE); + Draw(); + + // std::string text = std::format("SCORE: {}", score); + // DrawText(text.c_str(), GAME_WIDTH / 2 - 20, GAME_HEIGHT / 2 - 5, 20, BLACK); + for (auto petal : score_petals) { + Vector2 position = {petal.Position.x * SCALE, petal.Position.y * SCALE}; + DrawTextureEx(petal.Texture, position, 0, SCALE, WHITE); + } +} + +void UpdateDrawFrame() { + if (!initialized) { + difficulty = EM_ASM_DOUBLE({ return window.lcolonqJamStart || -1.0; }); + if (difficulty < 0.0) { + return; + } + + if (difficulty < 3) { + score_to_win = 2; + } else if (difficulty < 10) { + score_to_win = 3; + } else if (difficulty < 20) { + score_to_win = 5; + } else { + score_to_win = 8; + } + + std::stringstream ss; + ss << "window.parent.postMessage({op: \"started\", verb: \"cut" << score_to_win; + ss << "\" });"; + emscripten_run_script(ss.str().c_str()); + InitializeAssets(); + InitAudioDevice(); + SetAudioStreamBufferSizeDefault(4096); + StartNewGame(); + + initialized = true; + return; + } + + if (tutorial_is_running) { + UpdateTutorial(); + BeginDrawing(); + DrawTutorial(); + EndDrawing(); + return; + } + + if (game_over) { + UpdateGameOver(); + BeginDrawing(); + DrawGameOver(); + EndDrawing(); + return; + } + + Update(); + BeginDrawing(); + Draw(); + EndDrawing(); +} diff --git a/2026/games/just__jane/src/main.cpp b/2026/games/just__jane/src/main.cpp new file mode 100644 index 0000000..2c07641 --- /dev/null +++ b/2026/games/just__jane/src/main.cpp @@ -0,0 +1,17 @@ +#include "raylib.h" + +#include <emscripten/em_types.h> +#include <emscripten/emscripten.h> +#include <emscripten/html5.h> + +#include <cut.hpp> +#include <game_loop.hpp> + +int main() { + InitWindow(GAME_WIDTH * SCALE, GAME_HEIGHT * SCALE, "sakura samurai"); + emscripten_run_script("window.parent.postMessage({op: \"ready\"});"); + emscripten_set_main_loop(UpdateDrawFrame, 30, 1); + // EM_ASM(window.lcolonqJamStart = 1.0;); + + return 0; +} diff --git a/2026/games/just__jane/src/score.cpp b/2026/games/just__jane/src/score.cpp new file mode 100644 index 0000000..ea0aa78 --- /dev/null +++ b/2026/games/just__jane/src/score.cpp @@ -0,0 +1,79 @@ +#include <cstring> +#include <format> +#include <string> + +#include <emscripten/em_types.h> +#include <emscripten/emscripten.h> +#include <emscripten/fetch.h> +#include <emscripten/html5.h> + +struct PostData { + char *body; +}; + +EM_JS(char *, get_cookie, (const char *name), { + const cookieName = UTF8ToString(name) + "="; + const cookies = document.cookie.split(";"); + + for (let c of cookies) { + c = c.trim(); + + if (c.startsWith(cookieName)) { + const value = c.substring(cookieName.length); + const len = lengthBytesUTF8(value) + 1; + const buffer = _malloc(len); + stringToUTF8(value, buffer, len); + return buffer; + } + } + + return 0; +}); + +void cleanup(emscripten_fetch_t *fetch) { + auto *data = static_cast<PostData *>(fetch->userData); + free(data->body); + delete data; + emscripten_fetch_close(fetch); +} + +void on_success(emscripten_fetch_t *fetch) { + printf("success: %d\n", fetch->status); + cleanup(fetch); +} + +void on_error(emscripten_fetch_t *fetch) { + printf("error: %d\n", fetch->status); + cleanup(fetch); +} + +void post_score(int score) { + auto username = get_cookie("bahms_user_login"); + if (!username) { + return; + } + + std::string text = std::format("## {}\nscore: {}", username, score); + + auto *data = new PostData; + data->body = static_cast<char *>(malloc(text.size())); + memcpy(data->body, text.data(), text.size()); + + emscripten_fetch_attr_t attr; + emscripten_fetch_attr_init(&attr); + + strcpy(attr.requestMethod, "POST"); + attr.withCredentials = true; + + const char *headers[] = {"Content-Type", "text/plain; charset=utf-8", nullptr}; + + attr.requestHeaders = headers; + attr.requestData = data->body; + attr.requestDataSize = text.size(); + attr.userData = data; + + attr.onsuccess = on_success; + attr.onerror = on_error; + + emscripten_fetch(&attr, "https://api.bahms.org/v1/game/sakura-samurai"); +} diff --git a/2026/games_submissions/asrael_io/CREDITS.txt b/2026/games_submissions/asrael_io/CREDITS.txt new file mode 100644 index 0000000..82f26b5 --- /dev/null +++ b/2026/games_submissions/asrael_io/CREDITS.txt @@ -0,0 +1,8 @@ +cj2k26 by asrael https://github.com/asrael/cj2k26
+
+Thanks to the below third-parties!
+
+* DB32 color palette by DawnBringer (Richard Fhager) *
+* SID audio emulation by resid-rs (GPL license applies to the binary) *
+* Built with Rust, winit, softbuffer, cpal, glam, aseprite-io, embedded-graphics and Trunk *
+
diff --git a/2026/games_submissions/asrael_io/LICENSE b/2026/games_submissions/asrael_io/LICENSE new file mode 100644 index 0000000..85f3c07 --- /dev/null +++ b/2026/games_submissions/asrael_io/LICENSE @@ -0,0 +1,21 @@ +MIT License
+
+Copyright (c) 2026 asrael
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/2026/games_submissions/asrael_io/cj2k26-775b42dad04180ed.js b/2026/games_submissions/asrael_io/cj2k26-775b42dad04180ed.js new file mode 100644 index 0000000..cc22c9f --- /dev/null +++ b/2026/games_submissions/asrael_io/cj2k26-775b42dad04180ed.js @@ -0,0 +1,1294 @@ +/** + * Format that each sample has. Usually, this corresponds to the sampling + * depth of the audio source. For example, 16 bit quantized samples can be + * encoded in `i16` or `u16`. Note that the quantized sampling depth is not + * directly visible for formats where [`is_float`] is true. + * + * Also note that the backend must support the encoding of the quantized + * samples in the given format, as there is no generic transformation from one + * format into the other done inside the frontend-library code. You can query + * the supported formats by using [`supported_input_configs`]. + * + * A good rule of thumb is to use [`SampleFormat::I16`] as this covers typical + * music (WAV, MP3) as well as typical audio input devices on most platforms, + * + * [`is_float`]: SampleFormat::is_float + * [`supported_input_configs`]: crate::traits::DeviceTrait::supported_input_configs + * @enum {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14} + */ +export const SampleFormat = Object.freeze({ + /** + * `i8` with a valid range of `i8::MIN..=i8::MAX` with `0` being the origin. + */ + I8: 0, "0": "I8", + /** + * `i16` with a valid range of `i16::MIN..=i16::MAX` with `0` being the origin. + */ + I16: 1, "1": "I16", + /** + * `I24` with a valid range of `-(1 << 23)..=((1 << 23) - 1)` with `0` being the origin. + * + * This format uses 4 bytes of storage but only 24 bits are significant. + */ + I24: 2, "2": "I24", + /** + * `i32` with a valid range of `i32::MIN..=i32::MAX` with `0` being the origin. + */ + I32: 3, "3": "I32", + /** + * `i64` with a valid range of `i64::MIN..=i64::MAX` with `0` being the origin. + */ + I64: 4, "4": "I64", + /** + * `u8` with a valid range of `u8::MIN..=u8::MAX` with `1 << 7 == 128` being the origin. + */ + U8: 5, "5": "U8", + /** + * `u16` with a valid range of `u16::MIN..=u16::MAX` with `1 << 15 == 32768` being the origin. + */ + U16: 6, "6": "U16", + /** + * `U24` with a valid range of `0..=((1 << 24) - 1)` with `1 << 23 == 8388608` being the origin. + * + * This format uses 4 bytes of storage but only 24 bits are significant. + */ + U24: 7, "7": "U24", + /** + * `u32` with a valid range of `u32::MIN..=u32::MAX` with `1 << 31` being the origin. + */ + U32: 8, "8": "U32", + /** + * `U48` with a valid range of '0..(1 << 48)' with `1 << 47` being the origin + * `u64` with a valid range of `u64::MIN..=u64::MAX` with `1 << 63` being the origin. + */ + U64: 9, "9": "U64", + /** + * `f32` with a valid range of `-1.0..=1.0` with `0.0` being the origin. + */ + F32: 10, "10": "F32", + /** + * `f64` with a valid range of `-1.0..=1.0` with `0.0` being the origin. + */ + F64: 11, "11": "F64", + /** + * DSD 1-bit stream in u8 container (8 bits = 8 DSD samples) with 0x69 being the silence byte pattern. + */ + DsdU8: 12, "12": "DsdU8", + /** + * DSD 1-bit stream in u16 container (16 bits = 16 DSD samples) with 0x69 being the silence byte pattern. + */ + DsdU16: 13, "13": "DsdU16", + /** + * DSD 1-bit stream in u32 container (32 bits = 32 DSD samples) with 0x69 being the silence byte pattern. + */ + DsdU32: 14, "14": "DsdU32", +}); + +/** + * The set of parameters used to describe how to open a stream. + * + * The sample format is omitted in favour of using a sample type. + * + * See also [`BufferSize`] for details on buffer size behavior and latency considerations. + */ +export class StreamConfig { + __destroy_into_raw() { + const ptr = this.__wbg_ptr; + this.__wbg_ptr = 0; + StreamConfigFinalization.unregister(this); + return ptr; + } + free() { + const ptr = this.__destroy_into_raw(); + wasm.__wbg_streamconfig_free(ptr, 0); + } + /** + * @returns {number | undefined} + */ + get buffer_size() { + const ret = wasm.__wbg_get_streamconfig_buffer_size(this.__wbg_ptr); + return ret === Number.MAX_SAFE_INTEGER ? undefined : ret; + } + /** + * @returns {number} + */ + get channels() { + const ret = wasm.__wbg_get_streamconfig_channels(this.__wbg_ptr); + return ret; + } + /** + * @returns {number} + */ + get sample_rate() { + const ret = wasm.__wbg_get_streamconfig_sample_rate(this.__wbg_ptr); + return ret >>> 0; + } + /** + * @param {number | null} [arg0] + */ + set buffer_size(arg0) { + wasm.__wbg_set_streamconfig_buffer_size(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : (arg0) >>> 0); + } + /** + * @param {number} arg0 + */ + set channels(arg0) { + wasm.__wbg_set_streamconfig_channels(this.__wbg_ptr, arg0); + } + /** + * @param {number} arg0 + */ + set sample_rate(arg0) { + wasm.__wbg_set_streamconfig_sample_rate(this.__wbg_ptr, arg0); + } +} +if (Symbol.dispose) StreamConfig.prototype[Symbol.dispose] = StreamConfig.prototype.free; +function __wbg_get_imports() { + const import0 = { + __proto__: null, + __wbg_Window_c7f91e3f80ae0a0e: function(arg0) { + const ret = arg0.Window; + return ret; + }, + __wbg___wbindgen_debug_string_8a447059637473e2: function(arg0, arg1) { + const ret = debugString(arg1); + const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true); + getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true); + }, + __wbg___wbindgen_is_falsy_863e44ed68df4b26: function(arg0) { + const ret = !arg0; + return ret; + }, + __wbg___wbindgen_is_function_acc5528be2b923f2: function(arg0) { + const ret = typeof(arg0) === 'function'; + return ret; + }, + __wbg___wbindgen_is_undefined_721f8decd50c87a3: function(arg0) { + const ret = arg0 === undefined; + return ret; + }, + __wbg___wbindgen_number_get_1cc01dd708740256: function(arg0, arg1) { + const obj = arg1; + const ret = typeof(obj) === 'number' ? obj : undefined; + getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true); + getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true); + }, + __wbg___wbindgen_throw_ea4887a5f8f9a9db: function(arg0, arg1) { + throw new Error(getStringFromWasm0(arg0, arg1)); + }, + __wbg__wbg_cb_unref_33c39e13d73b25f6: function(arg0) { + arg0._wbg_cb_unref(); + }, + __wbg_abort_6e6ea7d259504afc: function(arg0) { + arg0.abort(); + }, + __wbg_activeElement_39e967783d67360b: function(arg0) { + const ret = arg0.activeElement; + return isLikeNone(ret) ? 0 : addToExternrefTable0(ret); + }, + __wbg_addEventListener_ea90bc131475777e: function() { return handleError(function (arg0, arg1, arg2, arg3) { + arg0.addEventListener(getStringFromWasm0(arg1, arg2), arg3); + }, arguments); }, + __wbg_addListener_ddaa585636995443: function() { return handleError(function (arg0, arg1) { + arg0.addListener(arg1); + }, arguments); }, + __wbg_altKey_7412dd64f8c921c7: function(arg0) { + const ret = arg0.altKey; + return ret; + }, + __wbg_altKey_bd27feb84dabed76: function(arg0) { + const ret = arg0.altKey; + return ret; + }, + __wbg_animate_8f41e2f47c7d04ab: function(arg0, arg1, arg2) { + const ret = arg0.animate(arg1, arg2); + return ret; + }, + __wbg_appendChild_acb7691406591783: function() { return handleError(function (arg0, arg1) { + const ret = arg0.appendChild(arg1); + return ret; + }, arguments); }, + __wbg_blockSize_ec8ab846ac2b2395: function(arg0) { + const ret = arg0.blockSize; + return ret; + }, + __wbg_body_c94f9310613c153b: function(arg0) { + const ret = arg0.body; + return isLikeNone(ret) ? 0 : addToExternrefTable0(ret); + }, + __wbg_brand_3bc196a43eceb8af: function(arg0, arg1) { + const ret = arg1.brand; + const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true); + getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true); + }, + __wbg_brands_b7dcf262485c3e7c: function(arg0) { + const ret = arg0.brands; + return ret; + }, + __wbg_button_bb3285fcdf965178: function(arg0) { + const ret = arg0.button; + return ret; + }, + __wbg_buttons_c15069bb056ecbe0: function(arg0) { + const ret = arg0.buttons; + return ret; + }, + __wbg_cancelAnimationFrame_32c0ef91e4077228: function() { return handleError(function (arg0, arg1) { + arg0.cancelAnimationFrame(arg1); + }, arguments); }, + __wbg_cancelIdleCallback_d2ed70e82f4d3a29: function(arg0, arg1) { + arg0.cancelIdleCallback(arg1 >>> 0); + }, + __wbg_cancel_65f38182e2eeac5c: function(arg0) { + arg0.cancel(); + }, + __wbg_catch_2bb4b6f2fafb00e7: function(arg0, arg1) { + const ret = arg0.catch(arg1); + return ret; + }, + __wbg_clearTimeout_ef73c3ecbb0ece69: function(arg0, arg1) { + arg0.clearTimeout(arg1); + }, + __wbg_close_38d22e2ee9732188: function(arg0) { + arg0.close(); + }, + __wbg_close_4a2ea9d027459db5: function() { return handleError(function (arg0) { + const ret = arg0.close(); + return ret; + }, arguments); }, + __wbg_code_87bb99fdec02d313: function(arg0, arg1) { + const ret = arg1.code; + const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true); + getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true); + }, + __wbg_connect_9e5c8070ebfff120: function() { return handleError(function (arg0, arg1) { + const ret = arg0.connect(arg1); + return ret; + }, arguments); }, + __wbg_contains_aeb13d2d343b24e8: function(arg0, arg1) { + const ret = arg0.contains(arg1); + return ret; + }, + __wbg_contentRect_0fb8c8900d689a0c: function(arg0) { + const ret = arg0.contentRect; + return ret; + }, + __wbg_copyToChannel_2dc84de416ae333c: function() { return handleError(function (arg0, arg1, arg2, arg3) { + arg0.copyToChannel(getArrayF32FromWasm0(arg1, arg2), arg3); + }, arguments); }, + __wbg_createBufferSource_4ab4dfdfe9715127: function() { return handleError(function (arg0) { + const ret = arg0.createBufferSource(); + return ret; + }, arguments); }, + __wbg_createBuffer_5c218bb6dd6cdecd: function() { return handleError(function (arg0, arg1, arg2, arg3) { + const ret = arg0.createBuffer(arg1 >>> 0, arg2 >>> 0, arg3); + return ret; + }, arguments); }, + __wbg_createElement_9e23ac95e40e302c: function() { return handleError(function (arg0, arg1, arg2) { + const ret = arg0.createElement(getStringFromWasm0(arg1, arg2)); + return ret; + }, arguments); }, + __wbg_createObjectURL_d8fd80787743974d: function() { return handleError(function (arg0, arg1) { + const ret = URL.createObjectURL(arg1); + const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true); + getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true); + }, arguments); }, + __wbg_ctrlKey_00097886a21597a7: function(arg0) { + const ret = arg0.ctrlKey; + return ret; + }, + __wbg_ctrlKey_e2bcba26214642c1: function(arg0) { + const ret = arg0.ctrlKey; + return ret; + }, + __wbg_currentTime_bbb4792a857fb8bd: function(arg0) { + const ret = arg0.currentTime; + return ret; + }, + __wbg_deltaMode_af2c1b6d0e654eb8: function(arg0) { + const ret = arg0.deltaMode; + return ret; + }, + __wbg_deltaX_002e415d6311b335: function(arg0) { + const ret = arg0.deltaX; + return ret; + }, + __wbg_deltaY_5c6a1e0334a84e24: function(arg0) { + const ret = arg0.deltaY; + return ret; + }, + __wbg_destination_5fd830d2afccd2e6: function(arg0) { + const ret = arg0.destination; + return ret; + }, + __wbg_devicePixelContentBoxSize_442c861e416326ba: function(arg0) { + const ret = arg0.devicePixelContentBoxSize; + return ret; + }, + __wbg_devicePixelRatio_8e5ca44720abafec: function(arg0) { + const ret = arg0.devicePixelRatio; + return ret; + }, + __wbg_disconnect_970650440e4877a1: function(arg0) { + arg0.disconnect(); + }, + __wbg_disconnect_fff596d884a74ee7: function(arg0) { + arg0.disconnect(); + }, + __wbg_document_2634180a4c694068: function(arg0) { + const ret = arg0.document; + return isLikeNone(ret) ? 0 : addToExternrefTable0(ret); + }, + __wbg_error_6fe2f1675730f2bd: function(arg0, arg1) { + console.error(arg0, arg1); + }, + __wbg_error_a6fa202b58aa1cd3: function(arg0, arg1) { + let deferred0_0; + let deferred0_1; + try { + deferred0_0 = arg0; + deferred0_1 = arg1; + console.error(getStringFromWasm0(arg0, arg1)); + } finally { + wasm.__wbindgen_free(deferred0_0, deferred0_1, 1); + } + }, + __wbg_focus_c80921c19b28520b: function() { return handleError(function (arg0) { + arg0.focus(); + }, arguments); }, + __wbg_fullscreenElement_0961e3f245820d9a: function(arg0) { + const ret = arg0.fullscreenElement; + return isLikeNone(ret) ? 0 : addToExternrefTable0(ret); + }, + __wbg_getCoalescedEvents_3e003f63d9ebbc05: function(arg0) { + const ret = arg0.getCoalescedEvents; + return ret; + }, + __wbg_getCoalescedEvents_b5b03d5636ebc2f4: function(arg0) { + const ret = arg0.getCoalescedEvents(); + return ret; + }, + __wbg_getComputedStyle_3fed4438a3d089a6: function() { return handleError(function (arg0, arg1) { + const ret = arg0.getComputedStyle(arg1); + return isLikeNone(ret) ? 0 : addToExternrefTable0(ret); + }, arguments); }, + __wbg_getContext_486aab500e1c34c9: function() { return handleError(function (arg0, arg1, arg2) { + const ret = arg0.getContext(getStringFromWasm0(arg1, arg2)); + return isLikeNone(ret) ? 0 : addToExternrefTable0(ret); + }, arguments); }, + __wbg_getOwnPropertyDescriptor_7f06ccc7c66b4ef1: function(arg0, arg1) { + const ret = Object.getOwnPropertyDescriptor(arg0, arg1); + return ret; + }, + __wbg_getPropertyValue_25192bdc8db9053c: function() { return handleError(function (arg0, arg1, arg2, arg3) { + const ret = arg1.getPropertyValue(getStringFromWasm0(arg2, arg3)); + const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true); + getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true); + }, arguments); }, + __wbg_get_197a3fe98f169e38: function(arg0, arg1) { + const ret = arg0[arg1 >>> 0]; + return ret; + }, + __wbg_get_dddb90ff5d27a080: function() { return handleError(function (arg0, arg1) { + const ret = Reflect.get(arg0, arg1); + return ret; + }, arguments); }, + __wbg_get_unchecked_54a4374c38e08460: function(arg0, arg1) { + const ret = arg0[arg1 >>> 0]; + return ret; + }, + __wbg_height_e9afb506f31052a9: function(arg0) { + const ret = arg0.height; + return ret; + }, + __wbg_inlineSize_8895590ca1875f8d: function(arg0) { + const ret = arg0.inlineSize; + return ret; + }, + __wbg_instanceof_CanvasRenderingContext2d_d0cab9e931424c52: function(arg0) { + let result; + try { + result = arg0 instanceof CanvasRenderingContext2D; + } catch (_) { + result = false; + } + const ret = result; + return ret; + }, + __wbg_instanceof_Window_0d356b88a2f77c42: function(arg0) { + let result; + try { + result = arg0 instanceof Window; + } catch (_) { + result = false; + } + const ret = result; + return ret; + }, + __wbg_isIntersecting_e02cd273824aee08: function(arg0) { + const ret = arg0.isIntersecting; + return ret; + }, + __wbg_is_de5b366c746e004c: function(arg0, arg1) { + const ret = Object.is(arg0, arg1); + return ret; + }, + __wbg_jamDone_2ac48972f7fb4f0d: function(arg0) { + jamDone(arg0 !== 0); + }, + __wbg_jamGetDifficulty_2e91265e302a31c4: function() { + const ret = jamGetDifficulty(); + return ret; + }, + __wbg_jamShouldStart_4ca65fa65f0c295d: function() { + const ret = jamShouldStart(); + return ret; + }, + __wbg_jamStarted_31e56ffec992bd70: function(arg0, arg1) { + jamStarted(getStringFromWasm0(arg0, arg1)); + }, + __wbg_key_d6b3d2cce3d41872: function(arg0, arg1) { + const ret = arg1.key; + const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true); + getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true); + }, + __wbg_length_c6054974c0a6cdb9: function(arg0) { + const ret = arg0.length; + return ret; + }, + __wbg_location_8fedbe6d61285cd1: function(arg0) { + const ret = arg0.location; + return ret; + }, + __wbg_matchMedia_049ef5c8f8f904f2: function() { return handleError(function (arg0, arg1, arg2) { + const ret = arg0.matchMedia(getStringFromWasm0(arg1, arg2)); + return isLikeNone(ret) ? 0 : addToExternrefTable0(ret); + }, arguments); }, + __wbg_matches_a4c6202857b1dac9: function(arg0) { + const ret = arg0.matches; + return ret; + }, + __wbg_maxChannelCount_a5848f76107b1af2: function(arg0) { + const ret = arg0.maxChannelCount; + return ret; + }, + __wbg_metaKey_1c2847b62ad062c1: function(arg0) { + const ret = arg0.metaKey; + return ret; + }, + __wbg_metaKey_e661374fe349fa2f: function(arg0) { + const ret = arg0.metaKey; + return ret; + }, + __wbg_movementX_128a28f825e5e554: function(arg0) { + const ret = arg0.movementX; + return ret; + }, + __wbg_movementY_10cde9bca43c7656: function(arg0) { + const ret = arg0.movementY; + return ret; + }, + __wbg_navigator_935098efd1dc7fe5: function(arg0) { + const ret = arg0.navigator; + return ret; + }, + __wbg_new_1e52e3c919312525: function() { return handleError(function (arg0) { + const ret = new ResizeObserver(arg0); + return ret; + }, arguments); }, + __wbg_new_227d7c05414eb861: function() { + const ret = new Error(); + return ret; + }, + __wbg_new_2e117a478906f062: function() { + const ret = new Object(); + return ret; + }, + __wbg_new_51233fa2a760b272: function() { return handleError(function () { + const ret = new AbortController(); + return ret; + }, arguments); }, + __wbg_new_98e81f23cc202cc4: function() { return handleError(function () { + const ret = new MessageChannel(); + return ret; + }, arguments); }, + __wbg_new_cbb1396a0ca9d6f4: function() { return handleError(function (arg0, arg1) { + const ret = new Worker(getStringFromWasm0(arg0, arg1)); + return ret; + }, arguments); }, + __wbg_new_e469d9dc75b3bc01: function() { return handleError(function (arg0) { + const ret = new IntersectionObserver(arg0); + return ret; + }, arguments); }, + __wbg_new_with_context_options_659dcd92353a5d8d: function() { return handleError(function (arg0) { + const ret = new lAudioContext(arg0); + return ret; + }, arguments); }, + __wbg_new_with_str_sequence_and_options_b67a6653749e1791: function() { return handleError(function (arg0, arg1) { + const ret = new Blob(arg0, arg1); + return ret; + }, arguments); }, + __wbg_new_with_u8_clamped_array_483dbce5ac9306c3: function() { return handleError(function (arg0, arg1, arg2) { + const ret = new ImageData(getClampedArrayU8FromWasm0(arg0, arg1), arg2 >>> 0); + return ret; + }, arguments); }, + __wbg_now_e7c6795a7f81e10f: function(arg0) { + const ret = arg0.now(); + return ret; + }, + __wbg_observe_592b94857eed8e27: function(arg0, arg1) { + arg0.observe(arg1); + }, + __wbg_observe_91d5c6a617c3d390: function(arg0, arg1, arg2) { + arg0.observe(arg1, arg2); + }, + __wbg_observe_a987521b8fae2aaf: function(arg0, arg1) { + arg0.observe(arg1); + }, + __wbg_of_3ed679d45555e384: function(arg0, arg1) { + const ret = Array.of(arg0, arg1); + return ret; + }, + __wbg_of_62183ea089c00bfa: function(arg0) { + const ret = Array.of(arg0); + return ret; + }, + __wbg_offsetX_a9bf2ea7f0575ac9: function(arg0) { + const ret = arg0.offsetX; + return ret; + }, + __wbg_offsetY_10e5433a1bbd4c01: function(arg0) { + const ret = arg0.offsetY; + return ret; + }, + __wbg_performance_3fcf6e32a7e1ed0a: function(arg0) { + const ret = arg0.performance; + return ret; + }, + __wbg_persisted_cce9b6da86c07260: function(arg0) { + const ret = arg0.persisted; + return ret; + }, + __wbg_play_3997a1be51d27925: function(arg0) { + arg0.play(); + }, + __wbg_pointerId_2c4027fd33473f83: function(arg0) { + const ret = arg0.pointerId; + return ret; + }, + __wbg_pointerType_2dfba7dcd3e033b4: function(arg0, arg1) { + const ret = arg1.pointerType; + const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true); + getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true); + }, + __wbg_port1_aaca04ed552c16ef: function(arg0) { + const ret = arg0.port1; + return ret; + }, + __wbg_port2_baea902d7925a544: function(arg0) { + const ret = arg0.port2; + return ret; + }, + __wbg_postMessage_5b1dc9f8de88488a: function() { return handleError(function (arg0, arg1) { + arg0.postMessage(arg1); + }, arguments); }, + __wbg_postMessage_d05b4de2ebb80b85: function() { return handleError(function (arg0, arg1, arg2) { + arg0.postMessage(arg1, arg2); + }, arguments); }, + __wbg_postTask_e2439afddcdfbb55: function(arg0, arg1, arg2) { + const ret = arg0.postTask(arg1, arg2); + return ret; + }, + __wbg_pressure_727ca025d24d77ec: function(arg0) { + const ret = arg0.pressure; + return ret; + }, + __wbg_preventDefault_c047d3e292b08cc4: function(arg0) { + arg0.preventDefault(); + }, + __wbg_prototype_0d5bb2023db3bcfc: function() { + const ret = ResizeObserverEntry.prototype; + return ret; + }, + __wbg_putImageData_253970d244a23731: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) { + arg0.putImageData(arg1, arg2, arg3, arg4, arg5, arg6, arg7); + }, arguments); }, + __wbg_putImageData_8205094a7b8e8699: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) { + arg0.putImageData(arg1, arg2, arg3, arg4, arg5, arg6, arg7); + }, arguments); }, + __wbg_queueMicrotask_1c9b3800e321a967: function(arg0) { + const ret = arg0.queueMicrotask; + return ret; + }, + __wbg_queueMicrotask_311744e534a929a3: function(arg0) { + queueMicrotask(arg0); + }, + __wbg_queueMicrotask_3d05fddf59c892b7: function(arg0, arg1) { + arg0.queueMicrotask(arg1); + }, + __wbg_removeEventListener_c6782a9c30557d31: function() { return handleError(function (arg0, arg1, arg2, arg3) { + arg0.removeEventListener(getStringFromWasm0(arg1, arg2), arg3); + }, arguments); }, + __wbg_removeListener_9b7f8155dd998421: function() { return handleError(function (arg0, arg1) { + arg0.removeListener(arg1); + }, arguments); }, + __wbg_removeProperty_2015da6fd4077af0: function() { return handleError(function (arg0, arg1, arg2, arg3) { + const ret = arg1.removeProperty(getStringFromWasm0(arg2, arg3)); + const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true); + getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true); + }, arguments); }, + __wbg_repeat_46a5c90df9f6ef0b: function(arg0) { + const ret = arg0.repeat; + return ret; + }, + __wbg_requestAnimationFrame_b92ccfbc8ca777a8: function() { return handleError(function (arg0, arg1) { + const ret = arg0.requestAnimationFrame(arg1); + return ret; + }, arguments); }, + __wbg_requestFullscreen_3f16e43f398ce624: function(arg0) { + const ret = arg0.requestFullscreen(); + return ret; + }, + __wbg_requestFullscreen_b977a3a0697e883c: function(arg0) { + const ret = arg0.requestFullscreen; + return ret; + }, + __wbg_requestIdleCallback_25d3b54bee33cdc0: function() { return handleError(function (arg0, arg1) { + const ret = arg0.requestIdleCallback(arg1); + return ret; + }, arguments); }, + __wbg_requestIdleCallback_3689e3e38f6cfc02: function(arg0) { + const ret = arg0.requestIdleCallback; + return ret; + }, + __wbg_resolve_d82363d90af6928a: function(arg0) { + const ret = Promise.resolve(arg0); + return ret; + }, + __wbg_resume_e4825497b62d86d3: function() { return handleError(function (arg0) { + const ret = arg0.resume(); + return ret; + }, arguments); }, + __wbg_revokeObjectURL_f8e75e321c6e13b8: function() { return handleError(function (arg0, arg1) { + URL.revokeObjectURL(getStringFromWasm0(arg0, arg1)); + }, arguments); }, + __wbg_scheduler_a17d41c9c822fc26: function(arg0) { + const ret = arg0.scheduler; + return ret; + }, + __wbg_scheduler_b35fe73ba70e89cc: function(arg0) { + const ret = arg0.scheduler; + return ret; + }, + __wbg_setAttribute_8bccfbabf2a83682: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) { + arg0.setAttribute(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4)); + }, arguments); }, + __wbg_setPointerCapture_87f6b55ceca474a9: function() { return handleError(function (arg0, arg1) { + arg0.setPointerCapture(arg1); + }, arguments); }, + __wbg_setProperty_da5e4438a912e787: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) { + arg0.setProperty(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4)); + }, arguments); }, + __wbg_setTimeout_6e540f43d21684d9: function() { return handleError(function (arg0, arg1) { + const ret = arg0.setTimeout(arg1); + return ret; + }, arguments); }, + __wbg_setTimeout_8afa0b5ed243c77d: function() { return handleError(function (arg0, arg1, arg2) { + const ret = arg0.setTimeout(arg1, arg2); + return ret; + }, arguments); }, + __wbg_set_4564f7dc44fcb0c9: function() { return handleError(function (arg0, arg1, arg2) { + const ret = Reflect.set(arg0, arg1, arg2); + return ret; + }, arguments); }, + __wbg_set_box_3fa4e9e6b8b96df4: function(arg0, arg1) { + arg0.box = __wbindgen_enum_ResizeObserverBoxOptions[arg1]; + }, + __wbg_set_buffer_1342d891015defc0: function(arg0, arg1) { + arg0.buffer = arg1; + }, + __wbg_set_channelCount_57987aecdb0e8d9b: function(arg0, arg1) { + arg0.channelCount = arg1 >>> 0; + }, + __wbg_set_height_ad5056ea051acd78: function(arg0, arg1) { + arg0.height = arg1 >>> 0; + }, + __wbg_set_height_ef298446b359b0c5: function(arg0, arg1) { + arg0.height = arg1 >>> 0; + }, + __wbg_set_onmessage_8700520361fa9f48: function(arg0, arg1) { + arg0.onmessage = arg1; + }, + __wbg_set_sample_rate_64be830809348ed1: function(arg0, arg1) { + arg0.sampleRate = arg1; + }, + __wbg_set_type_3194793b7f2a05be: function(arg0, arg1, arg2) { + arg0.type = getStringFromWasm0(arg1, arg2); + }, + __wbg_set_width_031bdecd763c5855: function(arg0, arg1) { + arg0.width = arg1 >>> 0; + }, + __wbg_set_width_f9e631f4ee129e5c: function(arg0, arg1) { + arg0.width = arg1 >>> 0; + }, + __wbg_shiftKey_273ee8c901267b55: function(arg0) { + const ret = arg0.shiftKey; + return ret; + }, + __wbg_shiftKey_e57eae650446e681: function(arg0) { + const ret = arg0.shiftKey; + return ret; + }, + __wbg_signal_4d9d567be73ea52c: function(arg0) { + const ret = arg0.signal; + return ret; + }, + __wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) { + const ret = arg1.stack; + const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true); + getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true); + }, + __wbg_start_830c81ac6a9a7733: function() { return handleError(function (arg0, arg1) { + arg0.start(arg1); + }, arguments); }, + __wbg_start_8ca2b69cfb7618b6: function(arg0) { + arg0.start(); + }, + __wbg_static_accessor_GLOBAL_THIS_2fee5048bcca5938: function() { + const ret = typeof globalThis === 'undefined' ? null : globalThis; + return isLikeNone(ret) ? 0 : addToExternrefTable0(ret); + }, + __wbg_static_accessor_GLOBAL_ce44e66a4935da8c: function() { + const ret = typeof global === 'undefined' ? null : global; + return isLikeNone(ret) ? 0 : addToExternrefTable0(ret); + }, + __wbg_static_accessor_SELF_44f6e0cb5e67cdad: function() { + const ret = typeof self === 'undefined' ? null : self; + return isLikeNone(ret) ? 0 : addToExternrefTable0(ret); + }, + __wbg_static_accessor_WINDOW_168f178805d978fe: function() { + const ret = typeof window === 'undefined' ? null : window; + return isLikeNone(ret) ? 0 : addToExternrefTable0(ret); + }, + __wbg_style_f00fbf31e0a68f0e: function(arg0) { + const ret = arg0.style; + return ret; + }, + __wbg_then_591b6b3a75ee817a: function(arg0, arg1) { + const ret = arg0.then(arg1); + return ret; + }, + __wbg_unobserve_e9b5d98f37ccf1ff: function(arg0, arg1) { + arg0.unobserve(arg1); + }, + __wbg_userAgentData_31b8f893e8977e94: function(arg0) { + const ret = arg0.userAgentData; + return isLikeNone(ret) ? 0 : addToExternrefTable0(ret); + }, + __wbg_userAgent_3ac81db86b32899a: function() { return handleError(function (arg0, arg1) { + const ret = arg1.userAgent; + const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true); + getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true); + }, arguments); }, + __wbg_visibilityState_39ac2e458f892eec: function(arg0) { + const ret = arg0.visibilityState; + return (__wbindgen_enum_VisibilityState.indexOf(ret) + 1 || 3) - 1; + }, + __wbg_webkitFullscreenElement_4055d847f8ff064e: function(arg0) { + const ret = arg0.webkitFullscreenElement; + return isLikeNone(ret) ? 0 : addToExternrefTable0(ret); + }, + __wbg_webkitRequestFullscreen_c4ec4df7be373ffd: function(arg0) { + arg0.webkitRequestFullscreen(); + }, + __wbg_width_08e66520b99071f4: function(arg0) { + const ret = arg0.width; + return ret; + }, + __wbindgen_cast_0000000000000001: function(arg0, arg1) { + // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 19, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`. + const ret = makeMutClosure(arg0, arg1, wasm_bindgen_c3ee25b2d604ba8d___convert__closures_____invoke___wasm_bindgen_c3ee25b2d604ba8d___JsValue______true_); + return ret; + }, + __wbindgen_cast_0000000000000002: function(arg0, arg1) { + // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 52, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`. + const ret = makeMutClosure(arg0, arg1, wasm_bindgen_c3ee25b2d604ba8d___convert__closures_____invoke___wasm_bindgen_c3ee25b2d604ba8d___JsValue__core_e2d3324fa3b902cb___result__Result_____wasm_bindgen_c3ee25b2d604ba8d___JsError___true_); + return ret; + }, + __wbindgen_cast_0000000000000003: function(arg0, arg1) { + // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Array<any>"), NamedExternref("ResizeObserver")], shim_idx: 70, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`. + const ret = makeMutClosure(arg0, arg1, wasm_bindgen_c3ee25b2d604ba8d___convert__closures_____invoke___js_sys_f09d93784898213f___Function_fn_wasm_bindgen_c3ee25b2d604ba8d___JsValue_____wasm_bindgen_c3ee25b2d604ba8d___sys__Undefined___js_sys_f09d93784898213f___Function_fn_wasm_bindgen_c3ee25b2d604ba8d___JsValue_____wasm_bindgen_c3ee25b2d604ba8d___sys__Undefined_______true_); + return ret; + }, + __wbindgen_cast_0000000000000004: function(arg0, arg1) { + // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Array<any>")], shim_idx: 19, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`. + const ret = makeMutClosure(arg0, arg1, wasm_bindgen_c3ee25b2d604ba8d___convert__closures_____invoke___wasm_bindgen_c3ee25b2d604ba8d___JsValue______true__3); + return ret; + }, + __wbindgen_cast_0000000000000005: function(arg0, arg1) { + // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Event")], shim_idx: 19, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`. + const ret = makeMutClosure(arg0, arg1, wasm_bindgen_c3ee25b2d604ba8d___convert__closures_____invoke___wasm_bindgen_c3ee25b2d604ba8d___JsValue______true__4); + return ret; + }, + __wbindgen_cast_0000000000000006: function(arg0, arg1) { + // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("FocusEvent")], shim_idx: 19, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`. + const ret = makeMutClosure(arg0, arg1, wasm_bindgen_c3ee25b2d604ba8d___convert__closures_____invoke___wasm_bindgen_c3ee25b2d604ba8d___JsValue______true__5); + return ret; + }, + __wbindgen_cast_0000000000000007: function(arg0, arg1) { + // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("KeyboardEvent")], shim_idx: 19, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`. + const ret = makeMutClosure(arg0, arg1, wasm_bindgen_c3ee25b2d604ba8d___convert__closures_____invoke___wasm_bindgen_c3ee25b2d604ba8d___JsValue______true__6); + return ret; + }, + __wbindgen_cast_0000000000000008: function(arg0, arg1) { + // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("PageTransitionEvent")], shim_idx: 19, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`. + const ret = makeMutClosure(arg0, arg1, wasm_bindgen_c3ee25b2d604ba8d___convert__closures_____invoke___wasm_bindgen_c3ee25b2d604ba8d___JsValue______true__7); + return ret; + }, + __wbindgen_cast_0000000000000009: function(arg0, arg1) { + // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("PointerEvent")], shim_idx: 19, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`. + const ret = makeMutClosure(arg0, arg1, wasm_bindgen_c3ee25b2d604ba8d___convert__closures_____invoke___wasm_bindgen_c3ee25b2d604ba8d___JsValue______true__8); + return ret; + }, + __wbindgen_cast_000000000000000a: function(arg0, arg1) { + // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("WheelEvent")], shim_idx: 19, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`. + const ret = makeMutClosure(arg0, arg1, wasm_bindgen_c3ee25b2d604ba8d___convert__closures_____invoke___wasm_bindgen_c3ee25b2d604ba8d___JsValue______true__9); + return ret; + }, + __wbindgen_cast_000000000000000b: function(arg0, arg1) { + // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 25, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`. + const ret = makeMutClosure(arg0, arg1, wasm_bindgen_c3ee25b2d604ba8d___convert__closures_____invoke_______true_); + return ret; + }, + __wbindgen_cast_000000000000000c: function(arg0) { + // Cast intrinsic for `F64 -> Externref`. + const ret = arg0; + return ret; + }, + __wbindgen_cast_000000000000000d: function(arg0, arg1) { + // Cast intrinsic for `Ref(String) -> Externref`. + const ret = getStringFromWasm0(arg0, arg1); + return ret; + }, + __wbindgen_init_externref_table: function() { + const table = wasm.__wbindgen_externrefs; + const offset = table.grow(4); + table.set(0, undefined); + table.set(offset + 0, undefined); + table.set(offset + 1, null); + table.set(offset + 2, true); + table.set(offset + 3, false); + }, + }; + return { + __proto__: null, + "./cj2k26_bg.js": import0, + }; +} + +const lAudioContext = (typeof AudioContext !== 'undefined' ? AudioContext : (typeof webkitAudioContext !== 'undefined' ? webkitAudioContext : undefined)); +function wasm_bindgen_c3ee25b2d604ba8d___convert__closures_____invoke_______true_(arg0, arg1) { + wasm.wasm_bindgen_c3ee25b2d604ba8d___convert__closures_____invoke_______true_(arg0, arg1); +} + +function wasm_bindgen_c3ee25b2d604ba8d___convert__closures_____invoke___wasm_bindgen_c3ee25b2d604ba8d___JsValue______true_(arg0, arg1, arg2) { + wasm.wasm_bindgen_c3ee25b2d604ba8d___convert__closures_____invoke___wasm_bindgen_c3ee25b2d604ba8d___JsValue______true_(arg0, arg1, arg2); +} + +function wasm_bindgen_c3ee25b2d604ba8d___convert__closures_____invoke___wasm_bindgen_c3ee25b2d604ba8d___JsValue______true__3(arg0, arg1, arg2) { + wasm.wasm_bindgen_c3ee25b2d604ba8d___convert__closures_____invoke___wasm_bindgen_c3ee25b2d604ba8d___JsValue______true__3(arg0, arg1, arg2); +} + +function wasm_bindgen_c3ee25b2d604ba8d___convert__closures_____invoke___wasm_bindgen_c3ee25b2d604ba8d___JsValue______true__4(arg0, arg1, arg2) { + wasm.wasm_bindgen_c3ee25b2d604ba8d___convert__closures_____invoke___wasm_bindgen_c3ee25b2d604ba8d___JsValue______true__4(arg0, arg1, arg2); +} + +function wasm_bindgen_c3ee25b2d604ba8d___convert__closures_____invoke___wasm_bindgen_c3ee25b2d604ba8d___JsValue______true__5(arg0, arg1, arg2) { + wasm.wasm_bindgen_c3ee25b2d604ba8d___convert__closures_____invoke___wasm_bindgen_c3ee25b2d604ba8d___JsValue______true__5(arg0, arg1, arg2); +} + +function wasm_bindgen_c3ee25b2d604ba8d___convert__closures_____invoke___wasm_bindgen_c3ee25b2d604ba8d___JsValue______true__6(arg0, arg1, arg2) { + wasm.wasm_bindgen_c3ee25b2d604ba8d___convert__closures_____invoke___wasm_bindgen_c3ee25b2d604ba8d___JsValue______true__6(arg0, arg1, arg2); +} + +function wasm_bindgen_c3ee25b2d604ba8d___convert__closures_____invoke___wasm_bindgen_c3ee25b2d604ba8d___JsValue______true__7(arg0, arg1, arg2) { + wasm.wasm_bindgen_c3ee25b2d604ba8d___convert__closures_____invoke___wasm_bindgen_c3ee25b2d604ba8d___JsValue______true__7(arg0, arg1, arg2); +} + +function wasm_bindgen_c3ee25b2d604ba8d___convert__closures_____invoke___wasm_bindgen_c3ee25b2d604ba8d___JsValue______true__8(arg0, arg1, arg2) { + wasm.wasm_bindgen_c3ee25b2d604ba8d___convert__closures_____invoke___wasm_bindgen_c3ee25b2d604ba8d___JsValue______true__8(arg0, arg1, arg2); +} + +function wasm_bindgen_c3ee25b2d604ba8d___convert__closures_____invoke___wasm_bindgen_c3ee25b2d604ba8d___JsValue______true__9(arg0, arg1, arg2) { + wasm.wasm_bindgen_c3ee25b2d604ba8d___convert__closures_____invoke___wasm_bindgen_c3ee25b2d604ba8d___JsValue______true__9(arg0, arg1, arg2); +} + +function wasm_bindgen_c3ee25b2d604ba8d___convert__closures_____invoke___wasm_bindgen_c3ee25b2d604ba8d___JsValue__core_e2d3324fa3b902cb___result__Result_____wasm_bindgen_c3ee25b2d604ba8d___JsError___true_(arg0, arg1, arg2) { + const ret = wasm.wasm_bindgen_c3ee25b2d604ba8d___convert__closures_____invoke___wasm_bindgen_c3ee25b2d604ba8d___JsValue__core_e2d3324fa3b902cb___result__Result_____wasm_bindgen_c3ee25b2d604ba8d___JsError___true_(arg0, arg1, arg2); + if (ret[1]) { + throw takeFromExternrefTable0(ret[0]); + } +} + +function wasm_bindgen_c3ee25b2d604ba8d___convert__closures_____invoke___js_sys_f09d93784898213f___Function_fn_wasm_bindgen_c3ee25b2d604ba8d___JsValue_____wasm_bindgen_c3ee25b2d604ba8d___sys__Undefined___js_sys_f09d93784898213f___Function_fn_wasm_bindgen_c3ee25b2d604ba8d___JsValue_____wasm_bindgen_c3ee25b2d604ba8d___sys__Undefined_______true_(arg0, arg1, arg2, arg3) { + wasm.wasm_bindgen_c3ee25b2d604ba8d___convert__closures_____invoke___js_sys_f09d93784898213f___Function_fn_wasm_bindgen_c3ee25b2d604ba8d___JsValue_____wasm_bindgen_c3ee25b2d604ba8d___sys__Undefined___js_sys_f09d93784898213f___Function_fn_wasm_bindgen_c3ee25b2d604ba8d___JsValue_____wasm_bindgen_c3ee25b2d604ba8d___sys__Undefined_______true_(arg0, arg1, arg2, arg3); +} + + +const __wbindgen_enum_ResizeObserverBoxOptions = ["border-box", "content-box", "device-pixel-content-box"]; + + +const __wbindgen_enum_VisibilityState = ["hidden", "visible"]; +const StreamConfigFinalization = (typeof FinalizationRegistry === 'undefined') + ? { register: () => {}, unregister: () => {} } + : new FinalizationRegistry(ptr => wasm.__wbg_streamconfig_free(ptr, 1)); + +function addToExternrefTable0(obj) { + const idx = wasm.__externref_table_alloc(); + wasm.__wbindgen_externrefs.set(idx, obj); + return idx; +} + +const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined') + ? { register: () => {}, unregister: () => {} } + : new FinalizationRegistry(state => wasm.__wbindgen_destroy_closure(state.a, state.b)); + +function debugString(val) { + // primitive types + const type = typeof val; + if (type == 'number' || type == 'boolean' || val == null) { + return `${val}`; + } + if (type == 'string') { + return `"${val}"`; + } + if (type == 'symbol') { + const description = val.description; + if (description == null) { + return 'Symbol'; + } else { + return `Symbol(${description})`; + } + } + if (type == 'function') { + const name = val.name; + if (typeof name == 'string' && name.length > 0) { + return `Function(${name})`; + } else { + return 'Function'; + } + } + // objects + if (Array.isArray(val)) { + const length = val.length; + let debug = '['; + if (length > 0) { + debug += debugString(val[0]); + } + for(let i = 1; i < length; i++) { + debug += ', ' + debugString(val[i]); + } + debug += ']'; + return debug; + } + // Test for built-in + const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val)); + let className; + if (builtInMatches && builtInMatches.length > 1) { + className = builtInMatches[1]; + } else { + // Failed to match the standard '[object ClassName]' + return toString.call(val); + } + if (className == 'Object') { + // we're a user defined class or Object + // JSON.stringify avoids problems with cycles, and is generally much + // easier than looping through ownProperties of `val`. + try { + return 'Object(' + JSON.stringify(val) + ')'; + } catch (_) { + return 'Object'; + } + } + // errors + if (val instanceof Error) { + return `${val.name}: ${val.message}\n${val.stack}`; + } + // TODO we could test for more things here, like `Set`s and `Map`s. + return className; +} + +function getArrayF32FromWasm0(ptr, len) { + ptr = ptr >>> 0; + return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len); +} + +function getClampedArrayU8FromWasm0(ptr, len) { + ptr = ptr >>> 0; + return getUint8ClampedArrayMemory0().subarray(ptr / 1, ptr / 1 + len); +} + +let cachedDataViewMemory0 = null; +function getDataViewMemory0() { + if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) { + cachedDataViewMemory0 = new DataView(wasm.memory.buffer); + } + return cachedDataViewMemory0; +} + +let cachedFloat32ArrayMemory0 = null; +function getFloat32ArrayMemory0() { + if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) { + cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer); + } + return cachedFloat32ArrayMemory0; +} + +function getStringFromWasm0(ptr, len) { + return decodeText(ptr >>> 0, len); +} + +let cachedUint8ArrayMemory0 = null; +function getUint8ArrayMemory0() { + if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) { + cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer); + } + return cachedUint8ArrayMemory0; +} + +let cachedUint8ClampedArrayMemory0 = null; +function getUint8ClampedArrayMemory0() { + if (cachedUint8ClampedArrayMemory0 === null || cachedUint8ClampedArrayMemory0.byteLength === 0) { + cachedUint8ClampedArrayMemory0 = new Uint8ClampedArray(wasm.memory.buffer); + } + return cachedUint8ClampedArrayMemory0; +} + +function handleError(f, args) { + try { + return f.apply(this, args); + } catch (e) { + const idx = addToExternrefTable0(e); + wasm.__wbindgen_exn_store(idx); + } +} + +function isLikeNone(x) { + return x === undefined || x === null; +} + +function makeMutClosure(arg0, arg1, f) { + const state = { a: arg0, b: arg1, cnt: 1 }; + const real = (...args) => { + + // First up with a closure we increment the internal reference + // count. This ensures that the Rust closure environment won't + // be deallocated while we're invoking it. + state.cnt++; + const a = state.a; + state.a = 0; + try { + return f(a, state.b, ...args); + } finally { + state.a = a; + real._wbg_cb_unref(); + } + }; + real._wbg_cb_unref = () => { + if (--state.cnt === 0) { + wasm.__wbindgen_destroy_closure(state.a, state.b); + state.a = 0; + CLOSURE_DTORS.unregister(state); + } + }; + CLOSURE_DTORS.register(real, state, state); + return real; +} + +function passStringToWasm0(arg, malloc, realloc) { + if (realloc === undefined) { + const buf = cachedTextEncoder.encode(arg); + const ptr = malloc(buf.length, 1) >>> 0; + getUint8ArrayMemory0().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 = getUint8ArrayMemory0(); + + 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 = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len); + const ret = cachedTextEncoder.encodeInto(arg, view); + + offset += ret.written; + ptr = realloc(ptr, len, offset, 1) >>> 0; + } + + WASM_VECTOR_LEN = offset; + return ptr; +} + +function takeFromExternrefTable0(idx) { + const value = wasm.__wbindgen_externrefs.get(idx); + wasm.__externref_table_dealloc(idx); + return value; +} + +let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }); +cachedTextDecoder.decode(); +const MAX_SAFARI_DECODE_BYTES = 2146435072; +let numBytesDecoded = 0; +function decodeText(ptr, len) { + numBytesDecoded += len; + if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) { + cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }); + cachedTextDecoder.decode(); + numBytesDecoded = len; + } + return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len)); +} + +const cachedTextEncoder = new TextEncoder(); + +if (!('encodeInto' in cachedTextEncoder)) { + cachedTextEncoder.encodeInto = function (arg, view) { + const buf = cachedTextEncoder.encode(arg); + view.set(buf); + return { + read: arg.length, + written: buf.length + }; + }; +} + +let WASM_VECTOR_LEN = 0; + +let wasmModule, wasmInstance, wasm; +function __wbg_finalize_init(instance, module) { + wasmInstance = instance; + wasm = instance.exports; + wasmModule = module; + cachedDataViewMemory0 = null; + cachedFloat32ArrayMemory0 = null; + cachedUint8ArrayMemory0 = null; + cachedUint8ClampedArrayMemory0 = null; + wasm.__wbindgen_start(); + return wasm; +} + +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) { + const validResponse = module.ok && expectedResponseType(module.type); + + if (validResponse && 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 expectedResponseType(type) { + switch (type) { + case 'basic': case 'cors': case 'default': return true; + } + return false; + } +} + +function initSync(module) { + if (wasm !== undefined) return wasm; + + + if (module !== undefined) { + if (Object.getPrototypeOf(module) === Object.prototype) { + ({module} = module) + } else { + console.warn('using deprecated parameters for `initSync()`; pass a single object instead') + } + } + + const imports = __wbg_get_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(module_or_path) { + if (wasm !== undefined) return wasm; + + + if (module_or_path !== undefined) { + if (Object.getPrototypeOf(module_or_path) === Object.prototype) { + ({module_or_path} = module_or_path) + } else { + console.warn('using deprecated parameters for the initialization function; pass a single object instead') + } + } + + if (module_or_path === undefined) { + module_or_path = new URL('cj2k26_bg.wasm', import.meta.url); + } + const imports = __wbg_get_imports(); + + if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) { + module_or_path = fetch(module_or_path); + } + + const { instance, module } = await __wbg_load(await module_or_path, imports); + + return __wbg_finalize_init(instance, module); +} + +export { initSync, __wbg_init as default }; diff --git a/2026/games_submissions/asrael_io/cj2k26-775b42dad04180ed_bg.wasm b/2026/games_submissions/asrael_io/cj2k26-775b42dad04180ed_bg.wasm Binary files differnew file mode 100644 index 0000000..b49ff10 --- /dev/null +++ b/2026/games_submissions/asrael_io/cj2k26-775b42dad04180ed_bg.wasm diff --git a/2026/games_submissions/asrael_io/index-d2f7d439dd4e8311.css b/2026/games_submissions/asrael_io/index-d2f7d439dd4e8311.css new file mode 100644 index 0000000..0565642 --- /dev/null +++ b/2026/games_submissions/asrael_io/index-d2f7d439dd4e8311.css @@ -0,0 +1,18 @@ +html, +body { + margin: 0; + overflow: hidden; + background: #000; +} + +canvas { + display: block; + position: fixed; + left: 50%; + top: 50%; + width: 240px !important; + height: 160px !important; + image-rendering: pixelated; + transform-origin: center; + outline: none; +} diff --git a/2026/games_submissions/asrael_io/index.html b/2026/games_submissions/asrael_io/index.html new file mode 100644 index 0000000..170f0f0 --- /dev/null +++ b/2026/games_submissions/asrael_io/index.html @@ -0,0 +1,64 @@ +<!doctype html>
+<html>
+ <head>
+ <link rel="stylesheet" href="./index-d2f7d439dd4e8311.css" integrity="sha384-oazrHREWfMzqvJsEZXQn/sGkexbgnuc46PCPYcj+5PQsn+e2XPzORPWZ0tV76QD1"/>
+ +<script type="module"> +import init, * as bindings from './cj2k26-775b42dad04180ed.js'; +const wasm = await init({ module_or_path: './cj2k26-775b42dad04180ed_bg.wasm' }); + + +window.wasmBindings = bindings; + + +dispatchEvent(new CustomEvent("TrunkApplicationStarted", {detail: {wasm}})); + +</script>
+ <script>
+ window.jamStart = false;
+ window.jamDifficulty = 0;
+ window.jamShouldStart = () =>
+ window.jamStart || Boolean(window.lcolonqJamStart);
+ window.jamGetDifficulty = () => {
+ if (window.jamDifficulty) return window.jamDifficulty;
+ if (typeof window.lcolonqJamStart === "number") return window.lcolonqJamStart;
+ return 0;
+ };
+ window.jamStarted = (verb) => window.parent.postMessage({op: "started", verb});
+ window.jamDone = (win) => window.parent.postMessage({op: "done", win});
+
+ window.addEventListener("message", (e) => {
+ if (e.data && e.data.op === "start") {
+ window.jamStart = true;
+ if (typeof e.data.difficulty === "number") {
+ window.jamDifficulty = e.data.difficulty;
+ }
+ }
+ });
+
+ if (window.parent === window) {
+ window.jamStart = true;
+ window.jamDifficulty = Math.floor(Math.random() * 8);
+ console.log("difficulty", window.jamDifficulty);
+ } else {
+ window.parent.postMessage({op: "ready"});
+ }
+
+ const fit = () => {
+ const c = document.querySelector("canvas");
+ if (!c) {
+ requestAnimationFrame(fit);
+ return;
+ }
+
+ const r = Math.max(
+ 1,
+ Math.min(Math.floor(innerWidth / 240), Math.floor(innerHeight / 160), 4),
+ );
+ c.style.transform = `translate(-50%, -50%) scale(${r})`;
+ };
+ window.addEventListener("resize", fit);
+ fit();
+ </script>
+ <link rel="modulepreload" href="./cj2k26-775b42dad04180ed.js" crossorigin="anonymous" integrity="sha384-MjPCRFB2j75GNy68lj1zVlI8KzEN9cW8KuPV8JiUDHReU6/X7gcCSFPpdrqySa91"><link rel="preload" href="./cj2k26-775b42dad04180ed_bg.wasm" crossorigin="anonymous" integrity="sha384-4x0fodXQ7MdX7xLj7yTcGbL7CyY3p39+PzkTnHBlRnhg2w8ueFc7SDoFWZBI3s/W" as="fetch" type="application/wasm"></head>
+</html>
diff --git a/2026/games_submissions/asrael_io/source/Cargo.lock b/2026/games_submissions/asrael_io/source/Cargo.lock new file mode 100644 index 0000000..d2740d4 --- /dev/null +++ b/2026/games_submissions/asrael_io/source/Cargo.lock @@ -0,0 +1,2622 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "ab_glyph" +version = "0.2.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "01c0457472c38ea5bd1c3b5ada5e368271cb550be7a4ca4a0b4634e9913f6cc2" +dependencies = [ + "ab_glyph_rasterizer", + "owned_ttf_parser", +] + +[[package]] +name = "ab_glyph_rasterizer" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "366ffbaa4442f4684d91e2cd7c5ea7c4ed8add41959a31447066e279e432b618" + +[[package]] +name = "adler2" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa" + +[[package]] +name = "ahash" +version = "0.8.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75" +dependencies = [ + "cfg-if", + "getrandom", + "once_cell", + "version_check", + "zerocopy", +] + +[[package]] +name = "aho-corasick" +version = "1.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301" +dependencies = [ + "memchr", +] + +[[package]] +name = "alsa" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "812947049edcd670a82cd5c73c3661d2e58468577ba8489de58e1a73c04cbd5d" +dependencies = [ + "alsa-sys", + "bitflags 2.13.0", + "cfg-if", + "libc", +] + +[[package]] +name = "alsa-sys" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad7569085a265dd3f607ebecce7458eaab2132a84393534c95b18dcbc3f31e04" +dependencies = [ + "libc", + "pkg-config", +] + +[[package]] +name = "android-activity" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f2a1bb052857d5dd49572219344a7332b31b76405648eabac5bc68978251bcd" +dependencies = [ + "android-properties", + "bitflags 2.13.0", + "cc", + "jni", + "libc", + "log", + "ndk", + "ndk-context", + "ndk-sys", + "num_enum", + "thiserror 2.0.18", +] + +[[package]] +name = "android-properties" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc7eb209b1518d6bb87b283c20095f5228ecda460da70b44f0802523dea6da04" + +[[package]] +name = "anstream" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d" +dependencies = [ + "anstyle", + "anstyle-parse", + "anstyle-query", + "anstyle-wincon", + "colorchoice", + "is_terminal_polyfill", + "utf8parse", +] + +[[package]] +name = "anstyle" +version = "1.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000" + +[[package]] +name = "anstyle-parse" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e" +dependencies = [ + "utf8parse", +] + +[[package]] +name = "anstyle-query" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc" +dependencies = [ + "windows-sys 0.61.2", +] + +[[package]] +name = "anstyle-wincon" +version = "3.0.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d" +dependencies = [ + "anstyle", + "once_cell_polyfill", + "windows-sys 0.61.2", +] + +[[package]] +name = "arrayref" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb" + +[[package]] +name = "arrayvec" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50" + +[[package]] +name = "as-raw-xcb-connection" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "175571dd1d178ced59193a6fc02dde1b972eb0bc56c892cde9beeceac5bf0f6b" + +[[package]] +name = "aseprite-io" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "303c59908b2ef2b9fafa3636f803b59c4a7f67b4d5d06a4d8185051cb019299a" +dependencies = [ + "flate2", +] + +[[package]] +name = "atomic-waker" +version = "1.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0" + +[[package]] +name = "autocfg" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" + +[[package]] +name = "az" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7b7e4c2464d97fe331d41de9d5db0def0a96f4d823b8b32a2efd503578988973" + +[[package]] +name = "bit_field" +version = "0.10.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e4b40c7323adcfc0a41c4b88143ed58346ff65a288fc144329c5c45e05d70c6" + +[[package]] +name = "bitflags" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" + +[[package]] +name = "bitflags" +version = "2.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4388bee8683e3d04af747c73422af53102d2bd24d9eadb6cbc100baef4b43f8" + +[[package]] +name = "block2" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c132eebf10f5cad5289222520a4a058514204aed6d791f1cf4fe8088b82d15f" +dependencies = [ + "objc2 0.5.2", +] + +[[package]] +name = "block2" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cdeb9d870516001442e364c5220d3574d2da8dc765554b4a617230d33fa58ef5" +dependencies = [ + "objc2 0.6.4", +] + +[[package]] +name = "bumpalo" +version = "3.20.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649" + +[[package]] +name = "bytemuck" +version = "1.25.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c8efb64bd706a16a1bdde310ae86b351e4d21550d98d056f22f8a7f7a2183fec" +dependencies = [ + "bytemuck_derive", +] + +[[package]] +name = "bytemuck_derive" +version = "1.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9abbd1bc6865053c427f7198e6af43bfdedc55ab791faed4fbd361d789575ff" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "byteorder" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" + +[[package]] +name = "bytes" +version = "1.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33" + +[[package]] +name = "calloop" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b99da2f8558ca23c71f4fd15dc57c906239752dd27ff3c00a1d56b685b7cbfec" +dependencies = [ + "bitflags 2.13.0", + "log", + "polling", + "rustix 0.38.44", + "slab", + "thiserror 1.0.69", +] + +[[package]] +name = "calloop-wayland-source" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "95a66a987056935f7efce4ab5668920b5d0dac4a7c99991a67395f13702ddd20" +dependencies = [ + "calloop", + "rustix 0.38.44", + "wayland-backend", + "wayland-client", +] + +[[package]] +name = "cc" +version = "1.2.64" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dad887fd958be91b5098c0248def011f4523ab786cd411be668777e55063501f" +dependencies = [ + "find-msvc-tools", + "jobserver", + "libc", + "shlex", +] + +[[package]] +name = "cfg-if" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" + +[[package]] +name = "cfg_aliases" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724" + +[[package]] +name = "cj2k26" +version = "0.1.0" +dependencies = [ + "aseprite-io", + "console_error_panic_hook", + "cpal", + "embedded-graphics", + "env_logger", + "gilrs", + "glam", + "log", + "resid-rs", + "softbuffer", + "wasm-bindgen", + "web-time", + "winit", +] + +[[package]] +name = "colorchoice" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570" + +[[package]] +name = "combine" +version = "4.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba5a308b75df32fe02788e748662718f03fde005016435c444eea572398219fd" +dependencies = [ + "bytes", + "memchr", +] + +[[package]] +name = "concurrent-queue" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973" +dependencies = [ + "crossbeam-utils", +] + +[[package]] +name = "console_error_panic_hook" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc" +dependencies = [ + "cfg-if", + "wasm-bindgen", +] + +[[package]] +name = "core-foundation" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "core-foundation-sys" +version = "0.8.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" + +[[package]] +name = "core-graphics" +version = "0.23.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c07782be35f9e1140080c6b96f0d44b739e2278479f64e02fdab4e32dfd8b081" +dependencies = [ + "bitflags 1.3.2", + "core-foundation", + "core-graphics-types", + "foreign-types", + "libc", +] + +[[package]] +name = "core-graphics-types" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "45390e6114f68f718cc7a830514a96f903cccd70d02a8f6d9f643ac4ba45afaf" +dependencies = [ + "bitflags 1.3.2", + "core-foundation", + "libc", +] + +[[package]] +name = "coreaudio-rs" +version = "0.14.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d5d7dca3ebcf65a035582c9ad4385371a9d9ee6537474d2a278f4e1e475bb58" +dependencies = [ + "bitflags 2.13.0", + "libc", + "objc2-audio-toolbox", + "objc2-core-audio", + "objc2-core-audio-types", + "objc2-core-foundation", +] + +[[package]] +name = "cpal" +version = "0.18.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f77b11176c37874be37e8d691c946e31b2b8c357abce9526f6a99eb469e1028" +dependencies = [ + "alsa", + "block2 0.6.2", + "coreaudio-rs", + "dasp_sample", + "jni", + "js-sys", + "libc", + "mach2", + "ndk", + "ndk-context", + "num-derive", + "num-traits", + "objc2 0.6.4", + "objc2-audio-toolbox", + "objc2-avf-audio", + "objc2-core-audio", + "objc2-core-audio-types", + "objc2-core-foundation", + "objc2-foundation 0.3.2", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", + "windows", + "windows-core", +] + +[[package]] +name = "crc32fast" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "crossbeam-utils" +version = "0.8.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28" + +[[package]] +name = "ctor" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "83cf0d42651b16c6dfe68685716d18480d18a9c39c62d76e8cf3eb6ed5d8bcbf" +dependencies = [ + "dtor", +] + +[[package]] +name = "cursor-icon" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f27ae1dd37df86211c42e150270f82743308803d90a6f6e6651cd730d5e1732f" + +[[package]] +name = "dasp_sample" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c87e182de0887fd5361989c677c4e8f5000cd9491d6d563161a8f3a5519fc7f" + +[[package]] +name = "dispatch" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bd0c93bb4b0c6d9b77f4435b0ae98c24d17f1c45b2ff844c6151a07256ca923b" + +[[package]] +name = "dispatch2" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e0e367e4e7da84520dedcac1901e4da967309406d1e51017ae1abfb97adbd38" +dependencies = [ + "bitflags 2.13.0", + "objc2 0.6.4", +] + +[[package]] +name = "dlib" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ab8ecd87370524b461f8557c119c405552c396ed91fc0a8eec68679eab26f94a" +dependencies = [ + "libloading", +] + +[[package]] +name = "downcast-rs" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75b325c5dbd37f80359721ad39aca5a29fb04c89279657cffdda8736d0c0b9d2" + +[[package]] +name = "dpi" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8b14ccef22fc6f5a8f4d7d768562a182c04ce9a3b3157b91390b52ddfdf1a76" + +[[package]] +name = "drm" +version = "0.14.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "80bc8c5c6c2941f70a55c15f8d9f00f9710ebda3ffda98075f996a0e6c92756f" +dependencies = [ + "bitflags 2.13.0", + "bytemuck", + "drm-ffi", + "drm-fourcc", + "libc", + "rustix 0.38.44", +] + +[[package]] +name = "drm-ffi" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "51a91c9b32ac4e8105dec255e849e0d66e27d7c34d184364fb93e469db08f690" +dependencies = [ + "drm-sys", + "rustix 1.1.4", +] + +[[package]] +name = "drm-fourcc" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0aafbcdb8afc29c1a7ee5fbe53b5d62f4565b35a042a662ca9fecd0b54dae6f4" + +[[package]] +name = "drm-sys" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ecc8e1361066d91f5ffccff060a3c3be9c3ecde15be2959c1937595f7a82a9f8" +dependencies = [ + "libc", + "linux-raw-sys 0.9.4", +] + +[[package]] +name = "dtor" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "edf234dd1594d6dd434a8fb8cada51ddbbc593e40e4a01556a0b31c62da2775b" + +[[package]] +name = "embedded-graphics" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4e8da660bb0c829b34a56a965490597f82a55e767b91f9543be80ce8ccb416fe" +dependencies = [ + "az", + "byteorder", + "embedded-graphics-core", + "float-cmp", + "micromath", +] + +[[package]] +name = "embedded-graphics-core" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "95743bef3ff70fcba3930246c4e6872882bbea0dcc6da2ca860112e0cd4bd09f" +dependencies = [ + "az", + "byteorder", +] + +[[package]] +name = "env_filter" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32e90c2accc4b07a8456ea0debdc2e7587bdd890680d71173a15d4ae604f6eef" +dependencies = [ + "log", + "regex", +] + +[[package]] +name = "env_logger" +version = "0.11.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0621c04f2196ac3f488dd583365b9c09be011a4ab8b9f37248ffcc8f6198b56a" +dependencies = [ + "anstream", + "anstyle", + "env_filter", + "jiff", + "log", +] + +[[package]] +name = "equivalent" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" + +[[package]] +name = "errno" +version = "0.3.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" +dependencies = [ + "libc", + "windows-sys 0.61.2", +] + +[[package]] +name = "fastrand" +version = "2.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6" + +[[package]] +name = "find-msvc-tools" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582" + +[[package]] +name = "flate2" +version = "1.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c" +dependencies = [ + "crc32fast", + "miniz_oxide", +] + +[[package]] +name = "float-cmp" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "98de4bbd547a563b716d8dfa9aad1cb19bfab00f4fa09a6a4ed21dbcf44ce9c4" +dependencies = [ + "num-traits", +] + +[[package]] +name = "fnv" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" + +[[package]] +name = "foreign-types" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d737d9aa519fb7b749cbc3b962edcf310a8dd1f4b67c91c4f83975dbdd17d965" +dependencies = [ + "foreign-types-macros", + "foreign-types-shared", +] + +[[package]] +name = "foreign-types-macros" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1a5c6c585bc94aaf2c7b51dd4c2ba22680844aba4c687be581871a6f518c5742" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "foreign-types-shared" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b" + +[[package]] +name = "futures-core" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d" + +[[package]] +name = "futures-task" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393" + +[[package]] +name = "futures-util" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6" +dependencies = [ + "futures-core", + "futures-task", + "pin-project-lite", + "slab", +] + +[[package]] +name = "gethostname" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1bd49230192a3797a9a4d6abe9b3eed6f7fa4c8a8a4947977c6f80025f92cbd8" +dependencies = [ + "rustix 1.1.4", + "windows-link", +] + +[[package]] +name = "getrandom" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd" +dependencies = [ + "cfg-if", + "libc", + "r-efi", + "wasip2", +] + +[[package]] +name = "gilrs" +version = "0.11.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "902fb00d3f6398e635be22e5c837b303c501835cca7ac11a47bba138f7aafdd8" +dependencies = [ + "fnv", + "gilrs-core", + "log", + "uuid", + "vec_map", +] + +[[package]] +name = "gilrs-core" +version = "0.6.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc7f0ce6237abcc0523f2a5502b1e3fe5802daaae47ac14e166fe49551301ea9" +dependencies = [ + "inotify", + "js-sys", + "libc", + "libudev-sys", + "log", + "nix", + "objc2-core-foundation", + "objc2-io-kit", + "uuid", + "vec_map", + "wasm-bindgen", + "web-sys", + "windows", +] + +[[package]] +name = "glam" +version = "0.33.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "898f5a568a84989b6c0f8caa50a93074b97dbdc58fc6d9543157bb4562758933" + +[[package]] +name = "hashbrown" +version = "0.17.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a" + +[[package]] +name = "hermit-abi" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c" + +[[package]] +name = "indexmap" +version = "2.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9" +dependencies = [ + "equivalent", + "hashbrown", +] + +[[package]] +name = "inotify" +version = "0.11.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "533e68a5842e734946fe159fb03fc9bbbb254f590dd0d8ad321ae5ff7beca2c1" +dependencies = [ + "bitflags 2.13.0", + "inotify-sys", + "libc", +] + +[[package]] +name = "inotify-sys" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e05c02b5e89bff3b946cedeca278abc628fe811e604f027c45a8aa3cf793d0eb" +dependencies = [ + "libc", +] + +[[package]] +name = "is_terminal_polyfill" +version = "1.70.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695" + +[[package]] +name = "jiff" +version = "0.2.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4603d3033e49e2b0e31229fcab20a5d40089c607d975cd9c80551dc69eed9102" +dependencies = [ + "jiff-static", + "log", + "portable-atomic", + "portable-atomic-util", + "serde_core", +] + +[[package]] +name = "jiff-static" +version = "0.2.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "782d32378dddf207193ac91cefb848ad41abb58195c95168e1291227a0832b47" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "jni" +version = "0.22.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5efd9a482cf3a427f00d6b35f14332adc7902ce91efb778580e180ff90fa3498" +dependencies = [ + "cfg-if", + "combine", + "jni-macros", + "jni-sys 0.4.1", + "log", + "simd_cesu8", + "thiserror 2.0.18", + "walkdir", + "windows-link", +] + +[[package]] +name = "jni-macros" +version = "0.22.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a00109accc170f0bdb141fed3e393c565b6f5e072365c3bd58f5b062591560a3" +dependencies = [ + "proc-macro2", + "quote", + "rustc_version", + "simd_cesu8", + "syn", +] + +[[package]] +name = "jni-sys" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41a652e1f9b6e0275df1f15b32661cf0d4b78d4d87ddec5e0c3c20f097433258" +dependencies = [ + "jni-sys 0.4.1", +] + +[[package]] +name = "jni-sys" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6377a88cb3910bee9b0fa88d4f42e1d2da8e79915598f65fb0c7ee14c878af2" +dependencies = [ + "jni-sys-macros", +] + +[[package]] +name = "jni-sys-macros" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38c0b942f458fe50cdac086d2f946512305e5631e720728f2a61aabcd47a6264" +dependencies = [ + "quote", + "syn", +] + +[[package]] +name = "jobserver" +version = "0.1.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33" +dependencies = [ + "getrandom", + "libc", +] + +[[package]] +name = "js-sys" +version = "0.3.102" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "03d04c30968dffe80775bd4d7fb676131cd04a1fb46d2686dbffbaec2d9dfd31" +dependencies = [ + "cfg-if", + "futures-util", + "wasm-bindgen", +] + +[[package]] +name = "libc" +version = "0.2.186" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66" + +[[package]] +name = "libloading" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55" +dependencies = [ + "cfg-if", + "windows-link", +] + +[[package]] +name = "libredox" +version = "0.1.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f02ab6bace2054fb888a3c16f990117b579d14a3088e472d63c6011fa185c9d3" +dependencies = [ + "bitflags 2.13.0", + "libc", + "plain", + "redox_syscall 0.8.1", +] + +[[package]] +name = "libudev-sys" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3c8469b4a23b962c1396b9b451dda50ef5b283e8dd309d69033475fa9b334324" +dependencies = [ + "libc", + "pkg-config", +] + +[[package]] +name = "linux-raw-sys" +version = "0.4.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab" + +[[package]] +name = "linux-raw-sys" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cd945864f07fe9f5371a27ad7b52a172b4b499999f1d97574c9fa68373937e12" + +[[package]] +name = "linux-raw-sys" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53" + +[[package]] +name = "log" +version = "0.4.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "953f07c43838f8e6f9758cab68bf5bed85465e7587ebe0b823f1bcd81978ad3a" + +[[package]] +name = "mach2" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dae608c151f68243f2b000364e1f7b186d9c29845f7d2d85bd31b9ad77ad552b" + +[[package]] +name = "memchr" +version = "2.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "88904434abc2901f197fe8cc55f0445e7ded921dba5911dad2e2b39b48e663c4" + +[[package]] +name = "memmap2" +version = "0.9.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "714098028fe011992e1c3962653c96b2d578c4b4bce9036e15ff220319b1e0e3" +dependencies = [ + "libc", +] + +[[package]] +name = "micromath" +version = "2.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3c8dda44ff03a2f238717214da50f65d5a53b45cd213a7370424ffdb6fae815" + +[[package]] +name = "miniz_oxide" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316" +dependencies = [ + "adler2", + "simd-adler32", +] + +[[package]] +name = "ndk" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3f42e7bbe13d351b6bead8286a43aac9534b82bd3cc43e47037f012ebfd62d4" +dependencies = [ + "bitflags 2.13.0", + "jni-sys 0.3.1", + "log", + "ndk-sys", + "num_enum", + "raw-window-handle", + "thiserror 1.0.69", +] + +[[package]] +name = "ndk-context" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "27b02d87554356db9e9a873add8782d4ea6e3e58ea071a9adb9a2e8ddb884a8b" + +[[package]] +name = "ndk-sys" +version = "0.6.0+11769913" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee6cda3051665f1fb8d9e08fc35c96d5a244fb1be711a03b71118828afc9a873" +dependencies = [ + "jni-sys 0.3.1", +] + +[[package]] +name = "nix" +version = "0.31.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf20d2fde8ff38632c426f1165ed7436270b44f199fc55284c38276f9db47c3d" +dependencies = [ + "bitflags 2.13.0", + "cfg-if", + "cfg_aliases", + "libc", +] + +[[package]] +name = "num-derive" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", +] + +[[package]] +name = "num_enum" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d0bca838442ec211fa11de3a8b0e0e8f3a4522575b5c4c06ed722e005036f26" +dependencies = [ + "num_enum_derive", + "rustversion", +] + +[[package]] +name = "num_enum_derive" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "680998035259dcfcafe653688bf2aa6d3e2dc05e98be6ab46afb089dc84f1df8" +dependencies = [ + "proc-macro-crate", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "objc-sys" +version = "0.3.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cdb91bdd390c7ce1a8607f35f3ca7151b65afc0ff5ff3b34fa350f7d7c7e4310" + +[[package]] +name = "objc2" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "46a785d4eeff09c14c487497c162e92766fbb3e4059a71840cecc03d9a50b804" +dependencies = [ + "objc-sys", + "objc2-encode", +] + +[[package]] +name = "objc2" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a12a8ed07aefc768292f076dc3ac8c48f3781c8f2d5851dd3d98950e8c5a89f" +dependencies = [ + "objc2-encode", +] + +[[package]] +name = "objc2-app-kit" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e4e89ad9e3d7d297152b17d39ed92cd50ca8063a89a9fa569046d41568891eff" +dependencies = [ + "bitflags 2.13.0", + "block2 0.5.1", + "libc", + "objc2 0.5.2", + "objc2-core-data", + "objc2-core-image", + "objc2-foundation 0.2.2", + "objc2-quartz-core 0.2.2", +] + +[[package]] +name = "objc2-audio-toolbox" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6948501a91121d6399b79abaa33a8aa4ea7857fe019f341b8c23ad6e81b79b08" +dependencies = [ + "bitflags 2.13.0", + "libc", + "objc2 0.6.4", + "objc2-core-audio", + "objc2-core-audio-types", + "objc2-core-foundation", + "objc2-foundation 0.3.2", +] + +[[package]] +name = "objc2-avf-audio" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13a380031deed8e99db00065c45937da434ca987c034e13b87e4441f9e4090be" +dependencies = [ + "bitflags 2.13.0", + "objc2 0.6.4", + "objc2-foundation 0.3.2", +] + +[[package]] +name = "objc2-cloud-kit" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "74dd3b56391c7a0596a295029734d3c1c5e7e510a4cb30245f8221ccea96b009" +dependencies = [ + "bitflags 2.13.0", + "block2 0.5.1", + "objc2 0.5.2", + "objc2-core-location", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "objc2-contacts" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a5ff520e9c33812fd374d8deecef01d4a840e7b41862d849513de77e44aa4889" +dependencies = [ + "block2 0.5.1", + "objc2 0.5.2", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "objc2-core-audio" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1eebcea8b0dbff5f7c8504f3107c68fc061a3eb44932051c8cf8a68d969c3b2" +dependencies = [ + "dispatch2", + "objc2 0.6.4", + "objc2-core-audio-types", + "objc2-core-foundation", + "objc2-foundation 0.3.2", +] + +[[package]] +name = "objc2-core-audio-types" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a89f2ec274a0cf4a32642b2991e8b351a404d290da87bb6a9a9d8632490bd1c" +dependencies = [ + "bitflags 2.13.0", + "objc2 0.6.4", +] + +[[package]] +name = "objc2-core-data" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "617fbf49e071c178c0b24c080767db52958f716d9eabdf0890523aeae54773ef" +dependencies = [ + "bitflags 2.13.0", + "block2 0.5.1", + "objc2 0.5.2", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "objc2-core-foundation" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536" +dependencies = [ + "bitflags 2.13.0", + "block2 0.6.2", + "dispatch2", + "libc", + "objc2 0.6.4", +] + +[[package]] +name = "objc2-core-graphics" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e022c9d066895efa1345f8e33e584b9f958da2fd4cd116792e15e07e4720a807" +dependencies = [ + "bitflags 2.13.0", + "dispatch2", + "objc2 0.6.4", + "objc2-core-foundation", + "objc2-io-surface", +] + +[[package]] +name = "objc2-core-image" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "55260963a527c99f1819c4f8e3b47fe04f9650694ef348ffd2227e8196d34c80" +dependencies = [ + "block2 0.5.1", + "objc2 0.5.2", + "objc2-foundation 0.2.2", + "objc2-metal", +] + +[[package]] +name = "objc2-core-location" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "000cfee34e683244f284252ee206a27953279d370e309649dc3ee317b37e5781" +dependencies = [ + "block2 0.5.1", + "objc2 0.5.2", + "objc2-contacts", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "objc2-encode" +version = "4.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33" + +[[package]] +name = "objc2-foundation" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ee638a5da3799329310ad4cfa62fbf045d5f56e3ef5ba4149e7452dcf89d5a8" +dependencies = [ + "bitflags 2.13.0", + "block2 0.5.1", + "dispatch", + "libc", + "objc2 0.5.2", +] + +[[package]] +name = "objc2-foundation" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3e0adef53c21f888deb4fa59fc59f7eb17404926ee8a6f59f5df0fd7f9f3272" +dependencies = [ + "bitflags 2.13.0", + "block2 0.6.2", + "libc", + "objc2 0.6.4", + "objc2-core-foundation", +] + +[[package]] +name = "objc2-io-kit" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "33fafba39597d6dc1fb709123dfa8289d39406734be322956a69f0931c73bb15" +dependencies = [ + "bitflags 2.13.0", + "libc", + "objc2-core-foundation", +] + +[[package]] +name = "objc2-io-surface" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "180788110936d59bab6bd83b6060ffdfffb3b922ba1396b312ae795e1de9d81d" +dependencies = [ + "bitflags 2.13.0", + "objc2 0.6.4", + "objc2-core-foundation", +] + +[[package]] +name = "objc2-link-presentation" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1a1ae721c5e35be65f01a03b6d2ac13a54cb4fa70d8a5da293d7b0020261398" +dependencies = [ + "block2 0.5.1", + "objc2 0.5.2", + "objc2-app-kit", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "objc2-metal" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd0cba1276f6023976a406a14ffa85e1fdd19df6b0f737b063b95f6c8c7aadd6" +dependencies = [ + "bitflags 2.13.0", + "block2 0.5.1", + "objc2 0.5.2", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "objc2-quartz-core" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e42bee7bff906b14b167da2bac5efe6b6a07e6f7c0a21a7308d40c960242dc7a" +dependencies = [ + "bitflags 2.13.0", + "block2 0.5.1", + "objc2 0.5.2", + "objc2-foundation 0.2.2", + "objc2-metal", +] + +[[package]] +name = "objc2-quartz-core" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96c1358452b371bf9f104e21ec536d37a650eb10f7ee379fff67d2e08d537f1f" +dependencies = [ + "bitflags 2.13.0", + "objc2 0.6.4", + "objc2-core-foundation", + "objc2-foundation 0.3.2", +] + +[[package]] +name = "objc2-symbols" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0a684efe3dec1b305badae1a28f6555f6ddd3bb2c2267896782858d5a78404dc" +dependencies = [ + "objc2 0.5.2", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "objc2-ui-kit" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8bb46798b20cd6b91cbd113524c490f1686f4c4e8f49502431415f3512e2b6f" +dependencies = [ + "bitflags 2.13.0", + "block2 0.5.1", + "objc2 0.5.2", + "objc2-cloud-kit", + "objc2-core-data", + "objc2-core-image", + "objc2-core-location", + "objc2-foundation 0.2.2", + "objc2-link-presentation", + "objc2-quartz-core 0.2.2", + "objc2-symbols", + "objc2-uniform-type-identifiers", + "objc2-user-notifications", +] + +[[package]] +name = "objc2-uniform-type-identifiers" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "44fa5f9748dbfe1ca6c0b79ad20725a11eca7c2218bceb4b005cb1be26273bfe" +dependencies = [ + "block2 0.5.1", + "objc2 0.5.2", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "objc2-user-notifications" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76cfcbf642358e8689af64cee815d139339f3ed8ad05103ed5eaf73db8d84cb3" +dependencies = [ + "bitflags 2.13.0", + "block2 0.5.1", + "objc2 0.5.2", + "objc2-core-location", + "objc2-foundation 0.2.2", +] + +[[package]] +name = "once_cell" +version = "1.21.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" + +[[package]] +name = "once_cell_polyfill" +version = "1.70.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe" + +[[package]] +name = "orbclient" +version = "0.3.55" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5df339f526ea9a60e371768d50efc2f2508c7203290731565d1f7a6f71d21747" +dependencies = [ + "libc", + "libredox", +] + +[[package]] +name = "owned_ttf_parser" +version = "0.25.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "36820e9051aca1014ddc75770aab4d68bc1e9e632f0f5627c4086bc216fb583b" +dependencies = [ + "ttf-parser", +] + +[[package]] +name = "percent-encoding" +version = "2.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220" + +[[package]] +name = "pin-project" +version = "1.1.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2466b2336ed02bcdca6b294417127b90ec92038d1d5c4fbeac971a922e0e0924" +dependencies = [ + "pin-project-internal", +] + +[[package]] +name = "pin-project-internal" +version = "1.1.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c96395f0a926bc13b1c17622aaddda1ecb55d49c8f1bf9777e4d877800a43f8b" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "pin-project-lite" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd" + +[[package]] +name = "pkg-config" +version = "0.3.33" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19f132c84eca552bf34cab8ec81f1c1dcc229b811638f9d283dceabe58c5569e" + +[[package]] +name = "plain" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6" + +[[package]] +name = "polling" +version = "3.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218" +dependencies = [ + "cfg-if", + "concurrent-queue", + "hermit-abi", + "pin-project-lite", + "rustix 1.1.4", + "windows-sys 0.61.2", +] + +[[package]] +name = "portable-atomic" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49" + +[[package]] +name = "portable-atomic-util" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2a106d1259c23fac8e543272398ae0e3c0b8d33c88ed73d0cc71b0f1d902618" +dependencies = [ + "portable-atomic", +] + +[[package]] +name = "proc-macro-crate" +version = "3.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f" +dependencies = [ + "toml_edit", +] + +[[package]] +name = "proc-macro2" +version = "1.0.106" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quick-xml" +version = "0.39.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cdcc8dd4e2f670d309a5f0e83fe36dfdc05af317008fea29144da1a2ac858e5e" +dependencies = [ + "memchr", +] + +[[package]] +name = "quote" +version = "1.0.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "r-efi" +version = "5.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" + +[[package]] +name = "raw-window-handle" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "20675572f6f24e9e76ef639bc5552774ed45f1c30e2951e1e99c59888861c539" + +[[package]] +name = "redox_syscall" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa" +dependencies = [ + "bitflags 1.3.2", +] + +[[package]] +name = "redox_syscall" +version = "0.5.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d" +dependencies = [ + "bitflags 2.13.0", +] + +[[package]] +name = "redox_syscall" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b44b894f2a6e36457d665d1e08c3866add6ed5e70050c1b4ba8a8ddedb02ce7" +dependencies = [ + "bitflags 2.13.0", +] + +[[package]] +name = "regex" +version = "1.12.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1292b7759ae1cb9ec195452d1390a074f0cd8541ab7a5a8c31cd6db45d4a6ba" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4" + +[[package]] +name = "resid-rs" +version = "1.1.1" +source = "git+https://github.com/asrael/resid-rs#d8c05733e22053f951dbf96ef63bc58b3e02c69a" +dependencies = [ + "bit_field", +] + +[[package]] +name = "rustc_version" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92" +dependencies = [ + "semver", +] + +[[package]] +name = "rustix" +version = "0.38.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154" +dependencies = [ + "bitflags 2.13.0", + "errno", + "libc", + "linux-raw-sys 0.4.15", + "windows-sys 0.59.0", +] + +[[package]] +name = "rustix" +version = "1.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190" +dependencies = [ + "bitflags 2.13.0", + "errno", + "libc", + "linux-raw-sys 0.12.1", + "windows-sys 0.61.2", +] + +[[package]] +name = "rustversion" +version = "1.0.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" + +[[package]] +name = "same-file" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "scoped-tls" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294" + +[[package]] +name = "sctk-adwaita" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6277f0217056f77f1d8f49f2950ac6c278c0d607c45f5ee99328d792ede24ec" +dependencies = [ + "ab_glyph", + "log", + "memmap2", + "smithay-client-toolkit", + "tiny-skia", +] + +[[package]] +name = "semver" +version = "1.0.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd" + +[[package]] +name = "serde" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e" +dependencies = [ + "serde_core", +] + +[[package]] +name = "serde_core" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "shlex" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba" + +[[package]] +name = "simd-adler32" +version = "0.3.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a219298ac11a56ea9a6d2120044824d6f01aeb034955e7af7bc16858527deea" + +[[package]] +name = "simd_cesu8" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94f90157bb87cddf702797c5dadfa0be7d266cdf49e22da2fcaa32eff75b2c33" +dependencies = [ + "rustc_version", + "simdutf8", +] + +[[package]] +name = "simdutf8" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e" + +[[package]] +name = "slab" +version = "0.4.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5" + +[[package]] +name = "smallvec" +version = "1.15.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ed6a63f02c8539c91a8685a86f4099661ba3da017932f6ebbea6de3f0fa7c90" + +[[package]] +name = "smithay-client-toolkit" +version = "0.19.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3457dea1f0eb631b4034d61d4d8c32074caa6cd1ab2d59f2327bd8461e2c0016" +dependencies = [ + "bitflags 2.13.0", + "calloop", + "calloop-wayland-source", + "cursor-icon", + "libc", + "log", + "memmap2", + "rustix 0.38.44", + "thiserror 1.0.69", + "wayland-backend", + "wayland-client", + "wayland-csd-frame", + "wayland-cursor", + "wayland-protocols", + "wayland-protocols-wlr", + "wayland-scanner", + "xkeysym", +] + +[[package]] +name = "smol_str" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd538fb6910ac1099850255cf94a94df6551fbdd602454387d0adb2d1ca6dead" +dependencies = [ + "serde", +] + +[[package]] +name = "softbuffer" +version = "0.4.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aac18da81ebbf05109ab275b157c22a653bb3c12cf884450179942f81bcbf6c3" +dependencies = [ + "as-raw-xcb-connection", + "bytemuck", + "drm", + "fastrand", + "js-sys", + "memmap2", + "ndk", + "objc2 0.6.4", + "objc2-core-foundation", + "objc2-core-graphics", + "objc2-foundation 0.3.2", + "objc2-quartz-core 0.3.2", + "raw-window-handle", + "redox_syscall 0.5.18", + "rustix 1.1.4", + "tiny-xlib", + "tracing", + "wasm-bindgen", + "wayland-backend", + "wayland-client", + "wayland-sys", + "web-sys", + "windows-sys 0.61.2", + "x11rb", +] + +[[package]] +name = "strict-num" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6637bab7722d379c8b41ba849228d680cc12d0a45ba1fa2b48f2a30577a06731" + +[[package]] +name = "syn" +version = "2.0.118" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b9ae57f904213ebb649ce6895b8a66c66f0203b9319718f69a5612a065b1422" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "thiserror" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52" +dependencies = [ + "thiserror-impl 1.0.69", +] + +[[package]] +name = "thiserror" +version = "2.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4" +dependencies = [ + "thiserror-impl 2.0.18", +] + +[[package]] +name = "thiserror-impl" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "tiny-skia" +version = "0.11.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "83d13394d44dae3207b52a326c0c85a8bf87f1541f23b0d143811088497b09ab" +dependencies = [ + "arrayref", + "arrayvec", + "bytemuck", + "cfg-if", + "log", + "tiny-skia-path", +] + +[[package]] +name = "tiny-skia-path" +version = "0.11.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c9e7fc0c2e86a30b117d0462aa261b72b7a99b7ebd7deb3a14ceda95c5bdc93" +dependencies = [ + "arrayref", + "bytemuck", + "strict-num", +] + +[[package]] +name = "tiny-xlib" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a90a0ca3ee6a69f2ad28fd11621a4c3f03b371f366be500b64df260c4ffbafb4" +dependencies = [ + "as-raw-xcb-connection", + "ctor", + "libloading", + "pkg-config", + "tracing", +] + +[[package]] +name = "toml_datetime" +version = "1.1.1+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3165f65f62e28e0115a00b2ebdd37eb6f3b641855f9d636d3cd4103767159ad7" +dependencies = [ + "serde_core", +] + +[[package]] +name = "toml_edit" +version = "0.25.12+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2153edc6955a6c354fad8f5efd38b6a8769bdccf9fe50f8e1329f81b0baa5d7" +dependencies = [ + "indexmap", + "toml_datetime", + "toml_parser", + "winnow", +] + +[[package]] +name = "toml_parser" +version = "1.1.2+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a2abe9b86193656635d2411dc43050282ca48aa31c2451210f4202550afb7526" +dependencies = [ + "winnow", +] + +[[package]] +name = "tracing" +version = "0.1.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100" +dependencies = [ + "pin-project-lite", + "tracing-core", +] + +[[package]] +name = "tracing-core" +version = "0.1.36" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a" + +[[package]] +name = "ttf-parser" +version = "0.25.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2df906b07856748fa3f6e0ad0cbaa047052d4a7dd609e231c4f72cee8c36f31" + +[[package]] +name = "unicode-ident" +version = "1.0.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" + +[[package]] +name = "unicode-segmentation" +version = "1.13.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8" + +[[package]] +name = "utf8parse" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821" + +[[package]] +name = "uuid" +version = "1.23.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "144d6b123cef80b301b8f72a9e2ca4370ddec21950d0a103dd22c437006d2db7" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "vec_map" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191" + +[[package]] +name = "version_check" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" + +[[package]] +name = "walkdir" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b" +dependencies = [ + "same-file", + "winapi-util", +] + +[[package]] +name = "wasip2" +version = "1.0.4+wasi-0.2.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b67efb37e106e55ce722a510d6b5f9c17f083e5fc79afc2badeb12cc313d9487" +dependencies = [ + "wit-bindgen", +] + +[[package]] +name = "wasm-bindgen" +version = "0.2.125" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ddb3f79143bced6de84270411622a2699cee572fc0875aeaf1e7867cf9fca1a" +dependencies = [ + "cfg-if", + "once_cell", + "rustversion", + "wasm-bindgen-macro", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-futures" +version = "0.4.75" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "503b14d284f2c8dac03b819967e155ea753f573586193b2b2c95990cb5d69280" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.125" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4e21a184b13fb19e157296e2c46056aec9092264fab83e4ba59e68c61b323c3d" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.125" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fecefd9c35bd935a20fc3fc344b5f29138961e4f47fb03297d88f2587afb5ebd" +dependencies = [ + "bumpalo", + "proc-macro2", + "quote", + "syn", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.125" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "23939e44bb9a5d7576fa2b563dc2e136628f1224e88a8deed09e04858b77871f" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "wayland-backend" +version = "0.3.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2857dd20b54e916ec7253b3d6b4d5c4d7d4ca2c33c2e11c6c76a99bd8744755d" +dependencies = [ + "cc", + "downcast-rs", + "rustix 1.1.4", + "scoped-tls", + "smallvec", + "wayland-sys", +] + +[[package]] +name = "wayland-client" +version = "0.31.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "645c7c96bb74690c3189b5c9cb4ca1627062bb23693a4fad9d8c3de958260144" +dependencies = [ + "bitflags 2.13.0", + "rustix 1.1.4", + "wayland-backend", + "wayland-scanner", +] + +[[package]] +name = "wayland-csd-frame" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "625c5029dbd43d25e6aa9615e88b829a5cad13b2819c4ae129fdbb7c31ab4c7e" +dependencies = [ + "bitflags 2.13.0", + "cursor-icon", + "wayland-backend", +] + +[[package]] +name = "wayland-cursor" +version = "0.31.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4a52d18780be9b1314328a3de5f930b73d2200112e3849ca6cb11822793fb34d" +dependencies = [ + "rustix 1.1.4", + "wayland-client", + "xcursor", +] + +[[package]] +name = "wayland-protocols" +version = "0.32.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "563a85523cade2429938e790815fd7319062103b9f4a2dc806e9b53b95982d8f" +dependencies = [ + "bitflags 2.13.0", + "wayland-backend", + "wayland-client", + "wayland-scanner", +] + +[[package]] +name = "wayland-protocols-plasma" +version = "0.3.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b6d8cf1eb2c1c31ed1f5643c88a6e53538129d4af80030c8cabd1f9fa884d91" +dependencies = [ + "bitflags 2.13.0", + "wayland-backend", + "wayland-client", + "wayland-protocols", + "wayland-scanner", +] + +[[package]] +name = "wayland-protocols-wlr" +version = "0.3.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eb04e52f7836d7c7976c78ca0250d61e33873c34156a2a1fc9474828ec268234" +dependencies = [ + "bitflags 2.13.0", + "wayland-backend", + "wayland-client", + "wayland-protocols", + "wayland-scanner", +] + +[[package]] +name = "wayland-scanner" +version = "0.31.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c324a910fd86ebdc364a3e61ec1f11737d3b1d6c273c0239ee8ff4bc0d24b4a" +dependencies = [ + "proc-macro2", + "quick-xml", + "quote", +] + +[[package]] +name = "wayland-sys" +version = "0.31.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8eab23fefc9e41f8e841df4a9c707e8a8c4ed26e944ef69297184de2785e3be" +dependencies = [ + "dlib", + "log", + "once_cell", + "pkg-config", +] + +[[package]] +name = "web-sys" +version = "0.3.102" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a6430a72df5eb332242960fe84b3002a241163998241eb596d4f739b9757061d" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "web-time" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "winapi-util" +version = "0.1.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" +dependencies = [ + "windows-sys 0.61.2", +] + +[[package]] +name = "windows" +version = "0.62.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "527fadee13e0c05939a6a05d5bd6eec6cd2e3dbd648b9f8e447c6518133d8580" +dependencies = [ + "windows-collections", + "windows-core", + "windows-future", + "windows-numerics", +] + +[[package]] +name = "windows-collections" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "23b2d95af1a8a14a3c7367e1ed4fc9c20e0a26e79551b1454d72583c97cc6610" +dependencies = [ + "windows-core", +] + +[[package]] +name = "windows-core" +version = "0.62.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb" +dependencies = [ + "windows-implement", + "windows-interface", + "windows-link", + "windows-result", + "windows-strings", +] + +[[package]] +name = "windows-future" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1d6f90251fe18a279739e78025bd6ddc52a7e22f921070ccdc67dde84c605cb" +dependencies = [ + "windows-core", + "windows-link", + "windows-threading", +] + +[[package]] +name = "windows-implement" +version = "0.60.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "windows-interface" +version = "0.59.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + +[[package]] +name = "windows-numerics" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e2e40844ac143cdb44aead537bbf727de9b044e107a0f1220392177d15b0f26" +dependencies = [ + "windows-core", + "windows-link", +] + +[[package]] +name = "windows-result" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-strings" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-sys" +version = "0.52.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" +dependencies = [ + "windows-targets", +] + +[[package]] +name = "windows-sys" +version = "0.59.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" +dependencies = [ + "windows-targets", +] + +[[package]] +name = "windows-sys" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-targets" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +dependencies = [ + "windows_aarch64_gnullvm", + "windows_aarch64_msvc", + "windows_i686_gnu", + "windows_i686_gnullvm", + "windows_i686_msvc", + "windows_x86_64_gnu", + "windows_x86_64_gnullvm", + "windows_x86_64_msvc", +] + +[[package]] +name = "windows-threading" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3949bd5b99cafdf1c7ca86b43ca564028dfe27d66958f2470940f73d86d75b37" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" + +[[package]] +name = "windows_i686_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" + +[[package]] +name = "windows_i686_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" + +[[package]] +name = "winit" +version = "0.30.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a6755fa58a9f8350bd1e472d4c3fcc25f824ec358933bba33306d0b63df5978d" +dependencies = [ + "ahash", + "android-activity", + "atomic-waker", + "bitflags 2.13.0", + "block2 0.5.1", + "bytemuck", + "calloop", + "cfg_aliases", + "concurrent-queue", + "core-foundation", + "core-graphics", + "cursor-icon", + "dpi", + "js-sys", + "libc", + "memmap2", + "ndk", + "objc2 0.5.2", + "objc2-app-kit", + "objc2-foundation 0.2.2", + "objc2-ui-kit", + "orbclient", + "percent-encoding", + "pin-project", + "raw-window-handle", + "redox_syscall 0.4.1", + "rustix 0.38.44", + "sctk-adwaita", + "smithay-client-toolkit", + "smol_str", + "tracing", + "unicode-segmentation", + "wasm-bindgen", + "wasm-bindgen-futures", + "wayland-backend", + "wayland-client", + "wayland-protocols", + "wayland-protocols-plasma", + "web-sys", + "web-time", + "windows-sys 0.52.0", + "x11-dl", + "x11rb", + "xkbcommon-dl", +] + +[[package]] +name = "winnow" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0592e1c9d151f854e6fd382574c3a0855250e1d9b2f99d9281c6e6391af352f1" +dependencies = [ + "memchr", +] + +[[package]] +name = "wit-bindgen" +version = "0.57.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e" + +[[package]] +name = "x11-dl" +version = "2.21.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38735924fedd5314a6e548792904ed8c6de6636285cb9fec04d5b1db85c1516f" +dependencies = [ + "libc", + "once_cell", + "pkg-config", +] + +[[package]] +name = "x11rb" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9993aa5be5a26815fe2c3eacfc1fde061fc1a1f094bf1ad2a18bf9c495dd7414" +dependencies = [ + "as-raw-xcb-connection", + "gethostname", + "libc", + "libloading", + "once_cell", + "rustix 1.1.4", + "x11rb-protocol", +] + +[[package]] +name = "x11rb-protocol" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea6fc2961e4ef194dcbfe56bb845534d0dc8098940c7e5c012a258bfec6701bd" + +[[package]] +name = "xcursor" +version = "0.3.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bec9e4a500ca8864c5b47b8b482a73d62e4237670e5b5f1d6b9e3cae50f28f2b" + +[[package]] +name = "xkbcommon-dl" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d039de8032a9a8856a6be89cea3e5d12fdd82306ab7c94d74e6deab2460651c5" +dependencies = [ + "bitflags 2.13.0", + "dlib", + "log", + "once_cell", + "xkeysym", +] + +[[package]] +name = "xkeysym" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9cc00251562a284751c9973bace760d86c0276c471b4be569fe6b068ee97a56" + +[[package]] +name = "zerocopy" +version = "0.8.52" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce1022995ff5ff5d841ad7d994facc23098cd40152f2c1d11cd607c6f530653f" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.52" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ae7f38b72ec2a254e2b87ef277cf2cd4fb97cbebf944faa6f33354da0867930" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] diff --git a/2026/games_submissions/asrael_io/source/Cargo.toml b/2026/games_submissions/asrael_io/source/Cargo.toml new file mode 100644 index 0000000..5853732 --- /dev/null +++ b/2026/games_submissions/asrael_io/source/Cargo.toml @@ -0,0 +1,38 @@ +[package]
+name = "cj2k26"
+version = "0.1.0"
+license = "MIT"
+repository = "https://github.com/asrael/cj2k26"
+edition = "2024"
+
+[dependencies]
+aseprite-io = "0.2"
+cpal = "0.18"
+embedded-graphics = "0.8"
+env_logger = "0.11"
+gilrs = "0.11"
+glam = "0.33"
+log = "0.4"
+resid-rs = { git = "https://github.com/asrael/resid-rs" }
+softbuffer = "0.4"
+web-time = "1.1"
+winit = "0.30"
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+console_error_panic_hook = "0.1"
+cpal = { version = "0.18", features = ["wasm-bindgen"] }
+wasm-bindgen = "0.2"
+
+[profile.dev]
+opt-level = 1
+panic = "abort"
+
+[profile.release]
+codegen-units = 1
+lto = true
+panic = "abort"
+strip = "debuginfo"
+
+[profile.wasm-release]
+inherits = "release"
+opt-level = "z"
diff --git a/2026/games_submissions/asrael_io/source/Trunk.toml b/2026/games_submissions/asrael_io/source/Trunk.toml new file mode 100644 index 0000000..964e421 --- /dev/null +++ b/2026/games_submissions/asrael_io/source/Trunk.toml @@ -0,0 +1,2 @@ +[build] +public_url = "./" diff --git a/2026/games_submissions/asrael_io/source/assets/sprites.aseprite b/2026/games_submissions/asrael_io/source/assets/sprites.aseprite Binary files differnew file mode 100644 index 0000000..8e6a04b --- /dev/null +++ b/2026/games_submissions/asrael_io/source/assets/sprites.aseprite diff --git a/2026/games_submissions/asrael_io/source/index.html b/2026/games_submissions/asrael_io/source/index.html new file mode 100644 index 0000000..5002f27 --- /dev/null +++ b/2026/games_submissions/asrael_io/source/index.html @@ -0,0 +1,53 @@ +<!doctype html>
+<html>
+ <head>
+ <link data-trunk rel="scss" href="index.scss" />
+ <link data-trunk rel="rust" />
+ <script>
+ window.jamStart = false;
+ window.jamDifficulty = 0;
+ window.jamShouldStart = () =>
+ window.jamStart || Boolean(window.lcolonqJamStart);
+ window.jamGetDifficulty = () => {
+ if (window.jamDifficulty) return window.jamDifficulty;
+ if (typeof window.lcolonqJamStart === "number") return window.lcolonqJamStart;
+ return 0;
+ };
+ window.jamStarted = (verb) => window.parent.postMessage({op: "started", verb});
+ window.jamDone = (win) => window.parent.postMessage({op: "done", win});
+
+ window.addEventListener("message", (e) => {
+ if (e.data && e.data.op === "start") {
+ window.jamStart = true;
+ if (typeof e.data.difficulty === "number") {
+ window.jamDifficulty = e.data.difficulty;
+ }
+ }
+ });
+
+ if (window.parent === window) {
+ window.jamStart = true;
+ window.jamDifficulty = Math.floor(Math.random() * 8);
+ console.log("difficulty", window.jamDifficulty);
+ } else {
+ window.parent.postMessage({op: "ready"});
+ }
+
+ const fit = () => {
+ const c = document.querySelector("canvas");
+ if (!c) {
+ requestAnimationFrame(fit);
+ return;
+ }
+
+ const r = Math.max(
+ 1,
+ Math.min(Math.floor(innerWidth / 240), Math.floor(innerHeight / 160), 4),
+ );
+ c.style.transform = `translate(-50%, -50%) scale(${r})`;
+ };
+ window.addEventListener("resize", fit);
+ fit();
+ </script>
+ </head>
+</html>
diff --git a/2026/games_submissions/asrael_io/source/index.scss b/2026/games_submissions/asrael_io/source/index.scss new file mode 100644 index 0000000..4b0f47f --- /dev/null +++ b/2026/games_submissions/asrael_io/source/index.scss @@ -0,0 +1,18 @@ +html, +body { + margin: 0; + overflow: hidden; + background: #000; +} + +canvas { + display: block; + position: fixed; + left: 50%; + top: 50%; + width: 240px !important; + height: 160px !important; + image-rendering: pixelated; + transform-origin: center; + outline: none; +} diff --git a/2026/games_submissions/asrael_io/source/src/anim.rs b/2026/games_submissions/asrael_io/source/src/anim.rs new file mode 100644 index 0000000..427e22e --- /dev/null +++ b/2026/games_submissions/asrael_io/source/src/anim.rs @@ -0,0 +1,42 @@ +use crate::color::Palette; +use crate::sprite::Sprite; + +use std::rc::Rc; + +use glam::Vec2; + +const FRAME_TICKS: u32 = 6; + +pub struct Anim { + center: Vec2, + frames: Rc<Vec<Sprite>>, + tick: u32, +} + +impl Anim { + pub fn new(frames: Rc<Vec<Sprite>>, center: Vec2) -> Self { + Self { + center, + frames, + tick: 0, + } + } + + pub fn done(&self) -> bool { + self.tick >= FRAME_TICKS * self.frames.len() as u32 + } + + pub fn update(&mut self) { + self.tick += 1; + } + + pub fn draw(&self, frame: &mut [u32], palette: &Palette) { + let i = (self.tick / FRAME_TICKS) as usize; + let Some(sprite) = self.frames.get(i) else { + return; + }; + + let pos = self.center - sprite.size.as_vec2() / 2.0; + sprite.draw_at(frame, palette, pos.round().as_ivec2()); + } +} diff --git a/2026/games_submissions/asrael_io/source/src/bullet.rs b/2026/games_submissions/asrael_io/source/src/bullet.rs new file mode 100644 index 0000000..ac44f25 --- /dev/null +++ b/2026/games_submissions/asrael_io/source/src/bullet.rs @@ -0,0 +1,118 @@ +use crate::color::Palette; +use crate::color::db32::{LIGHT_RED, LIME}; +use crate::math::aabb; +use crate::sprite::Sprite; +use crate::{GAME_H, GAME_W}; + +use glam::Vec2; + +const ENEMY_BULLET_W: i32 = 2; +const ENEMY_BULLET_H: i32 = 6; +const PLAYER_BULLET_W: i32 = 3; +const PLAYER_BULLET_H: i32 = 6; +const ENEMY_SHOT_SPEED: f32 = 1.5; +const PLAYER_SHOT_SPEED: f32 = 4.0; + +#[rustfmt::skip] +const ENEMY_BULLET_PIXELS: [u8; (ENEMY_BULLET_W * ENEMY_BULLET_H) as usize] = [ + LIME, LIME, + LIME, LIME, + LIME, LIME, + LIME, LIME, + LIME, LIME, + LIME, LIME, +]; + +#[rustfmt::skip] +const PLAYER_BULLET_PIXELS: [u8; (PLAYER_BULLET_W * PLAYER_BULLET_H) as usize] = [ + 0, LIGHT_RED, 0, + LIGHT_RED, LIGHT_RED, LIGHT_RED, + 0, 0, 0, + 0, LIGHT_RED, 0, + 0, LIGHT_RED, 0, + 0, LIGHT_RED, 0, +]; + +pub struct Bullet { + angle: Option<f32>, + pos: Vec2, + vel: Vec2, + sprite: Sprite, +} + +impl Bullet { + fn new( + pos: Vec2, + vel: Vec2, + angle: Option<f32>, + width: i32, + height: i32, + pixels: &[u8], + ) -> Self { + let sprite = Sprite::new(width, height, pixels.to_vec()); + + Self { + angle, + pos, + vel, + sprite, + } + } + + pub fn aimed(from: Vec2, target: Vec2) -> Self { + let dir = (target - from).normalize_or_zero(); + let vel = dir * ENEMY_SHOT_SPEED; + let pos = from + Vec2::new(-(ENEMY_BULLET_W as f32) / 2.0, 0.0); + let angle = (-dir.x).atan2(dir.y); + + Self::new( + pos, + vel, + Some(angle), + ENEMY_BULLET_W, + ENEMY_BULLET_H, + &ENEMY_BULLET_PIXELS, + ) + } + + pub fn fired(muzzle_pos: Vec2) -> Self { + let pos = + muzzle_pos + Vec2::new(-(PLAYER_BULLET_W as f32) / 2.0, -(PLAYER_BULLET_H as f32)); + + Self::new( + pos, + Vec2::new(0.0, -PLAYER_SHOT_SPEED), + None, + PLAYER_BULLET_W, + PLAYER_BULLET_H, + &PLAYER_BULLET_PIXELS, + ) + } + + pub fn hits(&self, pos: Vec2, size: Vec2) -> bool { + aabb(self.pos, self.sprite.size.as_vec2(), pos, size) + } + + pub fn offscreen(&self) -> bool { + self.pos.x + self.sprite.size.x as f32 <= 0.0 + || self.pos.x >= GAME_W as f32 + || self.pos.y + self.sprite.size.y as f32 <= 0.0 + || self.pos.y >= GAME_H as f32 + } + + pub fn update(&mut self) { + self.pos += self.vel; + } + + pub fn draw(&self, frame: &mut [u32], palette: &Palette, a: f32) { + let p = self.pos - self.vel * (1.0 - a); + + match self.angle { + Some(angle) => { + let center = p + self.sprite.size.as_vec2() / 2.0; + self.sprite.draw_rotated(frame, palette, center, angle, 0); + } + None => self.sprite.draw_at(frame, palette, p.round().as_ivec2()), + } + } +} diff --git a/2026/games_submissions/asrael_io/source/src/color.rs b/2026/games_submissions/asrael_io/source/src/color.rs new file mode 100644 index 0000000..1db0786 --- /dev/null +++ b/2026/games_submissions/asrael_io/source/src/color.rs @@ -0,0 +1,66 @@ +pub type Color = u32; + +#[allow(dead_code)] +pub mod db32 { + pub const BLACK: u8 = 0; + pub const DARK_PURPLE: u8 = 1; + pub const MAROON: u8 = 2; + pub const DARK_BROWN: u8 = 3; + pub const BROWN: u8 = 4; + pub const ORANGE: u8 = 5; + pub const TAN: u8 = 6; + pub const PEACH: u8 = 7; + pub const YELLOW: u8 = 8; + pub const LIME: u8 = 9; + pub const GREEN: u8 = 10; + pub const SEA_GREEN: u8 = 11; + pub const DARK_GREEN: u8 = 12; + pub const OLIVE: u8 = 13; + pub const CHARCOAL: u8 = 14; + pub const NAVY: u8 = 15; + pub const STEEL_BLUE: u8 = 16; + pub const INDIGO: u8 = 17; + pub const BLUE: u8 = 18; + pub const CYAN: u8 = 19; + pub const PALE_BLUE: u8 = 20; + pub const WHITE: u8 = 21; + pub const GRAY: u8 = 22; + pub const STONE: u8 = 23; + pub const DIM_GRAY: u8 = 24; + pub const SLATE: u8 = 25; + pub const PURPLE: u8 = 26; + pub const RED: u8 = 27; + pub const LIGHT_RED: u8 = 28; + pub const PINK: u8 = 29; + pub const MOSS: u8 = 30; + pub const KHAKI: u8 = 31; +} + +const fn from_rgb(r: u8, g: u8, b: u8) -> Color { + (r as u32) << 16 | (g as u32) << 8 | b as u32 +} + +#[derive(Clone, Copy)] +pub struct Palette([Color; 256]); + +impl Default for Palette { + fn default() -> Self { + Self([0; 256]) + } +} + +impl Palette { + pub fn at(&self, index: u8) -> Color { + self.0[index as usize] + } + + pub fn from_ase(src: &[aseprite::Color]) -> Self { + let mut out = [0u32; 256]; + + for (dst, s) in out.iter_mut().zip(src) { + *dst = from_rgb(s.r, s.g, s.b); + } + + Palette(out) + } +} diff --git a/2026/games_submissions/asrael_io/source/src/enemy.rs b/2026/games_submissions/asrael_io/source/src/enemy.rs new file mode 100644 index 0000000..46eabc0 --- /dev/null +++ b/2026/games_submissions/asrael_io/source/src/enemy.rs @@ -0,0 +1,174 @@ +use crate::color::Palette; +use crate::color::db32::{LIGHT_RED, PINK, PURPLE}; +use crate::gfx; +use crate::math; +use crate::rng::Rng; +use crate::sprite::Sprite; +use crate::{GAME_H, GAME_W}; + +use std::f32::consts::TAU; + +use aseprite::AsepriteFile; +use glam::Vec2; + +const ROT_STEPS: f32 = 16.0; + +#[derive(Default)] +enum State { + Dive { + path: [Vec2; 4], + fired: u32, + shots: u32, + t: f32, + }, + #[default] + Formation, +} + +pub struct Enemy { + base: Vec2, + flash: u32, + hp: u32, + pos: Vec2, + step: Vec2, + sprite: Sprite, + state: State, +} + +impl Enemy { + pub fn new(sprites: &AsepriteFile, layer: &str, base: Vec2, hp: u32) -> Self { + let pos = base; + let step = Vec2::ZERO; + let sprite = Sprite::from_ase(sprites, layer); + let state = State::default(); + + Self { + base, + flash: 0, + hp, + pos, + step, + sprite, + state, + } + } + + pub fn damage(&mut self) -> bool { + self.hp = self.hp.saturating_sub(1); + self.flash = 12; + self.hp == 0 + } + + pub fn center(&self) -> Vec2 { + self.pos + self.size() / 2.0 + } + + pub fn pos(&self) -> Vec2 { + self.pos + } + + pub fn size(&self) -> Vec2 { + self.sprite.size.as_vec2() + } + + pub fn start_dive(&mut self, player_x: f32, shots: u32, rng: &mut Rng) { + if matches!(self.state, State::Dive { .. }) { + return; + } + + let side = if self.pos.x < 70.0 { + 1.0 + } else if self.pos.x > GAME_W as f32 - 70.0 { + -1.0 + } else if rng.chance(0.5) { + 1.0 + } else { + -1.0 + }; + + let min = Vec2::new(4.0, 4.0); + let max = Vec2::new(GAME_W as f32 - 20.0, GAME_H as f32 - 20.0); + let swing = (self.pos + Vec2::new(side * 70.0, -40.0)).clamp(min, max); + let plunge = Vec2::new(player_x, GAME_H as f32 - 20.0).clamp(min, max); + + let path = [self.pos, swing, plunge, self.base]; + + self.state = State::Dive { + path, + fired: 0, + shots, + t: 0.0, + }; + } + + pub fn update(&mut self, sway: f32, player: Vec2) -> Option<Vec2> { + let before = self.pos; + let mut shot = None; + + self.flash = self.flash.saturating_sub(1); + + match &mut self.state { + State::Formation => { + let target = self.base.x + sway; + self.pos.x += (target - self.pos.x) * 0.2; + } + + State::Dive { + path, + fired, + shots, + t, + } => { + *t += 1.0 / 240.0; + + if *t >= 1.0 { + self.pos = self.base; + self.state = State::Formation; + } else { + self.pos = math::bezier(*path, *t); + + let center = self.pos + self.sprite.size.as_vec2() / 2.0; + let facing = self.step.normalize_or_zero(); + let to_player = (player - center).normalize_or_zero(); + + let next = 0.25 + 0.5 * *fired as f32 / *shots as f32; + if *fired < *shots && *t > next && facing.dot(to_player) > 0.8 { + *fired += 1; + shot = Some(center); + } + } + } + } + + self.step = self.pos - before; + shot + } + + pub fn draw(&self, frame: &mut [u32], palette: &Palette, a: f32, tick: u32) { + let pos = self.pos - self.step * (1.0 - a); + let tint = if self.flash > 0 && (tick / 2).is_multiple_of(2) { + LIGHT_RED + } else { + 0 + }; + + if matches!(self.state, State::Dive { .. }) && self.step.length_squared() > 0.001 { + let dir = self.step.normalize(); + let angle = (-dir.x).atan2(dir.y); + let angle = (angle * ROT_STEPS / TAU).round() * (TAU / ROT_STEPS); + let center = pos + self.sprite.size.as_vec2() / 2.0; + self.sprite + .draw_rotated(frame, palette, center, angle, tint); + + let half = self.sprite.size.y as f32 / 2.0; + for i in 0..3 { + let tail = center - dir * (half + 1.0 + i as f32 * 2.0); + let c = [PURPLE, PINK][(tick / 4 + i) as usize % 2]; + gfx::blit(frame, palette, &[c], tail.round().as_ivec2(), 1, 0); + } + } else { + self.sprite + .draw_tinted(frame, palette, pos.round().as_ivec2(), tint); + } + } +} diff --git a/2026/games_submissions/asrael_io/source/src/gfx.rs b/2026/games_submissions/asrael_io/source/src/gfx.rs new file mode 100644 index 0000000..4f515c1 --- /dev/null +++ b/2026/games_submissions/asrael_io/source/src/gfx.rs @@ -0,0 +1,113 @@ +use crate::color::Palette; +use crate::{GAME_H, GAME_W}; + +use embedded_graphics::Drawable; +use embedded_graphics::Pixel; +use embedded_graphics::draw_target::DrawTarget; +use embedded_graphics::geometry::{OriginDimensions, Point, Size}; +use embedded_graphics::mono_font::{MonoFont, MonoTextStyle}; +use embedded_graphics::pixelcolor::{Rgb888, RgbColor}; +use embedded_graphics::text::{Baseline, Text}; +use glam::{IVec2, Vec2}; + +pub struct Frame<'a>(pub &'a mut [u32]); + +impl OriginDimensions for Frame<'_> { + fn size(&self) -> Size { + Size::new(GAME_W, GAME_H) + } +} + +impl DrawTarget for Frame<'_> { + type Color = Rgb888; + type Error = core::convert::Infallible; + + fn draw_iter<I>(&mut self, pixels: I) -> Result<(), Self::Error> + where + I: IntoIterator<Item = Pixel<Rgb888>>, + { + for Pixel(p, color) in pixels { + if p.x < 0 || p.x >= GAME_W as i32 || p.y < 0 || p.y >= GAME_H as i32 { + continue; + } + + self.0[(p.y * GAME_W as i32 + p.x) as usize] = + (color.r() as u32) << 16 | (color.g() as u32) << 8 | color.b() as u32; + } + + Ok(()) + } +} + +pub fn draw_text(frame: &mut [u32], font: &MonoFont, text: &str, pos: IVec2, color: u32) { + let color = Rgb888::new((color >> 16) as u8, (color >> 8) as u8, color as u8); + let style = MonoTextStyle::new(font, color); + + let _ = Text::with_baseline(text, Point::new(pos.x, pos.y), style, Baseline::Top) + .draw(&mut Frame(frame)); +} + +pub fn blit( + frame: &mut [u32], + palette: &Palette, + pixels: &[u8], + origin: IVec2, + width: i32, + tint: u8, +) { + for (i, &px) in pixels.iter().enumerate() { + if px == 0 { + continue; + } + + let sx = origin.x + i as i32 % width; + let sy = origin.y + i as i32 / width; + if sx < 0 || sx >= GAME_W as i32 || sy < 0 || sy >= GAME_H as i32 { + continue; + } + + let px = if tint != 0 { tint } else { px }; + frame[(sy * GAME_W as i32 + sx) as usize] = palette.at(px); + } +} + +pub fn blit_rotated( + frame: &mut [u32], + palette: &Palette, + pixels: &[u8], + center: Vec2, + width: i32, + angle: f32, + tint: u8, +) { + let height = pixels.len() as i32 / width; + let half = Vec2::new(width as f32, height as f32) / 2.0; + let (sin, cos) = angle.sin_cos(); + let r = half.length().ceil() as i32; + + for dy in -r..=r { + for dx in -r..=r { + let x = dx as f32 + 0.5; + let y = dy as f32 + 0.5; + let sx = (cos * x + sin * y + half.x).floor() as i32; + let sy = (-sin * x + cos * y + half.y).floor() as i32; + if sx < 0 || sx >= width || sy < 0 || sy >= height { + continue; + } + + let px = pixels[(sy * width + sx) as usize]; + if px == 0 { + continue; + } + + let fx = center.x.round() as i32 + dx; + let fy = center.y.round() as i32 + dy; + if fx < 0 || fx >= GAME_W as i32 || fy < 0 || fy >= GAME_H as i32 { + continue; + } + + let px = if tint != 0 { tint } else { px }; + frame[(fy * GAME_W as i32 + fx) as usize] = palette.at(px); + } + } +} diff --git a/2026/games_submissions/asrael_io/source/src/main.rs b/2026/games_submissions/asrael_io/source/src/main.rs new file mode 100644 index 0000000..7e57f8b --- /dev/null +++ b/2026/games_submissions/asrael_io/source/src/main.rs @@ -0,0 +1,642 @@ +mod anim;
+mod bullet;
+mod color;
+mod enemy;
+mod gfx;
+mod math;
+mod player;
+mod rng;
+mod sfx;
+mod sprite;
+mod starfield;
+
+use anim::Anim;
+use bullet::Bullet;
+use color::Palette;
+use color::db32::{BLACK, CYAN, LIGHT_RED, LIME, RED, WHITE, YELLOW};
+use enemy::Enemy;
+use math::aabb;
+use player::Player;
+use rng::Rng;
+use sfx::Sfx;
+use sprite::Sprite;
+use starfield::Starfield;
+
+use std::f32::consts::TAU;
+use std::num::NonZeroU32;
+use std::rc::Rc;
+use std::sync::Arc;
+use std::time::Duration;
+
+use aseprite::AsepriteFile;
+use embedded_graphics::mono_font::ascii::{FONT_6X10, FONT_10X20};
+use glam::{IVec2, Vec2};
+use softbuffer::{Context, Surface};
+use web_time::Instant;
+use winit::application::ApplicationHandler;
+use winit::event::{ElementState, KeyEvent, MouseButton, WindowEvent};
+use winit::event_loop::{ActiveEventLoop, EventLoop};
+use winit::keyboard::{KeyCode, PhysicalKey};
+use winit::window::{Window, WindowId};
+
+const MAX_FRAME: Duration = Duration::from_millis(100);
+const TICK: Duration = Duration::from_nanos(16_666_667);
+
+const PLAYER_MOVES: [(Action, IVec2); 4] = [
+ (Action::Up, IVec2::new(0, -1)),
+ (Action::Down, IVec2::new(0, 1)),
+ (Action::Left, IVec2::new(-1, 0)),
+ (Action::Right, IVec2::new(1, 0)),
+];
+
+pub(crate) const GAME_W: u32 = 240;
+pub(crate) const GAME_H: u32 = 160;
+
+const SPRITES: &[u8] = include_bytes!("../assets/sprites.aseprite");
+
+const DONE_HOLD: u32 = 120;
+
+const WIN_CYCLE: [u8; 4] = [LIME, WHITE, CYAN, YELLOW];
+const OVER_CYCLE: [u8; 2] = [RED, LIGHT_RED];
+
+#[derive(Default)]
+struct Cj2k26 {
+ accumulator: Duration,
+ anims: Vec<Anim>,
+ cursor: Option<Vec2>,
+ difficulty: f32,
+ dive_timer: u32,
+ done_timer: u32,
+ enemies: Vec<Enemy>,
+ enemy_bullets: Vec<Bullet>,
+ explosion_frames: Rc<Vec<Sprite>>,
+ frame: Vec<u32>,
+ input: u32,
+ interacted: bool,
+ last: Option<Instant>,
+ state: State,
+ palette: Palette,
+ player: Player,
+ player_bullets: Vec<Bullet>,
+ rng: Rng,
+ sfx: Option<Sfx>,
+ starfield: Starfield,
+ surface: Option<Surface<Arc<Window>, Arc<Window>>>,
+ tick: u32,
+ volley_timer: u32,
+ window: Option<Arc<Window>>,
+}
+
+#[derive(Clone, Copy)]
+enum Action {
+ Up,
+ Down,
+ Left,
+ Right,
+ Fire,
+}
+
+#[derive(Default)]
+enum State {
+ #[default]
+ Waiting,
+ Playing,
+ Win,
+ GameOver,
+}
+
+#[cfg(target_arch = "wasm32")]
+mod jam {
+ use wasm_bindgen::prelude::wasm_bindgen;
+
+ #[wasm_bindgen]
+ extern "C" {
+ #[wasm_bindgen(js_name = jamShouldStart)]
+ pub fn should_start() -> bool;
+
+ #[wasm_bindgen(js_name = jamGetDifficulty)]
+ pub fn difficulty() -> f32;
+
+ #[wasm_bindgen(js_name = jamStarted)]
+ pub fn started(verb: &str);
+
+ #[wasm_bindgen(js_name = jamDone)]
+ pub fn done(win: bool);
+ }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+mod jam {
+ pub fn should_start() -> bool {
+ true
+ }
+
+ pub fn difficulty() -> f32 {
+ 0.0
+ }
+
+ pub fn started(_verb: &str) {}
+
+ pub fn done(_win: bool) {}
+}
+
+impl Cj2k26 {
+ fn has_action(&self, action: Action) -> bool {
+ self.input & (1 << action as u32) != 0
+ }
+
+ fn unlock_audio(&mut self) {
+ if let Some(sfx) = &mut self.sfx {
+ sfx.resume();
+ }
+ }
+
+ fn update(&mut self) {
+ self.tick = self.tick.wrapping_add(1);
+
+ if matches!(self.state, State::Waiting) && jam::should_start() {
+ jam::started("Shoot!");
+ self.difficulty = jam::difficulty().min(7.0);
+ self.state = State::Playing;
+ }
+
+ if self.input != 0 {
+ self.interacted = true;
+ }
+
+ let playing = matches!(self.state, State::Playing);
+
+ self.starfield.update();
+
+ if playing {
+ let player_dir = PLAYER_MOVES
+ .iter()
+ .filter(|(a, _)| self.has_action(*a))
+ .fold(IVec2::ZERO, |acc, (_, v)| acc + *v);
+
+ if player_dir != IVec2::ZERO {
+ self.cursor = None;
+ }
+
+ let mut mouse = Vec2::ZERO;
+ if let Some(cursor) = self.cursor {
+ let target = cursor - self.player.size() / 2.0;
+ mouse = target - self.player.pos();
+ }
+
+ self.player.update(player_dir, mouse);
+ }
+
+ let player_center = self.player.pos() + self.player.size() / 2.0;
+
+ if playing && self.interacted && !self.enemies.is_empty() {
+ let dive_after = (90.0 - self.difficulty * 6.0).max(45.0) as u32;
+ self.dive_timer += 1;
+ if self.dive_timer >= dive_after {
+ self.dive_timer = 0;
+
+ let i = self.rng.range(self.enemies.len() as u32) as usize;
+ let shots = (2.0 + self.difficulty / 4.0).min(5.0) as u32;
+ self.enemies[i].start_dive(player_center.x, shots, &mut self.rng);
+ }
+
+ let volley_after = (70.0 - self.difficulty * 4.0).max(30.0) as u32;
+ self.volley_timer += 1;
+ if self.volley_timer >= volley_after {
+ self.volley_timer = 0;
+
+ let volley = (2.0 + self.difficulty / 3.0).min(5.0) as u32;
+ for _ in 0..volley {
+ let i = self.rng.range(self.enemies.len() as u32) as usize;
+ let enemy = &self.enemies[i];
+ let muzzle = enemy.center() + Vec2::new(0.0, enemy.size().y / 2.0);
+ let spread = Vec2::new((self.rng.f32() - 0.5) * 60.0, 0.0);
+
+ self.enemy_bullets
+ .push(Bullet::aimed(muzzle, player_center + spread));
+ }
+
+ if let Some(sfx) = &self.sfx {
+ sfx.enemy_shoot();
+ }
+ }
+ }
+
+ let seconds = self.tick as f32 / 60.0;
+ let sway = 12.0 * (seconds * TAU / 3.0).sin();
+ for enemy in &mut self.enemies {
+ if let Some(muzzle_pos) = enemy.update(sway, player_center)
+ && playing
+ {
+ self.enemy_bullets
+ .push(Bullet::aimed(muzzle_pos, self.player.pos()));
+ if let Some(sfx) = &self.sfx {
+ sfx.enemy_shoot();
+ }
+ }
+ }
+
+ if playing
+ && self.has_action(Action::Fire)
+ && let Some(muzzle_pos) = self.player.try_fire()
+ {
+ if let Some(sfx) = &self.sfx {
+ sfx.shoot();
+ }
+
+ self.player_bullets.push(Bullet::fired(muzzle_pos));
+ }
+
+ for bullet in self
+ .player_bullets
+ .iter_mut()
+ .chain(&mut self.enemy_bullets)
+ {
+ bullet.update();
+ }
+
+ self.player_bullets.retain(|b| !b.offscreen());
+ self.enemy_bullets.retain(|b| !b.offscreen());
+
+ self.player_bullets.retain(|b| {
+ match self.enemies.iter().position(|e| b.hits(e.pos(), e.size())) {
+ Some(i) => {
+ if self.enemies[i].damage() {
+ let enemy = self.enemies.swap_remove(i);
+ self.anims
+ .push(Anim::new(self.explosion_frames.clone(), enemy.center()));
+ if let Some(sfx) = &self.sfx {
+ sfx.explode();
+ }
+ } else if let Some(sfx) = &self.sfx {
+ sfx.hit();
+ }
+ false
+ }
+ None => true,
+ }
+ });
+
+ if playing {
+ let p_pos = self.player.pos();
+ let p_size = self.player.size();
+
+ let mut player_hit = false;
+ self.enemy_bullets.retain(|b| {
+ !b.hits(p_pos, p_size) || {
+ player_hit = true;
+ false
+ }
+ });
+
+ player_hit |= self
+ .enemies
+ .iter()
+ .any(|e| aabb(p_pos, p_size, e.pos(), e.size()));
+
+ if player_hit {
+ self.state = State::GameOver;
+ self.done_timer = DONE_HOLD;
+ self.anims.push(Anim::new(
+ self.explosion_frames.clone(),
+ p_pos + p_size / 2.0,
+ ));
+ if let Some(sfx) = &self.sfx {
+ sfx.explode();
+ sfx.lose();
+ }
+ }
+ }
+
+ if matches!(self.state, State::Playing) && self.enemies.is_empty() {
+ self.state = State::Win;
+ self.done_timer = DONE_HOLD;
+ if let Some(sfx) = &self.sfx {
+ sfx.win();
+ }
+ }
+
+ if matches!(self.state, State::Win) {
+ self.player
+ .win_anim(DONE_HOLD.saturating_sub(self.done_timer));
+ }
+
+ if self.done_timer > 0 {
+ self.done_timer -= 1;
+ if self.done_timer == 0 {
+ jam::done(matches!(self.state, State::Win));
+ }
+ }
+
+ for anim in &mut self.anims {
+ anim.update();
+ }
+ self.anims.retain(|a| !a.done());
+ }
+
+ fn draw(&mut self, a: f32) {
+ self.frame.fill(self.palette.at(BLACK));
+
+ self.starfield.draw(&mut self.frame, &self.palette, a);
+
+ if !matches!(self.state, State::GameOver) {
+ self.player
+ .draw(&mut self.frame, &self.palette, a, self.tick);
+ }
+
+ for enemy in &self.enemies {
+ enemy.draw(&mut self.frame, &self.palette, a, self.tick);
+ }
+
+ for bullet in self.player_bullets.iter().chain(&self.enemy_bullets) {
+ bullet.draw(&mut self.frame, &self.palette, a);
+ }
+
+ for anim in &self.anims {
+ anim.draw(&mut self.frame, &self.palette);
+ }
+
+ let cycle = (self.tick / 8) as usize;
+ let banner = match self.state {
+ State::Win => Some(("YOU WIN", WIN_CYCLE[cycle % WIN_CYCLE.len()])),
+ State::GameOver => Some(("GAME OVER", OVER_CYCLE[cycle % OVER_CYCLE.len()])),
+ _ => None,
+ };
+
+ if let Some((text, color)) = banner {
+ let w = text.len() as i32 * FONT_10X20.character_size.width as i32;
+ let pos = IVec2::new((GAME_W as i32 - w) / 2, (GAME_H as i32 - 20) / 2);
+ gfx::draw_text(
+ &mut self.frame,
+ &FONT_10X20,
+ text,
+ pos,
+ self.palette.at(color),
+ );
+ }
+
+ if !self.interacted && matches!(self.state, State::Waiting | State::Playing) {
+ let lines = ["Mouse or WASD to Move", "Left Click or Space to Fire"];
+ for (i, hint) in lines.iter().enumerate() {
+ let w = hint.len() as i32 * FONT_6X10.character_size.width as i32;
+ let y = GAME_H as i32 / 2 + 20 + i as i32 * 12;
+ let pos = IVec2::new((GAME_W as i32 - w) / 2, y);
+ gfx::draw_text(
+ &mut self.frame,
+ &FONT_6X10,
+ hint,
+ pos,
+ self.palette.at(WHITE),
+ );
+ }
+ }
+
+ self.present();
+ }
+
+ fn present(&mut self) {
+ let Some(window) = self.window.as_ref() else {
+ return;
+ };
+ let Some(surface) = self.surface.as_mut() else {
+ return;
+ };
+
+ let size = window.inner_size();
+ let (w, h) = (size.width as usize, size.height as usize);
+ let scale = (w / GAME_W as usize).min(h / GAME_H as usize);
+ if scale == 0 {
+ return;
+ }
+
+ let Ok(mut buffer) = surface.buffer_mut() else {
+ return;
+ };
+ if buffer.len() != w * h {
+ return;
+ }
+ let out_w = GAME_W as usize * scale;
+ let x0 = w.saturating_sub(out_w) / 2;
+ let y0 = h.saturating_sub(GAME_H as usize * scale) / 2;
+
+ buffer.fill(0);
+
+ let mut row = vec![0u32; out_w];
+ for gy in 0..GAME_H as usize {
+ let src = &self.frame[gy * GAME_W as usize..(gy + 1) * GAME_W as usize];
+ for (i, &c) in src.iter().enumerate() {
+ row[i * scale..(i + 1) * scale].fill(c);
+ }
+
+ for sy in 0..scale {
+ let start = (y0 + gy * scale + sy) * w + x0;
+ buffer[start..start + out_w].copy_from_slice(&row);
+ }
+ }
+
+ let _ = buffer.present();
+ }
+}
+
+impl ApplicationHandler for Cj2k26 {
+ fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+ let attributes = Window::default_attributes().with_title("cj2k26");
+
+ #[cfg(not(target_arch = "wasm32"))]
+ let attributes = {
+ use winit::dpi::LogicalSize;
+
+ let size = LogicalSize::new(GAME_W * 4, GAME_H * 4);
+ attributes.with_inner_size(size).with_min_inner_size(size)
+ };
+
+ #[cfg(target_arch = "wasm32")]
+ let attributes = {
+ use winit::platform::web::WindowAttributesExtWebSys;
+ attributes.with_append(true)
+ };
+
+ let window = Arc::new(
+ event_loop
+ .create_window(attributes)
+ .expect("failed to create window"),
+ );
+ window.set_cursor_visible(false);
+
+ #[cfg(not(target_arch = "wasm32"))]
+ {
+ use winit::window::CursorGrabMode;
+ let _ = window
+ .set_cursor_grab(CursorGrabMode::Confined)
+ .or_else(|_| window.set_cursor_grab(CursorGrabMode::Locked));
+ }
+
+ let context = Context::new(window.clone()).expect("failed to create softbuffer context");
+ let mut surface = Surface::new(&context, window.clone()).expect("failed to create surface");
+
+ let inner = window.inner_size();
+ if let (Some(w), Some(h)) = (NonZeroU32::new(inner.width), NonZeroU32::new(inner.height)) {
+ let _ = surface.resize(w, h);
+ }
+
+ self.frame = vec![0; (GAME_W * GAME_H) as usize];
+ self.surface = Some(surface);
+
+ let sprites = AsepriteFile::from_reader(SPRITES).expect("failed to read sprites aseprite!");
+
+ self.enemies = (0..8)
+ .map(|i| {
+ let hp = if i % 3 == 0 { 2 } else { 1 };
+ Enemy::new(
+ &sprites,
+ "enemy",
+ Vec2::new(24.0 + i as f32 * 24.0, 24.0),
+ hp,
+ )
+ })
+ .collect();
+
+ self.explosion_frames = Rc::new(Sprite::frames_from_ase(&sprites, "explosion"));
+ self.palette = Palette::from_ase(sprites.palette());
+ self.player = Player::new(&sprites, 2.0);
+ self.rng = Rng::default();
+ self.sfx = Some(Sfx::new());
+ self.starfield = Starfield::new(60, &mut self.rng);
+ self.window = Some(window.clone());
+
+ window.request_redraw();
+ }
+
+ fn window_event(&mut self, event_loop: &ActiveEventLoop, _id: WindowId, event: WindowEvent) {
+ match event {
+ WindowEvent::CloseRequested => event_loop.exit(),
+
+ WindowEvent::Resized(size) => {
+ if let Some(surface) = self.surface.as_mut()
+ && let (Some(w), Some(h)) =
+ (NonZeroU32::new(size.width), NonZeroU32::new(size.height))
+ {
+ let _ = surface.resize(w, h);
+ }
+ }
+
+ WindowEvent::RedrawRequested => {
+ let now = Instant::now();
+ let dt = self
+ .last
+ .replace(now)
+ .map(|prev| (now - prev).min(MAX_FRAME))
+ .unwrap_or_default();
+ self.accumulator += dt;
+
+ while self.accumulator >= TICK {
+ self.update();
+ self.accumulator -= TICK;
+ }
+
+ let alpha = self.accumulator.as_secs_f32() / TICK.as_secs_f32();
+ self.draw(alpha);
+
+ #[cfg(not(target_arch = "wasm32"))]
+ std::thread::sleep(TICK.saturating_sub(now.elapsed()));
+
+ if let Some(window) = self.window.as_ref() {
+ window.request_redraw();
+ }
+ }
+
+ WindowEvent::KeyboardInput {
+ event:
+ KeyEvent {
+ physical_key: PhysicalKey::Code(code),
+ state,
+ ..
+ },
+ ..
+ } => {
+ self.unlock_audio();
+
+ if let Some(action) = bind_key(code) {
+ let bit = 1 << action as u32;
+
+ match state {
+ ElementState::Pressed => self.input |= bit,
+ ElementState::Released => self.input &= !bit,
+ }
+ }
+ }
+
+ WindowEvent::CursorMoved { position, .. } => {
+ if let Some(window) = self.window.as_ref() {
+ let size = window.inner_size();
+ let (w, h) = (size.width as i32, size.height as i32);
+ let scale = (w / GAME_W as i32).min(h / GAME_H as i32);
+
+ if scale > 0 {
+ let x0 = (w - GAME_W as i32 * scale) / 2;
+ let y0 = (h - GAME_H as i32 * scale) / 2;
+ let gx = (position.x as i32 - x0) as f32 / scale as f32;
+ let gy = (position.y as i32 - y0) as f32 / scale as f32;
+
+ self.cursor = Some(Vec2::new(gx, gy));
+ if matches!(self.state, State::Playing) {
+ self.interacted = true;
+ }
+ }
+ }
+ }
+
+ WindowEvent::MouseInput {
+ state,
+ button: MouseButton::Left,
+ ..
+ } => {
+ self.unlock_audio();
+
+ let bit = 1 << Action::Fire as u32;
+ match state {
+ ElementState::Pressed => self.input |= bit,
+ ElementState::Released => self.input &= !bit,
+ }
+ }
+
+ WindowEvent::MouseInput { .. } | WindowEvent::KeyboardInput { .. } => {
+ self.unlock_audio();
+ }
+
+ _ => {}
+ }
+ }
+}
+
+fn bind_key(code: KeyCode) -> Option<Action> {
+ match code {
+ KeyCode::KeyW | KeyCode::ArrowUp => Some(Action::Up),
+ KeyCode::KeyS | KeyCode::ArrowDown => Some(Action::Down),
+ KeyCode::KeyA | KeyCode::ArrowLeft => Some(Action::Left),
+ KeyCode::KeyD | KeyCode::ArrowRight => Some(Action::Right),
+ KeyCode::Space => Some(Action::Fire),
+
+ _ => None,
+ }
+}
+
+fn main() {
+ let event_loop = EventLoop::new().expect("failed to create event loop");
+
+ #[cfg(not(target_arch = "wasm32"))]
+ {
+ env_logger::init_from_env(env_logger::Env::default().default_filter_or("info"));
+ event_loop
+ .run_app(&mut Cj2k26::default())
+ .expect("failed to run app");
+ }
+
+ #[cfg(target_arch = "wasm32")]
+ {
+ use winit::platform::web::EventLoopExtWebSys;
+
+ console_error_panic_hook::set_once();
+ event_loop.spawn_app(Cj2k26::default());
+ }
+}
diff --git a/2026/games_submissions/asrael_io/source/src/math.rs b/2026/games_submissions/asrael_io/source/src/math.rs new file mode 100644 index 0000000..371f165 --- /dev/null +++ b/2026/games_submissions/asrael_io/source/src/math.rs @@ -0,0 +1,13 @@ +use glam::Vec2; + +pub fn aabb(a_pos: Vec2, a_size: Vec2, b_pos: Vec2, b_size: Vec2) -> bool { + a_pos.x < b_pos.x + b_size.x + && b_pos.x < a_pos.x + a_size.x + && a_pos.y < b_pos.y + b_size.y + && b_pos.y < a_pos.y + a_size.y +} + +pub fn bezier(p: [Vec2; 4], t: f32) -> Vec2 { + let u = 1.0 - t; + u * u * u * p[0] + 3.0 * u * u * t * p[1] + 3.0 * u * t * t * p[2] + t * t * t * p[3] +} diff --git a/2026/games_submissions/asrael_io/source/src/player.rs b/2026/games_submissions/asrael_io/source/src/player.rs new file mode 100644 index 0000000..637160b --- /dev/null +++ b/2026/games_submissions/asrael_io/source/src/player.rs @@ -0,0 +1,96 @@ +use crate::color::Palette; +use crate::color::db32::{ORANGE, YELLOW}; +use crate::gfx; +use crate::sprite::Sprite; +use crate::{GAME_H, GAME_W}; + +use aseprite::AsepriteFile; +use glam::{IVec2, Vec2}; + +const FIRE_COOLDOWN: u32 = 12; +const MOUSE_MAX: f32 = 2.0; + +#[derive(Default)] +pub struct Player { + cooldown: u32, + pos: Vec2, + step: Vec2, + speed: f32, + sprite: Sprite, +} + +impl Player { + pub fn new(sprites: &AsepriteFile, speed: f32) -> Self { + let cooldown = 0; + let pos = Vec2::new(GAME_W as f32 / 2.0, GAME_H as f32 / 2.0); + let step = Vec2::ZERO; + let sprite = Sprite::from_ase(sprites, "player"); + + Self { + cooldown, + pos, + step, + speed, + sprite, + } + } + + pub fn win_anim(&mut self, t: u32) { + let before = self.pos; + + if t < 40 { + self.pos.y += 0.3; + } else { + self.pos.y -= ((t - 40) as f32 * 0.25).min(8.0); + } + + self.step = self.pos - before; + } + + pub fn pos(&self) -> Vec2 { + self.pos + } + + pub fn size(&self) -> Vec2 { + self.sprite.size.as_vec2() + } + + pub fn try_fire(&mut self) -> Option<Vec2> { + (self.cooldown == 0).then(|| { + self.cooldown = FIRE_COOLDOWN; + self.pos + Vec2::new(self.sprite.size.x as f32 / 2.0, 0.0) + }) + } + + pub fn update(&mut self, direction: IVec2, mouse: Vec2) { + let before = self.pos; + + self.cooldown = self.cooldown.saturating_sub(1); + + let dir = direction.as_vec2().normalize_or_zero(); + self.pos += dir * self.speed + mouse.clamp_length_max(MOUSE_MAX); + + let w = self.sprite.size.x as f32; + let h = self.sprite.size.y as f32; + + self.pos.x = self.pos.x.clamp(0.0, GAME_W as f32 - w); + self.pos.y = self.pos.y.clamp(0.0, GAME_H as f32 - h); + self.step = self.pos - before; + } + + pub fn draw(&self, frame: &mut [u32], palette: &Palette, a: f32, tick: u32) { + let pos = (self.pos - self.step * (1.0 - a)).round().as_ivec2(); + self.sprite.draw_at(frame, palette, pos); + + if self.step.length_squared() > 0.01 { + let flame = if (tick / 4).is_multiple_of(2) { + ORANGE + } else { + YELLOW + }; + let exhaust = [flame, flame]; + let nozzle = pos + IVec2::new(self.sprite.size.x / 2, self.sprite.size.y); + gfx::blit(frame, palette, &exhaust, nozzle, 1, 0); + } + } +} diff --git a/2026/games_submissions/asrael_io/source/src/rng.rs b/2026/games_submissions/asrael_io/source/src/rng.rs new file mode 100644 index 0000000..6e46de0 --- /dev/null +++ b/2026/games_submissions/asrael_io/source/src/rng.rs @@ -0,0 +1,35 @@ +pub struct Rng(u32);
+
+impl Rng {
+ pub fn new(seed: u32) -> Self {
+ let mut rng = Self(seed.max(1));
+ rng.next();
+ rng
+ }
+
+ pub fn next(&mut self) -> u32 {
+ self.0 ^= self.0 << 13;
+ self.0 ^= self.0 >> 17;
+ self.0 ^= self.0 << 5;
+
+ self.0
+ }
+
+ pub fn range(&mut self, n: u32) -> u32 {
+ self.next() % n
+ }
+
+ pub fn f32(&mut self) -> f32 {
+ self.next() as f32 / u32::MAX as f32
+ }
+
+ pub fn chance(&mut self, p: f32) -> bool {
+ self.f32() < p
+ }
+}
+
+impl Default for Rng {
+ fn default() -> Self {
+ Self::new(u32::from_be_bytes(*b"CLNK"))
+ }
+}
diff --git a/2026/games_submissions/asrael_io/source/src/sfx.rs b/2026/games_submissions/asrael_io/source/src/sfx.rs new file mode 100644 index 0000000..a1367df --- /dev/null +++ b/2026/games_submissions/asrael_io/source/src/sfx.rs @@ -0,0 +1,302 @@ +use std::sync::mpsc::{Receiver, Sender, channel}; + +use cpal::traits::{DeviceTrait, HostTrait, StreamTrait}; +use cpal::{Device, OutputCallbackInfo, Stream, SupportedStreamConfig}; +use resid::{ChipModel, PAL_CLOCK, SamplingMethod, Sid}; + +const GATE: u8 = 0x01; +const TRIANGLE: u8 = 0x10; +const SAWTOOTH: u8 = 0x20; +const PULSE: u8 = 0x40; +const NOISE: u8 = 0x80; + +enum Sound { + EnemyShoot, + Explosion, + Hit, + Lose, + Shoot, + Win, +} + +struct Pending { + config: SupportedStreamConfig, + device: Device, + rx: Receiver<Sound>, + sid: Sid, +} + +pub struct Sfx { + pending: Option<Pending>, + stream: Option<Stream>, + tx: Sender<Sound>, +} + +impl Sfx { + pub fn new() -> Self { + let device = cpal::default_host() + .default_output_device() + .expect("no audio output device"); + + let config = device + .default_output_config() + .expect("no default audio config"); + + let mut sid = Sid::new(ChipModel::Mos6581); + let (tx, rx) = channel::<Sound>(); + + sid.set_sampling_parameters(SamplingMethod::ResampleFast, PAL_CLOCK, config.sample_rate()); + Self::set_volume(&mut sid, 0x0F); + Self::set_envelope(&mut sid, 0, 0x06, 0x00); + Self::set_envelope(&mut sid, 1, 0x06, 0x00); + Self::set_envelope(&mut sid, 2, 0x08, 0xA9); + + Self { + pending: Some(Pending { + config, + device, + rx, + sid, + }), + stream: None, + tx, + } + } + + pub fn resume(&mut self) { + if let Some(stream) = &self.stream { + let _ = stream.play(); + return; + } + + let Some(Pending { + config, + device, + rx, + mut sid, + }) = self.pending.take() + else { + return; + }; + + let channels = config.channels() as usize; + let sample_rate = config.sample_rate(); + let mut scratch: Vec<i16> = Vec::new(); + + let mut enemy_shoot_hz: f32 = 0.0; + let mut explosion_hz: f32 = 0.0; + let mut hit_t: u32 = 0; + let mut lose_hz: f32 = 0.0; + let mut lose_t: u32 = 0; + let mut lose_wob: f32 = 0.0; + let mut shoot_hz: f32 = 0.0; + let mut win_t: u32 = 0; + + let stream = device + .build_output_stream( + config.into(), + move |data: &mut [f32], _: &OutputCallbackInfo| { + while let Ok(sound) = rx.try_recv() { + match sound { + Sound::EnemyShoot => { + enemy_shoot_hz = 520.0; + Self::set_freq(&mut sid, 1, enemy_shoot_hz); + Self::gate_on(&mut sid, 1, TRIANGLE); + } + + Sound::Explosion => { + hit_t = 0; + Self::set_envelope(&mut sid, 2, 0x08, 0xA9); + + explosion_hz = 2500.0; + Self::set_freq(&mut sid, 2, explosion_hz); + Self::gate_on(&mut sid, 2, NOISE); + } + + Sound::Hit => { + Self::set_envelope(&mut sid, 2, 0x05, 0x00); + + hit_t = 45; + Self::set_freq(&mut sid, 2, 2500.0); + Self::gate_on(&mut sid, 2, NOISE); + } + + Sound::Lose => { + enemy_shoot_hz = 0.0; + Self::set_envelope(&mut sid, 1, 0x00, 0xC6); + Self::set_pulse_width(&mut sid, 1, 0x0800); + + lose_hz = 392.0; + lose_t = 300; + lose_wob = 0.0; + Self::set_freq(&mut sid, 1, lose_hz); + Self::gate_on(&mut sid, 1, PULSE); + } + + Sound::Shoot => { + shoot_hz = 1760.0; + Self::set_freq(&mut sid, 0, shoot_hz); + Self::gate_on(&mut sid, 0, SAWTOOTH); + } + + Sound::Win => { + shoot_hz = 0.0; + Self::set_envelope(&mut sid, 0, 0x00, 0xA9); + Self::set_pulse_width(&mut sid, 0, 0x0800); + + win_t = 300; + Self::set_freq(&mut sid, 0, 987.77); + Self::gate_on(&mut sid, 0, PULSE); + } + } + } + + let frames = data.len() / channels; + if scratch.len() < frames { + scratch.resize(frames, 0); + } + let out = &mut scratch[..frames]; + + for block in out.chunks_mut(64) { + Self::sweep(&mut sid, &mut shoot_hz, 0.975, 220.0, 0, SAWTOOTH); + Self::sweep(&mut sid, &mut enemy_shoot_hz, 0.97, 200.0, 1, TRIANGLE); + Self::sweep(&mut sid, &mut explosion_hz, 0.985, 150.0, 2, NOISE); + + if hit_t > 0 { + hit_t -= 1; + if hit_t == 0 { + Self::gate_off(&mut sid, 2, NOISE); + } + } + + if win_t > 0 { + win_t -= 1; + + if win_t == 245 || win_t == 190 { + let hz = if win_t == 245 { 1318.5 } else { 1661.2 }; + Self::set_freq(&mut sid, 0, hz); + Self::gate_on(&mut sid, 0, PULSE); + } + + if win_t == 0 { + Self::gate_off(&mut sid, 0, PULSE); + } + } + + if lose_t > 0 { + lose_t -= 1; + lose_hz *= 0.995; + lose_wob += 0.35; + + let hz = lose_hz * (1.0 + 0.05 * lose_wob.sin()); + Self::set_freq(&mut sid, 1, hz); + + if lose_t == 0 { + Self::gate_off(&mut sid, 1, PULSE); + } + } + + Self::fill(&mut sid, block, sample_rate); + } + + for (frame, &s) in data.chunks_mut(channels).zip(out.iter()) { + frame.fill(s as f32 / 32768.0); + } + }, + move |err| log::error!("audio stream error: {err}"), + None, + ) + .expect("failed to build audio stream"); + + stream.play().expect("failed to start audio stream"); + self.stream = Some(stream); + } + + pub fn enemy_shoot(&self) { + let _ = self.tx.send(Sound::EnemyShoot); + } + + pub fn explode(&self) { + let _ = self.tx.send(Sound::Explosion); + } + + pub fn hit(&self) { + let _ = self.tx.send(Sound::Hit); + } + + pub fn lose(&self) { + let _ = self.tx.send(Sound::Lose); + } + + pub fn shoot(&self) { + let _ = self.tx.send(Sound::Shoot); + } + + pub fn win(&self) { + let _ = self.tx.send(Sound::Win); + } + + fn fill(sid: &mut Sid, out: &mut [i16], sample_rate: u32) { + let budget = PAL_CLOCK / sample_rate + 1; + let mut i = 0; + + while i < out.len() { + let target = (out.len() - i) as u32; + let (n, _) = sid.sample(target * budget, &mut out[i..], 1); + + if n == 0 { + break; + } + + i += n; + } + } + + fn gate_off(sid: &mut Sid, voice: u8, wave: u8) { + sid.write(voice * 7 + 4, wave); + } + + fn gate_on(sid: &mut Sid, voice: u8, wave: u8) { + sid.write(voice * 7 + 4, wave); + sid.write(voice * 7 + 4, wave | GATE); + } + + fn set_envelope(sid: &mut Sid, voice: u8, attack_decay: u8, sustain_release: u8) { + let base = voice * 7; + + sid.write(base + 5, attack_decay); + sid.write(base + 6, sustain_release); + } + + fn set_freq(sid: &mut Sid, voice: u8, hz: f32) { + let base = voice * 7; + let freq = (hz * 16_777_216.0 / PAL_CLOCK as f32) as u16; + + sid.write(base, freq as u8); + sid.write(base + 1, (freq >> 8) as u8); + } + + fn set_pulse_width(sid: &mut Sid, voice: u8, width: u16) { + let base = voice * 7; + + sid.write(base + 2, width as u8); + sid.write(base + 3, (width >> 8) as u8); + } + + fn set_volume(sid: &mut Sid, volume: u8) { + sid.write(0x18, volume); + } + + fn sweep(sid: &mut Sid, hz: &mut f32, rate: f32, floor: f32, voice: u8, wave: u8) { + if *hz > 0.0 { + *hz *= rate; + + if *hz < floor { + *hz = 0.0; + Self::gate_off(sid, voice, wave); + } else { + Self::set_freq(sid, voice, *hz); + } + } + } +} diff --git a/2026/games_submissions/asrael_io/source/src/sprite.rs b/2026/games_submissions/asrael_io/source/src/sprite.rs new file mode 100644 index 0000000..2bfb104 --- /dev/null +++ b/2026/games_submissions/asrael_io/source/src/sprite.rs @@ -0,0 +1,89 @@ +use crate::color::Palette; +use crate::gfx; + +use aseprite::{AsepriteFile, CelKind}; +use glam::{IVec2, Vec2}; + +#[derive(Clone, Default)] +pub struct Sprite { + pixels: Vec<u8>, + pub size: IVec2, +} + +impl Sprite { + pub fn new(width: i32, height: i32, pixels: Vec<u8>) -> Self { + Self { + pixels, + size: IVec2::new(width, height), + } + } + + pub fn from_ase(file: &AsepriteFile, layer: &str) -> Self { + let index = file + .layers() + .iter() + .position(|l| l.name == layer) + .unwrap_or_else(|| panic!("no layer named {layer}")); + let cel = file.cel(file.layer_ref(index).unwrap(), 0).unwrap(); + + let (CelKind::Raw { pixels, .. } | CelKind::Compressed { pixels, .. }) = &cel.kind else { + panic!("layer {layer} has no pixel cel"); + }; + + Self::new( + pixels.width as i32, + pixels.height as i32, + pixels.data.clone(), + ) + } + + pub fn frames_from_ase(file: &AsepriteFile, layer: &str) -> Vec<Self> { + let index = file + .layers() + .iter() + .position(|l| l.name == layer) + .unwrap_or_else(|| panic!("no layer named {layer}")); + let layer_ref = file.layer_ref(index).unwrap(); + + (0..file.frames().len()) + .filter_map(|f| file.resolve_cel(layer_ref, f)) + .filter_map(|cel| match &cel.kind { + CelKind::Raw { pixels, .. } | CelKind::Compressed { pixels, .. } => { + Some(Self::new( + pixels.width as i32, + pixels.height as i32, + pixels.data.clone(), + )) + } + _ => None, + }) + .collect() + } + + pub fn draw_at(&self, frame: &mut [u32], palette: &Palette, pos: IVec2) { + gfx::blit(frame, palette, &self.pixels, pos, self.size.x, 0); + } + + pub fn draw_tinted(&self, frame: &mut [u32], palette: &Palette, pos: IVec2, tint: u8) { + gfx::blit(frame, palette, &self.pixels, pos, self.size.x, tint); + } + + pub fn draw_rotated( + &self, + frame: &mut [u32], + palette: &Palette, + center: Vec2, + angle: f32, + tint: u8, + ) { + gfx::blit_rotated( + frame, + palette, + &self.pixels, + center, + self.size.x, + angle, + tint, + ); + } +} diff --git a/2026/games_submissions/asrael_io/source/src/starfield.rs b/2026/games_submissions/asrael_io/source/src/starfield.rs new file mode 100644 index 0000000..ab7a199 --- /dev/null +++ b/2026/games_submissions/asrael_io/source/src/starfield.rs @@ -0,0 +1,59 @@ +use crate::color::Palette; +use crate::color::db32::{BLUE, CYAN, GRAY, LIGHT_RED, LIME, PALE_BLUE, WHITE, YELLOW}; +use crate::rng::Rng; +use crate::{GAME_H, GAME_W}; + +const STAR_COLORS: [u8; 8] = [WHITE, GRAY, PALE_BLUE, CYAN, BLUE, YELLOW, LIGHT_RED, LIME]; + +struct Star { + color: u8, + speed: f32, + x: i32, + y: f32, +} + +#[derive(Default)] +pub struct Starfield { + stars: Vec<Star>, +} + +impl Starfield { + pub fn new(count: usize, rng: &mut Rng) -> Self { + let stars = (0..count) + .map(|i| { + let speed = match i % 3 { + 0 => 0.5, + 1 => 1.0, + _ => 1.5, + }; + + Star { + color: STAR_COLORS[rng.range(STAR_COLORS.len() as u32) as usize], + speed, + x: rng.range(GAME_W) as i32, + y: rng.range(GAME_H) as f32, + } + }) + .collect(); + + Self { stars } + } + + pub fn update(&mut self) { + for star in &mut self.stars { + star.y += star.speed; + if star.y >= GAME_H as f32 { + star.y -= GAME_H as f32; + } + } + } + + pub fn draw(&self, frame: &mut [u32], palette: &Palette, a: f32) { + for star in &self.stars { + let y = star.y - star.speed * (1.0 - a); + let y = (y as i32).rem_euclid(GAME_H as i32); + + frame[(y * GAME_W as i32 + star.x) as usize] = palette.at(star.color); + } + } +} diff --git a/2026/games_submissions/bvnanana/index.audio.position.worklet.js b/2026/games_submissions/bvnanana/index.audio.position.worklet.js new file mode 100755 index 0000000..4e512c1 --- /dev/null +++ b/2026/games_submissions/bvnanana/index.audio.position.worklet.js @@ -0,0 +1,66 @@ +/**************************************************************************/ +/* godot.audio.position.worklet.js */ +/**************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/**************************************************************************/ +/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/**************************************************************************/ + +class GodotPositionReportingProcessor extends AudioWorkletProcessor { + static get parameterDescriptors() { + return [ + { + name: 'reset', + defaultValue: 0, + minValue: 0, + maxValue: 1, + automationRate: 'k-rate', + }, + ]; + } + + constructor(...args) { + super(...args); + this.position = 0; + } + + process(inputs, _outputs, parameters) { + if (parameters['reset'][0] > 0) { + this.position = 0; + } + + if (inputs.length > 0) { + const input = inputs[0]; + if (input.length > 0) { + this.position += input[0].length; + this.port.postMessage({ type: 'position', data: this.position }); + } + } + + return true; + } +} + +registerProcessor('godot-position-reporting-processor', GodotPositionReportingProcessor); diff --git a/2026/games_submissions/bvnanana/index.audio.worklet.js b/2026/games_submissions/bvnanana/index.audio.worklet.js new file mode 100755 index 0000000..3b94cab --- /dev/null +++ b/2026/games_submissions/bvnanana/index.audio.worklet.js @@ -0,0 +1,213 @@ +/**************************************************************************/ +/* audio.worklet.js */ +/**************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/**************************************************************************/ +/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/**************************************************************************/ + +class RingBuffer { + constructor(p_buffer, p_state, p_threads) { + this.buffer = p_buffer; + this.avail = p_state; + this.threads = p_threads; + this.rpos = 0; + this.wpos = 0; + } + + data_left() { + return this.threads ? Atomics.load(this.avail, 0) : this.avail; + } + + space_left() { + return this.buffer.length - this.data_left(); + } + + read(output) { + const size = this.buffer.length; + let from = 0; + let to_write = output.length; + if (this.rpos + to_write > size) { + const high = size - this.rpos; + output.set(this.buffer.subarray(this.rpos, size)); + from = high; + to_write -= high; + this.rpos = 0; + } + if (to_write) { + output.set(this.buffer.subarray(this.rpos, this.rpos + to_write), from); + } + this.rpos += to_write; + if (this.threads) { + Atomics.add(this.avail, 0, -output.length); + Atomics.notify(this.avail, 0); + } else { + this.avail -= output.length; + } + } + + write(p_buffer) { + const to_write = p_buffer.length; + const mw = this.buffer.length - this.wpos; + if (mw >= to_write) { + this.buffer.set(p_buffer, this.wpos); + this.wpos += to_write; + if (mw === to_write) { + this.wpos = 0; + } + } else { + const high = p_buffer.subarray(0, mw); + const low = p_buffer.subarray(mw); + this.buffer.set(high, this.wpos); + this.buffer.set(low); + this.wpos = low.length; + } + if (this.threads) { + Atomics.add(this.avail, 0, to_write); + Atomics.notify(this.avail, 0); + } else { + this.avail += to_write; + } + } +} + +class GodotProcessor extends AudioWorkletProcessor { + constructor() { + super(); + this.threads = false; + this.running = true; + this.lock = null; + this.notifier = null; + this.output = null; + this.output_buffer = new Float32Array(); + this.input = null; + this.input_buffer = new Float32Array(); + this.port.onmessage = (event) => { + const cmd = event.data['cmd']; + const data = event.data['data']; + this.parse_message(cmd, data); + }; + } + + process_notify() { + if (this.notifier) { + Atomics.add(this.notifier, 0, 1); + Atomics.notify(this.notifier, 0); + } + } + + parse_message(p_cmd, p_data) { + if (p_cmd === 'start' && p_data) { + const state = p_data[0]; + let idx = 0; + this.threads = true; + this.lock = state.subarray(idx, ++idx); + this.notifier = state.subarray(idx, ++idx); + const avail_in = state.subarray(idx, ++idx); + const avail_out = state.subarray(idx, ++idx); + this.input = new RingBuffer(p_data[1], avail_in, true); + this.output = new RingBuffer(p_data[2], avail_out, true); + } else if (p_cmd === 'stop') { + this.running = false; + this.output = null; + this.input = null; + this.lock = null; + this.notifier = null; + } else if (p_cmd === 'start_nothreads') { + this.output = new RingBuffer(p_data[0], p_data[0].length, false); + } else if (p_cmd === 'chunk') { + this.output.write(p_data); + } + } + + static array_has_data(arr) { + return arr.length && arr[0].length && arr[0][0].length; + } + + process(inputs, outputs, parameters) { + if (!this.running) { + return false; // Stop processing. + } + if (this.output === null) { + return true; // Not ready yet, keep processing. + } + const process_input = GodotProcessor.array_has_data(inputs); + if (process_input) { + const input = inputs[0]; + const chunk = input[0].length * input.length; + if (this.input_buffer.length !== chunk) { + this.input_buffer = new Float32Array(chunk); + } + if (!this.threads) { + GodotProcessor.write_input(this.input_buffer, input); + this.port.postMessage({ 'cmd': 'input', 'data': this.input_buffer }); + } else if (this.input.space_left() >= chunk) { + GodotProcessor.write_input(this.input_buffer, input); + this.input.write(this.input_buffer); + } else { + // this.port.postMessage('Input buffer is full! Skipping input frame.'); // Uncomment this line to debug input buffer. + } + } + const process_output = GodotProcessor.array_has_data(outputs); + if (process_output) { + const output = outputs[0]; + const chunk = output[0].length * output.length; + if (this.output_buffer.length !== chunk) { + this.output_buffer = new Float32Array(chunk); + } + if (this.output.data_left() >= chunk) { + this.output.read(this.output_buffer); + GodotProcessor.write_output(output, this.output_buffer); + if (!this.threads) { + this.port.postMessage({ 'cmd': 'read', 'data': chunk }); + } + } else { + // this.port.postMessage('Output buffer has not enough frames! Skipping output frame.'); // Uncomment this line to debug output buffer. + } + } + this.process_notify(); + return true; + } + + static write_output(dest, source) { + const channels = dest.length; + for (let ch = 0; ch < channels; ch++) { + for (let sample = 0; sample < dest[ch].length; sample++) { + dest[ch][sample] = source[sample * channels + ch]; + } + } + } + + static write_input(dest, source) { + const channels = source.length; + for (let ch = 0; ch < channels; ch++) { + for (let sample = 0; sample < source[ch].length; sample++) { + dest[sample * channels + ch] = source[ch][sample]; + } + } + } +} + +registerProcessor('godot-processor', GodotProcessor); diff --git a/2026/games_submissions/bvnanana/index.html b/2026/games_submissions/bvnanana/index.html new file mode 100755 index 0000000..75110e4 --- /dev/null +++ b/2026/games_submissions/bvnanana/index.html @@ -0,0 +1,218 @@ +<!DOCTYPE html> +<html lang="en"> + <head> + <meta charset="utf-8"> + <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0"> + <title>twetwis</title> + <style> +html, body, #canvas { + margin: 0; + padding: 0; + border: 0; +} + +body { + color: white; + background-color: black; + overflow: hidden; + touch-action: none; +} + +#canvas { + display: block; +} + +#canvas:focus { + outline: none; +} + +#status, #status-splash, #status-progress { + position: absolute; + left: 0; + right: 0; +} + +#status, #status-splash { + top: 0; + bottom: 0; +} + +#status { + background-color: #242424; + display: flex; + flex-direction: column; + justify-content: center; + align-items: center; + visibility: hidden; +} + +#status-splash { + max-height: 100%; + max-width: 100%; + margin: auto; +} + +#status-splash.show-image--false { + display: none; +} + +#status-splash.fullsize--true { + height: 100%; + width: 100%; + object-fit: contain; +} + +#status-splash.use-filter--false { + image-rendering: pixelated; +} + +#status-progress, #status-notice { + display: none; +} + +#status-progress { + bottom: 10%; + width: 50%; + margin: 0 auto; +} + +#status-notice { + background-color: #5b3943; + border-radius: 0.5rem; + border: 1px solid #9b3943; + color: #e0e0e0; + font-family: 'Noto Sans', 'Droid Sans', Arial, sans-serif; + line-height: 1.3; + margin: 0 2rem; + overflow: hidden; + padding: 1rem; + text-align: center; + z-index: 1; +} + </style> + + </head> + <body> + <canvas id="canvas"> + Your browser does not support the canvas tag. + </canvas> + + <noscript> + Your browser does not support JavaScript. + </noscript> + + <div id="status"> + <img id="status-splash" class="show-image--true fullsize--true use-filter--true" src="index.png" alt=""> + <progress id="status-progress"></progress> + <div id="status-notice"></div> + </div> + + <script src="index.js"></script> + <script> +const GODOT_CONFIG = {"args":[],"canvasResizePolicy":2,"emscriptenPoolSize":8,"ensureCrossOriginIsolationHeaders":true,"executable":"index","experimentalVK":false,"fileSizes":{"index.pck":2102136,"index.wasm":39509339},"focusCanvas":true,"gdextensionLibs":[],"godotPoolSize":4}; +const GODOT_THREADS_ENABLED = false; +const engine = new Engine(GODOT_CONFIG); + +(function () { + const statusOverlay = document.getElementById('status'); + const statusProgress = document.getElementById('status-progress'); + const statusNotice = document.getElementById('status-notice'); + + let initializing = true; + let statusMode = ''; + + function setStatusMode(mode) { + if (statusMode === mode || !initializing) { + return; + } + if (mode === 'hidden') { + statusOverlay.remove(); + initializing = false; + return; + } + statusOverlay.style.visibility = 'visible'; + statusProgress.style.display = mode === 'progress' ? 'block' : 'none'; + statusNotice.style.display = mode === 'notice' ? 'block' : 'none'; + statusMode = mode; + } + + function setStatusNotice(text) { + while (statusNotice.lastChild) { + statusNotice.removeChild(statusNotice.lastChild); + } + const lines = text.split('\n'); + lines.forEach((line) => { + statusNotice.appendChild(document.createTextNode(line)); + statusNotice.appendChild(document.createElement('br')); + }); + } + + function displayFailureNotice(err) { + console.error(err); + if (err instanceof Error) { + setStatusNotice(err.message); + } else if (typeof err === 'string') { + setStatusNotice(err); + } else { + setStatusNotice('An unknown error occurred.'); + } + setStatusMode('notice'); + initializing = false; + } + + const missing = Engine.getMissingFeatures({ + threads: GODOT_THREADS_ENABLED, + }); + + if (missing.length !== 0) { + if (GODOT_CONFIG['serviceWorker'] && GODOT_CONFIG['ensureCrossOriginIsolationHeaders'] && 'serviceWorker' in navigator) { + let serviceWorkerRegistrationPromise; + try { + serviceWorkerRegistrationPromise = navigator.serviceWorker.getRegistration(); + } catch (err) { + serviceWorkerRegistrationPromise = Promise.reject(new Error('Service worker registration failed.')); + } + // There's a chance that installing the service worker would fix the issue + Promise.race([ + serviceWorkerRegistrationPromise.then((registration) => { + if (registration != null) { + return Promise.reject(new Error('Service worker already exists.')); + } + return registration; + }).then(() => engine.installServiceWorker()), + // For some reason, `getRegistration()` can stall + new Promise((resolve) => { + setTimeout(() => resolve(), 2000); + }), + ]).then(() => { + // Reload if there was no error. + window.location.reload(); + }).catch((err) => { + console.error('Error while registering service worker:', err); + }); + } else { + // Display the message as usual + const missingMsg = 'Error\nThe following features required to run Godot projects on the Web are missing:\n'; + displayFailureNotice(missingMsg + missing.join('\n')); + } + } else { + setStatusMode('progress'); + engine.startGame({ + 'onProgress': function (current, total) { + if (current > 0 && total > 0) { + statusProgress.value = current; + statusProgress.max = total; + } else { + statusProgress.removeAttribute('value'); + statusProgress.removeAttribute('max'); + } + }, + }).then(() => { + setStatusMode('hidden'); + }, displayFailureNotice); + } +}()); + </script> + </body> +</html> + diff --git a/2026/games_submissions/bvnanana/index.js b/2026/games_submissions/bvnanana/index.js new file mode 100755 index 0000000..6ad78a7 --- /dev/null +++ b/2026/games_submissions/bvnanana/index.js @@ -0,0 +1,909 @@ +var Godot=(()=>{var _scriptName=globalThis.document?.currentScript?.src;return async function(moduleArg={}){var moduleRtn;var Module=moduleArg;var ENVIRONMENT_IS_WEB=!!globalThis.window;var ENVIRONMENT_IS_WORKER=!!globalThis.WorkerGlobalScope;var ENVIRONMENT_IS_NODE=globalThis.process?.versions?.node&&globalThis.process?.type!="renderer";var arguments_=[];var thisProgram="./this.program";var quit_=(status,toThrow)=>{throw toThrow};if(ENVIRONMENT_IS_WORKER){_scriptName=self.location.href}var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var readAsync,readBinary;if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){try{scriptDirectory=new URL(".",_scriptName).href}catch{}{if(ENVIRONMENT_IS_WORKER){readBinary=url=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)}}readAsync=async url=>{var response=await fetch(url,{credentials:"same-origin"});if(response.ok){return response.arrayBuffer()}throw new Error(response.status+" : "+response.url)}}}else{}var out=console.log.bind(console);var err=console.error.bind(console);var wasmBinary;var ABORT=false;var EXITSTATUS;var readyPromiseResolve,readyPromiseReject;var HEAP8,HEAPU8,HEAP16,HEAPU16,HEAP32,HEAPU32,HEAPF32,HEAPF64;var HEAP64,HEAPU64;var runtimeInitialized=false;var runtimeExited=false;function updateMemoryViews(){var b=wasmMemory.buffer;Module["HEAP8"]=HEAP8=new Int8Array(b);Module["HEAP16"]=HEAP16=new Int16Array(b);Module["HEAPU8"]=HEAPU8=new Uint8Array(b);Module["HEAPU16"]=HEAPU16=new Uint16Array(b);Module["HEAP32"]=HEAP32=new Int32Array(b);Module["HEAPU32"]=HEAPU32=new Uint32Array(b);Module["HEAPF32"]=HEAPF32=new Float32Array(b);Module["HEAPF64"]=HEAPF64=new Float64Array(b);Module["HEAP64"]=HEAP64=new BigInt64Array(b);Module["HEAPU64"]=HEAPU64=new BigUint64Array(b)}function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift())}}callRuntimeCallbacks(onPreRuns)}function initRuntime(){runtimeInitialized=true;if(!Module["noFSInit"]&&!FS.initialized)FS.init();TTY.init();wasmExports["pf"]();FS.ignorePermissions=false}function preMain(){}function exitRuntime(){___funcs_on_exit();FS.quit();TTY.shutdown();IDBFS.quit();runtimeExited=true}function postRun(){if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift())}}callRuntimeCallbacks(onPostRuns)}function abort(what){Module["onAbort"]?.(what);what="Aborted("+what+")";err(what);ABORT=true;what+=". Build with -sASSERTIONS for more info.";var e=new WebAssembly.RuntimeError(what);readyPromiseReject?.(e);throw e}var wasmBinaryFile;function findWasmBinary(){return locateFile("godot.web.template_release.wasm32.nothreads.wasm")}function getBinarySync(file){if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}if(readBinary){return readBinary(file)}throw"both async and sync fetching of the wasm failed"}async function getWasmBinary(binaryFile){if(!wasmBinary){try{var response=await readAsync(binaryFile);return new Uint8Array(response)}catch{}}return getBinarySync(binaryFile)}async function instantiateArrayBuffer(binaryFile,imports){try{var binary=await getWasmBinary(binaryFile);var instance=await WebAssembly.instantiate(binary,imports);return instance}catch(reason){err(`failed to asynchronously prepare wasm: ${reason}`);abort(reason)}}async function instantiateAsync(binary,binaryFile,imports){if(!binary){try{var response=fetch(binaryFile,{credentials:"same-origin"});var instantiationResult=await WebAssembly.instantiateStreaming(response,imports);return instantiationResult}catch(reason){err(`wasm streaming compile failed: ${reason}`);err("falling back to ArrayBuffer instantiation")}}return instantiateArrayBuffer(binaryFile,imports)}function getWasmImports(){var imports={a:wasmImports};return imports}async function createWasm(){function receiveInstance(instance,module){wasmExports=instance.exports;assignWasmExports(wasmExports);updateMemoryViews();return wasmExports}function receiveInstantiationResult(result){return receiveInstance(result["instance"])}var info=getWasmImports();if(Module["instantiateWasm"]){return new Promise((resolve,reject)=>{Module["instantiateWasm"](info,(inst,mod)=>{resolve(receiveInstance(inst,mod))})})}wasmBinaryFile??=findWasmBinary();var result=await instantiateAsync(wasmBinary,wasmBinaryFile,info);var exports=receiveInstantiationResult(result);return exports}class ExitStatus{name="ExitStatus";constructor(status){this.message=`Program terminated with exit(${status})`;this.status=status}}var callRuntimeCallbacks=callbacks=>{while(callbacks.length>0){callbacks.shift()(Module)}};var onPostRuns=[];var addOnPostRun=cb=>onPostRuns.push(cb);var onPreRuns=[];var addOnPreRun=cb=>onPreRuns.push(cb);function getValue(ptr,type="i8"){if(type.endsWith("*"))type="*";switch(type){case"i1":return HEAP8[ptr];case"i8":return HEAP8[ptr];case"i16":return HEAP16[ptr>>1];case"i32":return HEAP32[ptr>>2];case"i64":return HEAP64[ptr>>3];case"float":return HEAPF32[ptr>>2];case"double":return HEAPF64[ptr>>3];case"*":return HEAPU32[ptr>>2];default:abort(`invalid type for getValue: ${type}`)}}var noExitRuntime=false;function setValue(ptr,value,type="i8"){if(type.endsWith("*"))type="*";switch(type){case"i1":HEAP8[ptr]=value;break;case"i8":HEAP8[ptr]=value;break;case"i16":HEAP16[ptr>>1]=value;break;case"i32":HEAP32[ptr>>2]=value;break;case"i64":HEAP64[ptr>>3]=BigInt(value);break;case"float":HEAPF32[ptr>>2]=value;break;case"double":HEAPF64[ptr>>3]=value;break;case"*":HEAPU32[ptr>>2]=value;break;default:abort(`invalid type for setValue: ${type}`)}}var getWasmTableEntry=funcPtr=>wasmTable.get(funcPtr);var ___call_sighandler=(fp,sig)=>getWasmTableEntry(fp)(sig);var PATH={isAbs:path=>path.charAt(0)==="/",splitPath:filename=>{var splitPathRe=/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;return splitPathRe.exec(filename).slice(1)},normalizeArray:(parts,allowAboveRoot)=>{var up=0;for(var i=parts.length-1;i>=0;i--){var last=parts[i];if(last==="."){parts.splice(i,1)}else if(last===".."){parts.splice(i,1);up++}else if(up){parts.splice(i,1);up--}}if(allowAboveRoot){for(;up;up--){parts.unshift("..")}}return parts},normalize:path=>{var isAbsolute=PATH.isAbs(path),trailingSlash=path.slice(-1)==="/";path=PATH.normalizeArray(path.split("/").filter(p=>!!p),!isAbsolute).join("/");if(!path&&!isAbsolute){path="."}if(path&&trailingSlash){path+="/"}return(isAbsolute?"/":"")+path},dirname:path=>{var result=PATH.splitPath(path),root=result[0],dir=result[1];if(!root&&!dir){return"."}if(dir){dir=dir.slice(0,-1)}return root+dir},basename:path=>path&&path.match(/([^\/]+|\/)\/*$/)[1],join:(...paths)=>PATH.normalize(paths.join("/")),join2:(l,r)=>PATH.normalize(l+"/"+r)};var initRandomFill=()=>view=>crypto.getRandomValues(view);var randomFill=view=>{(randomFill=initRandomFill())(view)};var PATH_FS={resolve:(...args)=>{var resolvedPath="",resolvedAbsolute=false;for(var i=args.length-1;i>=-1&&!resolvedAbsolute;i--){var path=i>=0?args[i]:FS.cwd();if(typeof path!="string"){throw new TypeError("Arguments to path.resolve must be strings")}else if(!path){return""}resolvedPath=path+"/"+resolvedPath;resolvedAbsolute=PATH.isAbs(path)}resolvedPath=PATH.normalizeArray(resolvedPath.split("/").filter(p=>!!p),!resolvedAbsolute).join("/");return(resolvedAbsolute?"/":"")+resolvedPath||"."},relative:(from,to)=>{from=PATH_FS.resolve(from).slice(1);to=PATH_FS.resolve(to).slice(1);function trim(arr){var start=0;for(;start<arr.length;start++){if(arr[start]!=="")break}var end=arr.length-1;for(;end>=0;end--){if(arr[end]!=="")break}if(start>end)return[];return arr.slice(start,end-start+1)}var fromParts=trim(from.split("/"));var toParts=trim(to.split("/"));var length=Math.min(fromParts.length,toParts.length);var samePartsLength=length;for(var i=0;i<length;i++){if(fromParts[i]!==toParts[i]){samePartsLength=i;break}}var outputParts=[];for(var i=samePartsLength;i<fromParts.length;i++){outputParts.push("..")}outputParts=outputParts.concat(toParts.slice(samePartsLength));return outputParts.join("/")}};var UTF8Decoder=globalThis.TextDecoder&&new TextDecoder;var findStringEnd=(heapOrArray,idx,maxBytesToRead,ignoreNul)=>{var maxIdx=idx+maxBytesToRead;if(ignoreNul)return maxIdx;while(heapOrArray[idx]&&!(idx>=maxIdx))++idx;return idx};var UTF8ArrayToString=(heapOrArray,idx=0,maxBytesToRead,ignoreNul)=>{var endPtr=findStringEnd(heapOrArray,idx,maxBytesToRead,ignoreNul);if(endPtr-idx>16&&heapOrArray.buffer&&UTF8Decoder){return UTF8Decoder.decode(heapOrArray.subarray(idx,endPtr))}var str="";while(idx<endPtr){var u0=heapOrArray[idx++];if(!(u0&128)){str+=String.fromCharCode(u0);continue}var u1=heapOrArray[idx++]&63;if((u0&224)==192){str+=String.fromCharCode((u0&31)<<6|u1);continue}var u2=heapOrArray[idx++]&63;if((u0&240)==224){u0=(u0&15)<<12|u1<<6|u2}else{u0=(u0&7)<<18|u1<<12|u2<<6|heapOrArray[idx++]&63}if(u0<65536){str+=String.fromCharCode(u0)}else{var ch=u0-65536;str+=String.fromCharCode(55296|ch>>10,56320|ch&1023)}}return str};var FS_stdin_getChar_buffer=[];var lengthBytesUTF8=str=>{var len=0;for(var i=0;i<str.length;++i){var c=str.charCodeAt(i);if(c<=127){len++}else if(c<=2047){len+=2}else if(c>=55296&&c<=57343){len+=4;++i}else{len+=3}}return len};var stringToUTF8Array=(str,heap,outIdx,maxBytesToWrite)=>{if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i<str.length;++i){var u=str.codePointAt(i);if(u<=127){if(outIdx>=endIdx)break;heap[outIdx++]=u}else if(u<=2047){if(outIdx+1>=endIdx)break;heap[outIdx++]=192|u>>6;heap[outIdx++]=128|u&63}else if(u<=65535){if(outIdx+2>=endIdx)break;heap[outIdx++]=224|u>>12;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}else{if(outIdx+3>=endIdx)break;heap[outIdx++]=240|u>>18;heap[outIdx++]=128|u>>12&63;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63;i++}}heap[outIdx]=0;return outIdx-startIdx};var intArrayFromString=(stringy,dontAddNull,length)=>{var len=length>0?length:lengthBytesUTF8(stringy)+1;var u8array=new Array(len);var numBytesWritten=stringToUTF8Array(stringy,u8array,0,u8array.length);if(dontAddNull)u8array.length=numBytesWritten;return u8array};var FS_stdin_getChar=()=>{if(!FS_stdin_getChar_buffer.length){var result=null;if(globalThis.window?.prompt){result=window.prompt("Input: ");if(result!==null){result+="\n"}}else{}if(!result){return null}FS_stdin_getChar_buffer=intArrayFromString(result,true)}return FS_stdin_getChar_buffer.shift()};var TTY={ttys:[],init(){},shutdown(){},register(dev,ops){TTY.ttys[dev]={input:[],output:[],ops};FS.registerDevice(dev,TTY.stream_ops)},stream_ops:{open(stream){var tty=TTY.ttys[stream.node.rdev];if(!tty){throw new FS.ErrnoError(43)}stream.tty=tty;stream.seekable=false},close(stream){stream.tty.ops.fsync(stream.tty)},fsync(stream){stream.tty.ops.fsync(stream.tty)},read(stream,buffer,offset,length,pos){if(!stream.tty||!stream.tty.ops.get_char){throw new FS.ErrnoError(60)}var bytesRead=0;for(var i=0;i<length;i++){var result;try{result=stream.tty.ops.get_char(stream.tty)}catch(e){throw new FS.ErrnoError(29)}if(result===undefined&&bytesRead===0){throw new FS.ErrnoError(6)}if(result===null||result===undefined)break;bytesRead++;buffer[offset+i]=result}if(bytesRead){stream.node.atime=Date.now()}return bytesRead},write(stream,buffer,offset,length,pos){if(!stream.tty||!stream.tty.ops.put_char){throw new FS.ErrnoError(60)}try{for(var i=0;i<length;i++){stream.tty.ops.put_char(stream.tty,buffer[offset+i])}}catch(e){throw new FS.ErrnoError(29)}if(length){stream.node.mtime=stream.node.ctime=Date.now()}return i}},default_tty_ops:{get_char(tty){return FS_stdin_getChar()},put_char(tty,val){if(val===null||val===10){out(UTF8ArrayToString(tty.output));tty.output=[]}else{if(val!=0)tty.output.push(val)}},fsync(tty){if(tty.output?.length>0){out(UTF8ArrayToString(tty.output));tty.output=[]}},ioctl_tcgets(tty){return{c_iflag:25856,c_oflag:5,c_cflag:191,c_lflag:35387,c_cc:[3,28,127,21,4,0,1,0,17,19,26,0,18,15,23,22,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},ioctl_tcsets(tty,optional_actions,data){return 0},ioctl_tiocgwinsz(tty){return[24,80]}},default_tty1_ops:{put_char(tty,val){if(val===null||val===10){err(UTF8ArrayToString(tty.output));tty.output=[]}else{if(val!=0)tty.output.push(val)}},fsync(tty){if(tty.output?.length>0){err(UTF8ArrayToString(tty.output));tty.output=[]}}}};var zeroMemory=(ptr,size)=>HEAPU8.fill(0,ptr,ptr+size);var alignMemory=(size,alignment)=>Math.ceil(size/alignment)*alignment;var mmapAlloc=size=>{size=alignMemory(size,65536);var ptr=_emscripten_builtin_memalign(65536,size);if(ptr)zeroMemory(ptr,size);return ptr};var MEMFS={ops_table:null,mount(mount){return MEMFS.createNode(null,"/",16895,0)},createNode(parent,name,mode,dev){if(FS.isBlkdev(mode)||FS.isFIFO(mode)){throw new FS.ErrnoError(63)}MEMFS.ops_table||={dir:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr,lookup:MEMFS.node_ops.lookup,mknod:MEMFS.node_ops.mknod,rename:MEMFS.node_ops.rename,unlink:MEMFS.node_ops.unlink,rmdir:MEMFS.node_ops.rmdir,readdir:MEMFS.node_ops.readdir,symlink:MEMFS.node_ops.symlink},stream:{llseek:MEMFS.stream_ops.llseek}},file:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr},stream:{llseek:MEMFS.stream_ops.llseek,read:MEMFS.stream_ops.read,write:MEMFS.stream_ops.write,mmap:MEMFS.stream_ops.mmap,msync:MEMFS.stream_ops.msync}},link:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr,readlink:MEMFS.node_ops.readlink},stream:{}},chrdev:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr},stream:FS.chrdev_stream_ops}};var node=FS.createNode(parent,name,mode,dev);if(FS.isDir(node.mode)){node.node_ops=MEMFS.ops_table.dir.node;node.stream_ops=MEMFS.ops_table.dir.stream;node.contents={}}else if(FS.isFile(node.mode)){node.node_ops=MEMFS.ops_table.file.node;node.stream_ops=MEMFS.ops_table.file.stream;node.usedBytes=0;node.contents=null}else if(FS.isLink(node.mode)){node.node_ops=MEMFS.ops_table.link.node;node.stream_ops=MEMFS.ops_table.link.stream}else if(FS.isChrdev(node.mode)){node.node_ops=MEMFS.ops_table.chrdev.node;node.stream_ops=MEMFS.ops_table.chrdev.stream}node.atime=node.mtime=node.ctime=Date.now();if(parent){parent.contents[name]=node;parent.atime=parent.mtime=parent.ctime=node.atime}return node},getFileDataAsTypedArray(node){if(!node.contents)return new Uint8Array(0);if(node.contents.subarray)return node.contents.subarray(0,node.usedBytes);return new Uint8Array(node.contents)},expandFileStorage(node,newCapacity){var prevCapacity=node.contents?node.contents.length:0;if(prevCapacity>=newCapacity)return;var CAPACITY_DOUBLING_MAX=1024*1024;newCapacity=Math.max(newCapacity,prevCapacity*(prevCapacity<CAPACITY_DOUBLING_MAX?2:1.125)>>>0);if(prevCapacity!=0)newCapacity=Math.max(newCapacity,256);var oldContents=node.contents;node.contents=new Uint8Array(newCapacity);if(node.usedBytes>0)node.contents.set(oldContents.subarray(0,node.usedBytes),0)},resizeFileStorage(node,newSize){if(node.usedBytes==newSize)return;if(newSize==0){node.contents=null;node.usedBytes=0}else{var oldContents=node.contents;node.contents=new Uint8Array(newSize);if(oldContents){node.contents.set(oldContents.subarray(0,Math.min(newSize,node.usedBytes)))}node.usedBytes=newSize}},node_ops:{getattr(node){var attr={};attr.dev=FS.isChrdev(node.mode)?node.id:1;attr.ino=node.id;attr.mode=node.mode;attr.nlink=1;attr.uid=0;attr.gid=0;attr.rdev=node.rdev;if(FS.isDir(node.mode)){attr.size=4096}else if(FS.isFile(node.mode)){attr.size=node.usedBytes}else if(FS.isLink(node.mode)){attr.size=node.link.length}else{attr.size=0}attr.atime=new Date(node.atime);attr.mtime=new Date(node.mtime);attr.ctime=new Date(node.ctime);attr.blksize=4096;attr.blocks=Math.ceil(attr.size/attr.blksize);return attr},setattr(node,attr){for(const key of["mode","atime","mtime","ctime"]){if(attr[key]!=null){node[key]=attr[key]}}if(attr.size!==undefined){MEMFS.resizeFileStorage(node,attr.size)}},lookup(parent,name){if(!MEMFS.doesNotExistError){MEMFS.doesNotExistError=new FS.ErrnoError(44);MEMFS.doesNotExistError.stack="<generic error, no stack>"}throw MEMFS.doesNotExistError},mknod(parent,name,mode,dev){return MEMFS.createNode(parent,name,mode,dev)},rename(old_node,new_dir,new_name){var new_node;try{new_node=FS.lookupNode(new_dir,new_name)}catch(e){}if(new_node){if(FS.isDir(old_node.mode)){for(var i in new_node.contents){throw new FS.ErrnoError(55)}}FS.hashRemoveNode(new_node)}delete old_node.parent.contents[old_node.name];new_dir.contents[new_name]=old_node;old_node.name=new_name;new_dir.ctime=new_dir.mtime=old_node.parent.ctime=old_node.parent.mtime=Date.now()},unlink(parent,name){delete parent.contents[name];parent.ctime=parent.mtime=Date.now()},rmdir(parent,name){var node=FS.lookupNode(parent,name);for(var i in node.contents){throw new FS.ErrnoError(55)}delete parent.contents[name];parent.ctime=parent.mtime=Date.now()},readdir(node){return[".","..",...Object.keys(node.contents)]},symlink(parent,newname,oldpath){var node=MEMFS.createNode(parent,newname,511|40960,0);node.link=oldpath;return node},readlink(node){if(!FS.isLink(node.mode)){throw new FS.ErrnoError(28)}return node.link}},stream_ops:{read(stream,buffer,offset,length,position){var contents=stream.node.contents;if(position>=stream.node.usedBytes)return 0;var size=Math.min(stream.node.usedBytes-position,length);if(size>8&&contents.subarray){buffer.set(contents.subarray(position,position+size),offset)}else{for(var i=0;i<size;i++)buffer[offset+i]=contents[position+i]}return size},write(stream,buffer,offset,length,position,canOwn){if(buffer.buffer===HEAP8.buffer){canOwn=false}if(!length)return 0;var node=stream.node;node.mtime=node.ctime=Date.now();if(buffer.subarray&&(!node.contents||node.contents.subarray)){if(canOwn){node.contents=buffer.subarray(offset,offset+length);node.usedBytes=length;return length}else if(node.usedBytes===0&&position===0){node.contents=buffer.slice(offset,offset+length);node.usedBytes=length;return length}else if(position+length<=node.usedBytes){node.contents.set(buffer.subarray(offset,offset+length),position);return length}}MEMFS.expandFileStorage(node,position+length);if(node.contents.subarray&&buffer.subarray){node.contents.set(buffer.subarray(offset,offset+length),position)}else{for(var i=0;i<length;i++){node.contents[position+i]=buffer[offset+i]}}node.usedBytes=Math.max(node.usedBytes,position+length);return length},llseek(stream,offset,whence){var position=offset;if(whence===1){position+=stream.position}else if(whence===2){if(FS.isFile(stream.node.mode)){position+=stream.node.usedBytes}}if(position<0){throw new FS.ErrnoError(28)}return position},mmap(stream,length,position,prot,flags){if(!FS.isFile(stream.node.mode)){throw new FS.ErrnoError(43)}var ptr;var allocated;var contents=stream.node.contents;if(!(flags&2)&&contents&&contents.buffer===HEAP8.buffer){allocated=false;ptr=contents.byteOffset}else{allocated=true;ptr=mmapAlloc(length);if(!ptr){throw new FS.ErrnoError(48)}if(contents){if(position>0||position+length<contents.length){if(contents.subarray){contents=contents.subarray(position,position+length)}else{contents=Array.prototype.slice.call(contents,position,position+length)}}HEAP8.set(contents,ptr)}}return{ptr,allocated}},msync(stream,buffer,offset,length,mmapFlags){MEMFS.stream_ops.write(stream,buffer,0,length,offset,false);return 0}}};var FS_modeStringToFlags=str=>{var flagModes={r:0,"r+":2,w:512|64|1,"w+":512|64|2,a:1024|64|1,"a+":1024|64|2};var flags=flagModes[str];if(typeof flags=="undefined"){throw new Error(`Unknown file open mode: ${str}`)}return flags};var FS_getMode=(canRead,canWrite)=>{var mode=0;if(canRead)mode|=292|73;if(canWrite)mode|=146;return mode};var IDBFS={dbs:{},indexedDB:()=>indexedDB,DB_VERSION:21,DB_STORE_NAME:"FILE_DATA",queuePersist:mount=>{function onPersistComplete(){if(mount.idbPersistState==="again")startPersist();else mount.idbPersistState=0}function startPersist(){mount.idbPersistState="idb";IDBFS.syncfs(mount,false,onPersistComplete)}if(!mount.idbPersistState){mount.idbPersistState=setTimeout(startPersist,0)}else if(mount.idbPersistState==="idb"){mount.idbPersistState="again"}},mount:mount=>{var mnt=MEMFS.mount(mount);if(mount?.opts?.autoPersist){mount.idbPersistState=0;var memfs_node_ops=mnt.node_ops;mnt.node_ops={...mnt.node_ops};mnt.node_ops.mknod=(parent,name,mode,dev)=>{var node=memfs_node_ops.mknod(parent,name,mode,dev);node.node_ops=mnt.node_ops;node.idbfs_mount=mnt.mount;node.memfs_stream_ops=node.stream_ops;node.stream_ops={...node.stream_ops};node.stream_ops.write=(stream,buffer,offset,length,position,canOwn)=>{stream.node.isModified=true;return node.memfs_stream_ops.write(stream,buffer,offset,length,position,canOwn)};node.stream_ops.close=stream=>{var n=stream.node;if(n.isModified){IDBFS.queuePersist(n.idbfs_mount);n.isModified=false}if(n.memfs_stream_ops.close)return n.memfs_stream_ops.close(stream)};IDBFS.queuePersist(mnt.mount);return node};mnt.node_ops.rmdir=(...args)=>(IDBFS.queuePersist(mnt.mount),memfs_node_ops.rmdir(...args));mnt.node_ops.symlink=(...args)=>(IDBFS.queuePersist(mnt.mount),memfs_node_ops.symlink(...args));mnt.node_ops.unlink=(...args)=>(IDBFS.queuePersist(mnt.mount),memfs_node_ops.unlink(...args));mnt.node_ops.rename=(...args)=>(IDBFS.queuePersist(mnt.mount),memfs_node_ops.rename(...args))}return mnt},syncfs:(mount,populate,callback)=>{IDBFS.getLocalSet(mount,(err,local)=>{if(err)return callback(err);IDBFS.getRemoteSet(mount,(err,remote)=>{if(err)return callback(err);var src=populate?remote:local;var dst=populate?local:remote;IDBFS.reconcile(src,dst,callback)})})},quit:()=>{for(var value of Object.values(IDBFS.dbs)){value.close()}IDBFS.dbs={}},getDB:(name,callback)=>{var db=IDBFS.dbs[name];if(db){return callback(null,db)}var req;try{req=IDBFS.indexedDB().open(name,IDBFS.DB_VERSION)}catch(e){return callback(e)}if(!req){return callback("Unable to connect to IndexedDB")}req.onupgradeneeded=e=>{var db=e.target.result;var transaction=e.target.transaction;var fileStore;if(db.objectStoreNames.contains(IDBFS.DB_STORE_NAME)){fileStore=transaction.objectStore(IDBFS.DB_STORE_NAME)}else{fileStore=db.createObjectStore(IDBFS.DB_STORE_NAME)}if(!fileStore.indexNames.contains("timestamp")){fileStore.createIndex("timestamp","timestamp",{unique:false})}};req.onsuccess=()=>{db=req.result;IDBFS.dbs[name]=db;callback(null,db)};req.onerror=e=>{callback(e.target.error);e.preventDefault()}},getLocalSet:(mount,callback)=>{var entries={};function isRealDir(p){return p!=="."&&p!==".."}function toAbsolute(root){return p=>PATH.join2(root,p)}var check=FS.readdir(mount.mountpoint).filter(isRealDir).map(toAbsolute(mount.mountpoint));while(check.length){var path=check.pop();var stat;try{stat=FS.stat(path)}catch(e){return callback(e)}if(FS.isDir(stat.mode)){check.push(...FS.readdir(path).filter(isRealDir).map(toAbsolute(path)))}entries[path]={timestamp:stat.mtime}}return callback(null,{type:"local",entries})},getRemoteSet:(mount,callback)=>{var entries={};IDBFS.getDB(mount.mountpoint,(err,db)=>{if(err)return callback(err);try{var transaction=db.transaction([IDBFS.DB_STORE_NAME],"readonly");transaction.onerror=e=>{callback(e.target.error);e.preventDefault()};var store=transaction.objectStore(IDBFS.DB_STORE_NAME);var index=store.index("timestamp");index.openKeyCursor().onsuccess=event=>{var cursor=event.target.result;if(!cursor){return callback(null,{type:"remote",db,entries})}entries[cursor.primaryKey]={timestamp:cursor.key};cursor.continue()}}catch(e){return callback(e)}})},loadLocalEntry:(path,callback)=>{var stat,node;try{var lookup=FS.lookupPath(path);node=lookup.node;stat=FS.stat(path)}catch(e){return callback(e)}if(FS.isDir(stat.mode)){return callback(null,{timestamp:stat.mtime,mode:stat.mode})}else if(FS.isFile(stat.mode)){node.contents=MEMFS.getFileDataAsTypedArray(node);return callback(null,{timestamp:stat.mtime,mode:stat.mode,contents:node.contents})}else{return callback(new Error("node type not supported"))}},storeLocalEntry:(path,entry,callback)=>{try{if(FS.isDir(entry["mode"])){FS.mkdirTree(path,entry["mode"])}else if(FS.isFile(entry["mode"])){FS.writeFile(path,entry["contents"],{canOwn:true})}else{return callback(new Error("node type not supported"))}FS.chmod(path,entry["mode"]);FS.utime(path,entry["timestamp"],entry["timestamp"])}catch(e){return callback(e)}callback(null)},removeLocalEntry:(path,callback)=>{try{var stat=FS.stat(path);if(FS.isDir(stat.mode)){FS.rmdir(path)}else if(FS.isFile(stat.mode)){FS.unlink(path)}}catch(e){return callback(e)}callback(null)},loadRemoteEntry:(store,path,callback)=>{var req=store.get(path);req.onsuccess=event=>callback(null,event.target.result);req.onerror=e=>{callback(e.target.error);e.preventDefault()}},storeRemoteEntry:(store,path,entry,callback)=>{try{var req=store.put(entry,path)}catch(e){callback(e);return}req.onsuccess=event=>callback();req.onerror=e=>{callback(e.target.error);e.preventDefault()}},removeRemoteEntry:(store,path,callback)=>{var req=store.delete(path);req.onsuccess=event=>callback();req.onerror=e=>{callback(e.target.error);e.preventDefault()}},reconcile:(src,dst,callback)=>{var total=0;var create=[];for(var[key,e]of Object.entries(src.entries)){var e2=dst.entries[key];if(!e2||e["timestamp"].getTime()!=e2["timestamp"].getTime()){create.push(key);total++}}var remove=[];for(var key of Object.keys(dst.entries)){if(!src.entries[key]){remove.push(key);total++}}if(!total){return callback(null)}var errored=false;var db=src.type==="remote"?src.db:dst.db;var transaction=db.transaction([IDBFS.DB_STORE_NAME],"readwrite");var store=transaction.objectStore(IDBFS.DB_STORE_NAME);function done(err){if(err&&!errored){errored=true;return callback(err)}}transaction.onerror=transaction.onabort=e=>{done(e.target.error);e.preventDefault()};transaction.oncomplete=e=>{if(!errored){callback(null)}};for(const path of create.sort()){if(dst.type==="local"){IDBFS.loadRemoteEntry(store,path,(err,entry)=>{if(err)return done(err);IDBFS.storeLocalEntry(path,entry,done)})}else{IDBFS.loadLocalEntry(path,(err,entry)=>{if(err)return done(err);IDBFS.storeRemoteEntry(store,path,entry,done)})}}for(var path of remove.sort().reverse()){if(dst.type==="local"){IDBFS.removeLocalEntry(path,done)}else{IDBFS.removeRemoteEntry(store,path,done)}}}};var asyncLoad=async url=>{var arrayBuffer=await readAsync(url);return new Uint8Array(arrayBuffer)};var FS_createDataFile=(...args)=>FS.createDataFile(...args);var getUniqueRunDependency=id=>id;var runDependencies=0;var dependenciesFulfilled=null;var removeRunDependency=id=>{runDependencies--;Module["monitorRunDependencies"]?.(runDependencies);if(runDependencies==0){if(dependenciesFulfilled){var callback=dependenciesFulfilled;dependenciesFulfilled=null;callback()}}};var addRunDependency=id=>{runDependencies++;Module["monitorRunDependencies"]?.(runDependencies)};var preloadPlugins=[];var FS_handledByPreloadPlugin=async(byteArray,fullname)=>{if(typeof Browser!="undefined")Browser.init();for(var plugin of preloadPlugins){if(plugin["canHandle"](fullname)){return plugin["handle"](byteArray,fullname)}}return byteArray};var FS_preloadFile=async(parent,name,url,canRead,canWrite,dontCreateFile,canOwn,preFinish)=>{var fullname=name?PATH_FS.resolve(PATH.join2(parent,name)):parent;var dep=getUniqueRunDependency(`cp ${fullname}`);addRunDependency(dep);try{var byteArray=url;if(typeof url=="string"){byteArray=await asyncLoad(url)}byteArray=await FS_handledByPreloadPlugin(byteArray,fullname);preFinish?.();if(!dontCreateFile){FS_createDataFile(parent,name,byteArray,canRead,canWrite,canOwn)}}finally{removeRunDependency(dep)}};var FS_createPreloadedFile=(parent,name,url,canRead,canWrite,onload,onerror,dontCreateFile,canOwn,preFinish)=>{FS_preloadFile(parent,name,url,canRead,canWrite,dontCreateFile,canOwn,preFinish).then(onload).catch(onerror)};var FS={root:null,mounts:[],devices:{},streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,filesystems:null,syncFSRequests:0,readFiles:{},ErrnoError:class{name="ErrnoError";constructor(errno){this.errno=errno}},FSStream:class{shared={};get object(){return this.node}set object(val){this.node=val}get isRead(){return(this.flags&2097155)!==1}get isWrite(){return(this.flags&2097155)!==0}get isAppend(){return this.flags&1024}get flags(){return this.shared.flags}set flags(val){this.shared.flags=val}get position(){return this.shared.position}set position(val){this.shared.position=val}},FSNode:class{node_ops={};stream_ops={};readMode=292|73;writeMode=146;mounted=null;constructor(parent,name,mode,rdev){if(!parent){parent=this}this.parent=parent;this.mount=parent.mount;this.id=FS.nextInode++;this.name=name;this.mode=mode;this.rdev=rdev;this.atime=this.mtime=this.ctime=Date.now()}get read(){return(this.mode&this.readMode)===this.readMode}set read(val){val?this.mode|=this.readMode:this.mode&=~this.readMode}get write(){return(this.mode&this.writeMode)===this.writeMode}set write(val){val?this.mode|=this.writeMode:this.mode&=~this.writeMode}get isFolder(){return FS.isDir(this.mode)}get isDevice(){return FS.isChrdev(this.mode)}},lookupPath(path,opts={}){if(!path){throw new FS.ErrnoError(44)}opts.follow_mount??=true;if(!PATH.isAbs(path)){path=FS.cwd()+"/"+path}linkloop:for(var nlinks=0;nlinks<40;nlinks++){var parts=path.split("/").filter(p=>!!p);var current=FS.root;var current_path="/";for(var i=0;i<parts.length;i++){var islast=i===parts.length-1;if(islast&&opts.parent){break}if(parts[i]==="."){continue}if(parts[i]===".."){current_path=PATH.dirname(current_path);if(FS.isRoot(current)){path=current_path+"/"+parts.slice(i+1).join("/");nlinks--;continue linkloop}else{current=current.parent}continue}current_path=PATH.join2(current_path,parts[i]);try{current=FS.lookupNode(current,parts[i])}catch(e){if(e?.errno===44&&islast&&opts.noent_okay){return{path:current_path}}throw e}if(FS.isMountpoint(current)&&(!islast||opts.follow_mount)){current=current.mounted.root}if(FS.isLink(current.mode)&&(!islast||opts.follow)){if(!current.node_ops.readlink){throw new FS.ErrnoError(52)}var link=current.node_ops.readlink(current);if(!PATH.isAbs(link)){link=PATH.dirname(current_path)+"/"+link}path=link+"/"+parts.slice(i+1).join("/");continue linkloop}}return{path:current_path,node:current}}throw new FS.ErrnoError(32)},getPath(node){var path;while(true){if(FS.isRoot(node)){var mount=node.mount.mountpoint;if(!path)return mount;return mount[mount.length-1]!=="/"?`${mount}/${path}`:mount+path}path=path?`${node.name}/${path}`:node.name;node=node.parent}},hashName(parentid,name){var hash=0;for(var i=0;i<name.length;i++){hash=(hash<<5)-hash+name.charCodeAt(i)|0}return(parentid+hash>>>0)%FS.nameTable.length},hashAddNode(node){var hash=FS.hashName(node.parent.id,node.name);node.name_next=FS.nameTable[hash];FS.nameTable[hash]=node},hashRemoveNode(node){var hash=FS.hashName(node.parent.id,node.name);if(FS.nameTable[hash]===node){FS.nameTable[hash]=node.name_next}else{var current=FS.nameTable[hash];while(current){if(current.name_next===node){current.name_next=node.name_next;break}current=current.name_next}}},lookupNode(parent,name){var errCode=FS.mayLookup(parent);if(errCode){throw new FS.ErrnoError(errCode)}var hash=FS.hashName(parent.id,name);for(var node=FS.nameTable[hash];node;node=node.name_next){var nodeName=node.name;if(node.parent.id===parent.id&&nodeName===name){return node}}return FS.lookup(parent,name)},createNode(parent,name,mode,rdev){var node=new FS.FSNode(parent,name,mode,rdev);FS.hashAddNode(node);return node},destroyNode(node){FS.hashRemoveNode(node)},isRoot(node){return node===node.parent},isMountpoint(node){return!!node.mounted},isFile(mode){return(mode&61440)===32768},isDir(mode){return(mode&61440)===16384},isLink(mode){return(mode&61440)===40960},isChrdev(mode){return(mode&61440)===8192},isBlkdev(mode){return(mode&61440)===24576},isFIFO(mode){return(mode&61440)===4096},isSocket(mode){return(mode&49152)===49152},flagsToPermissionString(flag){var perms=["r","w","rw"][flag&3];if(flag&512){perms+="w"}return perms},nodePermissions(node,perms){if(FS.ignorePermissions){return 0}if(perms.includes("r")&&!(node.mode&292)){return 2}else if(perms.includes("w")&&!(node.mode&146)){return 2}else if(perms.includes("x")&&!(node.mode&73)){return 2}return 0},mayLookup(dir){if(!FS.isDir(dir.mode))return 54;var errCode=FS.nodePermissions(dir,"x");if(errCode)return errCode;if(!dir.node_ops.lookup)return 2;return 0},mayCreate(dir,name){if(!FS.isDir(dir.mode)){return 54}try{var node=FS.lookupNode(dir,name);return 20}catch(e){}return FS.nodePermissions(dir,"wx")},mayDelete(dir,name,isdir){var node;try{node=FS.lookupNode(dir,name)}catch(e){return e.errno}var errCode=FS.nodePermissions(dir,"wx");if(errCode){return errCode}if(isdir){if(!FS.isDir(node.mode)){return 54}if(FS.isRoot(node)||FS.getPath(node)===FS.cwd()){return 10}}else{if(FS.isDir(node.mode)){return 31}}return 0},mayOpen(node,flags){if(!node){return 44}if(FS.isLink(node.mode)){return 32}else if(FS.isDir(node.mode)){if(FS.flagsToPermissionString(flags)!=="r"||flags&(512|64)){return 31}}return FS.nodePermissions(node,FS.flagsToPermissionString(flags))},checkOpExists(op,err){if(!op){throw new FS.ErrnoError(err)}return op},MAX_OPEN_FDS:4096,nextfd(){for(var fd=0;fd<=FS.MAX_OPEN_FDS;fd++){if(!FS.streams[fd]){return fd}}throw new FS.ErrnoError(33)},getStreamChecked(fd){var stream=FS.getStream(fd);if(!stream){throw new FS.ErrnoError(8)}return stream},getStream:fd=>FS.streams[fd],createStream(stream,fd=-1){stream=Object.assign(new FS.FSStream,stream);if(fd==-1){fd=FS.nextfd()}stream.fd=fd;FS.streams[fd]=stream;return stream},closeStream(fd){FS.streams[fd]=null},dupStream(origStream,fd=-1){var stream=FS.createStream(origStream,fd);stream.stream_ops?.dup?.(stream);return stream},doSetAttr(stream,node,attr){var setattr=stream?.stream_ops.setattr;var arg=setattr?stream:node;setattr??=node.node_ops.setattr;FS.checkOpExists(setattr,63);setattr(arg,attr)},chrdev_stream_ops:{open(stream){var device=FS.getDevice(stream.node.rdev);stream.stream_ops=device.stream_ops;stream.stream_ops.open?.(stream)},llseek(){throw new FS.ErrnoError(70)}},major:dev=>dev>>8,minor:dev=>dev&255,makedev:(ma,mi)=>ma<<8|mi,registerDevice(dev,ops){FS.devices[dev]={stream_ops:ops}},getDevice:dev=>FS.devices[dev],getMounts(mount){var mounts=[];var check=[mount];while(check.length){var m=check.pop();mounts.push(m);check.push(...m.mounts)}return mounts},syncfs(populate,callback){if(typeof populate=="function"){callback=populate;populate=false}FS.syncFSRequests++;if(FS.syncFSRequests>1){err(`warning: ${FS.syncFSRequests} FS.syncfs operations in flight at once, probably just doing extra work`)}var mounts=FS.getMounts(FS.root.mount);var completed=0;function doCallback(errCode){FS.syncFSRequests--;return callback(errCode)}function done(errCode){if(errCode){if(!done.errored){done.errored=true;return doCallback(errCode)}return}if(++completed>=mounts.length){doCallback(null)}}for(var mount of mounts){if(mount.type.syncfs){mount.type.syncfs(mount,populate,done)}else{done(null)}}},mount(type,opts,mountpoint){var root=mountpoint==="/";var pseudo=!mountpoint;var node;if(root&&FS.root){throw new FS.ErrnoError(10)}else if(!root&&!pseudo){var lookup=FS.lookupPath(mountpoint,{follow_mount:false});mountpoint=lookup.path;node=lookup.node;if(FS.isMountpoint(node)){throw new FS.ErrnoError(10)}if(!FS.isDir(node.mode)){throw new FS.ErrnoError(54)}}var mount={type,opts,mountpoint,mounts:[]};var mountRoot=type.mount(mount);mountRoot.mount=mount;mount.root=mountRoot;if(root){FS.root=mountRoot}else if(node){node.mounted=mount;if(node.mount){node.mount.mounts.push(mount)}}return mountRoot},unmount(mountpoint){var lookup=FS.lookupPath(mountpoint,{follow_mount:false});if(!FS.isMountpoint(lookup.node)){throw new FS.ErrnoError(28)}var node=lookup.node;var mount=node.mounted;var mounts=FS.getMounts(mount);for(var[hash,current]of Object.entries(FS.nameTable)){while(current){var next=current.name_next;if(mounts.includes(current.mount)){FS.destroyNode(current)}current=next}}node.mounted=null;var idx=node.mount.mounts.indexOf(mount);node.mount.mounts.splice(idx,1)},lookup(parent,name){return parent.node_ops.lookup(parent,name)},mknod(path,mode,dev){var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;var name=PATH.basename(path);if(!name){throw new FS.ErrnoError(28)}if(name==="."||name===".."){throw new FS.ErrnoError(20)}var errCode=FS.mayCreate(parent,name);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.mknod){throw new FS.ErrnoError(63)}return parent.node_ops.mknod(parent,name,mode,dev)},statfs(path){return FS.statfsNode(FS.lookupPath(path,{follow:true}).node)},statfsStream(stream){return FS.statfsNode(stream.node)},statfsNode(node){var rtn={bsize:4096,frsize:4096,blocks:1e6,bfree:5e5,bavail:5e5,files:FS.nextInode,ffree:FS.nextInode-1,fsid:42,flags:2,namelen:255};if(node.node_ops.statfs){Object.assign(rtn,node.node_ops.statfs(node.mount.opts.root))}return rtn},create(path,mode=438){mode&=4095;mode|=32768;return FS.mknod(path,mode,0)},mkdir(path,mode=511){mode&=511|512;mode|=16384;return FS.mknod(path,mode,0)},mkdirTree(path,mode){var dirs=path.split("/");var d="";for(var dir of dirs){if(!dir)continue;if(d||PATH.isAbs(path))d+="/";d+=dir;try{FS.mkdir(d,mode)}catch(e){if(e.errno!=20)throw e}}},mkdev(path,mode,dev){if(typeof dev=="undefined"){dev=mode;mode=438}mode|=8192;return FS.mknod(path,mode,dev)},symlink(oldpath,newpath){if(!PATH_FS.resolve(oldpath)){throw new FS.ErrnoError(44)}var lookup=FS.lookupPath(newpath,{parent:true});var parent=lookup.node;if(!parent){throw new FS.ErrnoError(44)}var newname=PATH.basename(newpath);var errCode=FS.mayCreate(parent,newname);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.symlink){throw new FS.ErrnoError(63)}return parent.node_ops.symlink(parent,newname,oldpath)},rename(old_path,new_path){var old_dirname=PATH.dirname(old_path);var new_dirname=PATH.dirname(new_path);var old_name=PATH.basename(old_path);var new_name=PATH.basename(new_path);var lookup,old_dir,new_dir;lookup=FS.lookupPath(old_path,{parent:true});old_dir=lookup.node;lookup=FS.lookupPath(new_path,{parent:true});new_dir=lookup.node;if(!old_dir||!new_dir)throw new FS.ErrnoError(44);if(old_dir.mount!==new_dir.mount){throw new FS.ErrnoError(75)}var old_node=FS.lookupNode(old_dir,old_name);var relative=PATH_FS.relative(old_path,new_dirname);if(relative.charAt(0)!=="."){throw new FS.ErrnoError(28)}relative=PATH_FS.relative(new_path,old_dirname);if(relative.charAt(0)!=="."){throw new FS.ErrnoError(55)}var new_node;try{new_node=FS.lookupNode(new_dir,new_name)}catch(e){}if(old_node===new_node){return}var isdir=FS.isDir(old_node.mode);var errCode=FS.mayDelete(old_dir,old_name,isdir);if(errCode){throw new FS.ErrnoError(errCode)}errCode=new_node?FS.mayDelete(new_dir,new_name,isdir):FS.mayCreate(new_dir,new_name);if(errCode){throw new FS.ErrnoError(errCode)}if(!old_dir.node_ops.rename){throw new FS.ErrnoError(63)}if(FS.isMountpoint(old_node)||new_node&&FS.isMountpoint(new_node)){throw new FS.ErrnoError(10)}if(new_dir!==old_dir){errCode=FS.nodePermissions(old_dir,"w");if(errCode){throw new FS.ErrnoError(errCode)}}FS.hashRemoveNode(old_node);try{old_dir.node_ops.rename(old_node,new_dir,new_name);old_node.parent=new_dir}catch(e){throw e}finally{FS.hashAddNode(old_node)}},rmdir(path){var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;var name=PATH.basename(path);var node=FS.lookupNode(parent,name);var errCode=FS.mayDelete(parent,name,true);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.rmdir){throw new FS.ErrnoError(63)}if(FS.isMountpoint(node)){throw new FS.ErrnoError(10)}parent.node_ops.rmdir(parent,name);FS.destroyNode(node)},readdir(path){var lookup=FS.lookupPath(path,{follow:true});var node=lookup.node;var readdir=FS.checkOpExists(node.node_ops.readdir,54);return readdir(node)},unlink(path){var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;if(!parent){throw new FS.ErrnoError(44)}var name=PATH.basename(path);var node=FS.lookupNode(parent,name);var errCode=FS.mayDelete(parent,name,false);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.unlink){throw new FS.ErrnoError(63)}if(FS.isMountpoint(node)){throw new FS.ErrnoError(10)}parent.node_ops.unlink(parent,name);FS.destroyNode(node)},readlink(path){var lookup=FS.lookupPath(path);var link=lookup.node;if(!link){throw new FS.ErrnoError(44)}if(!link.node_ops.readlink){throw new FS.ErrnoError(28)}return link.node_ops.readlink(link)},stat(path,dontFollow){var lookup=FS.lookupPath(path,{follow:!dontFollow});var node=lookup.node;var getattr=FS.checkOpExists(node.node_ops.getattr,63);return getattr(node)},fstat(fd){var stream=FS.getStreamChecked(fd);var node=stream.node;var getattr=stream.stream_ops.getattr;var arg=getattr?stream:node;getattr??=node.node_ops.getattr;FS.checkOpExists(getattr,63);return getattr(arg)},lstat(path){return FS.stat(path,true)},doChmod(stream,node,mode,dontFollow){FS.doSetAttr(stream,node,{mode:mode&4095|node.mode&~4095,ctime:Date.now(),dontFollow})},chmod(path,mode,dontFollow){var node;if(typeof path=="string"){var lookup=FS.lookupPath(path,{follow:!dontFollow});node=lookup.node}else{node=path}FS.doChmod(null,node,mode,dontFollow)},lchmod(path,mode){FS.chmod(path,mode,true)},fchmod(fd,mode){var stream=FS.getStreamChecked(fd);FS.doChmod(stream,stream.node,mode,false)},doChown(stream,node,dontFollow){FS.doSetAttr(stream,node,{timestamp:Date.now(),dontFollow})},chown(path,uid,gid,dontFollow){var node;if(typeof path=="string"){var lookup=FS.lookupPath(path,{follow:!dontFollow});node=lookup.node}else{node=path}FS.doChown(null,node,dontFollow)},lchown(path,uid,gid){FS.chown(path,uid,gid,true)},fchown(fd,uid,gid){var stream=FS.getStreamChecked(fd);FS.doChown(stream,stream.node,false)},doTruncate(stream,node,len){if(FS.isDir(node.mode)){throw new FS.ErrnoError(31)}if(!FS.isFile(node.mode)){throw new FS.ErrnoError(28)}var errCode=FS.nodePermissions(node,"w");if(errCode){throw new FS.ErrnoError(errCode)}FS.doSetAttr(stream,node,{size:len,timestamp:Date.now()})},truncate(path,len){if(len<0){throw new FS.ErrnoError(28)}var node;if(typeof path=="string"){var lookup=FS.lookupPath(path,{follow:true});node=lookup.node}else{node=path}FS.doTruncate(null,node,len)},ftruncate(fd,len){var stream=FS.getStreamChecked(fd);if(len<0||(stream.flags&2097155)===0){throw new FS.ErrnoError(28)}FS.doTruncate(stream,stream.node,len)},utime(path,atime,mtime){var lookup=FS.lookupPath(path,{follow:true});var node=lookup.node;var setattr=FS.checkOpExists(node.node_ops.setattr,63);setattr(node,{atime,mtime})},open(path,flags,mode=438){if(path===""){throw new FS.ErrnoError(44)}flags=typeof flags=="string"?FS_modeStringToFlags(flags):flags;if(flags&64){mode=mode&4095|32768}else{mode=0}var node;var isDirPath;if(typeof path=="object"){node=path}else{isDirPath=path.endsWith("/");var lookup=FS.lookupPath(path,{follow:!(flags&131072),noent_okay:true});node=lookup.node;path=lookup.path}var created=false;if(flags&64){if(node){if(flags&128){throw new FS.ErrnoError(20)}}else if(isDirPath){throw new FS.ErrnoError(31)}else{node=FS.mknod(path,mode|511,0);created=true}}if(!node){throw new FS.ErrnoError(44)}if(FS.isChrdev(node.mode)){flags&=~512}if(flags&65536&&!FS.isDir(node.mode)){throw new FS.ErrnoError(54)}if(!created){var errCode=FS.mayOpen(node,flags);if(errCode){throw new FS.ErrnoError(errCode)}}if(flags&512&&!created){FS.truncate(node,0)}flags&=~(128|512|131072);var stream=FS.createStream({node,path:FS.getPath(node),flags,seekable:true,position:0,stream_ops:node.stream_ops,ungotten:[],error:false});if(stream.stream_ops.open){stream.stream_ops.open(stream)}if(created){FS.chmod(node,mode&511)}if(Module["logReadFiles"]&&!(flags&1)){if(!(path in FS.readFiles)){FS.readFiles[path]=1}}return stream},close(stream){if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if(stream.getdents)stream.getdents=null;try{if(stream.stream_ops.close){stream.stream_ops.close(stream)}}catch(e){throw e}finally{FS.closeStream(stream.fd)}stream.fd=null},isClosed(stream){return stream.fd===null},llseek(stream,offset,whence){if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if(!stream.seekable||!stream.stream_ops.llseek){throw new FS.ErrnoError(70)}if(whence!=0&&whence!=1&&whence!=2){throw new FS.ErrnoError(28)}stream.position=stream.stream_ops.llseek(stream,offset,whence);stream.ungotten=[];return stream.position},read(stream,buffer,offset,length,position){if(length<0||position<0){throw new FS.ErrnoError(28)}if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if((stream.flags&2097155)===1){throw new FS.ErrnoError(8)}if(FS.isDir(stream.node.mode)){throw new FS.ErrnoError(31)}if(!stream.stream_ops.read){throw new FS.ErrnoError(28)}var seeking=typeof position!="undefined";if(!seeking){position=stream.position}else if(!stream.seekable){throw new FS.ErrnoError(70)}var bytesRead=stream.stream_ops.read(stream,buffer,offset,length,position);if(!seeking)stream.position+=bytesRead;return bytesRead},write(stream,buffer,offset,length,position,canOwn){if(length<0||position<0){throw new FS.ErrnoError(28)}if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if((stream.flags&2097155)===0){throw new FS.ErrnoError(8)}if(FS.isDir(stream.node.mode)){throw new FS.ErrnoError(31)}if(!stream.stream_ops.write){throw new FS.ErrnoError(28)}if(stream.seekable&&stream.flags&1024){FS.llseek(stream,0,2)}var seeking=typeof position!="undefined";if(!seeking){position=stream.position}else if(!stream.seekable){throw new FS.ErrnoError(70)}var bytesWritten=stream.stream_ops.write(stream,buffer,offset,length,position,canOwn);if(!seeking)stream.position+=bytesWritten;return bytesWritten},mmap(stream,length,position,prot,flags){if((prot&2)!==0&&(flags&2)===0&&(stream.flags&2097155)!==2){throw new FS.ErrnoError(2)}if((stream.flags&2097155)===1){throw new FS.ErrnoError(2)}if(!stream.stream_ops.mmap){throw new FS.ErrnoError(43)}if(!length){throw new FS.ErrnoError(28)}return stream.stream_ops.mmap(stream,length,position,prot,flags)},msync(stream,buffer,offset,length,mmapFlags){if(!stream.stream_ops.msync){return 0}return stream.stream_ops.msync(stream,buffer,offset,length,mmapFlags)},ioctl(stream,cmd,arg){if(!stream.stream_ops.ioctl){throw new FS.ErrnoError(59)}return stream.stream_ops.ioctl(stream,cmd,arg)},readFile(path,opts={}){opts.flags=opts.flags||0;opts.encoding=opts.encoding||"binary";if(opts.encoding!=="utf8"&&opts.encoding!=="binary"){abort(`Invalid encoding type "${opts.encoding}"`)}var stream=FS.open(path,opts.flags);var stat=FS.stat(path);var length=stat.size;var buf=new Uint8Array(length);FS.read(stream,buf,0,length,0);if(opts.encoding==="utf8"){buf=UTF8ArrayToString(buf)}FS.close(stream);return buf},writeFile(path,data,opts={}){opts.flags=opts.flags||577;var stream=FS.open(path,opts.flags,opts.mode);if(typeof data=="string"){data=new Uint8Array(intArrayFromString(data,true))}if(ArrayBuffer.isView(data)){FS.write(stream,data,0,data.byteLength,undefined,opts.canOwn)}else{abort("Unsupported data type")}FS.close(stream)},cwd:()=>FS.currentPath,chdir(path){var lookup=FS.lookupPath(path,{follow:true});if(lookup.node===null){throw new FS.ErrnoError(44)}if(!FS.isDir(lookup.node.mode)){throw new FS.ErrnoError(54)}var errCode=FS.nodePermissions(lookup.node,"x");if(errCode){throw new FS.ErrnoError(errCode)}FS.currentPath=lookup.path},createDefaultDirectories(){FS.mkdir("/tmp");FS.mkdir("/home");FS.mkdir("/home/web_user")},createDefaultDevices(){FS.mkdir("/dev");FS.registerDevice(FS.makedev(1,3),{read:()=>0,write:(stream,buffer,offset,length,pos)=>length,llseek:()=>0});FS.mkdev("/dev/null",FS.makedev(1,3));TTY.register(FS.makedev(5,0),TTY.default_tty_ops);TTY.register(FS.makedev(6,0),TTY.default_tty1_ops);FS.mkdev("/dev/tty",FS.makedev(5,0));FS.mkdev("/dev/tty1",FS.makedev(6,0));var randomBuffer=new Uint8Array(1024),randomLeft=0;var randomByte=()=>{if(randomLeft===0){randomFill(randomBuffer);randomLeft=randomBuffer.byteLength}return randomBuffer[--randomLeft]};FS.createDevice("/dev","random",randomByte);FS.createDevice("/dev","urandom",randomByte);FS.mkdir("/dev/shm");FS.mkdir("/dev/shm/tmp")},createSpecialDirectories(){FS.mkdir("/proc");var proc_self=FS.mkdir("/proc/self");FS.mkdir("/proc/self/fd");FS.mount({mount(){var node=FS.createNode(proc_self,"fd",16895,73);node.stream_ops={llseek:MEMFS.stream_ops.llseek};node.node_ops={lookup(parent,name){var fd=+name;var stream=FS.getStreamChecked(fd);var ret={parent:null,mount:{mountpoint:"fake"},node_ops:{readlink:()=>stream.path},id:fd+1};ret.parent=ret;return ret},readdir(){return Array.from(FS.streams.entries()).filter(([k,v])=>v).map(([k,v])=>k.toString())}};return node}},{},"/proc/self/fd")},createStandardStreams(input,output,error){if(input){FS.createDevice("/dev","stdin",input)}else{FS.symlink("/dev/tty","/dev/stdin")}if(output){FS.createDevice("/dev","stdout",null,output)}else{FS.symlink("/dev/tty","/dev/stdout")}if(error){FS.createDevice("/dev","stderr",null,error)}else{FS.symlink("/dev/tty1","/dev/stderr")}var stdin=FS.open("/dev/stdin",0);var stdout=FS.open("/dev/stdout",1);var stderr=FS.open("/dev/stderr",1)},staticInit(){FS.nameTable=new Array(4096);FS.mount(MEMFS,{},"/");FS.createDefaultDirectories();FS.createDefaultDevices();FS.createSpecialDirectories();FS.filesystems={MEMFS,IDBFS}},init(input,output,error){FS.initialized=true;input??=Module["stdin"];output??=Module["stdout"];error??=Module["stderr"];FS.createStandardStreams(input,output,error)},quit(){FS.initialized=false;_fflush(0);for(var stream of FS.streams){if(stream){FS.close(stream)}}},findObject(path,dontResolveLastLink){var ret=FS.analyzePath(path,dontResolveLastLink);if(!ret.exists){return null}return ret.object},analyzePath(path,dontResolveLastLink){try{var lookup=FS.lookupPath(path,{follow:!dontResolveLastLink});path=lookup.path}catch(e){}var ret={isRoot:false,exists:false,error:0,name:null,path:null,object:null,parentExists:false,parentPath:null,parentObject:null};try{var lookup=FS.lookupPath(path,{parent:true});ret.parentExists=true;ret.parentPath=lookup.path;ret.parentObject=lookup.node;ret.name=PATH.basename(path);lookup=FS.lookupPath(path,{follow:!dontResolveLastLink});ret.exists=true;ret.path=lookup.path;ret.object=lookup.node;ret.name=lookup.node.name;ret.isRoot=lookup.path==="/"}catch(e){ret.error=e.errno}return ret},createPath(parent,path,canRead,canWrite){parent=typeof parent=="string"?parent:FS.getPath(parent);var parts=path.split("/").reverse();while(parts.length){var part=parts.pop();if(!part)continue;var current=PATH.join2(parent,part);try{FS.mkdir(current)}catch(e){if(e.errno!=20)throw e}parent=current}return current},createFile(parent,name,properties,canRead,canWrite){var path=PATH.join2(typeof parent=="string"?parent:FS.getPath(parent),name);var mode=FS_getMode(canRead,canWrite);return FS.create(path,mode)},createDataFile(parent,name,data,canRead,canWrite,canOwn){var path=name;if(parent){parent=typeof parent=="string"?parent:FS.getPath(parent);path=name?PATH.join2(parent,name):parent}var mode=FS_getMode(canRead,canWrite);var node=FS.create(path,mode);if(data){if(typeof data=="string"){var arr=new Array(data.length);for(var i=0,len=data.length;i<len;++i)arr[i]=data.charCodeAt(i);data=arr}FS.chmod(node,mode|146);var stream=FS.open(node,577);FS.write(stream,data,0,data.length,0,canOwn);FS.close(stream);FS.chmod(node,mode)}},createDevice(parent,name,input,output){var path=PATH.join2(typeof parent=="string"?parent:FS.getPath(parent),name);var mode=FS_getMode(!!input,!!output);FS.createDevice.major??=64;var dev=FS.makedev(FS.createDevice.major++,0);FS.registerDevice(dev,{open(stream){stream.seekable=false},close(stream){if(output?.buffer?.length){output(10)}},read(stream,buffer,offset,length,pos){var bytesRead=0;for(var i=0;i<length;i++){var result;try{result=input()}catch(e){throw new FS.ErrnoError(29)}if(result===undefined&&bytesRead===0){throw new FS.ErrnoError(6)}if(result===null||result===undefined)break;bytesRead++;buffer[offset+i]=result}if(bytesRead){stream.node.atime=Date.now()}return bytesRead},write(stream,buffer,offset,length,pos){for(var i=0;i<length;i++){try{output(buffer[offset+i])}catch(e){throw new FS.ErrnoError(29)}}if(length){stream.node.mtime=stream.node.ctime=Date.now()}return i}});return FS.mkdev(path,mode,dev)},forceLoadFile(obj){if(obj.isDevice||obj.isFolder||obj.link||obj.contents)return true;if(globalThis.XMLHttpRequest){abort("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.")}else{try{obj.contents=readBinary(obj.url)}catch(e){throw new FS.ErrnoError(29)}}},createLazyFile(parent,name,url,canRead,canWrite){class LazyUint8Array{lengthKnown=false;chunks=[];get(idx){if(idx>this.length-1||idx<0){return undefined}var chunkOffset=idx%this.chunkSize;var chunkNum=idx/this.chunkSize|0;return this.getter(chunkNum)[chunkOffset]}setDataGetter(getter){this.getter=getter}cacheLength(){var xhr=new XMLHttpRequest;xhr.open("HEAD",url,false);xhr.send(null);if(!(xhr.status>=200&&xhr.status<300||xhr.status===304))abort("Couldn't load "+url+". Status: "+xhr.status);var datalength=Number(xhr.getResponseHeader("Content-length"));var header;var hasByteServing=(header=xhr.getResponseHeader("Accept-Ranges"))&&header==="bytes";var usesGzip=(header=xhr.getResponseHeader("Content-Encoding"))&&header==="gzip";var chunkSize=1024*1024;if(!hasByteServing)chunkSize=datalength;var doXHR=(from,to)=>{if(from>to)abort("invalid range ("+from+", "+to+") or no bytes requested!");if(to>datalength-1)abort("only "+datalength+" bytes available! programmer error!");var xhr=new XMLHttpRequest;xhr.open("GET",url,false);if(datalength!==chunkSize)xhr.setRequestHeader("Range","bytes="+from+"-"+to);xhr.responseType="arraybuffer";if(xhr.overrideMimeType){xhr.overrideMimeType("text/plain; charset=x-user-defined")}xhr.send(null);if(!(xhr.status>=200&&xhr.status<300||xhr.status===304))abort("Couldn't load "+url+". Status: "+xhr.status);if(xhr.response!==undefined){return new Uint8Array(xhr.response||[])}return intArrayFromString(xhr.responseText||"",true)};var lazyArray=this;lazyArray.setDataGetter(chunkNum=>{var start=chunkNum*chunkSize;var end=(chunkNum+1)*chunkSize-1;end=Math.min(end,datalength-1);if(typeof lazyArray.chunks[chunkNum]=="undefined"){lazyArray.chunks[chunkNum]=doXHR(start,end)}if(typeof lazyArray.chunks[chunkNum]=="undefined")abort("doXHR failed!");return lazyArray.chunks[chunkNum]});if(usesGzip||!datalength){chunkSize=datalength=1;datalength=this.getter(0).length;chunkSize=datalength;out("LazyFiles on gzip forces download of the whole file when length is accessed")}this._length=datalength;this._chunkSize=chunkSize;this.lengthKnown=true}get length(){if(!this.lengthKnown){this.cacheLength()}return this._length}get chunkSize(){if(!this.lengthKnown){this.cacheLength()}return this._chunkSize}}if(globalThis.XMLHttpRequest){if(!ENVIRONMENT_IS_WORKER)abort("Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc");var lazyArray=new LazyUint8Array;var properties={isDevice:false,contents:lazyArray}}else{var properties={isDevice:false,url}}var node=FS.createFile(parent,name,properties,canRead,canWrite);if(properties.contents){node.contents=properties.contents}else if(properties.url){node.contents=null;node.url=properties.url}Object.defineProperties(node,{usedBytes:{get:function(){return this.contents.length}}});var stream_ops={};for(const[key,fn]of Object.entries(node.stream_ops)){stream_ops[key]=(...args)=>{FS.forceLoadFile(node);return fn(...args)}}function writeChunks(stream,buffer,offset,length,position){var contents=stream.node.contents;if(position>=contents.length)return 0;var size=Math.min(contents.length-position,length);if(contents.slice){for(var i=0;i<size;i++){buffer[offset+i]=contents[position+i]}}else{for(var i=0;i<size;i++){buffer[offset+i]=contents.get(position+i)}}return size}stream_ops.read=(stream,buffer,offset,length,position)=>{FS.forceLoadFile(node);return writeChunks(stream,buffer,offset,length,position)};stream_ops.mmap=(stream,length,position,prot,flags)=>{FS.forceLoadFile(node);var ptr=mmapAlloc(length);if(!ptr){throw new FS.ErrnoError(48)}writeChunks(stream,HEAP8,ptr,length,position);return{ptr,allocated:true}};node.stream_ops=stream_ops;return node}};var UTF8ToString=(ptr,maxBytesToRead,ignoreNul)=>ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead,ignoreNul):"";var SYSCALLS={DEFAULT_POLLMASK:5,calculateAt(dirfd,path,allowEmpty){if(PATH.isAbs(path)){return path}var dir;if(dirfd===-100){dir=FS.cwd()}else{var dirstream=SYSCALLS.getStreamFromFD(dirfd);dir=dirstream.path}if(path.length==0){if(!allowEmpty){throw new FS.ErrnoError(44)}return dir}return dir+"/"+path},writeStat(buf,stat){HEAPU32[buf>>2]=stat.dev;HEAPU32[buf+4>>2]=stat.mode;HEAPU32[buf+8>>2]=stat.nlink;HEAPU32[buf+12>>2]=stat.uid;HEAPU32[buf+16>>2]=stat.gid;HEAPU32[buf+20>>2]=stat.rdev;HEAP64[buf+24>>3]=BigInt(stat.size);HEAP32[buf+32>>2]=4096;HEAP32[buf+36>>2]=stat.blocks;var atime=stat.atime.getTime();var mtime=stat.mtime.getTime();var ctime=stat.ctime.getTime();HEAP64[buf+40>>3]=BigInt(Math.floor(atime/1e3));HEAPU32[buf+48>>2]=atime%1e3*1e3*1e3;HEAP64[buf+56>>3]=BigInt(Math.floor(mtime/1e3));HEAPU32[buf+64>>2]=mtime%1e3*1e3*1e3;HEAP64[buf+72>>3]=BigInt(Math.floor(ctime/1e3));HEAPU32[buf+80>>2]=ctime%1e3*1e3*1e3;HEAP64[buf+88>>3]=BigInt(stat.ino);return 0},writeStatFs(buf,stats){HEAPU32[buf+4>>2]=stats.bsize;HEAPU32[buf+60>>2]=stats.bsize;HEAP64[buf+8>>3]=BigInt(stats.blocks);HEAP64[buf+16>>3]=BigInt(stats.bfree);HEAP64[buf+24>>3]=BigInt(stats.bavail);HEAP64[buf+32>>3]=BigInt(stats.files);HEAP64[buf+40>>3]=BigInt(stats.ffree);HEAPU32[buf+48>>2]=stats.fsid;HEAPU32[buf+64>>2]=stats.flags;HEAPU32[buf+56>>2]=stats.namelen},doMsync(addr,stream,len,flags,offset){if(!FS.isFile(stream.node.mode)){throw new FS.ErrnoError(43)}if(flags&2){return 0}var buffer=HEAPU8.slice(addr,addr+len);FS.msync(stream,buffer,offset,len,flags)},getStreamFromFD(fd){var stream=FS.getStreamChecked(fd);return stream},varargs:undefined,getStr(ptr){var ret=UTF8ToString(ptr);return ret}};function ___syscall_chdir(path){try{path=SYSCALLS.getStr(path);FS.chdir(path);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_chmod(path,mode){try{path=SYSCALLS.getStr(path);FS.chmod(path,mode);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_faccessat(dirfd,path,amode,flags){try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);if(amode&~7){return-28}var lookup=FS.lookupPath(path,{follow:true});var node=lookup.node;if(!node){return-44}var perms="";if(amode&4)perms+="r";if(amode&2)perms+="w";if(amode&1)perms+="x";if(perms&&FS.nodePermissions(node,perms)){return-2}return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_fchmod(fd,mode){try{FS.fchmod(fd,mode);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}var syscallGetVarargI=()=>{var ret=HEAP32[+SYSCALLS.varargs>>2];SYSCALLS.varargs+=4;return ret};var syscallGetVarargP=syscallGetVarargI;function ___syscall_fcntl64(fd,cmd,varargs){SYSCALLS.varargs=varargs;try{var stream=SYSCALLS.getStreamFromFD(fd);switch(cmd){case 0:{var arg=syscallGetVarargI();if(arg<0){return-28}while(FS.streams[arg]){arg++}var newStream;newStream=FS.dupStream(stream,arg);return newStream.fd}case 1:case 2:return 0;case 3:return stream.flags;case 4:{var arg=syscallGetVarargI();stream.flags|=arg;return 0}case 12:{var arg=syscallGetVarargP();var offset=0;HEAP16[arg+offset>>1]=2;return 0}case 13:case 14:return 0}return-28}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_fstat64(fd,buf){try{return SYSCALLS.writeStat(buf,FS.fstat(fd))}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}var INT53_MAX=9007199254740992;var INT53_MIN=-9007199254740992;var bigintToI53Checked=num=>num<INT53_MIN||num>INT53_MAX?NaN:Number(num);function ___syscall_ftruncate64(fd,length){length=bigintToI53Checked(length);try{if(isNaN(length))return-61;FS.ftruncate(fd,length);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}var stringToUTF8=(str,outPtr,maxBytesToWrite)=>stringToUTF8Array(str,HEAPU8,outPtr,maxBytesToWrite);function ___syscall_getcwd(buf,size){try{if(size===0)return-28;var cwd=FS.cwd();var cwdLengthInBytes=lengthBytesUTF8(cwd)+1;if(size<cwdLengthInBytes)return-68;stringToUTF8(cwd,buf,size);return cwdLengthInBytes}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_getdents64(fd,dirp,count){try{var stream=SYSCALLS.getStreamFromFD(fd);stream.getdents||=FS.readdir(stream.path);var struct_size=280;var pos=0;var off=FS.llseek(stream,0,1);var startIdx=Math.floor(off/struct_size);var endIdx=Math.min(stream.getdents.length,startIdx+Math.floor(count/struct_size));for(var idx=startIdx;idx<endIdx;idx++){var id;var type;var name=stream.getdents[idx];if(name==="."){id=stream.node.id;type=4}else if(name===".."){var lookup=FS.lookupPath(stream.path,{parent:true});id=lookup.node.id;type=4}else{var child;try{child=FS.lookupNode(stream.node,name)}catch(e){if(e?.errno===28){continue}throw e}id=child.id;type=FS.isChrdev(child.mode)?2:FS.isDir(child.mode)?4:FS.isLink(child.mode)?10:8}HEAP64[dirp+pos>>3]=BigInt(id);HEAP64[dirp+pos+8>>3]=BigInt((idx+1)*struct_size);HEAP16[dirp+pos+16>>1]=280;HEAP8[dirp+pos+18]=type;stringToUTF8(name,dirp+pos+19,256);pos+=struct_size}FS.llseek(stream,idx*struct_size,0);return pos}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_ioctl(fd,op,varargs){SYSCALLS.varargs=varargs;try{var stream=SYSCALLS.getStreamFromFD(fd);switch(op){case 21509:{if(!stream.tty)return-59;return 0}case 21505:{if(!stream.tty)return-59;if(stream.tty.ops.ioctl_tcgets){var termios=stream.tty.ops.ioctl_tcgets(stream);var argp=syscallGetVarargP();HEAP32[argp>>2]=termios.c_iflag||0;HEAP32[argp+4>>2]=termios.c_oflag||0;HEAP32[argp+8>>2]=termios.c_cflag||0;HEAP32[argp+12>>2]=termios.c_lflag||0;for(var i=0;i<32;i++){HEAP8[argp+i+17]=termios.c_cc[i]||0}return 0}return 0}case 21510:case 21511:case 21512:{if(!stream.tty)return-59;return 0}case 21506:case 21507:case 21508:{if(!stream.tty)return-59;if(stream.tty.ops.ioctl_tcsets){var argp=syscallGetVarargP();var c_iflag=HEAP32[argp>>2];var c_oflag=HEAP32[argp+4>>2];var c_cflag=HEAP32[argp+8>>2];var c_lflag=HEAP32[argp+12>>2];var c_cc=[];for(var i=0;i<32;i++){c_cc.push(HEAP8[argp+i+17])}return stream.tty.ops.ioctl_tcsets(stream.tty,op,{c_iflag,c_oflag,c_cflag,c_lflag,c_cc})}return 0}case 21519:{if(!stream.tty)return-59;var argp=syscallGetVarargP();HEAP32[argp>>2]=0;return 0}case 21520:{if(!stream.tty)return-59;return-28}case 21537:case 21531:{var argp=syscallGetVarargP();return FS.ioctl(stream,op,argp)}case 21523:{if(!stream.tty)return-59;if(stream.tty.ops.ioctl_tiocgwinsz){var winsize=stream.tty.ops.ioctl_tiocgwinsz(stream.tty);var argp=syscallGetVarargP();HEAP16[argp>>1]=winsize[0];HEAP16[argp+2>>1]=winsize[1]}return 0}case 21524:{if(!stream.tty)return-59;return 0}case 21515:{if(!stream.tty)return-59;return 0}default:return-28}}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_lstat64(path,buf){try{path=SYSCALLS.getStr(path);return SYSCALLS.writeStat(buf,FS.lstat(path))}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_mkdirat(dirfd,path,mode){try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);FS.mkdir(path,mode,0);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_mknodat(dirfd,path,mode,dev){try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);switch(mode&61440){case 32768:case 8192:case 24576:case 4096:case 49152:break;default:return-28}FS.mknod(path,mode,dev);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_newfstatat(dirfd,path,buf,flags){try{path=SYSCALLS.getStr(path);var nofollow=flags&256;var allowEmpty=flags&4096;flags=flags&~6400;path=SYSCALLS.calculateAt(dirfd,path,allowEmpty);return SYSCALLS.writeStat(buf,nofollow?FS.lstat(path):FS.stat(path))}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_openat(dirfd,path,flags,varargs){SYSCALLS.varargs=varargs;try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);var mode=varargs?syscallGetVarargI():0;return FS.open(path,flags,mode).fd}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_readlinkat(dirfd,path,buf,bufsize){try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);if(bufsize<=0)return-28;var ret=FS.readlink(path);var len=Math.min(bufsize,lengthBytesUTF8(ret));var endChar=HEAP8[buf+len];stringToUTF8(ret,buf,bufsize+1);HEAP8[buf+len]=endChar;return len}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_renameat(olddirfd,oldpath,newdirfd,newpath){try{oldpath=SYSCALLS.getStr(oldpath);newpath=SYSCALLS.getStr(newpath);oldpath=SYSCALLS.calculateAt(olddirfd,oldpath);newpath=SYSCALLS.calculateAt(newdirfd,newpath);FS.rename(oldpath,newpath);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_rmdir(path){try{path=SYSCALLS.getStr(path);FS.rmdir(path);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_stat64(path,buf){try{path=SYSCALLS.getStr(path);return SYSCALLS.writeStat(buf,FS.stat(path))}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_statfs64(path,size,buf){try{SYSCALLS.writeStatFs(buf,FS.statfs(SYSCALLS.getStr(path)));return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_symlinkat(target,dirfd,linkpath){try{target=SYSCALLS.getStr(target);linkpath=SYSCALLS.getStr(linkpath);linkpath=SYSCALLS.calculateAt(dirfd,linkpath);FS.symlink(target,linkpath);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_unlinkat(dirfd,path,flags){try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);if(!flags){FS.unlink(path)}else if(flags===512){FS.rmdir(path)}else{return-28}return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}var __abort_js=()=>abort("");var runtimeKeepaliveCounter=0;var __emscripten_runtime_keepalive_clear=()=>{noExitRuntime=false;runtimeKeepaliveCounter=0};function __gmtime_js(time,tmPtr){time=bigintToI53Checked(time);var date=new Date(time*1e3);HEAP32[tmPtr>>2]=date.getUTCSeconds();HEAP32[tmPtr+4>>2]=date.getUTCMinutes();HEAP32[tmPtr+8>>2]=date.getUTCHours();HEAP32[tmPtr+12>>2]=date.getUTCDate();HEAP32[tmPtr+16>>2]=date.getUTCMonth();HEAP32[tmPtr+20>>2]=date.getUTCFullYear()-1900;HEAP32[tmPtr+24>>2]=date.getUTCDay();var start=Date.UTC(date.getUTCFullYear(),0,1,0,0,0,0);var yday=(date.getTime()-start)/(1e3*60*60*24)|0;HEAP32[tmPtr+28>>2]=yday}var isLeapYear=year=>year%4===0&&(year%100!==0||year%400===0);var MONTH_DAYS_LEAP_CUMULATIVE=[0,31,60,91,121,152,182,213,244,274,305,335];var MONTH_DAYS_REGULAR_CUMULATIVE=[0,31,59,90,120,151,181,212,243,273,304,334];var ydayFromDate=date=>{var leap=isLeapYear(date.getFullYear());var monthDaysCumulative=leap?MONTH_DAYS_LEAP_CUMULATIVE:MONTH_DAYS_REGULAR_CUMULATIVE;var yday=monthDaysCumulative[date.getMonth()]+date.getDate()-1;return yday};function __localtime_js(time,tmPtr){time=bigintToI53Checked(time);var date=new Date(time*1e3);HEAP32[tmPtr>>2]=date.getSeconds();HEAP32[tmPtr+4>>2]=date.getMinutes();HEAP32[tmPtr+8>>2]=date.getHours();HEAP32[tmPtr+12>>2]=date.getDate();HEAP32[tmPtr+16>>2]=date.getMonth();HEAP32[tmPtr+20>>2]=date.getFullYear()-1900;HEAP32[tmPtr+24>>2]=date.getDay();var yday=ydayFromDate(date)|0;HEAP32[tmPtr+28>>2]=yday;HEAP32[tmPtr+36>>2]=-(date.getTimezoneOffset()*60);var start=new Date(date.getFullYear(),0,1);var summerOffset=new Date(date.getFullYear(),6,1).getTimezoneOffset();var winterOffset=start.getTimezoneOffset();var dst=(summerOffset!=winterOffset&&date.getTimezoneOffset()==Math.min(winterOffset,summerOffset))|0;HEAP32[tmPtr+32>>2]=dst}var timers={};var handleException=e=>{if(e instanceof ExitStatus||e=="unwind"){return EXITSTATUS}quit_(1,e)};var keepRuntimeAlive=()=>noExitRuntime||runtimeKeepaliveCounter>0;var _proc_exit=code=>{EXITSTATUS=code;if(!keepRuntimeAlive()){Module["onExit"]?.(code);ABORT=true}quit_(code,new ExitStatus(code))};var exitJS=(status,implicit)=>{EXITSTATUS=status;if(!keepRuntimeAlive()){exitRuntime()}_proc_exit(status)};var _exit=exitJS;var maybeExit=()=>{if(runtimeExited){return}if(!keepRuntimeAlive()){try{_exit(EXITSTATUS)}catch(e){handleException(e)}}};var callUserCallback=func=>{if(runtimeExited||ABORT){return}try{func();maybeExit()}catch(e){handleException(e)}};var _emscripten_get_now=()=>performance.now();var __setitimer_js=(which,timeout_ms)=>{if(timers[which]){clearTimeout(timers[which].id);delete timers[which]}if(!timeout_ms)return 0;var id=setTimeout(()=>{delete timers[which];callUserCallback(()=>__emscripten_timeout(which,_emscripten_get_now()))},timeout_ms);timers[which]={id,timeout_ms};return 0};var __tzset_js=(timezone,daylight,std_name,dst_name)=>{var currentYear=(new Date).getFullYear();var winter=new Date(currentYear,0,1);var summer=new Date(currentYear,6,1);var winterOffset=winter.getTimezoneOffset();var summerOffset=summer.getTimezoneOffset();var stdTimezoneOffset=Math.max(winterOffset,summerOffset);HEAPU32[timezone>>2]=stdTimezoneOffset*60;HEAP32[daylight>>2]=Number(winterOffset!=summerOffset);var extractZone=timezoneOffset=>{var sign=timezoneOffset>=0?"-":"+";var absOffset=Math.abs(timezoneOffset);var hours=String(Math.floor(absOffset/60)).padStart(2,"0");var minutes=String(absOffset%60).padStart(2,"0");return`UTC${sign}${hours}${minutes}`};var winterName=extractZone(winterOffset);var summerName=extractZone(summerOffset);if(summerOffset<winterOffset){stringToUTF8(winterName,std_name,17);stringToUTF8(summerName,dst_name,17)}else{stringToUTF8(winterName,dst_name,17);stringToUTF8(summerName,std_name,17)}};var _emscripten_date_now=()=>Date.now();var nowIsMonotonic=1;var checkWasiClock=clock_id=>clock_id>=0&&clock_id<=3;function _clock_time_get(clk_id,ignored_precision,ptime){ignored_precision=bigintToI53Checked(ignored_precision);if(!checkWasiClock(clk_id)){return 28}var now;if(clk_id===0){now=_emscripten_date_now()}else if(nowIsMonotonic){now=_emscripten_get_now()}else{return 52}var nsec=Math.round(now*1e3*1e3);HEAP64[ptime>>3]=BigInt(nsec);return 0}var runtimeKeepalivePush=()=>{runtimeKeepaliveCounter+=1};var _emscripten_set_main_loop_timing=(mode,value)=>{MainLoop.timingMode=mode;MainLoop.timingValue=value;if(!MainLoop.func){return 1}if(!MainLoop.running){runtimeKeepalivePush();MainLoop.running=true}if(mode==0){MainLoop.scheduler=function MainLoop_scheduler_setTimeout(){var timeUntilNextTick=Math.max(0,MainLoop.tickStartTime+value-_emscripten_get_now())|0;setTimeout(MainLoop.runner,timeUntilNextTick)};MainLoop.method="timeout"}else if(mode==1){MainLoop.scheduler=function MainLoop_scheduler_rAF(){MainLoop.requestAnimationFrame(MainLoop.runner)};MainLoop.method="rAF"}else if(mode==2){if(!MainLoop.setImmediate){if(globalThis.setImmediate){MainLoop.setImmediate=setImmediate}else{var setImmediates=[];var emscriptenMainLoopMessageId="setimmediate";var MainLoop_setImmediate_messageHandler=event=>{if(event.data===emscriptenMainLoopMessageId||event.data.target===emscriptenMainLoopMessageId){event.stopPropagation();setImmediates.shift()()}};addEventListener("message",MainLoop_setImmediate_messageHandler,true);MainLoop.setImmediate=func=>{setImmediates.push(func);if(ENVIRONMENT_IS_WORKER){Module["setImmediates"]??=[];Module["setImmediates"].push(func);postMessage({target:emscriptenMainLoopMessageId})}else postMessage(emscriptenMainLoopMessageId,"*")}}}MainLoop.scheduler=function MainLoop_scheduler_setImmediate(){MainLoop.setImmediate(MainLoop.runner)};MainLoop.method="immediate"}return 0};var runtimeKeepalivePop=()=>{runtimeKeepaliveCounter-=1};var setMainLoop=(iterFunc,fps,simulateInfiniteLoop,arg,noSetTiming)=>{MainLoop.func=iterFunc;MainLoop.arg=arg;var thisMainLoopId=MainLoop.currentlyRunningMainloop;function checkIsRunning(){if(thisMainLoopId<MainLoop.currentlyRunningMainloop){runtimeKeepalivePop();maybeExit();return false}return true}MainLoop.running=false;MainLoop.runner=function MainLoop_runner(){if(ABORT)return;if(MainLoop.queue.length>0){var start=Date.now();var blocker=MainLoop.queue.shift();blocker.func(blocker.arg);if(MainLoop.remainingBlockers){var remaining=MainLoop.remainingBlockers;var next=remaining%1==0?remaining-1:Math.floor(remaining);if(blocker.counted){MainLoop.remainingBlockers=next}else{next=next+.5;MainLoop.remainingBlockers=(8*remaining+next)/9}}MainLoop.updateStatus();if(!checkIsRunning())return;setTimeout(MainLoop.runner,0);return}if(!checkIsRunning())return;MainLoop.currentFrameNumber=MainLoop.currentFrameNumber+1|0;if(MainLoop.timingMode==1&&MainLoop.timingValue>1&&MainLoop.currentFrameNumber%MainLoop.timingValue!=0){MainLoop.scheduler();return}else if(MainLoop.timingMode==0){MainLoop.tickStartTime=_emscripten_get_now()}MainLoop.runIter(iterFunc);if(!checkIsRunning())return;MainLoop.scheduler()};if(!noSetTiming){if(fps>0){_emscripten_set_main_loop_timing(0,1e3/fps)}else{_emscripten_set_main_loop_timing(1,1)}MainLoop.scheduler()}if(simulateInfiniteLoop){throw"unwind"}};var MainLoop={running:false,scheduler:null,method:"",currentlyRunningMainloop:0,func:null,arg:0,timingMode:0,timingValue:0,currentFrameNumber:0,queue:[],preMainLoop:[],postMainLoop:[],pause(){MainLoop.scheduler=null;MainLoop.currentlyRunningMainloop++},resume(){MainLoop.currentlyRunningMainloop++;var timingMode=MainLoop.timingMode;var timingValue=MainLoop.timingValue;var func=MainLoop.func;MainLoop.func=null;setMainLoop(func,0,false,MainLoop.arg,true);_emscripten_set_main_loop_timing(timingMode,timingValue);MainLoop.scheduler()},updateStatus(){if(Module["setStatus"]){var message=Module["statusMessage"]||"Please wait...";var remaining=MainLoop.remainingBlockers??0;var expected=MainLoop.expectedBlockers??0;if(remaining){if(remaining<expected){Module["setStatus"](`{message} ({expected - remaining}/{expected})`)}else{Module["setStatus"](message)}}else{Module["setStatus"]("")}}},init(){Module["preMainLoop"]&&MainLoop.preMainLoop.push(Module["preMainLoop"]);Module["postMainLoop"]&&MainLoop.postMainLoop.push(Module["postMainLoop"])},runIter(func){if(ABORT)return;for(var pre of MainLoop.preMainLoop){if(pre()===false){return}}callUserCallback(func);for(var post of MainLoop.postMainLoop){post()}},nextRAF:0,fakeRequestAnimationFrame(func){var now=Date.now();if(MainLoop.nextRAF===0){MainLoop.nextRAF=now+1e3/60}else{while(now+2>=MainLoop.nextRAF){MainLoop.nextRAF+=1e3/60}}var delay=Math.max(MainLoop.nextRAF-now,0);setTimeout(func,delay)},requestAnimationFrame(func){if(globalThis.requestAnimationFrame){requestAnimationFrame(func)}else{MainLoop.fakeRequestAnimationFrame(func)}}};var _emscripten_cancel_main_loop=()=>{MainLoop.pause();MainLoop.func=null};var _emscripten_force_exit=status=>{__emscripten_runtime_keepalive_clear();_exit(status)};var getHeapMax=()=>2147483648;var _emscripten_get_heap_max=()=>getHeapMax();var growMemory=size=>{var oldHeapSize=wasmMemory.buffer.byteLength;var pages=(size-oldHeapSize+65535)/65536|0;try{wasmMemory.grow(pages);updateMemoryViews();return 1}catch(e){}};var _emscripten_resize_heap=requestedSize=>{var oldSize=HEAPU8.length;requestedSize>>>=0;var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignMemory(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=growMemory(newSize);if(replacement){return true}}return false};var maybeCStringToJsString=cString=>cString>2?UTF8ToString(cString):cString;var specialHTMLTargets=[0,typeof document!="undefined"?document:0,typeof window!="undefined"?window:0];var findEventTarget=target=>{target=maybeCStringToJsString(target);var domElement=specialHTMLTargets[target]||(typeof document!="undefined"?document.querySelector(target):null);return domElement};var findCanvasEventTarget=findEventTarget;var _emscripten_set_canvas_element_size=(target,width,height)=>{var canvas=findCanvasEventTarget(target);if(!canvas)return-4;canvas.width=width;canvas.height=height;if(canvas.GLctxObject)GL.resizeOffscreenFramebuffer(canvas.GLctxObject);return 0};var _emscripten_set_main_loop=(func,fps,simulateInfiniteLoop)=>{var iterFunc=getWasmTableEntry(func);setMainLoop(iterFunc,fps,simulateInfiniteLoop)};var GLctx;var webgl_enable_ANGLE_instanced_arrays=ctx=>{var ext=ctx.getExtension("ANGLE_instanced_arrays");if(ext){ctx["vertexAttribDivisor"]=(index,divisor)=>ext["vertexAttribDivisorANGLE"](index,divisor);ctx["drawArraysInstanced"]=(mode,first,count,primcount)=>ext["drawArraysInstancedANGLE"](mode,first,count,primcount);ctx["drawElementsInstanced"]=(mode,count,type,indices,primcount)=>ext["drawElementsInstancedANGLE"](mode,count,type,indices,primcount);return 1}};var webgl_enable_OES_vertex_array_object=ctx=>{var ext=ctx.getExtension("OES_vertex_array_object");if(ext){ctx["createVertexArray"]=()=>ext["createVertexArrayOES"]();ctx["deleteVertexArray"]=vao=>ext["deleteVertexArrayOES"](vao);ctx["bindVertexArray"]=vao=>ext["bindVertexArrayOES"](vao);ctx["isVertexArray"]=vao=>ext["isVertexArrayOES"](vao);return 1}};var webgl_enable_WEBGL_draw_buffers=ctx=>{var ext=ctx.getExtension("WEBGL_draw_buffers");if(ext){ctx["drawBuffers"]=(n,bufs)=>ext["drawBuffersWEBGL"](n,bufs);return 1}};var webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance=ctx=>!!(ctx.dibvbi=ctx.getExtension("WEBGL_draw_instanced_base_vertex_base_instance"));var webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance=ctx=>!!(ctx.mdibvbi=ctx.getExtension("WEBGL_multi_draw_instanced_base_vertex_base_instance"));var webgl_enable_EXT_polygon_offset_clamp=ctx=>!!(ctx.extPolygonOffsetClamp=ctx.getExtension("EXT_polygon_offset_clamp"));var webgl_enable_EXT_clip_control=ctx=>!!(ctx.extClipControl=ctx.getExtension("EXT_clip_control"));var webgl_enable_WEBGL_polygon_mode=ctx=>!!(ctx.webglPolygonMode=ctx.getExtension("WEBGL_polygon_mode"));var webgl_enable_WEBGL_multi_draw=ctx=>!!(ctx.multiDrawWebgl=ctx.getExtension("WEBGL_multi_draw"));var getEmscriptenSupportedExtensions=ctx=>{var supportedExtensions=["ANGLE_instanced_arrays","EXT_blend_minmax","EXT_disjoint_timer_query","EXT_frag_depth","EXT_shader_texture_lod","EXT_sRGB","OES_element_index_uint","OES_fbo_render_mipmap","OES_standard_derivatives","OES_texture_float","OES_texture_half_float","OES_texture_half_float_linear","OES_vertex_array_object","WEBGL_color_buffer_float","WEBGL_depth_texture","WEBGL_draw_buffers","EXT_color_buffer_float","EXT_conservative_depth","EXT_disjoint_timer_query_webgl2","EXT_texture_norm16","NV_shader_noperspective_interpolation","WEBGL_clip_cull_distance","EXT_clip_control","EXT_color_buffer_half_float","EXT_depth_clamp","EXT_float_blend","EXT_polygon_offset_clamp","EXT_texture_compression_bptc","EXT_texture_compression_rgtc","EXT_texture_filter_anisotropic","KHR_parallel_shader_compile","OES_texture_float_linear","WEBGL_blend_func_extended","WEBGL_compressed_texture_astc","WEBGL_compressed_texture_etc","WEBGL_compressed_texture_etc1","WEBGL_compressed_texture_s3tc","WEBGL_compressed_texture_s3tc_srgb","WEBGL_debug_renderer_info","WEBGL_debug_shaders","WEBGL_lose_context","WEBGL_multi_draw","WEBGL_polygon_mode"];return(ctx.getSupportedExtensions()||[]).filter(ext=>supportedExtensions.includes(ext))};var GL={counter:1,buffers:[],programs:[],framebuffers:[],renderbuffers:[],textures:[],shaders:[],vaos:[],contexts:[],offscreenCanvases:{},queries:[],samplers:[],transformFeedbacks:[],syncs:[],stringCache:{},stringiCache:{},unpackAlignment:4,unpackRowLength:0,recordError:errorCode=>{if(!GL.lastError){GL.lastError=errorCode}},getNewId:table=>{var ret=GL.counter++;for(var i=table.length;i<ret;i++){table[i]=null}return ret},genObject:(n,buffers,createFunction,objectTable)=>{for(var i=0;i<n;i++){var buffer=GLctx[createFunction]();var id=buffer&&GL.getNewId(objectTable);if(buffer){buffer.name=id;objectTable[id]=buffer}else{GL.recordError(1282)}HEAP32[buffers+i*4>>2]=id}},getSource:(shader,count,string,length)=>{var source="";for(var i=0;i<count;++i){var len=length?HEAPU32[length+i*4>>2]:undefined;source+=UTF8ToString(HEAPU32[string+i*4>>2],len)}return source},createContext:(canvas,webGLContextAttributes)=>{if(webGLContextAttributes.renderViaOffscreenBackBuffer)webGLContextAttributes["preserveDrawingBuffer"]=true;var ctx=webGLContextAttributes.majorVersion>1?canvas.getContext("webgl2",webGLContextAttributes):canvas.getContext("webgl",webGLContextAttributes);if(!ctx)return 0;var handle=GL.registerContext(ctx,webGLContextAttributes);return handle},enableOffscreenFramebufferAttributes:webGLContextAttributes=>{webGLContextAttributes.renderViaOffscreenBackBuffer=true;webGLContextAttributes.preserveDrawingBuffer=true},createOffscreenFramebuffer:context=>{var gl=context.GLctx;var fbo=gl.createFramebuffer();gl.bindFramebuffer(36160,fbo);context.defaultFbo=fbo;context.defaultFboForbidBlitFramebuffer=false;if(gl.getContextAttributes().antialias){context.defaultFboForbidBlitFramebuffer=true}context.defaultColorTarget=gl.createTexture();context.defaultDepthTarget=gl.createRenderbuffer();GL.resizeOffscreenFramebuffer(context);gl.bindTexture(3553,context.defaultColorTarget);gl.texParameteri(3553,10241,9728);gl.texParameteri(3553,10240,9728);gl.texParameteri(3553,10242,33071);gl.texParameteri(3553,10243,33071);gl.texImage2D(3553,0,6408,gl.canvas.width,gl.canvas.height,0,6408,5121,null);gl.framebufferTexture2D(36160,36064,3553,context.defaultColorTarget,0);gl.bindTexture(3553,null);var depthTarget=gl.createRenderbuffer();gl.bindRenderbuffer(36161,context.defaultDepthTarget);gl.renderbufferStorage(36161,33189,gl.canvas.width,gl.canvas.height);gl.framebufferRenderbuffer(36160,36096,36161,context.defaultDepthTarget);gl.bindRenderbuffer(36161,null);var vertices=[-1,-1,-1,1,1,-1,1,1];var vb=gl.createBuffer();gl.bindBuffer(34962,vb);gl.bufferData(34962,new Float32Array(vertices),35044);gl.bindBuffer(34962,null);context.blitVB=vb;var vsCode="attribute vec2 pos;"+"varying lowp vec2 tex;"+"void main() { tex = pos * 0.5 + vec2(0.5,0.5); gl_Position = vec4(pos, 0.0, 1.0); }";var vs=gl.createShader(35633);gl.shaderSource(vs,vsCode);gl.compileShader(vs);var fsCode="varying lowp vec2 tex;"+"uniform sampler2D sampler;"+"void main() { gl_FragColor = texture2D(sampler, tex); }";var fs=gl.createShader(35632);gl.shaderSource(fs,fsCode);gl.compileShader(fs);var blitProgram=gl.createProgram();gl.attachShader(blitProgram,vs);gl.attachShader(blitProgram,fs);gl.linkProgram(blitProgram);context.blitProgram=blitProgram;context.blitPosLoc=gl.getAttribLocation(blitProgram,"pos");gl.useProgram(blitProgram);gl.uniform1i(gl.getUniformLocation(blitProgram,"sampler"),0);gl.useProgram(null);if(gl.createVertexArray){context.defaultVao=gl.createVertexArray();gl.bindVertexArray(context.defaultVao);gl.enableVertexAttribArray(context.blitPosLoc);gl.bindVertexArray(null)}},resizeOffscreenFramebuffer:context=>{var gl=context.GLctx;if(context.defaultColorTarget){var prevTextureBinding=gl.getParameter(32873);gl.bindTexture(3553,context.defaultColorTarget);gl.texImage2D(3553,0,6408,gl.drawingBufferWidth,gl.drawingBufferHeight,0,6408,5121,null);gl.bindTexture(3553,prevTextureBinding)}if(context.defaultDepthTarget){var prevRenderBufferBinding=gl.getParameter(36007);gl.bindRenderbuffer(36161,context.defaultDepthTarget);gl.renderbufferStorage(36161,33189,gl.drawingBufferWidth,gl.drawingBufferHeight);gl.bindRenderbuffer(36161,prevRenderBufferBinding)}},blitOffscreenFramebuffer:context=>{var gl=context.GLctx;var prevScissorTest=gl.getParameter(3089);if(prevScissorTest)gl.disable(3089);var prevFbo=gl.getParameter(36006);if(gl.blitFramebuffer&&!context.defaultFboForbidBlitFramebuffer){gl.bindFramebuffer(36008,context.defaultFbo);gl.bindFramebuffer(36009,null);gl.blitFramebuffer(0,0,gl.canvas.width,gl.canvas.height,0,0,gl.canvas.width,gl.canvas.height,16384,9728)}else{gl.bindFramebuffer(36160,null);var prevProgram=gl.getParameter(35725);gl.useProgram(context.blitProgram);if(!gl.isProgram(prevProgram))prevProgram=null;var prevVB=gl.getParameter(34964);gl.bindBuffer(34962,context.blitVB);var prevActiveTexture=gl.getParameter(34016);gl.activeTexture(33984);var prevTextureBinding=gl.getParameter(32873);gl.bindTexture(3553,context.defaultColorTarget);var prevBlend=gl.getParameter(3042);if(prevBlend)gl.disable(3042);var prevCullFace=gl.getParameter(2884);if(prevCullFace)gl.disable(2884);var prevDepthTest=gl.getParameter(2929);if(prevDepthTest)gl.disable(2929);var prevStencilTest=gl.getParameter(2960);if(prevStencilTest)gl.disable(2960);function draw(){gl.vertexAttribPointer(context.blitPosLoc,2,5126,false,0,0);gl.drawArrays(5,0,4)}if(context.defaultVao){var prevVAO=gl.getParameter(34229);gl.bindVertexArray(context.defaultVao);draw();gl.bindVertexArray(prevVAO)}else{var prevVertexAttribPointer={buffer:gl.getVertexAttrib(context.blitPosLoc,34975),size:gl.getVertexAttrib(context.blitPosLoc,34339),stride:gl.getVertexAttrib(context.blitPosLoc,34340),type:gl.getVertexAttrib(context.blitPosLoc,34341),normalized:gl.getVertexAttrib(context.blitPosLoc,34922),pointer:gl.getVertexAttribOffset(context.blitPosLoc,34373)};var maxVertexAttribs=gl.getParameter(34921);var prevVertexAttribEnables=[];for(var i=0;i<maxVertexAttribs;++i){var prevEnabled=gl.getVertexAttrib(i,34338);var wantEnabled=i==context.blitPosLoc;if(prevEnabled&&!wantEnabled){gl.disableVertexAttribArray(i)}if(!prevEnabled&&wantEnabled){gl.enableVertexAttribArray(i)}prevVertexAttribEnables[i]=prevEnabled}draw();for(var i=0;i<maxVertexAttribs;++i){var prevEnabled=prevVertexAttribEnables[i];var nowEnabled=i==context.blitPosLoc;if(prevEnabled&&!nowEnabled){gl.enableVertexAttribArray(i)}if(!prevEnabled&&nowEnabled){gl.disableVertexAttribArray(i)}}gl.bindBuffer(34962,prevVertexAttribPointer.buffer);gl.vertexAttribPointer(context.blitPosLoc,prevVertexAttribPointer.size,prevVertexAttribPointer.type,prevVertexAttribPointer.normalized,prevVertexAttribPointer.stride,prevVertexAttribPointer.offset)}if(prevStencilTest)gl.enable(2960);if(prevDepthTest)gl.enable(2929);if(prevCullFace)gl.enable(2884);if(prevBlend)gl.enable(3042);gl.bindTexture(3553,prevTextureBinding);gl.activeTexture(prevActiveTexture);gl.bindBuffer(34962,prevVB);gl.useProgram(prevProgram)}gl.bindFramebuffer(36160,prevFbo);if(prevScissorTest)gl.enable(3089)},registerContext:(ctx,webGLContextAttributes)=>{var handle=GL.getNewId(GL.contexts);var context={handle,attributes:webGLContextAttributes,version:webGLContextAttributes.majorVersion,GLctx:ctx};if(ctx.canvas)ctx.canvas.GLctxObject=context;GL.contexts[handle]=context;if(typeof webGLContextAttributes.enableExtensionsByDefault=="undefined"||webGLContextAttributes.enableExtensionsByDefault){GL.initExtensions(context)}if(webGLContextAttributes.renderViaOffscreenBackBuffer)GL.createOffscreenFramebuffer(context);return handle},makeContextCurrent:contextHandle=>{GL.currentContext=GL.contexts[contextHandle];Module["ctx"]=GLctx=GL.currentContext?.GLctx;return!(contextHandle&&!GLctx)},getContext:contextHandle=>GL.contexts[contextHandle],deleteContext:contextHandle=>{if(GL.currentContext===GL.contexts[contextHandle]){GL.currentContext=null}if(typeof JSEvents=="object"){JSEvents.removeAllHandlersOnTarget(GL.contexts[contextHandle].GLctx.canvas)}if(GL.contexts[contextHandle]?.GLctx.canvas){GL.contexts[contextHandle].GLctx.canvas.GLctxObject=undefined}GL.contexts[contextHandle]=null},initExtensions:context=>{context||=GL.currentContext;if(context.initExtensionsDone)return;context.initExtensionsDone=true;var GLctx=context.GLctx;webgl_enable_WEBGL_multi_draw(GLctx);webgl_enable_EXT_polygon_offset_clamp(GLctx);webgl_enable_EXT_clip_control(GLctx);webgl_enable_WEBGL_polygon_mode(GLctx);webgl_enable_ANGLE_instanced_arrays(GLctx);webgl_enable_OES_vertex_array_object(GLctx);webgl_enable_WEBGL_draw_buffers(GLctx);webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance(GLctx);webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance(GLctx);if(context.version>=2){GLctx.disjointTimerQueryExt=GLctx.getExtension("EXT_disjoint_timer_query_webgl2")}if(context.version<2||!GLctx.disjointTimerQueryExt){GLctx.disjointTimerQueryExt=GLctx.getExtension("EXT_disjoint_timer_query")}for(var ext of getEmscriptenSupportedExtensions(GLctx)){if(!ext.includes("lose_context")&&!ext.includes("debug")){GLctx.getExtension(ext)}}}};var _emscripten_webgl_do_commit_frame=()=>{if(!GL.currentContext||!GL.currentContext.GLctx){return-3}if(GL.currentContext.defaultFbo){GL.blitOffscreenFramebuffer(GL.currentContext);return 0}if(!GL.currentContext.attributes.explicitSwapControl){return-3}return 0};var _emscripten_webgl_commit_frame=_emscripten_webgl_do_commit_frame;var webglPowerPreferences=["default","low-power","high-performance"];var _emscripten_webgl_do_create_context=(target,attributes)=>{var attr32=attributes>>2;var powerPreference=HEAP32[attr32+(8>>2)];var contextAttributes={alpha:!!HEAP8[attributes+0],depth:!!HEAP8[attributes+1],stencil:!!HEAP8[attributes+2],antialias:!!HEAP8[attributes+3],premultipliedAlpha:!!HEAP8[attributes+4],preserveDrawingBuffer:!!HEAP8[attributes+5],powerPreference:webglPowerPreferences[powerPreference],failIfMajorPerformanceCaveat:!!HEAP8[attributes+12],majorVersion:HEAP32[attr32+(16>>2)],minorVersion:HEAP32[attr32+(20>>2)],enableExtensionsByDefault:HEAP8[attributes+24],explicitSwapControl:HEAP8[attributes+25],proxyContextToMainThread:HEAP32[attr32+(28>>2)],renderViaOffscreenBackBuffer:HEAP8[attributes+32]};var canvas=findCanvasEventTarget(target);if(!canvas){return 0}if(contextAttributes.explicitSwapControl&&!contextAttributes.renderViaOffscreenBackBuffer){contextAttributes.renderViaOffscreenBackBuffer=true}var contextHandle=GL.createContext(canvas,contextAttributes);return contextHandle};var _emscripten_webgl_create_context=_emscripten_webgl_do_create_context;var _emscripten_webgl_destroy_context=contextHandle=>{if(GL.currentContext==contextHandle)GL.currentContext=0;GL.deleteContext(contextHandle)};var _emscripten_webgl_enable_extension=(contextHandle,extension)=>{var context=GL.getContext(contextHandle);var extString=UTF8ToString(extension);if(extString.startsWith("GL_"))extString=extString.slice(3);if(extString=="ANGLE_instanced_arrays")webgl_enable_ANGLE_instanced_arrays(GLctx);if(extString=="OES_vertex_array_object")webgl_enable_OES_vertex_array_object(GLctx);if(extString=="WEBGL_draw_buffers")webgl_enable_WEBGL_draw_buffers(GLctx);if(extString=="WEBGL_draw_instanced_base_vertex_base_instance")webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance(GLctx);if(extString=="WEBGL_multi_draw_instanced_base_vertex_base_instance")webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance(GLctx);if(extString=="WEBGL_multi_draw")webgl_enable_WEBGL_multi_draw(GLctx);if(extString=="EXT_polygon_offset_clamp")webgl_enable_EXT_polygon_offset_clamp(GLctx);if(extString=="EXT_clip_control")webgl_enable_EXT_clip_control(GLctx);if(extString=="WEBGL_polygon_mode")webgl_enable_WEBGL_polygon_mode(GLctx);var ext=context.GLctx.getExtension(extString);return!!ext};var stringToNewUTF8=str=>{var size=lengthBytesUTF8(str)+1;var ret=_malloc(size);if(ret)stringToUTF8(str,ret,size);return ret};var _emscripten_webgl_get_supported_extensions=()=>stringToNewUTF8(GLctx.getSupportedExtensions().join(" "));var _emscripten_webgl_make_context_current=contextHandle=>{var success=GL.makeContextCurrent(contextHandle);return success?0:-5};var ENV={};var getExecutableName=()=>thisProgram||"./this.program";var getEnvStrings=()=>{if(!getEnvStrings.strings){var lang=(typeof navigator=="object"&&navigator.language||"C").replace("-","_")+".UTF-8";var env={USER:"web_user",LOGNAME:"web_user",PATH:"/",PWD:"/",HOME:"/home/web_user",LANG:lang,_:getExecutableName()};for(var x in ENV){if(ENV[x]===undefined)delete env[x];else env[x]=ENV[x]}var strings=[];for(var x in env){strings.push(`${x}=${env[x]}`)}getEnvStrings.strings=strings}return getEnvStrings.strings};var _environ_get=(__environ,environ_buf)=>{var bufSize=0;var envp=0;for(var string of getEnvStrings()){var ptr=environ_buf+bufSize;HEAPU32[__environ+envp>>2]=ptr;bufSize+=stringToUTF8(string,ptr,Infinity)+1;envp+=4}return 0};var _environ_sizes_get=(penviron_count,penviron_buf_size)=>{var strings=getEnvStrings();HEAPU32[penviron_count>>2]=strings.length;var bufSize=0;for(var string of strings){bufSize+=lengthBytesUTF8(string)+1}HEAPU32[penviron_buf_size>>2]=bufSize;return 0};function _fd_close(fd){try{var stream=SYSCALLS.getStreamFromFD(fd);FS.close(stream);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}function _fd_fdstat_get(fd,pbuf){try{var rightsBase=0;var rightsInheriting=0;var flags=0;{var stream=SYSCALLS.getStreamFromFD(fd);var type=stream.tty?2:FS.isDir(stream.mode)?3:FS.isLink(stream.mode)?7:4}HEAP8[pbuf]=type;HEAP16[pbuf+2>>1]=flags;HEAP64[pbuf+8>>3]=BigInt(rightsBase);HEAP64[pbuf+16>>3]=BigInt(rightsInheriting);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}var doReadv=(stream,iov,iovcnt,offset)=>{var ret=0;for(var i=0;i<iovcnt;i++){var ptr=HEAPU32[iov>>2];var len=HEAPU32[iov+4>>2];iov+=8;var curr=FS.read(stream,HEAP8,ptr,len,offset);if(curr<0)return-1;ret+=curr;if(curr<len)break;if(typeof offset!="undefined"){offset+=curr}}return ret};function _fd_read(fd,iov,iovcnt,pnum){try{var stream=SYSCALLS.getStreamFromFD(fd);var num=doReadv(stream,iov,iovcnt);HEAPU32[pnum>>2]=num;return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}function _fd_seek(fd,offset,whence,newOffset){offset=bigintToI53Checked(offset);try{if(isNaN(offset))return 61;var stream=SYSCALLS.getStreamFromFD(fd);FS.llseek(stream,offset,whence);HEAP64[newOffset>>3]=BigInt(stream.position);if(stream.getdents&&offset===0&&whence===0)stream.getdents=null;return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}var doWritev=(stream,iov,iovcnt,offset)=>{var ret=0;for(var i=0;i<iovcnt;i++){var ptr=HEAPU32[iov>>2];var len=HEAPU32[iov+4>>2];iov+=8;var curr=FS.write(stream,HEAP8,ptr,len,offset);if(curr<0)return-1;ret+=curr;if(curr<len){break}if(typeof offset!="undefined"){offset+=curr}}return ret};function _fd_write(fd,iov,iovcnt,pnum){try{var stream=SYSCALLS.getStreamFromFD(fd);var num=doWritev(stream,iov,iovcnt);HEAPU32[pnum>>2]=num;return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}var _emscripten_glActiveTexture=x0=>GLctx.activeTexture(x0);var _glActiveTexture=_emscripten_glActiveTexture;var _emscripten_glAttachShader=(program,shader)=>{GLctx.attachShader(GL.programs[program],GL.shaders[shader])};var _glAttachShader=_emscripten_glAttachShader;var _emscripten_glBeginTransformFeedback=x0=>GLctx.beginTransformFeedback(x0);var _glBeginTransformFeedback=_emscripten_glBeginTransformFeedback;var _emscripten_glBindBuffer=(target,buffer)=>{if(target==35051){GLctx.currentPixelPackBufferBinding=buffer}else if(target==35052){GLctx.currentPixelUnpackBufferBinding=buffer}GLctx.bindBuffer(target,GL.buffers[buffer])};var _glBindBuffer=_emscripten_glBindBuffer;var _emscripten_glBindBufferBase=(target,index,buffer)=>{GLctx.bindBufferBase(target,index,GL.buffers[buffer])};var _glBindBufferBase=_emscripten_glBindBufferBase;var _emscripten_glBindBufferRange=(target,index,buffer,offset,ptrsize)=>{GLctx.bindBufferRange(target,index,GL.buffers[buffer],offset,ptrsize)};var _glBindBufferRange=_emscripten_glBindBufferRange;var _emscripten_glBindFramebuffer=(target,framebuffer)=>{GLctx.bindFramebuffer(target,framebuffer?GL.framebuffers[framebuffer]:GL.currentContext.defaultFbo)};var _glBindFramebuffer=_emscripten_glBindFramebuffer;var _emscripten_glBindRenderbuffer=(target,renderbuffer)=>{GLctx.bindRenderbuffer(target,GL.renderbuffers[renderbuffer])};var _glBindRenderbuffer=_emscripten_glBindRenderbuffer;var _emscripten_glBindTexture=(target,texture)=>{GLctx.bindTexture(target,GL.textures[texture])};var _glBindTexture=_emscripten_glBindTexture;var _emscripten_glBindVertexArray=vao=>{GLctx.bindVertexArray(GL.vaos[vao])};var _glBindVertexArray=_emscripten_glBindVertexArray;var _emscripten_glBlendColor=(x0,x1,x2,x3)=>GLctx.blendColor(x0,x1,x2,x3);var _glBlendColor=_emscripten_glBlendColor;var _emscripten_glBlendEquation=x0=>GLctx.blendEquation(x0);var _glBlendEquation=_emscripten_glBlendEquation;var _emscripten_glBlendFunc=(x0,x1)=>GLctx.blendFunc(x0,x1);var _glBlendFunc=_emscripten_glBlendFunc;var _emscripten_glBlendFuncSeparate=(x0,x1,x2,x3)=>GLctx.blendFuncSeparate(x0,x1,x2,x3);var _glBlendFuncSeparate=_emscripten_glBlendFuncSeparate;var _emscripten_glBlitFramebuffer=(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9)=>GLctx.blitFramebuffer(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9);var _glBlitFramebuffer=_emscripten_glBlitFramebuffer;var _emscripten_glBufferData=(target,size,data,usage)=>{if(GL.currentContext.version>=2){if(data&&size){GLctx.bufferData(target,HEAPU8,usage,data,size)}else{GLctx.bufferData(target,size,usage)}return}GLctx.bufferData(target,data?HEAPU8.subarray(data,data+size):size,usage)};var _glBufferData=_emscripten_glBufferData;var _emscripten_glBufferSubData=(target,offset,size,data)=>{if(GL.currentContext.version>=2){size&&GLctx.bufferSubData(target,offset,HEAPU8,data,size);return}GLctx.bufferSubData(target,offset,HEAPU8.subarray(data,data+size))};var _glBufferSubData=_emscripten_glBufferSubData;var _emscripten_glCheckFramebufferStatus=x0=>GLctx.checkFramebufferStatus(x0);var _glCheckFramebufferStatus=_emscripten_glCheckFramebufferStatus;var _emscripten_glClear=x0=>GLctx.clear(x0);var _glClear=_emscripten_glClear;var _emscripten_glClearBufferfv=(buffer,drawbuffer,value)=>{GLctx.clearBufferfv(buffer,drawbuffer,HEAPF32,value>>2)};var _glClearBufferfv=_emscripten_glClearBufferfv;var _emscripten_glClearColor=(x0,x1,x2,x3)=>GLctx.clearColor(x0,x1,x2,x3);var _glClearColor=_emscripten_glClearColor;var _emscripten_glClearDepthf=x0=>GLctx.clearDepth(x0);var _glClearDepthf=_emscripten_glClearDepthf;var _emscripten_glClearStencil=x0=>GLctx.clearStencil(x0);var _glClearStencil=_emscripten_glClearStencil;var _emscripten_glColorMask=(red,green,blue,alpha)=>{GLctx.colorMask(!!red,!!green,!!blue,!!alpha)};var _glColorMask=_emscripten_glColorMask;var _emscripten_glCompileShader=shader=>{GLctx.compileShader(GL.shaders[shader])};var _glCompileShader=_emscripten_glCompileShader;var _emscripten_glCompressedTexImage2D=(target,level,internalFormat,width,height,border,imageSize,data)=>{if(GL.currentContext.version>=2){if(GLctx.currentPixelUnpackBufferBinding||!imageSize){GLctx.compressedTexImage2D(target,level,internalFormat,width,height,border,imageSize,data);return}GLctx.compressedTexImage2D(target,level,internalFormat,width,height,border,HEAPU8,data,imageSize);return}GLctx.compressedTexImage2D(target,level,internalFormat,width,height,border,HEAPU8.subarray(data,data+imageSize))};var _glCompressedTexImage2D=_emscripten_glCompressedTexImage2D;var _emscripten_glCompressedTexImage3D=(target,level,internalFormat,width,height,depth,border,imageSize,data)=>{if(GLctx.currentPixelUnpackBufferBinding){GLctx.compressedTexImage3D(target,level,internalFormat,width,height,depth,border,imageSize,data)}else{GLctx.compressedTexImage3D(target,level,internalFormat,width,height,depth,border,HEAPU8,data,imageSize)}};var _glCompressedTexImage3D=_emscripten_glCompressedTexImage3D;var _emscripten_glCompressedTexSubImage3D=(target,level,xoffset,yoffset,zoffset,width,height,depth,format,imageSize,data)=>{if(GLctx.currentPixelUnpackBufferBinding){GLctx.compressedTexSubImage3D(target,level,xoffset,yoffset,zoffset,width,height,depth,format,imageSize,data)}else{GLctx.compressedTexSubImage3D(target,level,xoffset,yoffset,zoffset,width,height,depth,format,HEAPU8,data,imageSize)}};var _glCompressedTexSubImage3D=_emscripten_glCompressedTexSubImage3D;var _emscripten_glCopyBufferSubData=(x0,x1,x2,x3,x4)=>GLctx.copyBufferSubData(x0,x1,x2,x3,x4);var _glCopyBufferSubData=_emscripten_glCopyBufferSubData;var _emscripten_glCreateProgram=()=>{var id=GL.getNewId(GL.programs);var program=GLctx.createProgram();program.name=id;program.maxUniformLength=program.maxAttributeLength=program.maxUniformBlockNameLength=0;program.uniformIdCounter=1;GL.programs[id]=program;return id};var _glCreateProgram=_emscripten_glCreateProgram;var _emscripten_glCreateShader=shaderType=>{var id=GL.getNewId(GL.shaders);GL.shaders[id]=GLctx.createShader(shaderType);return id};var _glCreateShader=_emscripten_glCreateShader;var _emscripten_glCullFace=x0=>GLctx.cullFace(x0);var _glCullFace=_emscripten_glCullFace;var _emscripten_glDeleteBuffers=(n,buffers)=>{for(var i=0;i<n;i++){var id=HEAP32[buffers+i*4>>2];var buffer=GL.buffers[id];if(!buffer)continue;GLctx.deleteBuffer(buffer);buffer.name=0;GL.buffers[id]=null;if(id==GLctx.currentPixelPackBufferBinding)GLctx.currentPixelPackBufferBinding=0;if(id==GLctx.currentPixelUnpackBufferBinding)GLctx.currentPixelUnpackBufferBinding=0}};var _glDeleteBuffers=_emscripten_glDeleteBuffers;var _emscripten_glDeleteFramebuffers=(n,framebuffers)=>{for(var i=0;i<n;++i){var id=HEAP32[framebuffers+i*4>>2];var framebuffer=GL.framebuffers[id];if(!framebuffer)continue;GLctx.deleteFramebuffer(framebuffer);framebuffer.name=0;GL.framebuffers[id]=null}};var _glDeleteFramebuffers=_emscripten_glDeleteFramebuffers;var _emscripten_glDeleteProgram=id=>{if(!id)return;var program=GL.programs[id];if(!program){GL.recordError(1281);return}GLctx.deleteProgram(program);program.name=0;GL.programs[id]=null};var _glDeleteProgram=_emscripten_glDeleteProgram;var _emscripten_glDeleteQueries=(n,ids)=>{for(var i=0;i<n;i++){var id=HEAP32[ids+i*4>>2];var query=GL.queries[id];if(!query)continue;GLctx.deleteQuery(query);GL.queries[id]=null}};var _glDeleteQueries=_emscripten_glDeleteQueries;var _emscripten_glDeleteRenderbuffers=(n,renderbuffers)=>{for(var i=0;i<n;i++){var id=HEAP32[renderbuffers+i*4>>2];var renderbuffer=GL.renderbuffers[id];if(!renderbuffer)continue;GLctx.deleteRenderbuffer(renderbuffer);renderbuffer.name=0;GL.renderbuffers[id]=null}};var _glDeleteRenderbuffers=_emscripten_glDeleteRenderbuffers;var _emscripten_glDeleteShader=id=>{if(!id)return;var shader=GL.shaders[id];if(!shader){GL.recordError(1281);return}GLctx.deleteShader(shader);GL.shaders[id]=null};var _glDeleteShader=_emscripten_glDeleteShader;var _emscripten_glDeleteSync=id=>{if(!id)return;var sync=GL.syncs[id];if(!sync){GL.recordError(1281);return}GLctx.deleteSync(sync);sync.name=0;GL.syncs[id]=null};var _glDeleteSync=_emscripten_glDeleteSync;var _emscripten_glDeleteTextures=(n,textures)=>{for(var i=0;i<n;i++){var id=HEAP32[textures+i*4>>2];var texture=GL.textures[id];if(!texture)continue;GLctx.deleteTexture(texture);texture.name=0;GL.textures[id]=null}};var _glDeleteTextures=_emscripten_glDeleteTextures;var _emscripten_glDeleteVertexArrays=(n,vaos)=>{for(var i=0;i<n;i++){var id=HEAP32[vaos+i*4>>2];GLctx.deleteVertexArray(GL.vaos[id]);GL.vaos[id]=null}};var _glDeleteVertexArrays=_emscripten_glDeleteVertexArrays;var _emscripten_glDepthFunc=x0=>GLctx.depthFunc(x0);var _glDepthFunc=_emscripten_glDepthFunc;var _emscripten_glDepthMask=flag=>{GLctx.depthMask(!!flag)};var _glDepthMask=_emscripten_glDepthMask;var _emscripten_glDisable=x0=>GLctx.disable(x0);var _glDisable=_emscripten_glDisable;var _emscripten_glDisableVertexAttribArray=index=>{GLctx.disableVertexAttribArray(index)};var _glDisableVertexAttribArray=_emscripten_glDisableVertexAttribArray;var _emscripten_glDrawArrays=(mode,first,count)=>{GLctx.drawArrays(mode,first,count)};var _glDrawArrays=_emscripten_glDrawArrays;var _emscripten_glDrawArraysInstanced=(mode,first,count,primcount)=>{GLctx.drawArraysInstanced(mode,first,count,primcount)};var _glDrawArraysInstanced=_emscripten_glDrawArraysInstanced;var tempFixedLengthArray=[];var _emscripten_glDrawBuffers=(n,bufs)=>{var bufArray=tempFixedLengthArray[n];for(var i=0;i<n;i++){bufArray[i]=HEAP32[bufs+i*4>>2]}GLctx.drawBuffers(bufArray)};var _glDrawBuffers=_emscripten_glDrawBuffers;var _emscripten_glDrawElements=(mode,count,type,indices)=>{GLctx.drawElements(mode,count,type,indices)};var _glDrawElements=_emscripten_glDrawElements;var _emscripten_glDrawElementsInstanced=(mode,count,type,indices,primcount)=>{GLctx.drawElementsInstanced(mode,count,type,indices,primcount)};var _glDrawElementsInstanced=_emscripten_glDrawElementsInstanced;var _emscripten_glEnable=x0=>GLctx.enable(x0);var _glEnable=_emscripten_glEnable;var _emscripten_glEnableVertexAttribArray=index=>{GLctx.enableVertexAttribArray(index)};var _glEnableVertexAttribArray=_emscripten_glEnableVertexAttribArray;var _emscripten_glEndTransformFeedback=()=>GLctx.endTransformFeedback();var _glEndTransformFeedback=_emscripten_glEndTransformFeedback;var _emscripten_glFenceSync=(condition,flags)=>{var sync=GLctx.fenceSync(condition,flags);if(sync){var id=GL.getNewId(GL.syncs);sync.name=id;GL.syncs[id]=sync;return id}return 0};var _glFenceSync=_emscripten_glFenceSync;var _emscripten_glFinish=()=>GLctx.finish();var _glFinish=_emscripten_glFinish;var _emscripten_glFramebufferRenderbuffer=(target,attachment,renderbuffertarget,renderbuffer)=>{GLctx.framebufferRenderbuffer(target,attachment,renderbuffertarget,GL.renderbuffers[renderbuffer])};var _glFramebufferRenderbuffer=_emscripten_glFramebufferRenderbuffer;var _emscripten_glFramebufferTexture2D=(target,attachment,textarget,texture,level)=>{GLctx.framebufferTexture2D(target,attachment,textarget,GL.textures[texture],level)};var _glFramebufferTexture2D=_emscripten_glFramebufferTexture2D;var _emscripten_glFramebufferTextureLayer=(target,attachment,texture,level,layer)=>{GLctx.framebufferTextureLayer(target,attachment,GL.textures[texture],level,layer)};var _glFramebufferTextureLayer=_emscripten_glFramebufferTextureLayer;var _emscripten_glFrontFace=x0=>GLctx.frontFace(x0);var _glFrontFace=_emscripten_glFrontFace;var _emscripten_glGenBuffers=(n,buffers)=>{GL.genObject(n,buffers,"createBuffer",GL.buffers)};var _glGenBuffers=_emscripten_glGenBuffers;var _emscripten_glGenFramebuffers=(n,ids)=>{GL.genObject(n,ids,"createFramebuffer",GL.framebuffers)};var _glGenFramebuffers=_emscripten_glGenFramebuffers;var _emscripten_glGenQueries=(n,ids)=>{GL.genObject(n,ids,"createQuery",GL.queries)};var _glGenQueries=_emscripten_glGenQueries;var _emscripten_glGenRenderbuffers=(n,renderbuffers)=>{GL.genObject(n,renderbuffers,"createRenderbuffer",GL.renderbuffers)};var _glGenRenderbuffers=_emscripten_glGenRenderbuffers;var _emscripten_glGenTextures=(n,textures)=>{GL.genObject(n,textures,"createTexture",GL.textures)};var _glGenTextures=_emscripten_glGenTextures;var _emscripten_glGenVertexArrays=(n,arrays)=>{GL.genObject(n,arrays,"createVertexArray",GL.vaos)};var _glGenVertexArrays=_emscripten_glGenVertexArrays;var _emscripten_glGenerateMipmap=x0=>GLctx.generateMipmap(x0);var _glGenerateMipmap=_emscripten_glGenerateMipmap;var writeI53ToI64=(ptr,num)=>{HEAPU32[ptr>>2]=num;var lower=HEAPU32[ptr>>2];HEAPU32[ptr+4>>2]=(num-lower)/4294967296};var webglGetExtensions=()=>{var exts=getEmscriptenSupportedExtensions(GLctx);exts=exts.concat(exts.map(e=>"GL_"+e));return exts};var emscriptenWebGLGet=(name_,p,type)=>{if(!p){GL.recordError(1281);return}var ret=undefined;switch(name_){case 36346:ret=1;break;case 36344:if(type!=0&&type!=1){GL.recordError(1280)}return;case 34814:case 36345:ret=0;break;case 34466:var formats=GLctx.getParameter(34467);ret=formats?formats.length:0;break;case 33309:if(GL.currentContext.version<2){GL.recordError(1282);return}ret=webglGetExtensions().length;break;case 33307:case 33308:if(GL.currentContext.version<2){GL.recordError(1280);return}ret=name_==33307?3:0;break}if(ret===undefined){var result=GLctx.getParameter(name_);switch(typeof result){case"number":ret=result;break;case"boolean":ret=result?1:0;break;case"string":GL.recordError(1280);return;case"object":if(result===null){switch(name_){case 34964:case 35725:case 34965:case 36006:case 36007:case 32873:case 34229:case 36662:case 36663:case 35053:case 35055:case 36010:case 35097:case 35869:case 32874:case 36389:case 35983:case 35368:case 34068:{ret=0;break}default:{GL.recordError(1280);return}}}else if(result instanceof Float32Array||result instanceof Uint32Array||result instanceof Int32Array||result instanceof Array){for(var i=0;i<result.length;++i){switch(type){case 0:HEAP32[p+i*4>>2]=result[i];break;case 2:HEAPF32[p+i*4>>2]=result[i];break;case 4:HEAP8[p+i]=result[i]?1:0;break}}return}else{try{ret=result.name|0}catch(e){GL.recordError(1280);err(`GL_INVALID_ENUM in glGet${type}v: Unknown object returned from WebGL getParameter(${name_})! (error: ${e})`);return}}break;default:GL.recordError(1280);err(`GL_INVALID_ENUM in glGet${type}v: Native code calling glGet${type}v(${name_}) and it returns ${result} of type ${typeof result}!`);return}}switch(type){case 1:writeI53ToI64(p,ret);break;case 0:HEAP32[p>>2]=ret;break;case 2:HEAPF32[p>>2]=ret;break;case 4:HEAP8[p]=ret?1:0;break}};var _emscripten_glGetFloatv=(name_,p)=>emscriptenWebGLGet(name_,p,2);var _glGetFloatv=_emscripten_glGetFloatv;var _emscripten_glGetInteger64v=(name_,p)=>{emscriptenWebGLGet(name_,p,1)};var _glGetInteger64v=_emscripten_glGetInteger64v;var _emscripten_glGetIntegerv=(name_,p)=>emscriptenWebGLGet(name_,p,0);var _glGetIntegerv=_emscripten_glGetIntegerv;var _emscripten_glGetProgramInfoLog=(program,maxLength,length,infoLog)=>{var log=GLctx.getProgramInfoLog(GL.programs[program]);if(log===null)log="(unknown error)";var numBytesWrittenExclNull=maxLength>0&&infoLog?stringToUTF8(log,infoLog,maxLength):0;if(length)HEAP32[length>>2]=numBytesWrittenExclNull};var _glGetProgramInfoLog=_emscripten_glGetProgramInfoLog;var _emscripten_glGetProgramiv=(program,pname,p)=>{if(!p){GL.recordError(1281);return}if(program>=GL.counter){GL.recordError(1281);return}program=GL.programs[program];if(pname==35716){var log=GLctx.getProgramInfoLog(program);if(log===null)log="(unknown error)";HEAP32[p>>2]=log.length+1}else if(pname==35719){if(!program.maxUniformLength){var numActiveUniforms=GLctx.getProgramParameter(program,35718);for(var i=0;i<numActiveUniforms;++i){program.maxUniformLength=Math.max(program.maxUniformLength,GLctx.getActiveUniform(program,i).name.length+1)}}HEAP32[p>>2]=program.maxUniformLength}else if(pname==35722){if(!program.maxAttributeLength){var numActiveAttributes=GLctx.getProgramParameter(program,35721);for(var i=0;i<numActiveAttributes;++i){program.maxAttributeLength=Math.max(program.maxAttributeLength,GLctx.getActiveAttrib(program,i).name.length+1)}}HEAP32[p>>2]=program.maxAttributeLength}else if(pname==35381){if(!program.maxUniformBlockNameLength){var numActiveUniformBlocks=GLctx.getProgramParameter(program,35382);for(var i=0;i<numActiveUniformBlocks;++i){program.maxUniformBlockNameLength=Math.max(program.maxUniformBlockNameLength,GLctx.getActiveUniformBlockName(program,i).length+1)}}HEAP32[p>>2]=program.maxUniformBlockNameLength}else{HEAP32[p>>2]=GLctx.getProgramParameter(program,pname)}};var _glGetProgramiv=_emscripten_glGetProgramiv;var _emscripten_glGetShaderInfoLog=(shader,maxLength,length,infoLog)=>{var log=GLctx.getShaderInfoLog(GL.shaders[shader]);if(log===null)log="(unknown error)";var numBytesWrittenExclNull=maxLength>0&&infoLog?stringToUTF8(log,infoLog,maxLength):0;if(length)HEAP32[length>>2]=numBytesWrittenExclNull};var _glGetShaderInfoLog=_emscripten_glGetShaderInfoLog;var _emscripten_glGetShaderiv=(shader,pname,p)=>{if(!p){GL.recordError(1281);return}if(pname==35716){var log=GLctx.getShaderInfoLog(GL.shaders[shader]);if(log===null)log="(unknown error)";var logLength=log?log.length+1:0;HEAP32[p>>2]=logLength}else if(pname==35720){var source=GLctx.getShaderSource(GL.shaders[shader]);var sourceLength=source?source.length+1:0;HEAP32[p>>2]=sourceLength}else{HEAP32[p>>2]=GLctx.getShaderParameter(GL.shaders[shader],pname)}};var _glGetShaderiv=_emscripten_glGetShaderiv;var _emscripten_glGetString=name_=>{var ret=GL.stringCache[name_];if(!ret){switch(name_){case 7939:ret=stringToNewUTF8(webglGetExtensions().join(" "));break;case 7936:case 7937:case 37445:case 37446:var s=GLctx.getParameter(name_);if(!s){GL.recordError(1280)}ret=s?stringToNewUTF8(s):0;break;case 7938:var webGLVersion=GLctx.getParameter(7938);var glVersion=`OpenGL ES 2.0 (${webGLVersion})`;if(GL.currentContext.version>=2)glVersion=`OpenGL ES 3.0 (${webGLVersion})`;ret=stringToNewUTF8(glVersion);break;case 35724:var glslVersion=GLctx.getParameter(35724);var ver_re=/^WebGL GLSL ES ([0-9]\.[0-9][0-9]?)(?:$| .*)/;var ver_num=glslVersion.match(ver_re);if(ver_num!==null){if(ver_num[1].length==3)ver_num[1]=ver_num[1]+"0";glslVersion=`OpenGL ES GLSL ES ${ver_num[1]} (${glslVersion})`}ret=stringToNewUTF8(glslVersion);break;default:GL.recordError(1280)}GL.stringCache[name_]=ret}return ret};var _glGetString=_emscripten_glGetString;var _emscripten_glGetSynciv=(sync,pname,bufSize,length,values)=>{if(bufSize<0){GL.recordError(1281);return}if(!values){GL.recordError(1281);return}var ret=GLctx.getSyncParameter(GL.syncs[sync],pname);if(ret!==null){HEAP32[values>>2]=ret;if(length)HEAP32[length>>2]=1}};var _glGetSynciv=_emscripten_glGetSynciv;var _emscripten_glGetUniformBlockIndex=(program,uniformBlockName)=>GLctx.getUniformBlockIndex(GL.programs[program],UTF8ToString(uniformBlockName));var _glGetUniformBlockIndex=_emscripten_glGetUniformBlockIndex;var jstoi_q=str=>parseInt(str);var webglGetLeftBracePos=name=>name.slice(-1)=="]"&&name.lastIndexOf("[");var webglPrepareUniformLocationsBeforeFirstUse=program=>{var uniformLocsById=program.uniformLocsById,uniformSizeAndIdsByName=program.uniformSizeAndIdsByName,i,j;if(!uniformLocsById){program.uniformLocsById=uniformLocsById={};program.uniformArrayNamesById={};var numActiveUniforms=GLctx.getProgramParameter(program,35718);for(i=0;i<numActiveUniforms;++i){var u=GLctx.getActiveUniform(program,i);var nm=u.name;var sz=u.size;var lb=webglGetLeftBracePos(nm);var arrayName=lb>0?nm.slice(0,lb):nm;var id=program.uniformIdCounter;program.uniformIdCounter+=sz;uniformSizeAndIdsByName[arrayName]=[sz,id];for(j=0;j<sz;++j){uniformLocsById[id]=j;program.uniformArrayNamesById[id++]=arrayName}}}};var _emscripten_glGetUniformLocation=(program,name)=>{name=UTF8ToString(name);if(program=GL.programs[program]){webglPrepareUniformLocationsBeforeFirstUse(program);var uniformLocsById=program.uniformLocsById;var arrayIndex=0;var uniformBaseName=name;var leftBrace=webglGetLeftBracePos(name);if(leftBrace>0){arrayIndex=jstoi_q(name.slice(leftBrace+1))>>>0;uniformBaseName=name.slice(0,leftBrace)}var sizeAndId=program.uniformSizeAndIdsByName[uniformBaseName];if(sizeAndId&&arrayIndex<sizeAndId[0]){arrayIndex+=sizeAndId[1];if(uniformLocsById[arrayIndex]=uniformLocsById[arrayIndex]||GLctx.getUniformLocation(program,name)){return arrayIndex}}}else{GL.recordError(1281)}return-1};var _glGetUniformLocation=_emscripten_glGetUniformLocation;var _emscripten_glLinkProgram=program=>{program=GL.programs[program];GLctx.linkProgram(program);program.uniformLocsById=0;program.uniformSizeAndIdsByName={}};var _glLinkProgram=_emscripten_glLinkProgram;var _emscripten_glPixelStorei=(pname,param)=>{if(pname==3317){GL.unpackAlignment=param}else if(pname==3314){GL.unpackRowLength=param}GLctx.pixelStorei(pname,param)};var _glPixelStorei=_emscripten_glPixelStorei;var _emscripten_glReadBuffer=x0=>GLctx.readBuffer(x0);var _glReadBuffer=_emscripten_glReadBuffer;var computeUnpackAlignedImageSize=(width,height,sizePerPixel)=>{function roundedToNextMultipleOf(x,y){return x+y-1&-y}var plainRowSize=(GL.unpackRowLength||width)*sizePerPixel;var alignedRowSize=roundedToNextMultipleOf(plainRowSize,GL.unpackAlignment);return height*alignedRowSize};var colorChannelsInGlTextureFormat=format=>{var colorChannels={5:3,6:4,8:2,29502:3,29504:4,26917:2,26918:2,29846:3,29847:4};return colorChannels[format-6402]||1};var heapObjectForWebGLType=type=>{type-=5120;if(type==0)return HEAP8;if(type==1)return HEAPU8;if(type==2)return HEAP16;if(type==4)return HEAP32;if(type==6)return HEAPF32;if(type==5||type==28922||type==28520||type==30779||type==30782)return HEAPU32;return HEAPU16};var toTypedArrayIndex=(pointer,heap)=>pointer>>>31-Math.clz32(heap.BYTES_PER_ELEMENT);var emscriptenWebGLGetTexPixelData=(type,format,width,height,pixels,internalFormat)=>{var heap=heapObjectForWebGLType(type);var sizePerPixel=colorChannelsInGlTextureFormat(format)*heap.BYTES_PER_ELEMENT;var bytes=computeUnpackAlignedImageSize(width,height,sizePerPixel);return heap.subarray(toTypedArrayIndex(pixels,heap),toTypedArrayIndex(pixels+bytes,heap))};var _emscripten_glReadPixels=(x,y,width,height,format,type,pixels)=>{if(GL.currentContext.version>=2){if(GLctx.currentPixelPackBufferBinding){GLctx.readPixels(x,y,width,height,format,type,pixels);return}var heap=heapObjectForWebGLType(type);var target=toTypedArrayIndex(pixels,heap);GLctx.readPixels(x,y,width,height,format,type,heap,target);return}var pixelData=emscriptenWebGLGetTexPixelData(type,format,width,height,pixels,format);if(!pixelData){GL.recordError(1280);return}GLctx.readPixels(x,y,width,height,format,type,pixelData)};var _glReadPixels=_emscripten_glReadPixels;var _emscripten_glRenderbufferStorage=(x0,x1,x2,x3)=>GLctx.renderbufferStorage(x0,x1,x2,x3);var _glRenderbufferStorage=_emscripten_glRenderbufferStorage;var _emscripten_glRenderbufferStorageMultisample=(x0,x1,x2,x3,x4)=>GLctx.renderbufferStorageMultisample(x0,x1,x2,x3,x4);var _glRenderbufferStorageMultisample=_emscripten_glRenderbufferStorageMultisample;var _emscripten_glScissor=(x0,x1,x2,x3)=>GLctx.scissor(x0,x1,x2,x3);var _glScissor=_emscripten_glScissor;var _emscripten_glShaderSource=(shader,count,string,length)=>{var source=GL.getSource(shader,count,string,length);GLctx.shaderSource(GL.shaders[shader],source)};var _glShaderSource=_emscripten_glShaderSource;var _emscripten_glStencilFunc=(x0,x1,x2)=>GLctx.stencilFunc(x0,x1,x2);var _glStencilFunc=_emscripten_glStencilFunc;var _emscripten_glStencilMask=x0=>GLctx.stencilMask(x0);var _glStencilMask=_emscripten_glStencilMask;var _emscripten_glStencilOp=(x0,x1,x2)=>GLctx.stencilOp(x0,x1,x2);var _glStencilOp=_emscripten_glStencilOp;var _emscripten_glTexImage2D=(target,level,internalFormat,width,height,border,format,type,pixels)=>{if(GL.currentContext.version>=2){if(GLctx.currentPixelUnpackBufferBinding){GLctx.texImage2D(target,level,internalFormat,width,height,border,format,type,pixels);return}if(pixels){var heap=heapObjectForWebGLType(type);var index=toTypedArrayIndex(pixels,heap);GLctx.texImage2D(target,level,internalFormat,width,height,border,format,type,heap,index);return}}var pixelData=pixels?emscriptenWebGLGetTexPixelData(type,format,width,height,pixels,internalFormat):null;GLctx.texImage2D(target,level,internalFormat,width,height,border,format,type,pixelData)};var _glTexImage2D=_emscripten_glTexImage2D;var _emscripten_glTexImage3D=(target,level,internalFormat,width,height,depth,border,format,type,pixels)=>{if(GLctx.currentPixelUnpackBufferBinding){GLctx.texImage3D(target,level,internalFormat,width,height,depth,border,format,type,pixels)}else if(pixels){var heap=heapObjectForWebGLType(type);GLctx.texImage3D(target,level,internalFormat,width,height,depth,border,format,type,heap,toTypedArrayIndex(pixels,heap))}else{GLctx.texImage3D(target,level,internalFormat,width,height,depth,border,format,type,null)}};var _glTexImage3D=_emscripten_glTexImage3D;var _emscripten_glTexParameterf=(x0,x1,x2)=>GLctx.texParameterf(x0,x1,x2);var _glTexParameterf=_emscripten_glTexParameterf;var _emscripten_glTexParameteri=(x0,x1,x2)=>GLctx.texParameteri(x0,x1,x2);var _glTexParameteri=_emscripten_glTexParameteri;var _emscripten_glTexStorage2D=(x0,x1,x2,x3,x4)=>GLctx.texStorage2D(x0,x1,x2,x3,x4);var _glTexStorage2D=_emscripten_glTexStorage2D;var _emscripten_glTexSubImage3D=(target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,pixels)=>{if(GLctx.currentPixelUnpackBufferBinding){GLctx.texSubImage3D(target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,pixels)}else if(pixels){var heap=heapObjectForWebGLType(type);GLctx.texSubImage3D(target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,heap,toTypedArrayIndex(pixels,heap))}else{GLctx.texSubImage3D(target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,null)}};var _glTexSubImage3D=_emscripten_glTexSubImage3D;var _emscripten_glTransformFeedbackVaryings=(program,count,varyings,bufferMode)=>{program=GL.programs[program];var vars=[];for(var i=0;i<count;i++)vars.push(UTF8ToString(HEAP32[varyings+i*4>>2]));GLctx.transformFeedbackVaryings(program,vars,bufferMode)};var _glTransformFeedbackVaryings=_emscripten_glTransformFeedbackVaryings;var webglGetUniformLocation=location=>{var p=GLctx.currentProgram;if(p){var webglLoc=p.uniformLocsById[location];if(typeof webglLoc=="number"){p.uniformLocsById[location]=webglLoc=GLctx.getUniformLocation(p,p.uniformArrayNamesById[location]+(webglLoc>0?`[${webglLoc}]`:""))}return webglLoc}else{GL.recordError(1282)}};var _emscripten_glUniform1f=(location,v0)=>{GLctx.uniform1f(webglGetUniformLocation(location),v0)};var _glUniform1f=_emscripten_glUniform1f;var _emscripten_glUniform1i=(location,v0)=>{GLctx.uniform1i(webglGetUniformLocation(location),v0)};var _glUniform1i=_emscripten_glUniform1i;var miniTempWebGLIntBuffers=[];var _emscripten_glUniform1iv=(location,count,value)=>{if(GL.currentContext.version>=2){count&&GLctx.uniform1iv(webglGetUniformLocation(location),HEAP32,value>>2,count);return}if(count<=288){var view=miniTempWebGLIntBuffers[count];for(var i=0;i<count;++i){view[i]=HEAP32[value+4*i>>2]}}else{var view=HEAP32.subarray(value>>2,value+count*4>>2)}GLctx.uniform1iv(webglGetUniformLocation(location),view)};var _glUniform1iv=_emscripten_glUniform1iv;var _emscripten_glUniform1ui=(location,v0)=>{GLctx.uniform1ui(webglGetUniformLocation(location),v0)};var _glUniform1ui=_emscripten_glUniform1ui;var _emscripten_glUniform1uiv=(location,count,value)=>{count&&GLctx.uniform1uiv(webglGetUniformLocation(location),HEAPU32,value>>2,count)};var _glUniform1uiv=_emscripten_glUniform1uiv;var _emscripten_glUniform2f=(location,v0,v1)=>{GLctx.uniform2f(webglGetUniformLocation(location),v0,v1)};var _glUniform2f=_emscripten_glUniform2f;var miniTempWebGLFloatBuffers=[];var _emscripten_glUniform2fv=(location,count,value)=>{if(GL.currentContext.version>=2){count&&GLctx.uniform2fv(webglGetUniformLocation(location),HEAPF32,value>>2,count*2);return}if(count<=144){count*=2;var view=miniTempWebGLFloatBuffers[count];for(var i=0;i<count;i+=2){view[i]=HEAPF32[value+4*i>>2];view[i+1]=HEAPF32[value+(4*i+4)>>2]}}else{var view=HEAPF32.subarray(value>>2,value+count*8>>2)}GLctx.uniform2fv(webglGetUniformLocation(location),view)};var _glUniform2fv=_emscripten_glUniform2fv;var _emscripten_glUniform2iv=(location,count,value)=>{if(GL.currentContext.version>=2){count&&GLctx.uniform2iv(webglGetUniformLocation(location),HEAP32,value>>2,count*2);return}if(count<=144){count*=2;var view=miniTempWebGLIntBuffers[count];for(var i=0;i<count;i+=2){view[i]=HEAP32[value+4*i>>2];view[i+1]=HEAP32[value+(4*i+4)>>2]}}else{var view=HEAP32.subarray(value>>2,value+count*8>>2)}GLctx.uniform2iv(webglGetUniformLocation(location),view)};var _glUniform2iv=_emscripten_glUniform2iv;var _emscripten_glUniform3fv=(location,count,value)=>{if(GL.currentContext.version>=2){count&&GLctx.uniform3fv(webglGetUniformLocation(location),HEAPF32,value>>2,count*3);return}if(count<=96){count*=3;var view=miniTempWebGLFloatBuffers[count];for(var i=0;i<count;i+=3){view[i]=HEAPF32[value+4*i>>2];view[i+1]=HEAPF32[value+(4*i+4)>>2];view[i+2]=HEAPF32[value+(4*i+8)>>2]}}else{var view=HEAPF32.subarray(value>>2,value+count*12>>2)}GLctx.uniform3fv(webglGetUniformLocation(location),view)};var _glUniform3fv=_emscripten_glUniform3fv;var _emscripten_glUniform4f=(location,v0,v1,v2,v3)=>{GLctx.uniform4f(webglGetUniformLocation(location),v0,v1,v2,v3)};var _glUniform4f=_emscripten_glUniform4f;var _emscripten_glUniform4fv=(location,count,value)=>{if(GL.currentContext.version>=2){count&&GLctx.uniform4fv(webglGetUniformLocation(location),HEAPF32,value>>2,count*4);return}if(count<=72){var view=miniTempWebGLFloatBuffers[4*count];var heap=HEAPF32;value=value>>2;count*=4;for(var i=0;i<count;i+=4){var dst=value+i;view[i]=heap[dst];view[i+1]=heap[dst+1];view[i+2]=heap[dst+2];view[i+3]=heap[dst+3]}}else{var view=HEAPF32.subarray(value>>2,value+count*16>>2)}GLctx.uniform4fv(webglGetUniformLocation(location),view)};var _glUniform4fv=_emscripten_glUniform4fv;var _emscripten_glUniformBlockBinding=(program,uniformBlockIndex,uniformBlockBinding)=>{program=GL.programs[program];GLctx.uniformBlockBinding(program,uniformBlockIndex,uniformBlockBinding)};var _glUniformBlockBinding=_emscripten_glUniformBlockBinding;var _emscripten_glUniformMatrix3fv=(location,count,transpose,value)=>{if(GL.currentContext.version>=2){count&&GLctx.uniformMatrix3fv(webglGetUniformLocation(location),!!transpose,HEAPF32,value>>2,count*9);return}if(count<=32){count*=9;var view=miniTempWebGLFloatBuffers[count];for(var i=0;i<count;i+=9){view[i]=HEAPF32[value+4*i>>2];view[i+1]=HEAPF32[value+(4*i+4)>>2];view[i+2]=HEAPF32[value+(4*i+8)>>2];view[i+3]=HEAPF32[value+(4*i+12)>>2];view[i+4]=HEAPF32[value+(4*i+16)>>2];view[i+5]=HEAPF32[value+(4*i+20)>>2];view[i+6]=HEAPF32[value+(4*i+24)>>2];view[i+7]=HEAPF32[value+(4*i+28)>>2];view[i+8]=HEAPF32[value+(4*i+32)>>2]}}else{var view=HEAPF32.subarray(value>>2,value+count*36>>2)}GLctx.uniformMatrix3fv(webglGetUniformLocation(location),!!transpose,view)};var _glUniformMatrix3fv=_emscripten_glUniformMatrix3fv;var _emscripten_glUniformMatrix4fv=(location,count,transpose,value)=>{if(GL.currentContext.version>=2){count&&GLctx.uniformMatrix4fv(webglGetUniformLocation(location),!!transpose,HEAPF32,value>>2,count*16);return}if(count<=18){var view=miniTempWebGLFloatBuffers[16*count];var heap=HEAPF32;value=value>>2;count*=16;for(var i=0;i<count;i+=16){var dst=value+i;view[i]=heap[dst];view[i+1]=heap[dst+1];view[i+2]=heap[dst+2];view[i+3]=heap[dst+3];view[i+4]=heap[dst+4];view[i+5]=heap[dst+5];view[i+6]=heap[dst+6];view[i+7]=heap[dst+7];view[i+8]=heap[dst+8];view[i+9]=heap[dst+9];view[i+10]=heap[dst+10];view[i+11]=heap[dst+11];view[i+12]=heap[dst+12];view[i+13]=heap[dst+13];view[i+14]=heap[dst+14];view[i+15]=heap[dst+15]}}else{var view=HEAPF32.subarray(value>>2,value+count*64>>2)}GLctx.uniformMatrix4fv(webglGetUniformLocation(location),!!transpose,view)};var _glUniformMatrix4fv=_emscripten_glUniformMatrix4fv;var _emscripten_glUseProgram=program=>{program=GL.programs[program];GLctx.useProgram(program);GLctx.currentProgram=program};var _glUseProgram=_emscripten_glUseProgram;var _emscripten_glVertexAttrib4f=(x0,x1,x2,x3,x4)=>GLctx.vertexAttrib4f(x0,x1,x2,x3,x4);var _glVertexAttrib4f=_emscripten_glVertexAttrib4f;var _emscripten_glVertexAttribDivisor=(index,divisor)=>{GLctx.vertexAttribDivisor(index,divisor)};var _glVertexAttribDivisor=_emscripten_glVertexAttribDivisor;var _emscripten_glVertexAttribI4ui=(x0,x1,x2,x3,x4)=>GLctx.vertexAttribI4ui(x0,x1,x2,x3,x4);var _glVertexAttribI4ui=_emscripten_glVertexAttribI4ui;var _emscripten_glVertexAttribIPointer=(index,size,type,stride,ptr)=>{GLctx.vertexAttribIPointer(index,size,type,stride,ptr)};var _glVertexAttribIPointer=_emscripten_glVertexAttribIPointer;var _emscripten_glVertexAttribPointer=(index,size,type,normalized,stride,ptr)=>{GLctx.vertexAttribPointer(index,size,type,!!normalized,stride,ptr)};var _glVertexAttribPointer=_emscripten_glVertexAttribPointer;var _emscripten_glViewport=(x0,x1,x2,x3)=>GLctx.viewport(x0,x1,x2,x3);var _glViewport=_emscripten_glViewport;var GodotRuntime={get_func:function(ptr){return wasmTable.get(ptr)},error:function(){err.apply(null,Array.from(arguments))},print:function(){out.apply(null,Array.from(arguments))},malloc:function(p_size){return _malloc(p_size)},free:function(p_ptr){_free(p_ptr)},getHeapValue:function(p_ptr,p_type){return getValue(p_ptr,p_type)},setHeapValue:function(p_ptr,p_value,p_type){setValue(p_ptr,p_value,p_type)},heapSub:function(p_heap,p_ptr,p_len){const bytes=p_heap.BYTES_PER_ELEMENT;return p_heap.subarray(p_ptr/bytes,p_ptr/bytes+p_len)},heapSlice:function(p_heap,p_ptr,p_len){const bytes=p_heap.BYTES_PER_ELEMENT;return p_heap.slice(p_ptr/bytes,p_ptr/bytes+p_len)},heapCopy:function(p_dst,p_src,p_ptr){const bytes=p_src.BYTES_PER_ELEMENT;return p_dst.set(p_src,p_ptr/bytes)},parseString:function(p_ptr){return UTF8ToString(p_ptr)},parseStringArray:function(p_ptr,p_size){const strings=[];const ptrs=GodotRuntime.heapSub(HEAP32,p_ptr,p_size);ptrs.forEach(function(ptr){strings.push(GodotRuntime.parseString(ptr))});return strings},strlen:function(p_str){return lengthBytesUTF8(p_str)},allocString:function(p_str){const length=GodotRuntime.strlen(p_str)+1;const c_str=GodotRuntime.malloc(length);stringToUTF8(p_str,c_str,length);return c_str},allocStringArray:function(p_strings){const size=p_strings.length;const c_ptr=GodotRuntime.malloc(size*4);for(let i=0;i<size;i++){HEAP32[(c_ptr>>2)+i]=GodotRuntime.allocString(p_strings[i])}return c_ptr},freeStringArray:function(p_ptr,p_len){for(let i=0;i<p_len;i++){GodotRuntime.free(HEAP32[(p_ptr>>2)+i])}GodotRuntime.free(p_ptr)},stringToHeap:function(p_str,p_ptr,p_len){return stringToUTF8Array(p_str,HEAP8,p_ptr,p_len)}};var GodotConfig={canvas:null,locale:"en",canvas_resize_policy:2,virtual_keyboard:false,persistent_drops:false,godot_pool_size:4,on_execute:null,on_exit:null,init_config:function(p_opts){GodotConfig.canvas_resize_policy=p_opts["canvasResizePolicy"];GodotConfig.canvas=p_opts["canvas"];GodotConfig.locale=p_opts["locale"]||GodotConfig.locale;GodotConfig.virtual_keyboard=p_opts["virtualKeyboard"];GodotConfig.persistent_drops=!!p_opts["persistentDrops"];GodotConfig.godot_pool_size=p_opts["godotPoolSize"];GodotConfig.on_execute=p_opts["onExecute"];GodotConfig.on_exit=p_opts["onExit"];if(p_opts["focusCanvas"]){GodotConfig.canvas.focus()}},locate_file:function(file){return Module["locateFile"](file)},clear:function(){GodotConfig.canvas=null;GodotConfig.locale="en";GodotConfig.canvas_resize_policy=2;GodotConfig.virtual_keyboard=false;GodotConfig.persistent_drops=false;GodotConfig.on_execute=null;GodotConfig.on_exit=null}};var GodotFS={ENOENT:44,_idbfs:false,_syncing:false,_mount_points:[],is_persistent:function(){return GodotFS._idbfs?1:0},init:function(persistentPaths){GodotFS._idbfs=false;if(!Array.isArray(persistentPaths)){return Promise.reject(new Error("Persistent paths must be an array"))}if(!persistentPaths.length){return Promise.resolve()}GodotFS._mount_points=persistentPaths.slice();function createRecursive(dir){try{FS.stat(dir)}catch(e){if(e.errno!==GodotFS.ENOENT){GodotRuntime.error(e)}FS.mkdirTree(dir)}}GodotFS._mount_points.forEach(function(path){createRecursive(path);FS.mount(IDBFS,{},path)});return new Promise(function(resolve,reject){FS.syncfs(true,function(err){if(err){GodotFS._mount_points=[];GodotFS._idbfs=false;GodotRuntime.print(`IndexedDB not available: ${err.message}`)}else{GodotFS._idbfs=true}resolve(err)})})},deinit:function(){GodotFS._mount_points.forEach(function(path){try{FS.unmount(path)}catch(e){GodotRuntime.print("Already unmounted",e)}if(GodotFS._idbfs&&IDBFS.dbs[path]){IDBFS.dbs[path].close();delete IDBFS.dbs[path]}});GodotFS._mount_points=[];GodotFS._idbfs=false;GodotFS._syncing=false},sync:function(){if(GodotFS._syncing){GodotRuntime.error("Already syncing!");return Promise.resolve()}GodotFS._syncing=true;return new Promise(function(resolve,reject){FS.syncfs(false,function(error){if(error){GodotRuntime.error(`Failed to save IDB file system: ${error.message}`)}GodotFS._syncing=false;resolve(error)})})},copy_to_fs:function(path,buffer){const idx=path.lastIndexOf("/");let dir="/";if(idx>0){dir=path.slice(0,idx)}try{FS.stat(dir)}catch(e){if(e.errno!==GodotFS.ENOENT){GodotRuntime.error(e)}FS.mkdirTree(dir)}FS.writeFile(path,new Uint8Array(buffer))}};var GodotOS={request_quit:function(){},_async_cbs:[],_fs_sync_promise:null,atexit:function(p_promise_cb){GodotOS._async_cbs.push(p_promise_cb)},cleanup:function(exit_code){const cb=GodotConfig.on_exit;GodotFS.deinit();GodotConfig.clear();if(cb){cb(exit_code)}},finish_async:function(callback){GodotOS._fs_sync_promise.then(function(err){const promises=[];GodotOS._async_cbs.forEach(function(cb){promises.push(new Promise(cb))});return Promise.all(promises)}).then(function(){return GodotFS.sync()}).then(function(err){setTimeout(function(){callback()},0)})}};var GodotAudio={MAX_VOLUME_CHANNELS:8,GodotChannel:{CHANNEL_L:0,CHANNEL_R:1,CHANNEL_C:3,CHANNEL_LFE:4,CHANNEL_RL:5,CHANNEL_RR:6,CHANNEL_SL:7,CHANNEL_SR:8},WebChannel:{CHANNEL_L:0,CHANNEL_R:1,CHANNEL_SL:2,CHANNEL_SR:3,CHANNEL_C:4,CHANNEL_LFE:5},samples:null,Sample:class Sample{static getSample(id){if(!GodotAudio.samples.has(id)){throw new ReferenceError(`Could not find sample "${id}"`)}return GodotAudio.samples.get(id)}static getSampleOrNull(id){return GodotAudio.samples.get(id)??null}static create(params,options={}){const sample=new GodotAudio.Sample(params,options);GodotAudio.samples.set(params.id,sample);return sample}static delete(id){GodotAudio.samples.delete(id)}constructor(params,options={}){this.id=params.id;this._audioBuffer=null;this.numberOfChannels=options.numberOfChannels??2;this.sampleRate=options.sampleRate??44100;this.loopMode=options.loopMode??"disabled";this.loopBegin=options.loopBegin??0;this.loopEnd=options.loopEnd??0;this.setAudioBuffer(params.audioBuffer)}getAudioBuffer(){return this._duplicateAudioBuffer()}setAudioBuffer(val){this._audioBuffer=val}clear(){this.setAudioBuffer(null);GodotAudio.Sample.delete(this.id)}_duplicateAudioBuffer(){if(this._audioBuffer==null){throw new Error("couldn't duplicate a null audioBuffer")}const channels=new Array(this._audioBuffer.numberOfChannels);for(let i=0;i<this._audioBuffer.numberOfChannels;i++){const channel=new Float32Array(this._audioBuffer.getChannelData(i));channels[i]=channel}const buffer=GodotAudio.ctx.createBuffer(this.numberOfChannels,this._audioBuffer.length,this._audioBuffer.sampleRate);for(let i=0;i<channels.length;i++){buffer.copyToChannel(channels[i],i,0)}return buffer}},SampleNodeBus:class SampleNodeBus{static create(bus){return new GodotAudio.SampleNodeBus(bus)}constructor(bus){const NUMBER_OF_WEB_CHANNELS=6;this._bus=bus;this._channelSplitter=GodotAudio.ctx.createChannelSplitter(NUMBER_OF_WEB_CHANNELS);this._l=GodotAudio.ctx.createGain();this._r=GodotAudio.ctx.createGain();this._sl=GodotAudio.ctx.createGain();this._sr=GodotAudio.ctx.createGain();this._c=GodotAudio.ctx.createGain();this._lfe=GodotAudio.ctx.createGain();this._channelMerger=GodotAudio.ctx.createChannelMerger(NUMBER_OF_WEB_CHANNELS);this._channelSplitter.connect(this._l,GodotAudio.WebChannel.CHANNEL_L).connect(this._channelMerger,GodotAudio.WebChannel.CHANNEL_L,GodotAudio.WebChannel.CHANNEL_L);this._channelSplitter.connect(this._r,GodotAudio.WebChannel.CHANNEL_R).connect(this._channelMerger,GodotAudio.WebChannel.CHANNEL_L,GodotAudio.WebChannel.CHANNEL_R);this._channelSplitter.connect(this._sl,GodotAudio.WebChannel.CHANNEL_SL).connect(this._channelMerger,GodotAudio.WebChannel.CHANNEL_L,GodotAudio.WebChannel.CHANNEL_SL);this._channelSplitter.connect(this._sr,GodotAudio.WebChannel.CHANNEL_SR).connect(this._channelMerger,GodotAudio.WebChannel.CHANNEL_L,GodotAudio.WebChannel.CHANNEL_SR);this._channelSplitter.connect(this._c,GodotAudio.WebChannel.CHANNEL_C).connect(this._channelMerger,GodotAudio.WebChannel.CHANNEL_L,GodotAudio.WebChannel.CHANNEL_C);this._channelSplitter.connect(this._lfe,GodotAudio.WebChannel.CHANNEL_L).connect(this._channelMerger,GodotAudio.WebChannel.CHANNEL_L,GodotAudio.WebChannel.CHANNEL_LFE);this._channelMerger.connect(this._bus.getInputNode())}getInputNode(){return this._channelSplitter}getOutputNode(){return this._channelMerger}setVolume(volume){if(volume.length!==GodotAudio.MAX_VOLUME_CHANNELS){throw new Error(`Volume length isn't "${GodotAudio.MAX_VOLUME_CHANNELS}", is ${volume.length} instead`)}this._l.gain.value=volume[GodotAudio.GodotChannel.CHANNEL_L]??0;this._r.gain.value=volume[GodotAudio.GodotChannel.CHANNEL_R]??0;this._sl.gain.value=volume[GodotAudio.GodotChannel.CHANNEL_SL]??0;this._sr.gain.value=volume[GodotAudio.GodotChannel.CHANNEL_SR]??0;this._c.gain.value=volume[GodotAudio.GodotChannel.CHANNEL_C]??0;this._lfe.gain.value=volume[GodotAudio.GodotChannel.CHANNEL_LFE]??0}clear(){this._bus=null;this._channelSplitter.disconnect();this._channelSplitter=null;this._l.disconnect();this._l=null;this._r.disconnect();this._r=null;this._sl.disconnect();this._sl=null;this._sr.disconnect();this._sr=null;this._c.disconnect();this._c=null;this._lfe.disconnect();this._lfe=null;this._channelMerger.disconnect();this._channelMerger=null}},sampleNodes:null,SampleNode:class SampleNode{static getSampleNode(id){if(!GodotAudio.sampleNodes.has(id)){throw new ReferenceError(`Could not find sample node "${id}"`)}return GodotAudio.sampleNodes.get(id)}static getSampleNodeOrNull(id){return GodotAudio.sampleNodes.get(id)??null}static stopSampleNode(id){const sampleNode=GodotAudio.SampleNode.getSampleNodeOrNull(id);if(sampleNode==null){return}sampleNode.stop()}static pauseSampleNode(id,enable){const sampleNode=GodotAudio.SampleNode.getSampleNodeOrNull(id);if(sampleNode==null){return}sampleNode.pause(enable)}static create(params,options={}){const sampleNode=new GodotAudio.SampleNode(params,options);GodotAudio.sampleNodes.set(params.id,sampleNode);return sampleNode}static delete(id){GodotAudio.deleteSampleNode(id)}constructor(params,options={}){this.id=params.id;this.streamObjectId=params.streamObjectId;this.offset=options.offset??0;this._playbackPosition=options.offset;this.startTime=options.startTime??0;this.isPaused=false;this.isStarted=false;this.isCanceled=false;this.pauseTime=0;this._playbackRate=44100;this.loopMode=options.loopMode??this.getSample().loopMode??"disabled";this._pitchScale=options.pitchScale??1;this._sourceStartTime=0;this._sampleNodeBuses=new Map;this._source=GodotAudio.ctx.createBufferSource();this._onended=null;this._positionWorklet=null;this.setPlaybackRate(options.playbackRate??44100);this._source.buffer=this.getSample().getAudioBuffer();this._addEndedListener();const bus=GodotAudio.Bus.getBus(params.busIndex);const sampleNodeBus=this.getSampleNodeBus(bus);sampleNodeBus.setVolume(options.volume);this.connectPositionWorklet(options.start).catch(err=>{const newErr=new Error("Failed to create PositionWorklet.");newErr.cause=err;GodotRuntime.error(newErr)})}getPlaybackRate(){return this._playbackRate}getPlaybackPosition(){return this._playbackPosition}setPlaybackRate(val){this._playbackRate=val;this._syncPlaybackRate()}getPitchScale(){return this._pitchScale}setPitchScale(val){this._pitchScale=val;this._syncPlaybackRate()}getSample(){return GodotAudio.Sample.getSample(this.streamObjectId)}getOutputNode(){return this._source}start(){if(this.isStarted){return}this._resetSourceStartTime();this._source.start(this.startTime,this.offset);this.isStarted=true}stop(){this.clear()}restart(){this.isPaused=false;this.pauseTime=0;this._resetSourceStartTime();this._restart()}pause(enable=true){if(enable){this._pause();return}this._unpause()}connect(node){return this.getOutputNode().connect(node)}setVolumes(buses,volumes){for(let busIdx=0;busIdx<buses.length;busIdx++){const sampleNodeBus=this.getSampleNodeBus(buses[busIdx]);sampleNodeBus.setVolume(volumes.slice(busIdx*GodotAudio.MAX_VOLUME_CHANNELS,busIdx*GodotAudio.MAX_VOLUME_CHANNELS+GodotAudio.MAX_VOLUME_CHANNELS))}}getSampleNodeBus(bus){if(!this._sampleNodeBuses.has(bus)){const sampleNodeBus=GodotAudio.SampleNodeBus.create(bus);this._sampleNodeBuses.set(bus,sampleNodeBus);this._source.connect(sampleNodeBus.getInputNode())}return this._sampleNodeBuses.get(bus)}async connectPositionWorklet(start){await GodotAudio.audioPositionWorkletPromise;if(this.isCanceled){return}this._source.connect(this.getPositionWorklet());if(start){this.start()}}getPositionWorklet(){if(this._positionWorklet!=null){return this._positionWorklet}if(GodotAudio.audioPositionWorkletNodes.length>0){this._positionWorklet=GodotAudio.audioPositionWorkletNodes.pop()}else{this._positionWorklet=new AudioWorkletNode(GodotAudio.ctx,"godot-position-reporting-processor")}this._playbackPosition=this.offset;this._positionWorklet.port.onmessage=event=>{switch(event.data["type"]){case"position":this._playbackPosition=parseInt(event.data.data,10)/this.getSample().sampleRate+this.offset;break;default:}};const resetParameter=this._positionWorklet.parameters.get("reset");resetParameter.setValueAtTime(1,GodotAudio.ctx.currentTime);resetParameter.setValueAtTime(0,GodotAudio.ctx.currentTime+1);return this._positionWorklet}clear(){this.isCanceled=true;this.isPaused=false;this.pauseTime=0;if(this._source!=null){this._source.removeEventListener("ended",this._onended);this._onended=null;if(this.isStarted){this._source.stop()}this._source.disconnect();this._source=null}for(const sampleNodeBus of this._sampleNodeBuses.values()){sampleNodeBus.clear()}this._sampleNodeBuses.clear();if(this._positionWorklet){this._positionWorklet.disconnect();this._positionWorklet.port.onmessage=null;GodotAudio.audioPositionWorkletNodes.push(this._positionWorklet);this._positionWorklet=null}GodotAudio.SampleNode.delete(this.id)}_resetSourceStartTime(){this._sourceStartTime=GodotAudio.ctx.currentTime}_syncPlaybackRate(){this._source.playbackRate.value=this.getPlaybackRate()*this.getPitchScale()}_restart(){if(this._source!=null){this._source.disconnect()}this._source=GodotAudio.ctx.createBufferSource();this._source.buffer=this.getSample().getAudioBuffer();for(const sampleNodeBus of this._sampleNodeBuses.values()){this.connect(sampleNodeBus.getInputNode())}this._addEndedListener();const pauseTime=this.isPaused?this.pauseTime:0;if(this._positionWorklet!=null){this._positionWorklet.port.postMessage({type:"clear"});this._source.connect(this._positionWorklet)}this._source.start(this.startTime,this.offset+pauseTime);this.isStarted=true}_pause(){if(!this.isStarted){return}this.isPaused=true;this.pauseTime=(GodotAudio.ctx.currentTime-this._sourceStartTime)/this.getPlaybackRate();this._source.stop()}_unpause(){this._restart();this.isPaused=false;this.pauseTime=0}_addEndedListener(){if(this._onended!=null){this._source.removeEventListener("ended",this._onended)}const self=this;this._onended=_=>{if(self.isPaused){return}switch(self.getSample().loopMode){case"disabled":self.stop();break;case"forward":case"backward":self.restart();break;default:}};this._source.addEventListener("ended",this._onended)}},deleteSampleNode:pSampleNodeId=>{GodotAudio.sampleNodes.delete(pSampleNodeId);if(GodotAudio.sampleFinishedCallback==null){return}const sampleNodeIdPtr=GodotRuntime.allocString(pSampleNodeId);GodotAudio.sampleFinishedCallback(sampleNodeIdPtr);GodotRuntime.free(sampleNodeIdPtr)},buses:null,busSolo:null,Bus:class Bus{static getCount(){return GodotAudio.buses.length}static setCount(val){const buses=GodotAudio.buses;if(val===buses.length){return}if(val<buses.length){const deletedBuses=buses.slice(val);for(let i=0;i<deletedBuses.length;i++){const deletedBus=deletedBuses[i];deletedBus.clear()}GodotAudio.buses=buses.slice(0,val);return}for(let i=GodotAudio.buses.length;i<val;i++){GodotAudio.Bus.create()}}static getBus(index){if(index<0||index>=GodotAudio.buses.length){throw new ReferenceError(`invalid bus index "${index}"`)}return GodotAudio.buses[index]}static getBusOrNull(index){if(index<0||index>=GodotAudio.buses.length){return null}return GodotAudio.buses[index]}static move(fromIndex,toIndex){const movedBus=GodotAudio.Bus.getBusOrNull(fromIndex);if(movedBus==null){return}const buses=GodotAudio.buses.filter((_,i)=>i!==fromIndex);buses.splice(toIndex-1,0,movedBus);GodotAudio.buses=buses}static addAt(index){const newBus=GodotAudio.Bus.create();if(index!==newBus.getId()){GodotAudio.Bus.move(newBus.getId(),index)}}static create(){const newBus=new GodotAudio.Bus;const isFirstBus=GodotAudio.buses.length===0;GodotAudio.buses.push(newBus);if(isFirstBus){newBus.setSend(null)}else{newBus.setSend(GodotAudio.Bus.getBus(0))}return newBus}constructor(){this._sampleNodes=new Set;this.isSolo=false;this._send=null;this._gainNode=GodotAudio.ctx.createGain();this._soloNode=GodotAudio.ctx.createGain();this._muteNode=GodotAudio.ctx.createGain();this._gainNode.connect(this._soloNode).connect(this._muteNode)}getId(){return GodotAudio.buses.indexOf(this)}getVolumeDb(){return GodotAudio.linear_to_db(this._gainNode.gain.value)}setVolumeDb(val){const linear=GodotAudio.db_to_linear(val);if(isFinite(linear)){this._gainNode.gain.value=linear}}getSend(){return this._send}setSend(val){this._send=val;if(val==null){if(this.getId()==0){this.getOutputNode().connect(GodotAudio.ctx.destination);return}throw new Error(`Cannot send to "${val}" without the bus being at index 0 (current index: ${this.getId()})`)}this.connect(val)}getInputNode(){return this._gainNode}getOutputNode(){return this._muteNode}mute(enable){this._muteNode.gain.value=enable?0:1}solo(enable){if(this.isSolo===enable){return}if(enable){if(GodotAudio.busSolo!=null&&GodotAudio.busSolo!==this){GodotAudio.busSolo._disableSolo()}this._enableSolo();return}this._disableSolo()}addSampleNode(sampleNode){this._sampleNodes.add(sampleNode);sampleNode.getOutputNode().connect(this.getInputNode())}removeSampleNode(sampleNode){this._sampleNodes.delete(sampleNode);sampleNode.getOutputNode().disconnect()}connect(bus){if(bus==null){throw new Error("cannot connect to null bus")}this.getOutputNode().disconnect();this.getOutputNode().connect(bus.getInputNode());return bus}clear(){GodotAudio.buses=GodotAudio.buses.filter(v=>v!==this)}_syncSampleNodes(){const sampleNodes=Array.from(this._sampleNodes);for(let i=0;i<sampleNodes.length;i++){const sampleNode=sampleNodes[i];sampleNode.getOutputNode().disconnect();sampleNode.getOutputNode().connect(this.getInputNode())}}_enableSolo(){this.isSolo=true;GodotAudio.busSolo=this;this._soloNode.gain.value=1;const otherBuses=GodotAudio.buses.filter(otherBus=>otherBus!==this);for(let i=0;i<otherBuses.length;i++){const otherBus=otherBuses[i];otherBus._soloNode.gain.value=0}}_disableSolo(){this.isSolo=false;GodotAudio.busSolo=null;this._soloNode.gain.value=1;const otherBuses=GodotAudio.buses.filter(otherBus=>otherBus!==this);for(let i=0;i<otherBuses.length;i++){const otherBus=otherBuses[i];otherBus._soloNode.gain.value=1}}},sampleFinishedCallback:null,ctx:null,input:null,driver:null,interval:0,audioPositionWorkletPromise:null,audioPositionWorkletNodes:null,linear_to_db:function(linear){return Math.log(linear)*8.685889638065037},db_to_linear:function(db){return Math.exp(db*.11512925464970228)},init:function(mix_rate,latency,onstatechange,onlatencyupdate){GodotAudio.samples=new Map;GodotAudio.sampleNodes=new Map;GodotAudio.buses=[];GodotAudio.busSolo=null;GodotAudio.audioPositionWorkletNodes=[];const opts={};if(mix_rate){GodotAudio.sampleRate=mix_rate;opts["sampleRate"]=mix_rate}const ctx=new(window.AudioContext||window.webkitAudioContext)(opts);GodotAudio.ctx=ctx;ctx.onstatechange=function(){let state=0;switch(ctx.state){case"suspended":state=0;break;case"running":state=1;break;case"closed":state=2;break;default:}onstatechange(state)};ctx.onstatechange();GodotAudio.interval=setInterval(function(){let computed_latency=0;if(ctx.baseLatency){computed_latency+=GodotAudio.ctx.baseLatency}if(ctx.outputLatency){computed_latency+=GodotAudio.ctx.outputLatency}onlatencyupdate(computed_latency)},1e3);GodotOS.atexit(GodotAudio.close_async);const path=GodotConfig.locate_file("godot.audio.position.worklet.js");GodotAudio.audioPositionWorkletPromise=ctx.audioWorklet.addModule(path);return ctx.destination.channelCount},create_input:function(callback){if(GodotAudio.input){return 0}function gotMediaInput(stream){try{GodotAudio.input=GodotAudio.ctx.createMediaStreamSource(stream);callback(GodotAudio.input)}catch(e){GodotRuntime.error("Failed creating input.",e)}}if(navigator.mediaDevices&&navigator.mediaDevices.getUserMedia){navigator.mediaDevices.getUserMedia({audio:true}).then(gotMediaInput,function(e){GodotRuntime.error("Error getting user media.",e)})}else{if(!navigator.getUserMedia){navigator.getUserMedia=navigator.webkitGetUserMedia||navigator.mozGetUserMedia}if(!navigator.getUserMedia){GodotRuntime.error("getUserMedia not available.");return 1}navigator.getUserMedia({audio:true},gotMediaInput,function(e){GodotRuntime.print(e)})}return 0},close_async:function(resolve,reject){const ctx=GodotAudio.ctx;GodotAudio.ctx=null;if(!ctx){resolve();return}if(GodotAudio.interval){clearInterval(GodotAudio.interval);GodotAudio.interval=0}if(GodotAudio.input){GodotAudio.input.disconnect();GodotAudio.input=null}let closed=Promise.resolve();if(GodotAudio.driver){closed=GodotAudio.driver.close()}closed.then(function(){return ctx.close()}).then(function(){ctx.onstatechange=null;resolve()}).catch(function(e){ctx.onstatechange=null;GodotRuntime.error("Error closing AudioContext",e);resolve()})},start_sample:function(playbackObjectId,streamObjectId,busIndex,startOptions){GodotAudio.SampleNode.stopSampleNode(playbackObjectId);GodotAudio.SampleNode.create({busIndex,id:playbackObjectId,streamObjectId},startOptions)},stop_sample:function(playbackObjectId){GodotAudio.SampleNode.stopSampleNode(playbackObjectId)},sample_set_pause:function(playbackObjectId,pause){GodotAudio.SampleNode.pauseSampleNode(playbackObjectId,pause)},update_sample_pitch_scale:function(playbackObjectId,pitchScale){const sampleNode=GodotAudio.SampleNode.getSampleNodeOrNull(playbackObjectId);if(sampleNode==null){return}sampleNode.setPitchScale(pitchScale)},sample_set_volumes_linear:function(playbackObjectId,busIndexes,volumes){const sampleNode=GodotAudio.SampleNode.getSampleNodeOrNull(playbackObjectId);if(sampleNode==null){return}const buses=busIndexes.map(busIndex=>GodotAudio.Bus.getBus(busIndex));sampleNode.setVolumes(buses,volumes)},set_sample_bus_count:function(count){GodotAudio.Bus.setCount(count)},remove_sample_bus:function(index){const bus=GodotAudio.Bus.getBusOrNull(index);if(bus==null){return}bus.clear()},add_sample_bus:function(atPos){GodotAudio.Bus.addAt(atPos)},move_sample_bus:function(busIndex,toPos){GodotAudio.Bus.move(busIndex,toPos)},set_sample_bus_send:function(busIndex,sendIndex){const bus=GodotAudio.Bus.getBusOrNull(busIndex);if(bus==null){return}let targetBus=GodotAudio.Bus.getBusOrNull(sendIndex);if(targetBus==null){targetBus=GodotAudio.Bus.getBus(0)}bus.setSend(targetBus)},set_sample_bus_volume_db:function(busIndex,volumeDb){const bus=GodotAudio.Bus.getBusOrNull(busIndex);if(bus==null){return}bus.setVolumeDb(volumeDb)},set_sample_bus_solo:function(busIndex,enable){const bus=GodotAudio.Bus.getBusOrNull(busIndex);if(bus==null){return}bus.solo(enable)},set_sample_bus_mute:function(busIndex,enable){const bus=GodotAudio.Bus.getBusOrNull(busIndex);if(bus==null){return}bus.mute(enable)}};function _godot_audio_get_sample_playback_position(playbackObjectIdStrPtr){const playbackObjectId=GodotRuntime.parseString(playbackObjectIdStrPtr);const sampleNode=GodotAudio.SampleNode.getSampleNodeOrNull(playbackObjectId);if(sampleNode==null){return 0}return sampleNode.getPlaybackPosition()}function _godot_audio_has_script_processor(){return GodotAudio.ctx&&GodotAudio.ctx.createScriptProcessor?1:0}function _godot_audio_has_worklet(){return GodotAudio.ctx&&GodotAudio.ctx.audioWorklet?1:0}function _godot_audio_init(p_mix_rate,p_latency,p_state_change,p_latency_update){const statechange=GodotRuntime.get_func(p_state_change);const latencyupdate=GodotRuntime.get_func(p_latency_update);const mix_rate=GodotRuntime.getHeapValue(p_mix_rate,"i32");const channels=GodotAudio.init(mix_rate,p_latency,statechange,latencyupdate);GodotRuntime.setHeapValue(p_mix_rate,GodotAudio.ctx.sampleRate,"i32");return channels}function _godot_audio_input_start(){return GodotAudio.create_input(function(input){input.connect(GodotAudio.driver.get_node())})}function _godot_audio_input_stop(){if(GodotAudio.input){const tracks=GodotAudio.input["mediaStream"]["getTracks"]();for(let i=0;i<tracks.length;i++){tracks[i]["stop"]()}GodotAudio.input.disconnect();GodotAudio.input=null}}function _godot_audio_is_available(){if(!(window.AudioContext||window.webkitAudioContext)){return 0}return 1}function _godot_audio_resume(){if(GodotAudio.ctx&&GodotAudio.ctx.state!=="running"){GodotAudio.ctx.resume()}}function _godot_audio_sample_bus_add(atPos){GodotAudio.add_sample_bus(atPos)}function _godot_audio_sample_bus_move(fromPos,toPos){GodotAudio.move_sample_bus(fromPos,toPos)}function _godot_audio_sample_bus_remove(index){GodotAudio.remove_sample_bus(index)}function _godot_audio_sample_bus_set_count(count){GodotAudio.set_sample_bus_count(count)}function _godot_audio_sample_bus_set_mute(bus,enable){GodotAudio.set_sample_bus_mute(bus,Boolean(enable))}function _godot_audio_sample_bus_set_send(bus,sendIndex){GodotAudio.set_sample_bus_send(bus,sendIndex)}function _godot_audio_sample_bus_set_solo(bus,enable){GodotAudio.set_sample_bus_solo(bus,Boolean(enable))}function _godot_audio_sample_bus_set_volume_db(bus,volumeDb){GodotAudio.set_sample_bus_volume_db(bus,volumeDb)}function _godot_audio_sample_is_active(playbackObjectIdStrPtr){const playbackObjectId=GodotRuntime.parseString(playbackObjectIdStrPtr);return Number(GodotAudio.sampleNodes.has(playbackObjectId))}function _godot_audio_sample_register_stream(streamObjectIdStrPtr,framesPtr,framesTotal,loopModeStrPtr,loopBegin,loopEnd){const BYTES_PER_FLOAT32=4;const streamObjectId=GodotRuntime.parseString(streamObjectIdStrPtr);const loopMode=GodotRuntime.parseString(loopModeStrPtr);const numberOfChannels=2;const sampleRate=GodotAudio.ctx.sampleRate;const subLeft=GodotRuntime.heapSub(HEAPF32,framesPtr,framesTotal);const subRight=GodotRuntime.heapSub(HEAPF32,framesPtr+framesTotal*BYTES_PER_FLOAT32,framesTotal);const audioBuffer=GodotAudio.ctx.createBuffer(numberOfChannels,framesTotal,sampleRate);audioBuffer.copyToChannel(new Float32Array(subLeft),0,0);audioBuffer.copyToChannel(new Float32Array(subRight),1,0);GodotAudio.Sample.create({id:streamObjectId,audioBuffer},{loopBegin,loopEnd,loopMode,numberOfChannels,sampleRate})}function _godot_audio_sample_set_finished_callback(callbackPtr){GodotAudio.sampleFinishedCallback=GodotRuntime.get_func(callbackPtr)}function _godot_audio_sample_set_pause(playbackObjectIdStrPtr,pause){const playbackObjectId=GodotRuntime.parseString(playbackObjectIdStrPtr);GodotAudio.sample_set_pause(playbackObjectId,Boolean(pause))}function _godot_audio_sample_set_volumes_linear(playbackObjectIdStrPtr,busesPtr,busesSize,volumesPtr,volumesSize){const playbackObjectId=GodotRuntime.parseString(playbackObjectIdStrPtr);const buses=GodotRuntime.heapSub(HEAP32,busesPtr,busesSize);const volumes=GodotRuntime.heapSub(HEAPF32,volumesPtr,volumesSize);GodotAudio.sample_set_volumes_linear(playbackObjectId,Array.from(buses),volumes)}function _godot_audio_sample_start(playbackObjectIdStrPtr,streamObjectIdStrPtr,busIndex,offset,pitchScale,volumePtr){const playbackObjectId=GodotRuntime.parseString(playbackObjectIdStrPtr);const streamObjectId=GodotRuntime.parseString(streamObjectIdStrPtr);const volume=GodotRuntime.heapSub(HEAPF32,volumePtr,8);const startOptions={offset,volume,playbackRate:1,pitchScale,start:true};GodotAudio.start_sample(playbackObjectId,streamObjectId,busIndex,startOptions)}function _godot_audio_sample_stop(playbackObjectIdStrPtr){const playbackObjectId=GodotRuntime.parseString(playbackObjectIdStrPtr);GodotAudio.stop_sample(playbackObjectId)}function _godot_audio_sample_stream_is_registered(streamObjectIdStrPtr){const streamObjectId=GodotRuntime.parseString(streamObjectIdStrPtr);return Number(GodotAudio.Sample.getSampleOrNull(streamObjectId)!=null)}function _godot_audio_sample_unregister_stream(streamObjectIdStrPtr){const streamObjectId=GodotRuntime.parseString(streamObjectIdStrPtr);const sample=GodotAudio.Sample.getSampleOrNull(streamObjectId);if(sample!=null){sample.clear()}}function _godot_audio_sample_update_pitch_scale(playbackObjectIdStrPtr,pitchScale){const playbackObjectId=GodotRuntime.parseString(playbackObjectIdStrPtr);GodotAudio.update_sample_pitch_scale(playbackObjectId,pitchScale)}var GodotAudioScript={script:null,create:function(buffer_length,channel_count){GodotAudioScript.script=GodotAudio.ctx.createScriptProcessor(buffer_length,2,channel_count);GodotAudio.driver=GodotAudioScript;return GodotAudioScript.script.bufferSize},start:function(p_in_buf,p_in_size,p_out_buf,p_out_size,onprocess){GodotAudioScript.script.onaudioprocess=function(event){const inb=GodotRuntime.heapSub(HEAPF32,p_in_buf,p_in_size);const input=event.inputBuffer;if(GodotAudio.input){const inlen=input.getChannelData(0).length;for(let ch=0;ch<2;ch++){const data=input.getChannelData(ch);for(let s=0;s<inlen;s++){inb[s*2+ch]=data[s]}}}onprocess();const outb=GodotRuntime.heapSub(HEAPF32,p_out_buf,p_out_size);const output=event.outputBuffer;const channels=output.numberOfChannels;for(let ch=0;ch<channels;ch++){const data=output.getChannelData(ch);for(let sample=0;sample<data.length;sample++){data[sample]=outb[sample*channels+ch]}}};GodotAudioScript.script.connect(GodotAudio.ctx.destination)},get_node:function(){return GodotAudioScript.script},close:function(){return new Promise(function(resolve,reject){GodotAudioScript.script.disconnect();GodotAudioScript.script.onaudioprocess=null;GodotAudioScript.script=null;resolve()})}};function _godot_audio_script_create(buffer_length,channel_count){const buf_len=GodotRuntime.getHeapValue(buffer_length,"i32");try{const out_len=GodotAudioScript.create(buf_len,channel_count);GodotRuntime.setHeapValue(buffer_length,out_len,"i32")}catch(e){GodotRuntime.error("Error starting AudioDriverScriptProcessor",e);return 1}return 0}function _godot_audio_script_start(p_in_buf,p_in_size,p_out_buf,p_out_size,p_cb){const onprocess=GodotRuntime.get_func(p_cb);GodotAudioScript.start(p_in_buf,p_in_size,p_out_buf,p_out_size,onprocess)}var GodotAudioWorklet={promise:null,worklet:null,ring_buffer:null,create:function(channels){const path=GodotConfig.locate_file("godot.audio.worklet.js");GodotAudioWorklet.promise=GodotAudio.ctx.audioWorklet.addModule(path).then(function(){GodotAudioWorklet.worklet=new AudioWorkletNode(GodotAudio.ctx,"godot-processor",{outputChannelCount:[channels]});return Promise.resolve()});GodotAudio.driver=GodotAudioWorklet},start:function(in_buf,out_buf,state){GodotAudioWorklet.promise.then(function(){const node=GodotAudioWorklet.worklet;node.connect(GodotAudio.ctx.destination);node.port.postMessage({cmd:"start",data:[state,in_buf,out_buf]});node.port.onmessage=function(event){GodotRuntime.error(event.data)}})},start_no_threads:function(p_out_buf,p_out_size,out_callback,p_in_buf,p_in_size,in_callback){function RingBuffer(){let wpos=0;let rpos=0;let pending_samples=0;const wbuf=new Float32Array(p_out_size);function send(port){if(pending_samples===0){return}const buffer=GodotRuntime.heapSub(HEAPF32,p_out_buf,p_out_size);const size=buffer.length;const tot_sent=pending_samples;out_callback(wpos,pending_samples);if(wpos+pending_samples>=size){const high=size-wpos;wbuf.set(buffer.subarray(wpos,size));pending_samples-=high;wpos=0}if(pending_samples>0){wbuf.set(buffer.subarray(wpos,wpos+pending_samples),tot_sent-pending_samples)}port.postMessage({cmd:"chunk",data:wbuf.subarray(0,tot_sent)});wpos+=pending_samples;pending_samples=0}this.receive=function(recv_buf){const buffer=GodotRuntime.heapSub(HEAPF32,p_in_buf,p_in_size);const from=rpos;let to_write=recv_buf.length;let high=0;if(rpos+to_write>=p_in_size){high=p_in_size-rpos;buffer.set(recv_buf.subarray(0,high),rpos);to_write-=high;rpos=0}if(to_write){buffer.set(recv_buf.subarray(high,to_write),rpos)}in_callback(from,recv_buf.length);rpos+=to_write};this.consumed=function(size,port){pending_samples+=size;send(port)}}GodotAudioWorklet.ring_buffer=new RingBuffer;GodotAudioWorklet.promise.then(function(){const node=GodotAudioWorklet.worklet;const buffer=GodotRuntime.heapSlice(HEAPF32,p_out_buf,p_out_size);node.connect(GodotAudio.ctx.destination);node.port.postMessage({cmd:"start_nothreads",data:[buffer,p_in_size]});node.port.onmessage=function(event){if(!GodotAudioWorklet.worklet){return}if(event.data["cmd"]==="read"){const read=event.data["data"];GodotAudioWorklet.ring_buffer.consumed(read,GodotAudioWorklet.worklet.port)}else if(event.data["cmd"]==="input"){const buf=event.data["data"];if(buf.length>p_in_size){GodotRuntime.error("Input chunk is too big");return}GodotAudioWorklet.ring_buffer.receive(buf)}else{GodotRuntime.error(event.data)}}})},get_node:function(){return GodotAudioWorklet.worklet},close:function(){return new Promise(function(resolve,reject){if(GodotAudioWorklet.promise===null){return}const p=GodotAudioWorklet.promise;p.then(function(){GodotAudioWorklet.worklet.port.postMessage({cmd:"stop",data:null});GodotAudioWorklet.worklet.disconnect();GodotAudioWorklet.worklet.port.onmessage=null;GodotAudioWorklet.worklet=null;GodotAudioWorklet.promise=null;resolve()}).catch(function(err){GodotRuntime.error(err)})})}};function _godot_audio_worklet_create(channels){try{GodotAudioWorklet.create(channels)}catch(e){GodotRuntime.error("Error starting AudioDriverWorklet",e);return 1}return 0}function _godot_audio_worklet_start_no_threads(p_out_buf,p_out_size,p_out_callback,p_in_buf,p_in_size,p_in_callback){const out_callback=GodotRuntime.get_func(p_out_callback);const in_callback=GodotRuntime.get_func(p_in_callback);GodotAudioWorklet.start_no_threads(p_out_buf,p_out_size,out_callback,p_in_buf,p_in_size,in_callback)}function _godot_js_config_canvas_id_get(p_ptr,p_ptr_max){GodotRuntime.stringToHeap(`#${GodotConfig.canvas.id}`,p_ptr,p_ptr_max)}function _godot_js_config_locale_get(p_ptr,p_ptr_max){GodotRuntime.stringToHeap(GodotConfig.locale,p_ptr,p_ptr_max)}var GodotDisplayCursor={shape:"default",visible:true,cursors:{},set_style:function(style){GodotConfig.canvas.style.cursor=style},set_shape:function(shape){GodotDisplayCursor.shape=shape;let css=shape;if(shape in GodotDisplayCursor.cursors){const c=GodotDisplayCursor.cursors[shape];css=`url("${c.url}") ${c.x} ${c.y}, default`}if(GodotDisplayCursor.visible){GodotDisplayCursor.set_style(css)}},clear:function(){GodotDisplayCursor.set_style("");GodotDisplayCursor.shape="default";GodotDisplayCursor.visible=true;Object.keys(GodotDisplayCursor.cursors).forEach(function(key){URL.revokeObjectURL(GodotDisplayCursor.cursors[key]);delete GodotDisplayCursor.cursors[key]})},lockPointer:function(){const canvas=GodotConfig.canvas;if(canvas.requestPointerLock){canvas.requestPointerLock()}},releasePointer:function(){if(document.exitPointerLock){document.exitPointerLock()}},isPointerLocked:function(){return document.pointerLockElement===GodotConfig.canvas}};var GodotEventListeners={handlers:[],has:function(target,event,method,capture){return GodotEventListeners.handlers.findIndex(function(e){return e.target===target&&e.event===event&&e.method===method&&e.capture===capture})!==-1},add:function(target,event,method,capture){if(GodotEventListeners.has(target,event,method,capture)){return}function Handler(p_target,p_event,p_method,p_capture){this.target=p_target;this.event=p_event;this.method=p_method;this.capture=p_capture}GodotEventListeners.handlers.push(new Handler(target,event,method,capture));target.addEventListener(event,method,capture)},clear:function(){GodotEventListeners.handlers.forEach(function(h){h.target.removeEventListener(h.event,h.method,h.capture)});GodotEventListeners.handlers.length=0}};var _emscripten_webgl_do_get_current_context=()=>GL.currentContext?GL.currentContext.handle:0;var _emscripten_webgl_get_current_context=_emscripten_webgl_do_get_current_context;var GodotDisplayScreen={desired_size:[0,0],hidpi:true,getPixelRatio:function(){return GodotDisplayScreen.hidpi?window.devicePixelRatio||1:1},isFullscreen:function(){const elem=document.fullscreenElement||document.mozFullscreenElement||document.webkitFullscreenElement||document.msFullscreenElement;if(elem){return elem===GodotConfig.canvas}return document.fullscreen||document.mozFullScreen||document.webkitIsFullscreen},hasFullscreen:function(){return document.fullscreenEnabled||document.mozFullScreenEnabled||document.webkitFullscreenEnabled},requestFullscreen:function(){if(!GodotDisplayScreen.hasFullscreen()){return 1}const canvas=GodotConfig.canvas;try{const promise=(canvas.requestFullscreen||canvas.msRequestFullscreen||canvas.mozRequestFullScreen||canvas.mozRequestFullscreen||canvas.webkitRequestFullscreen).call(canvas);if(promise){promise.catch(function(){})}}catch(e){return 1}return 0},exitFullscreen:function(){if(!GodotDisplayScreen.isFullscreen()){return 0}try{const promise=document.exitFullscreen();if(promise){promise.catch(function(){})}}catch(e){return 1}return 0},_updateGL:function(){const gl_context_handle=_emscripten_webgl_get_current_context();const gl=GL.getContext(gl_context_handle);if(gl){GL.resizeOffscreenFramebuffer(gl)}},updateSize:function(){const isFullscreen=GodotDisplayScreen.isFullscreen();const wantsFullWindow=GodotConfig.canvas_resize_policy===2;const noResize=GodotConfig.canvas_resize_policy===0;const dWidth=GodotDisplayScreen.desired_size[0];const dHeight=GodotDisplayScreen.desired_size[1];const canvas=GodotConfig.canvas;let width=dWidth;let height=dHeight;if(noResize){if(canvas.width!==width||canvas.height!==height){GodotDisplayScreen.desired_size=[canvas.width,canvas.height];GodotDisplayScreen._updateGL();return 1}return 0}const scale=GodotDisplayScreen.getPixelRatio();if(isFullscreen||wantsFullWindow){width=Math.floor(window.innerWidth*scale);height=Math.floor(window.innerHeight*scale)}const csw=`${Math.floor(width/scale)}px`;const csh=`${Math.floor(height/scale)}px`;if(canvas.style.width!==csw||canvas.style.height!==csh||canvas.width!==width||canvas.height!==height){canvas.width=width;canvas.height=height;canvas.style.width=csw;canvas.style.height=csh;GodotDisplayScreen._updateGL();return 1}return 0}};var GodotInputGamepads={samples:[],get_pads:function(){try{const pads=navigator.getGamepads();if(pads){return pads}return[]}catch(e){return[]}},get_samples:function(){return GodotInputGamepads.samples},get_sample:function(index){const samples=GodotInputGamepads.samples;return index<samples.length?samples[index]:null},sample:function(){const pads=GodotInputGamepads.get_pads();const samples=[];for(let i=0;i<pads.length;i++){const pad=pads[i];if(!pad){samples.push(null);continue}const s={standard:pad.mapping==="standard",buttons:[],axes:[],connected:pad.connected};for(let b=0;b<pad.buttons.length;b++){s.buttons.push(pad.buttons[b].value)}for(let a=0;a<pad.axes.length;a++){s.axes.push(pad.axes[a])}samples.push(s)}GodotInputGamepads.samples=samples},init:function(onchange){GodotInputGamepads.samples=[];function add(pad){const guid=GodotInputGamepads.get_guid(pad);const c_id=GodotRuntime.allocString(pad.id);const c_guid=GodotRuntime.allocString(guid);onchange(pad.index,1,c_id,c_guid);GodotRuntime.free(c_id);GodotRuntime.free(c_guid)}const pads=GodotInputGamepads.get_pads();for(let i=0;i<pads.length;i++){if(pads[i]){add(pads[i])}}GodotEventListeners.add(window,"gamepadconnected",function(evt){if(evt.gamepad){add(evt.gamepad)}},false);GodotEventListeners.add(window,"gamepaddisconnected",function(evt){if(evt.gamepad){onchange(evt.gamepad.index,0)}},false)},get_guid:function(pad){if(pad.mapping){return pad.mapping}const ua=navigator.userAgent;let os="Unknown";if(ua.indexOf("Android")>=0){os="Android"}else if(ua.indexOf("Linux")>=0){os="Linux"}else if(ua.indexOf("iPhone")>=0){os="iOS"}else if(ua.indexOf("Macintosh")>=0){os="MacOSX"}else if(ua.indexOf("Windows")>=0){os="Windows"}const id=pad.id;const exp1=/vendor: ([0-9a-f]{4}) product: ([0-9a-f]{4})/i;const exp2=/^([0-9a-f]+)-([0-9a-f]+)-/i;let vendor="";let product="";if(exp1.test(id)){const match=exp1.exec(id);vendor=match[1].padStart(4,"0");product=match[2].padStart(4,"0")}else if(exp2.test(id)){const match=exp2.exec(id);vendor=match[1].padStart(4,"0");product=match[2].padStart(4,"0")}if(!vendor||!product){return`${os}Unknown`}return os+vendor+product}};var GodotInputDragDrop={promises:[],pending_files:[],add_entry:function(entry){if(entry.isDirectory){GodotInputDragDrop.add_dir(entry)}else if(entry.isFile){GodotInputDragDrop.add_file(entry)}else{GodotRuntime.error("Unrecognized entry...",entry)}},add_dir:function(entry){GodotInputDragDrop.promises.push(new Promise(function(resolve,reject){const reader=entry.createReader();reader.readEntries(function(entries){for(let i=0;i<entries.length;i++){GodotInputDragDrop.add_entry(entries[i])}resolve()})}))},add_file:function(entry){GodotInputDragDrop.promises.push(new Promise(function(resolve,reject){entry.file(function(file){const reader=new FileReader;reader.onload=function(){const f={path:file.relativePath||file.webkitRelativePath,name:file.name,type:file.type,size:file.size,data:reader.result};if(!f["path"]){f["path"]=f["name"]}GodotInputDragDrop.pending_files.push(f);resolve()};reader.onerror=function(){GodotRuntime.print("Error reading file");reject()};reader.readAsArrayBuffer(file)},function(err){GodotRuntime.print("Error!");reject()})}))},process:function(resolve,reject){if(GodotInputDragDrop.promises.length===0){resolve();return}GodotInputDragDrop.promises.pop().then(function(){setTimeout(function(){GodotInputDragDrop.process(resolve,reject)},0)})},_process_event:function(ev,callback){ev.preventDefault();if(ev.dataTransfer.items){for(let i=0;i<ev.dataTransfer.items.length;i++){const item=ev.dataTransfer.items[i];let entry=null;if("getAsEntry"in item){entry=item.getAsEntry()}else if("webkitGetAsEntry"in item){entry=item.webkitGetAsEntry()}if(entry){GodotInputDragDrop.add_entry(entry)}}}else{GodotRuntime.error("File upload not supported")}new Promise(GodotInputDragDrop.process).then(function(){const DROP=`/tmp/drop-${parseInt(Math.random()*(1<<30),10)}/`;const drops=[];const files=[];FS.mkdir(DROP.slice(0,-1));GodotInputDragDrop.pending_files.forEach(elem=>{const path=elem["path"];GodotFS.copy_to_fs(DROP+path,elem["data"]);let idx=path.indexOf("/");if(idx===-1){drops.push(DROP+path)}else{const sub=path.substr(0,idx);idx=sub.indexOf("/");if(idx<0&&drops.indexOf(DROP+sub)===-1){drops.push(DROP+sub)}}files.push(DROP+path)});GodotInputDragDrop.promises=[];GodotInputDragDrop.pending_files=[];callback(drops);if(GodotConfig.persistent_drops){GodotOS.atexit(function(resolve,reject){GodotInputDragDrop.remove_drop(files,DROP);resolve()})}else{GodotInputDragDrop.remove_drop(files,DROP)}})},remove_drop:function(files,drop_path){const dirs=[drop_path.substr(0,drop_path.length-1)];files.forEach(function(file){FS.unlink(file);let dir=file.replace(drop_path,"");let idx=dir.lastIndexOf("/");while(idx>0){dir=dir.substr(0,idx);if(dirs.indexOf(drop_path+dir)===-1){dirs.push(drop_path+dir)}idx=dir.lastIndexOf("/")}});dirs.sort(function(a,b){const al=(a.match(/\//g)||[]).length;const bl=(b.match(/\//g)||[]).length;if(al>bl){return-1}else if(al<bl){return 1}return 0}).forEach(function(dir){FS.rmdir(dir)})},handler:function(callback){return function(ev){GodotInputDragDrop._process_event(ev,callback)}}};var GodotIME={ime:null,active:false,focusTimerIntervalId:-1,getModifiers:function(evt){return evt.shiftKey+0+(evt.altKey+0<<1)+(evt.ctrlKey+0<<2)+(evt.metaKey+0<<3)},ime_active:function(active){function clearFocusTimerInterval(){clearInterval(GodotIME.focusTimerIntervalId);GodotIME.focusTimerIntervalId=-1}function focusTimer(){if(GodotIME.ime==null){clearFocusTimerInterval();return}GodotIME.ime.focus()}if(GodotIME.focusTimerIntervalId>-1){clearFocusTimerInterval()}if(GodotIME.ime==null){return}GodotIME.active=active;if(active){GodotIME.ime.style.display="block";GodotIME.focusTimerIntervalId=setInterval(focusTimer,100)}else{GodotIME.ime.style.display="none";GodotConfig.canvas.focus()}},ime_position:function(x,y){if(GodotIME.ime==null){return}const canvas=GodotConfig.canvas;const rect=canvas.getBoundingClientRect();const rw=canvas.width/rect.width;const rh=canvas.height/rect.height;const clx=x/rw+rect.x;const cly=y/rh+rect.y;GodotIME.ime.style.left=`${clx}px`;GodotIME.ime.style.top=`${cly}px`},init:function(ime_cb,key_cb,code,key){function key_event_cb(pressed,evt){const modifiers=GodotIME.getModifiers(evt);GodotRuntime.stringToHeap(evt.code,code,32);GodotRuntime.stringToHeap(evt.key,key,32);key_cb(pressed,evt.repeat,modifiers);evt.preventDefault()}function ime_event_cb(event){if(GodotIME.ime==null){return}switch(event.type){case"compositionstart":ime_cb(0,null);GodotIME.ime.innerHTML="";break;case"compositionupdate":{const ptr=GodotRuntime.allocString(event.data);ime_cb(1,ptr);GodotRuntime.free(ptr)}break;case"compositionend":{const ptr=GodotRuntime.allocString(event.data);ime_cb(2,ptr);GodotRuntime.free(ptr);GodotIME.ime.innerHTML=""}break;default:}}const ime=document.createElement("div");ime.className="ime";ime.style.background="none";ime.style.opacity=0;ime.style.position="fixed";ime.style.textAlign="left";ime.style.fontSize="1px";ime.style.left="0px";ime.style.top="0px";ime.style.width="100%";ime.style.height="40px";ime.style.pointerEvents="none";ime.style.display="none";ime.contentEditable="true";GodotEventListeners.add(ime,"compositionstart",ime_event_cb,false);GodotEventListeners.add(ime,"compositionupdate",ime_event_cb,false);GodotEventListeners.add(ime,"compositionend",ime_event_cb,false);GodotEventListeners.add(ime,"keydown",key_event_cb.bind(null,1),false);GodotEventListeners.add(ime,"keyup",key_event_cb.bind(null,0),false);ime.onblur=function(){this.style.display="none";GodotConfig.canvas.focus();GodotIME.active=false};GodotConfig.canvas.parentElement.appendChild(ime);GodotIME.ime=ime},clear:function(){if(GodotIME.ime==null){return}if(GodotIME.focusTimerIntervalId>-1){clearInterval(GodotIME.focusTimerIntervalId);GodotIME.focusTimerIntervalId=-1}GodotIME.ime.remove();GodotIME.ime=null}};var GodotInput={inputKeyCallback:null,setInputKeyData:null,getModifiers:function(evt){return evt.shiftKey+0+(evt.altKey+0<<1)+(evt.ctrlKey+0<<2)+(evt.metaKey+0<<3)},computePosition:function(evt,rect){const canvas=GodotConfig.canvas;const rw=canvas.width/rect.width;const rh=canvas.height/rect.height;const x=(evt.clientX-rect.x)*rw;const y=(evt.clientY-rect.y)*rh;return[x,y]},onKeyEvent:function(pIsPressed,pEvent){if(GodotInput.inputKeyCallback==null){throw new TypeError("GodotInput.onKeyEvent(): GodotInput.inputKeyCallback is null, cannot process key event.")}if(GodotInput.setInputKeyData==null){throw new TypeError("GodotInput.onKeyEvent(): GodotInput.setInputKeyData is null, cannot process key event.")}const modifiers=GodotInput.getModifiers(pEvent);GodotInput.setInputKeyData(pEvent.code,pEvent.key);GodotInput.inputKeyCallback(pIsPressed?1:0,pEvent.repeat,modifiers);pEvent.preventDefault()}};var GodotDisplayVK={textinput:null,textarea:null,available:function(){return GodotConfig.virtual_keyboard&&"ontouchstart"in window},init:function(input_cb){function create(what){const elem=document.createElement(what);elem.style.display="none";elem.style.position="absolute";elem.style.zIndex="-1";elem.style.background="transparent";elem.style.padding="0px";elem.style.margin="0px";elem.style.overflow="hidden";elem.style.width="0px";elem.style.height="0px";elem.style.border="0px";elem.style.outline="none";elem.readonly=true;elem.disabled=true;GodotEventListeners.add(elem,"input",function(evt){const c_str=GodotRuntime.allocString(elem.value);input_cb(c_str,elem.selectionEnd);GodotRuntime.free(c_str)},false);if(what==="input"){const onKey=(pEvent,pEventName)=>{if(pEvent.key!=="Enter"){return}GodotInput.onKeyEvent(pEventName==="keydown",pEvent)};GodotEventListeners.add(elem,"keydown",pEvent=>onKey(pEvent,"keydown"),false);GodotEventListeners.add(elem,"keyup",pEvent=>onKey(pEvent,"keyup"),false)}GodotEventListeners.add(elem,"blur",function(evt){elem.style.display="none";elem.readonly=true;elem.disabled=true},false);GodotConfig.canvas.insertAdjacentElement("beforebegin",elem);return elem}GodotDisplayVK.textinput=create("input");GodotDisplayVK.textarea=create("textarea");GodotDisplayVK.updateSize()},show:function(text,type,start,end){if(!GodotDisplayVK.textinput||!GodotDisplayVK.textarea){return}if(GodotDisplayVK.textinput.style.display!==""||GodotDisplayVK.textarea.style.display!==""){GodotDisplayVK.hide()}GodotDisplayVK.updateSize();let elem=GodotDisplayVK.textinput;switch(type){case 0:elem.type="text";elem.inputmode="";break;case 1:elem=GodotDisplayVK.textarea;break;case 2:elem.type="text";elem.inputmode="numeric";break;case 3:elem.type="text";elem.inputmode="decimal";break;case 4:elem.type="tel";elem.inputmode="";break;case 5:elem.type="email";elem.inputmode="";break;case 6:elem.type="password";elem.inputmode="";break;case 7:elem.type="url";elem.inputmode="";break;default:elem.type="text";elem.inputmode="";break}elem.readonly=false;elem.disabled=false;elem.value=text;elem.style.display="block";elem.focus();elem.setSelectionRange(start,end)},hide:function(){if(!GodotDisplayVK.textinput||!GodotDisplayVK.textarea){return}[GodotDisplayVK.textinput,GodotDisplayVK.textarea].forEach(function(elem){elem.blur();elem.style.display="none";elem.value=""})},updateSize:function(){if(!GodotDisplayVK.textinput||!GodotDisplayVK.textarea){return}const rect=GodotConfig.canvas.getBoundingClientRect();function update(elem){elem.style.left=`${rect.left}px`;elem.style.top=`${rect.top}px`;elem.style.width=`${rect.width}px`;elem.style.height=`${rect.height}px`}update(GodotDisplayVK.textinput);update(GodotDisplayVK.textarea)},clear:function(){if(GodotDisplayVK.textinput){GodotDisplayVK.textinput.remove();GodotDisplayVK.textinput=null}if(GodotDisplayVK.textarea){GodotDisplayVK.textarea.remove();GodotDisplayVK.textarea=null}}};var GodotDisplay={window_icon:"",getDPI:function(){const dpi=Math.round(window.devicePixelRatio*96);return dpi>=96?dpi:96}};function _godot_js_display_alert(p_text){window.alert(GodotRuntime.parseString(p_text))}function _godot_js_display_canvas_focus(){GodotConfig.canvas.focus()}function _godot_js_display_canvas_is_focused(){return document.activeElement===GodotConfig.canvas}function _godot_js_display_clipboard_get(callback){const func=GodotRuntime.get_func(callback);try{navigator.clipboard.readText().then(function(result){const ptr=GodotRuntime.allocString(result);func(ptr);GodotRuntime.free(ptr)}).catch(function(e){})}catch(e){}}function _godot_js_display_clipboard_set(p_text){const text=GodotRuntime.parseString(p_text);if(!navigator.clipboard||!navigator.clipboard.writeText){return 1}navigator.clipboard.writeText(text).catch(function(e){GodotRuntime.error("Setting OS clipboard is only possible from an input callback for the Web platform. Exception:",e)});return 0}function _godot_js_display_cursor_is_hidden(){return!GodotDisplayCursor.visible}function _godot_js_display_cursor_is_locked(){return GodotDisplayCursor.isPointerLocked()?1:0}function _godot_js_display_cursor_lock_set(p_lock){if(p_lock){GodotDisplayCursor.lockPointer()}else{GodotDisplayCursor.releasePointer()}}function _godot_js_display_cursor_set_custom_shape(p_shape,p_ptr,p_len,p_hotspot_x,p_hotspot_y){const shape=GodotRuntime.parseString(p_shape);const old_shape=GodotDisplayCursor.cursors[shape];if(p_len>0){const png=new Blob([GodotRuntime.heapSlice(HEAPU8,p_ptr,p_len)],{type:"image/png"});const url=URL.createObjectURL(png);GodotDisplayCursor.cursors[shape]={url,x:p_hotspot_x,y:p_hotspot_y}}else{delete GodotDisplayCursor.cursors[shape]}if(shape===GodotDisplayCursor.shape){GodotDisplayCursor.set_shape(GodotDisplayCursor.shape)}if(old_shape){URL.revokeObjectURL(old_shape.url)}}function _godot_js_display_cursor_set_shape(p_string){GodotDisplayCursor.set_shape(GodotRuntime.parseString(p_string))}function _godot_js_display_cursor_set_visible(p_visible){const visible=p_visible!==0;if(visible===GodotDisplayCursor.visible){return}GodotDisplayCursor.visible=visible;if(visible){GodotDisplayCursor.set_shape(GodotDisplayCursor.shape)}else{GodotDisplayCursor.set_style("none")}}function _godot_js_display_desired_size_set(width,height){GodotDisplayScreen.desired_size=[width,height];GodotDisplayScreen.updateSize()}function _godot_js_display_fullscreen_cb(callback){const canvas=GodotConfig.canvas;const func=GodotRuntime.get_func(callback);function change_cb(evt){if(evt.target===canvas){func(GodotDisplayScreen.isFullscreen())}}GodotEventListeners.add(document,"fullscreenchange",change_cb,false);GodotEventListeners.add(document,"mozfullscreenchange",change_cb,false);GodotEventListeners.add(document,"webkitfullscreenchange",change_cb,false)}function _godot_js_display_fullscreen_exit(){return GodotDisplayScreen.exitFullscreen()}function _godot_js_display_fullscreen_request(){return GodotDisplayScreen.requestFullscreen()}function _godot_js_display_has_webgl(p_version){if(p_version!==1&&p_version!==2){return false}try{return!!document.createElement("canvas").getContext(p_version===2?"webgl2":"webgl")}catch(e){}return false}function _godot_js_display_is_swap_ok_cancel(){const win=["Windows","Win64","Win32","WinCE"];const plat=navigator.platform||"";if(win.indexOf(plat)!==-1){return 1}return 0}function _godot_js_display_notification_cb(callback,p_enter,p_exit,p_in,p_out){const canvas=GodotConfig.canvas;const func=GodotRuntime.get_func(callback);const notif=[p_enter,p_exit,p_in,p_out];["mouseover","mouseleave","focus","blur"].forEach(function(evt_name,idx){GodotEventListeners.add(canvas,evt_name,function(){func(notif[idx])},true)})}function _godot_js_display_pixel_ratio_get(){return GodotDisplayScreen.getPixelRatio()}function _godot_js_display_screen_dpi_get(){return GodotDisplay.getDPI()}function _godot_js_display_screen_size_get(width,height){const scale=GodotDisplayScreen.getPixelRatio();GodotRuntime.setHeapValue(width,window.screen.width*scale,"i32");GodotRuntime.setHeapValue(height,window.screen.height*scale,"i32")}function _godot_js_display_setup_canvas(p_width,p_height,p_fullscreen,p_hidpi){const canvas=GodotConfig.canvas;GodotEventListeners.add(canvas,"contextmenu",function(ev){ev.preventDefault()},false);GodotEventListeners.add(canvas,"webglcontextlost",function(ev){alert("WebGL context lost, please reload the page");ev.preventDefault()},false);GodotDisplayScreen.hidpi=!!p_hidpi;switch(GodotConfig.canvas_resize_policy){case 0:GodotDisplayScreen.desired_size=[canvas.width,canvas.height];break;case 1:GodotDisplayScreen.desired_size=[p_width,p_height];break;default:canvas.style.position="absolute";canvas.style.top=0;canvas.style.left=0;break}GodotDisplayScreen.updateSize();if(p_fullscreen){GodotDisplayScreen.requestFullscreen()}}function _godot_js_display_size_update(){const updated=GodotDisplayScreen.updateSize();if(updated){GodotDisplayVK.updateSize()}return updated}function _godot_js_display_touchscreen_is_available(){return"ontouchstart"in window}function _godot_js_display_tts_available(){return"speechSynthesis"in window}function _godot_js_display_vk_available(){return GodotDisplayVK.available()}function _godot_js_display_vk_cb(p_input_cb){const input_cb=GodotRuntime.get_func(p_input_cb);if(GodotDisplayVK.available()){GodotDisplayVK.init(input_cb)}}function _godot_js_display_vk_hide(){GodotDisplayVK.hide()}function _godot_js_display_vk_show(p_text,p_type,p_start,p_end){const text=GodotRuntime.parseString(p_text);const start=p_start>0?p_start:0;const end=p_end>0?p_end:start;GodotDisplayVK.show(text,p_type,start,end)}function _godot_js_display_window_blur_cb(callback){const func=GodotRuntime.get_func(callback);GodotEventListeners.add(window,"blur",function(){func()},false)}function _godot_js_display_window_icon_set(p_ptr,p_len){let link=document.getElementById("-gd-engine-icon");const old_icon=GodotDisplay.window_icon;if(p_ptr){if(link===null){link=document.createElement("link");link.rel="icon";link.id="-gd-engine-icon";document.head.appendChild(link)}const png=new Blob([GodotRuntime.heapSlice(HEAPU8,p_ptr,p_len)],{type:"image/png"});GodotDisplay.window_icon=URL.createObjectURL(png);link.href=GodotDisplay.window_icon}else{if(link){link.remove()}GodotDisplay.window_icon=null}if(old_icon){URL.revokeObjectURL(old_icon)}}function _godot_js_display_window_size_get(p_width,p_height){GodotRuntime.setHeapValue(p_width,GodotConfig.canvas.width,"i32");GodotRuntime.setHeapValue(p_height,GodotConfig.canvas.height,"i32")}function _godot_js_display_window_title_set(p_data){document.title=GodotRuntime.parseString(p_data)}function _godot_js_emscripten_get_version(){const emscriptenVersionPtr=GodotRuntime.allocString("4.0.20");return emscriptenVersionPtr}function _godot_js_eval(p_js,p_use_global_ctx,p_union_ptr,p_byte_arr,p_byte_arr_write,p_callback){const js_code=GodotRuntime.parseString(p_js);let eval_ret=null;try{if(p_use_global_ctx){const global_eval=eval;eval_ret=global_eval(js_code)}else{eval_ret=eval(js_code)}}catch(e){GodotRuntime.error(e)}switch(typeof eval_ret){case"boolean":GodotRuntime.setHeapValue(p_union_ptr,eval_ret,"i32");return 1;case"number":GodotRuntime.setHeapValue(p_union_ptr,eval_ret,"double");return 3;case"string":GodotRuntime.setHeapValue(p_union_ptr,GodotRuntime.allocString(eval_ret),"*");return 4;case"object":if(eval_ret===null){break}if(ArrayBuffer.isView(eval_ret)&&!(eval_ret instanceof Uint8Array)){eval_ret=new Uint8Array(eval_ret.buffer)}else if(eval_ret instanceof ArrayBuffer){eval_ret=new Uint8Array(eval_ret)}if(eval_ret instanceof Uint8Array){const func=GodotRuntime.get_func(p_callback);const bytes_ptr=func(p_byte_arr,p_byte_arr_write,eval_ret.length);HEAPU8.set(eval_ret,bytes_ptr);return 29}break}return 0}var IDHandler={_last_id:0,_references:{},get:function(p_id){return IDHandler._references[p_id]},add:function(p_data){const id=++IDHandler._last_id;IDHandler._references[id]=p_data;return id},remove:function(p_id){delete IDHandler._references[p_id]}};var GodotFetch={onread:function(id,result){const obj=IDHandler.get(id);if(!obj){return}if(result.value){obj.chunks.push(result.value)}obj.reading=false;obj.done=result.done},onresponse:function(id,response){const obj=IDHandler.get(id);if(!obj){return}let chunked=false;response.headers.forEach(function(value,header){const v=value.toLowerCase().trim();const h=header.toLowerCase().trim();if(h==="transfer-encoding"&&v==="chunked"){chunked=true}});obj.status=response.status;obj.response=response;obj.reader=response.body?.getReader();obj.chunked=chunked},onerror:function(id,err){GodotRuntime.error(err);const obj=IDHandler.get(id);if(!obj){return}obj.error=err},create:function(method,url,headers,body){const obj={request:null,response:null,reader:null,error:null,done:false,reading:false,status:0,chunks:[]};const id=IDHandler.add(obj);const init={method,headers,body};obj.request=fetch(url,init);obj.request.then(GodotFetch.onresponse.bind(null,id)).catch(GodotFetch.onerror.bind(null,id));return id},free:function(id){const obj=IDHandler.get(id);if(!obj){return}IDHandler.remove(id);if(!obj.request){return}obj.request.then(function(response){response.abort()}).catch(function(e){})},read:function(id){const obj=IDHandler.get(id);if(!obj){return}if(obj.reader&&!obj.reading){if(obj.done){obj.reader=null;return}obj.reading=true;obj.reader.read().then(GodotFetch.onread.bind(null,id)).catch(GodotFetch.onerror.bind(null,id))}else if(obj.reader==null&&obj.response.body==null){obj.reading=true;GodotFetch.onread(id,{value:undefined,done:true})}}};function _godot_js_fetch_create(p_method,p_url,p_headers,p_headers_size,p_body,p_body_size){const method=GodotRuntime.parseString(p_method);const url=GodotRuntime.parseString(p_url);const headers=GodotRuntime.parseStringArray(p_headers,p_headers_size);const body=p_body_size?GodotRuntime.heapSlice(HEAP8,p_body,p_body_size):null;return GodotFetch.create(method,url,headers.map(function(hv){const idx=hv.indexOf(":");if(idx<=0){return[]}return[hv.slice(0,idx).trim(),hv.slice(idx+1).trim()]}).filter(function(v){return v.length===2}),body)}function _godot_js_fetch_free(id){GodotFetch.free(id)}function _godot_js_fetch_http_status_get(p_id){const obj=IDHandler.get(p_id);if(!obj||!obj.response){return 0}return obj.status}function _godot_js_fetch_is_chunked(p_id){const obj=IDHandler.get(p_id);if(!obj||!obj.response){return-1}return obj.chunked?1:0}function _godot_js_fetch_read_chunk(p_id,p_buf,p_buf_size){const obj=IDHandler.get(p_id);if(!obj||!obj.response){return 0}let to_read=p_buf_size;const chunks=obj.chunks;while(to_read&&chunks.length){const chunk=obj.chunks[0];if(chunk.length>to_read){GodotRuntime.heapCopy(HEAP8,chunk.slice(0,to_read),p_buf);chunks[0]=chunk.slice(to_read);to_read=0}else{GodotRuntime.heapCopy(HEAP8,chunk,p_buf);to_read-=chunk.length;chunks.pop()}}if(!chunks.length){GodotFetch.read(p_id)}return p_buf_size-to_read}function _godot_js_fetch_read_headers(p_id,p_parse_cb,p_ref){const obj=IDHandler.get(p_id);if(!obj||!obj.response){return 1}const cb=GodotRuntime.get_func(p_parse_cb);const arr=[];obj.response.headers.forEach(function(v,h){arr.push(`${h}:${v}`)});const c_ptr=GodotRuntime.allocStringArray(arr);cb(arr.length,c_ptr,p_ref);GodotRuntime.freeStringArray(c_ptr,arr.length);return 0}function _godot_js_fetch_state_get(p_id){const obj=IDHandler.get(p_id);if(!obj){return-1}if(obj.error){return-1}if(!obj.response){return 0}if(obj.reader||obj.response.body==null&&!obj.done){return 1}if(obj.done){return 2}return-1}function _godot_js_input_drop_files_cb(callback){const func=GodotRuntime.get_func(callback);const dropFiles=function(files){const args=files||[];if(!args.length){return}const argc=args.length;const argv=GodotRuntime.allocStringArray(args);func(argv,argc);GodotRuntime.freeStringArray(argv,argc)};const canvas=GodotConfig.canvas;GodotEventListeners.add(canvas,"dragover",function(ev){ev.preventDefault()},false);GodotEventListeners.add(canvas,"drop",GodotInputDragDrop.handler(dropFiles))}function _godot_js_input_gamepad_cb(change_cb){const onchange=GodotRuntime.get_func(change_cb);GodotInputGamepads.init(onchange)}function _godot_js_input_gamepad_sample(){GodotInputGamepads.sample();return 0}function _godot_js_input_gamepad_sample_count(){return GodotInputGamepads.get_samples().length}function _godot_js_input_gamepad_sample_get(p_index,r_btns,r_btns_num,r_axes,r_axes_num,r_standard){const sample=GodotInputGamepads.get_sample(p_index);if(!sample||!sample.connected){return 1}const btns=sample.buttons;const btns_len=btns.length<16?btns.length:16;for(let i=0;i<btns_len;i++){GodotRuntime.setHeapValue(r_btns+(i<<2),btns[i],"float")}GodotRuntime.setHeapValue(r_btns_num,btns_len,"i32");const axes=sample.axes;const axes_len=axes.length<10?axes.length:10;for(let i=0;i<axes_len;i++){GodotRuntime.setHeapValue(r_axes+(i<<2),axes[i],"float")}GodotRuntime.setHeapValue(r_axes_num,axes_len,"i32");const is_standard=sample.standard?1:0;GodotRuntime.setHeapValue(r_standard,is_standard,"i32");return 0}var _godot_js_input_key_cb=function(pCallback,pCodePtr,pKeyPtr){GodotInput.inputKeyCallback=GodotRuntime.get_func(pCallback);GodotInput.setInputKeyData=(pCode,pKey)=>{GodotRuntime.stringToHeap(pCode,pCodePtr,32);GodotRuntime.stringToHeap(pKey,pKeyPtr,32)};GodotEventListeners.add(GodotConfig.canvas,"keydown",GodotInput.onKeyEvent.bind(null,true),false);GodotEventListeners.add(GodotConfig.canvas,"keyup",GodotInput.onKeyEvent.bind(null,false),false)};function _godot_js_input_mouse_button_cb(callback){const func=GodotRuntime.get_func(callback);const canvas=GodotConfig.canvas;function button_cb(p_pressed,evt){const rect=canvas.getBoundingClientRect();const pos=GodotInput.computePosition(evt,rect);const modifiers=GodotInput.getModifiers(evt);if(p_pressed){GodotConfig.canvas.focus()}if(func(p_pressed,evt.button,pos[0],pos[1],modifiers)){evt.preventDefault()}}GodotEventListeners.add(canvas,"mousedown",button_cb.bind(null,1),false);GodotEventListeners.add(window,"mouseup",button_cb.bind(null,0),false)}function _godot_js_input_mouse_move_cb(callback){const func=GodotRuntime.get_func(callback);const canvas=GodotConfig.canvas;function move_cb(evt){const rect=canvas.getBoundingClientRect();const pos=GodotInput.computePosition(evt,rect);const rw=canvas.width/rect.width;const rh=canvas.height/rect.height;const rel_pos_x=evt.movementX*rw;const rel_pos_y=evt.movementY*rh;const modifiers=GodotInput.getModifiers(evt);func(pos[0],pos[1],rel_pos_x,rel_pos_y,modifiers,evt.pressure)}GodotEventListeners.add(window,"pointermove",move_cb,false)}function _godot_js_input_mouse_wheel_cb(callback){const func=GodotRuntime.get_func(callback);function wheel_cb(evt){if(func(evt.deltaMode,evt.deltaX??0,evt.deltaY??0)){evt.preventDefault()}}GodotEventListeners.add(GodotConfig.canvas,"wheel",wheel_cb,false)}function _godot_js_input_paste_cb(callback){const func=GodotRuntime.get_func(callback);GodotEventListeners.add(window,"paste",function(evt){const text=evt.clipboardData.getData("text");const ptr=GodotRuntime.allocString(text);func(ptr);GodotRuntime.free(ptr)},false)}function _godot_js_input_touch_cb(callback,ids,coords){const func=GodotRuntime.get_func(callback);const canvas=GodotConfig.canvas;function touch_cb(type,evt){if(type===0){GodotConfig.canvas.focus()}const rect=canvas.getBoundingClientRect();const touches=evt.changedTouches;for(let i=0;i<touches.length;i++){const touch=touches[i];const pos=GodotInput.computePosition(touch,rect);GodotRuntime.setHeapValue(coords+i*2*8,pos[0],"double");GodotRuntime.setHeapValue(coords+(i*2+1)*8,pos[1],"double");GodotRuntime.setHeapValue(ids+i*4,touch.identifier,"i32")}func(type,touches.length);if(evt.cancelable){evt.preventDefault()}}GodotEventListeners.add(canvas,"touchstart",touch_cb.bind(null,0),false);GodotEventListeners.add(canvas,"touchend",touch_cb.bind(null,1),false);GodotEventListeners.add(canvas,"touchcancel",touch_cb.bind(null,1),false);GodotEventListeners.add(canvas,"touchmove",touch_cb.bind(null,2),false)}function _godot_js_input_vibrate_handheld(p_duration_ms){if(typeof navigator.vibrate!=="function"){GodotRuntime.print("This browser does not support vibration.")}else{navigator.vibrate(p_duration_ms)}}function _godot_js_is_ime_focused(){return GodotIME.active}function _godot_js_os_download_buffer(p_ptr,p_size,p_name,p_mime){const buf=GodotRuntime.heapSlice(HEAP8,p_ptr,p_size);const name=GodotRuntime.parseString(p_name);const mime=GodotRuntime.parseString(p_mime);const blob=new Blob([buf],{type:mime});const url=window.URL.createObjectURL(blob);const a=document.createElement("a");a.href=url;a.download=name;a.style.display="none";document.body.appendChild(a);a.click();a.remove();window.URL.revokeObjectURL(url)}function _godot_js_os_execute(p_json){const json_args=GodotRuntime.parseString(p_json);const args=JSON.parse(json_args);if(GodotConfig.on_execute){GodotConfig.on_execute(args);return 0}return 1}function _godot_js_os_finish_async(p_callback){const func=GodotRuntime.get_func(p_callback);GodotOS.finish_async(func)}function _godot_js_os_fs_is_persistent(){return GodotFS.is_persistent()}function _godot_js_os_fs_sync(callback){const func=GodotRuntime.get_func(callback);GodotOS._fs_sync_promise=GodotFS.sync();GodotOS._fs_sync_promise.then(function(err){func()})}function _godot_js_os_has_feature(p_ftr){const ftr=GodotRuntime.parseString(p_ftr);const ua=navigator.userAgent;if(ftr==="web_macos"){return ua.indexOf("Mac")!==-1?1:0}if(ftr==="web_windows"){return ua.indexOf("Windows")!==-1?1:0}if(ftr==="web_android"){return ua.indexOf("Android")!==-1?1:0}if(ftr==="web_ios"){return ua.indexOf("iPhone")!==-1||ua.indexOf("iPad")!==-1||ua.indexOf("iPod")!==-1?1:0}if(ftr==="web_linuxbsd"){return ua.indexOf("CrOS")!==-1||ua.indexOf("BSD")!==-1||ua.indexOf("Linux")!==-1||ua.indexOf("X11")!==-1?1:0}return 0}function _godot_js_os_hw_concurrency_get(){const concurrency=navigator.hardwareConcurrency||1;return concurrency<2?concurrency:2}function _godot_js_os_request_quit_cb(p_callback){GodotOS.request_quit=GodotRuntime.get_func(p_callback)}function _godot_js_os_shell_open(p_uri){window.open(GodotRuntime.parseString(p_uri),"_blank")}var GodotPWA={hasUpdate:false,updateState:function(cb,reg){if(!reg){return}if(!reg.active){return}if(reg.waiting){GodotPWA.hasUpdate=true;cb()}GodotEventListeners.add(reg,"updatefound",function(){const installing=reg.installing;GodotEventListeners.add(installing,"statechange",function(){if(installing.state==="installed"){GodotPWA.hasUpdate=true;cb()}})})}};function _godot_js_pwa_cb(p_update_cb){if("serviceWorker"in navigator){try{const cb=GodotRuntime.get_func(p_update_cb);navigator.serviceWorker.getRegistration().then(GodotPWA.updateState.bind(null,cb))}catch(e){GodotRuntime.error("Failed to assign PWA callback",e)}}}function _godot_js_pwa_update(){if("serviceWorker"in navigator&&GodotPWA.hasUpdate){try{navigator.serviceWorker.getRegistration().then(function(reg){if(!reg||!reg.waiting){return}reg.waiting.postMessage("update")})}catch(e){GodotRuntime.error(e);return 1}return 0}return 1}var GodotRTCDataChannel={connect:function(p_id,p_on_open,p_on_message,p_on_error,p_on_close){const ref=IDHandler.get(p_id);if(!ref){return}ref.binaryType="arraybuffer";ref.onopen=function(event){p_on_open()};ref.onclose=function(event){p_on_close()};ref.onerror=function(event){p_on_error()};ref.onmessage=function(event){let buffer;let is_string=0;if(event.data instanceof ArrayBuffer){buffer=new Uint8Array(event.data)}else if(event.data instanceof Blob){GodotRuntime.error("Blob type not supported");return}else if(typeof event.data==="string"){is_string=1;const enc=new TextEncoder("utf-8");buffer=new Uint8Array(enc.encode(event.data))}else{GodotRuntime.error("Unknown message type");return}const len=buffer.length*buffer.BYTES_PER_ELEMENT;const out=GodotRuntime.malloc(len);HEAPU8.set(buffer,out);p_on_message(out,len,is_string);GodotRuntime.free(out)}},close:function(p_id){const ref=IDHandler.get(p_id);if(!ref){return}ref.onopen=null;ref.onmessage=null;ref.onerror=null;ref.onclose=null;ref.close()},get_prop:function(p_id,p_prop,p_def){const ref=IDHandler.get(p_id);return ref&&ref[p_prop]!==undefined?ref[p_prop]:p_def}};function _godot_js_rtc_datachannel_close(p_id){const ref=IDHandler.get(p_id);if(!ref){return}GodotRTCDataChannel.close(p_id)}function _godot_js_rtc_datachannel_connect(p_id,p_ref,p_on_open,p_on_message,p_on_error,p_on_close){const onopen=GodotRuntime.get_func(p_on_open).bind(null,p_ref);const onmessage=GodotRuntime.get_func(p_on_message).bind(null,p_ref);const onerror=GodotRuntime.get_func(p_on_error).bind(null,p_ref);const onclose=GodotRuntime.get_func(p_on_close).bind(null,p_ref);GodotRTCDataChannel.connect(p_id,onopen,onmessage,onerror,onclose)}function _godot_js_rtc_datachannel_destroy(p_id){GodotRTCDataChannel.close(p_id);IDHandler.remove(p_id)}function _godot_js_rtc_datachannel_get_buffered_amount(p_id){return GodotRTCDataChannel.get_prop(p_id,"bufferedAmount",0)}function _godot_js_rtc_datachannel_id_get(p_id){return GodotRTCDataChannel.get_prop(p_id,"id",65535)}function _godot_js_rtc_datachannel_is_negotiated(p_id){return GodotRTCDataChannel.get_prop(p_id,"negotiated",65535)}function _godot_js_rtc_datachannel_is_ordered(p_id){return GodotRTCDataChannel.get_prop(p_id,"ordered",true)}function _godot_js_rtc_datachannel_label_get(p_id){const ref=IDHandler.get(p_id);if(!ref||!ref.label){return 0}return GodotRuntime.allocString(ref.label)}function _godot_js_rtc_datachannel_max_packet_lifetime_get(p_id){const ref=IDHandler.get(p_id);if(!ref){return 65535}if(ref["maxPacketLifeTime"]!==undefined){return ref["maxPacketLifeTime"]}else if(ref["maxRetransmitTime"]!==undefined){return ref["maxRetransmitTime"]}return 65535}function _godot_js_rtc_datachannel_max_retransmits_get(p_id){return GodotRTCDataChannel.get_prop(p_id,"maxRetransmits",65535)}function _godot_js_rtc_datachannel_protocol_get(p_id){const ref=IDHandler.get(p_id);if(!ref||!ref.protocol){return 0}return GodotRuntime.allocString(ref.protocol)}function _godot_js_rtc_datachannel_ready_state_get(p_id){const ref=IDHandler.get(p_id);if(!ref){return 3}switch(ref.readyState){case"connecting":return 0;case"open":return 1;case"closing":return 2;case"closed":default:return 3}}function _godot_js_rtc_datachannel_send(p_id,p_buffer,p_length,p_raw){const ref=IDHandler.get(p_id);if(!ref){return 1}const bytes_array=new Uint8Array(p_length);for(let i=0;i<p_length;i++){bytes_array[i]=GodotRuntime.getHeapValue(p_buffer+i,"i8")}if(p_raw){ref.send(bytes_array.buffer)}else{const string=new TextDecoder("utf-8").decode(bytes_array);ref.send(string)}return 0}var GodotRTCPeerConnection={ConnectionState:{new:0,connecting:1,connected:2,disconnected:3,failed:4,closed:5},ConnectionStateCompat:{new:0,checking:1,connected:2,completed:2,disconnected:3,failed:4,closed:5},IceGatheringState:{new:0,gathering:1,complete:2},SignalingState:{stable:0,"have-local-offer":1,"have-remote-offer":2,"have-local-pranswer":3,"have-remote-pranswer":4,closed:5},create:function(config,onConnectionChange,onSignalingChange,onIceGatheringChange,onIceCandidate,onDataChannel){let conn=null;try{conn=new RTCPeerConnection(config)}catch(e){GodotRuntime.error(e);return 0}const id=IDHandler.add(conn);if("connectionState"in conn&&conn["connectionState"]!==undefined){conn.onconnectionstatechange=function(event){if(!IDHandler.get(id)){return}onConnectionChange(GodotRTCPeerConnection.ConnectionState[conn.connectionState]||0)}}else{conn.oniceconnectionstatechange=function(event){if(!IDHandler.get(id)){return}onConnectionChange(GodotRTCPeerConnection.ConnectionStateCompat[conn.iceConnectionState]||0)}}conn.onicegatheringstatechange=function(event){if(!IDHandler.get(id)){return}onIceGatheringChange(GodotRTCPeerConnection.IceGatheringState[conn.iceGatheringState]||0)};conn.onsignalingstatechange=function(event){if(!IDHandler.get(id)){return}onSignalingChange(GodotRTCPeerConnection.SignalingState[conn.signalingState]||0)};conn.onicecandidate=function(event){if(!IDHandler.get(id)){return}const c=event.candidate;if(!c||!c.candidate){return}const candidate_str=GodotRuntime.allocString(c.candidate);const mid_str=GodotRuntime.allocString(c.sdpMid);onIceCandidate(mid_str,c.sdpMLineIndex,candidate_str);GodotRuntime.free(candidate_str);GodotRuntime.free(mid_str)};conn.ondatachannel=function(event){if(!IDHandler.get(id)){return}const cid=IDHandler.add(event.channel);onDataChannel(cid)};return id},destroy:function(p_id){const conn=IDHandler.get(p_id);if(!conn){return}conn.onconnectionstatechange=null;conn.oniceconnectionstatechange=null;conn.onicegatheringstatechange=null;conn.onsignalingstatechange=null;conn.onicecandidate=null;conn.ondatachannel=null;IDHandler.remove(p_id)},onsession:function(p_id,callback,session){if(!IDHandler.get(p_id)){return}const type_str=GodotRuntime.allocString(session.type);const sdp_str=GodotRuntime.allocString(session.sdp);callback(type_str,sdp_str);GodotRuntime.free(type_str);GodotRuntime.free(sdp_str)},onerror:function(p_id,callback,error){const ref=IDHandler.get(p_id);if(!ref){return}GodotRuntime.error(error);callback()}};function _godot_js_rtc_pc_close(p_id){const ref=IDHandler.get(p_id);if(!ref){return}ref.close()}function _godot_js_rtc_pc_create(p_config,p_ref,p_on_connection_state_change,p_on_ice_gathering_state_change,p_on_signaling_state_change,p_on_ice_candidate,p_on_datachannel){const wrap=function(p_func){return GodotRuntime.get_func(p_func).bind(null,p_ref)};return GodotRTCPeerConnection.create(JSON.parse(GodotRuntime.parseString(p_config)),wrap(p_on_connection_state_change),wrap(p_on_signaling_state_change),wrap(p_on_ice_gathering_state_change),wrap(p_on_ice_candidate),wrap(p_on_datachannel))}function _godot_js_rtc_pc_datachannel_create(p_id,p_label,p_config){try{const ref=IDHandler.get(p_id);if(!ref){return 0}const label=GodotRuntime.parseString(p_label);const config=JSON.parse(GodotRuntime.parseString(p_config));const channel=ref.createDataChannel(label,config);return IDHandler.add(channel)}catch(e){GodotRuntime.error(e);return 0}}function _godot_js_rtc_pc_destroy(p_id){GodotRTCPeerConnection.destroy(p_id)}function _godot_js_rtc_pc_ice_candidate_add(p_id,p_mid_name,p_mline_idx,p_sdp){const ref=IDHandler.get(p_id);if(!ref){return}const sdpMidName=GodotRuntime.parseString(p_mid_name);const sdpName=GodotRuntime.parseString(p_sdp);ref.addIceCandidate(new RTCIceCandidate({candidate:sdpName,sdpMid:sdpMidName,sdpMlineIndex:p_mline_idx}))}function _godot_js_rtc_pc_local_description_set(p_id,p_type,p_sdp,p_obj,p_on_error){const ref=IDHandler.get(p_id);if(!ref){return}const type=GodotRuntime.parseString(p_type);const sdp=GodotRuntime.parseString(p_sdp);const onerror=GodotRuntime.get_func(p_on_error).bind(null,p_obj);ref.setLocalDescription({sdp,type}).catch(function(error){GodotRTCPeerConnection.onerror(p_id,onerror,error)})}function _godot_js_rtc_pc_offer_create(p_id,p_obj,p_on_session,p_on_error){const ref=IDHandler.get(p_id);if(!ref){return}const onsession=GodotRuntime.get_func(p_on_session).bind(null,p_obj);const onerror=GodotRuntime.get_func(p_on_error).bind(null,p_obj);ref.createOffer().then(function(session){GodotRTCPeerConnection.onsession(p_id,onsession,session)}).catch(function(error){GodotRTCPeerConnection.onerror(p_id,onerror,error)})}function _godot_js_rtc_pc_remote_description_set(p_id,p_type,p_sdp,p_obj,p_session_created,p_on_error){const ref=IDHandler.get(p_id);if(!ref){return}const type=GodotRuntime.parseString(p_type);const sdp=GodotRuntime.parseString(p_sdp);const onerror=GodotRuntime.get_func(p_on_error).bind(null,p_obj);const onsession=GodotRuntime.get_func(p_session_created).bind(null,p_obj);ref.setRemoteDescription({sdp,type}).then(function(){if(type!=="offer"){return Promise.resolve()}return ref.createAnswer().then(function(session){GodotRTCPeerConnection.onsession(p_id,onsession,session)})}).catch(function(error){GodotRTCPeerConnection.onerror(p_id,onerror,error)})}function _godot_js_set_ime_active(p_active){GodotIME.ime_active(p_active)}function _godot_js_set_ime_cb(p_ime_cb,p_key_cb,code,key){const ime_cb=GodotRuntime.get_func(p_ime_cb);const key_cb=GodotRuntime.get_func(p_key_cb);GodotIME.init(ime_cb,key_cb,code,key)}function _godot_js_set_ime_position(p_x,p_y){GodotIME.ime_position(p_x,p_y)}function _godot_js_tts_get_voices(p_callback){const func=GodotRuntime.get_func(p_callback);try{const arr=[];const voices=window.speechSynthesis.getVoices();for(let i=0;i<voices.length;i++){arr.push(`${voices[i].lang};${voices[i].name}`)}const c_ptr=GodotRuntime.allocStringArray(arr);func(arr.length,c_ptr);GodotRuntime.freeStringArray(c_ptr,arr.length)}catch(e){}}function _godot_js_tts_is_paused(){return window.speechSynthesis.paused}function _godot_js_tts_is_speaking(){return window.speechSynthesis.speaking}function _godot_js_tts_pause(){window.speechSynthesis.pause()}function _godot_js_tts_resume(){window.speechSynthesis.resume()}function _godot_js_tts_speak(p_text,p_voice,p_volume,p_pitch,p_rate,p_utterance_id,p_callback){const func=GodotRuntime.get_func(p_callback);function listener_end(evt){evt.currentTarget.cb(1,evt.currentTarget.id,0)}function listener_start(evt){evt.currentTarget.cb(0,evt.currentTarget.id,0)}function listener_error(evt){evt.currentTarget.cb(2,evt.currentTarget.id,0)}function listener_bound(evt){evt.currentTarget.cb(3,evt.currentTarget.id,evt.charIndex)}const utterance=new SpeechSynthesisUtterance(GodotRuntime.parseString(p_text));utterance.rate=p_rate;utterance.pitch=p_pitch;utterance.volume=p_volume/100;utterance.addEventListener("end",listener_end);utterance.addEventListener("start",listener_start);utterance.addEventListener("error",listener_error);utterance.addEventListener("boundary",listener_bound);utterance.id=p_utterance_id;utterance.cb=func;const voice=GodotRuntime.parseString(p_voice);const voices=window.speechSynthesis.getVoices();for(let i=0;i<voices.length;i++){if(voices[i].name===voice){utterance.voice=voices[i];break}}window.speechSynthesis.resume();window.speechSynthesis.speak(utterance)}function _godot_js_tts_stop(){window.speechSynthesis.cancel();window.speechSynthesis.resume()}var GodotWebMidi={abortControllers:[],isListening:false};function _godot_js_webmidi_close_midi_inputs(){for(const abortController of GodotWebMidi.abortControllers){abortController.abort()}GodotWebMidi.abortControllers=[];GodotWebMidi.isListening=false}function _godot_js_webmidi_open_midi_inputs(pSetInputNamesCb,pOnMidiMessageCb,pDataBuffer,dataBufferLen){if(GodotWebMidi.is_listening){return 0}if(!navigator.requestMIDIAccess){return 2}const setInputNamesCb=GodotRuntime.get_func(pSetInputNamesCb);const onMidiMessageCb=GodotRuntime.get_func(pOnMidiMessageCb);GodotWebMidi.isListening=true;navigator.requestMIDIAccess().then(midi=>{const inputs=[...midi.inputs.values()];const inputNames=inputs.map(input=>input.name);const c_ptr=GodotRuntime.allocStringArray(inputNames);setInputNamesCb(inputNames.length,c_ptr);GodotRuntime.freeStringArray(c_ptr,inputNames.length);inputs.forEach((input,i)=>{const abortController=new AbortController;GodotWebMidi.abortControllers.push(abortController);input.addEventListener("midimessage",event=>{const status=event.data[0];const data=event.data.slice(1);const size=data.length;if(size>dataBufferLen){throw new Error(`data too big ${size} > ${dataBufferLen}`)}HEAPU8.set(data,pDataBuffer);onMidiMessageCb(i,status,pDataBuffer,data.length)},{signal:abortController.signal})})});return 0}var GodotWebSocket={_onopen:function(p_id,callback,event){const ref=IDHandler.get(p_id);if(!ref){return}const c_str=GodotRuntime.allocString(ref.protocol);callback(c_str);GodotRuntime.free(c_str)},_onmessage:function(p_id,callback,event){const ref=IDHandler.get(p_id);if(!ref){return}let buffer;let is_string=0;if(event.data instanceof ArrayBuffer){buffer=new Uint8Array(event.data)}else if(event.data instanceof Blob){GodotRuntime.error("Blob type not supported");return}else if(typeof event.data==="string"){is_string=1;buffer=new TextEncoder("utf-8").encode(event.data)}else{GodotRuntime.error("Unknown message type");return}const len=buffer.length*buffer.BYTES_PER_ELEMENT;const out=GodotRuntime.malloc(len);HEAPU8.set(buffer,out);callback(out,len,is_string);GodotRuntime.free(out)},_onerror:function(p_id,callback,event){const ref=IDHandler.get(p_id);if(!ref){return}callback()},_onclose:function(p_id,callback,event){const ref=IDHandler.get(p_id);if(!ref){return}const c_str=GodotRuntime.allocString(event.reason);callback(event.code,c_str,event.wasClean?1:0);GodotRuntime.free(c_str)},send:function(p_id,p_data){const ref=IDHandler.get(p_id);if(!ref||ref.readyState!==ref.OPEN){return 1}ref.send(p_data);return 0},bufferedAmount:function(p_id){const ref=IDHandler.get(p_id);if(!ref){return 0}return ref.bufferedAmount},create:function(socket,p_on_open,p_on_message,p_on_error,p_on_close){const id=IDHandler.add(socket);socket.onopen=GodotWebSocket._onopen.bind(null,id,p_on_open);socket.onmessage=GodotWebSocket._onmessage.bind(null,id,p_on_message);socket.onerror=GodotWebSocket._onerror.bind(null,id,p_on_error);socket.onclose=GodotWebSocket._onclose.bind(null,id,p_on_close);return id},close:function(p_id,p_code,p_reason){const ref=IDHandler.get(p_id);if(ref&&ref.readyState<ref.CLOSING){const code=p_code;const reason=p_reason;ref.close(code,reason)}},destroy:function(p_id){const ref=IDHandler.get(p_id);if(!ref){return}GodotWebSocket.close(p_id,3001,"destroyed");IDHandler.remove(p_id);ref.onopen=null;ref.onmessage=null;ref.onerror=null;ref.onclose=null}};function _godot_js_websocket_buffered_amount(p_id){return GodotWebSocket.bufferedAmount(p_id)}function _godot_js_websocket_close(p_id,p_code,p_reason){const code=p_code;const reason=GodotRuntime.parseString(p_reason);GodotWebSocket.close(p_id,code,reason)}function _godot_js_websocket_create(p_ref,p_url,p_proto,p_on_open,p_on_message,p_on_error,p_on_close){const on_open=GodotRuntime.get_func(p_on_open).bind(null,p_ref);const on_message=GodotRuntime.get_func(p_on_message).bind(null,p_ref);const on_error=GodotRuntime.get_func(p_on_error).bind(null,p_ref);const on_close=GodotRuntime.get_func(p_on_close).bind(null,p_ref);const url=GodotRuntime.parseString(p_url);const protos=GodotRuntime.parseString(p_proto);let socket=null;try{if(protos){socket=new WebSocket(url,protos.split(","))}else{socket=new WebSocket(url)}}catch(e){return 0}socket.binaryType="arraybuffer";return GodotWebSocket.create(socket,on_open,on_message,on_error,on_close)}function _godot_js_websocket_destroy(p_id){GodotWebSocket.destroy(p_id)}function _godot_js_websocket_send(p_id,p_buf,p_buf_len,p_raw){let out=GodotRuntime.heapSlice(HEAPU8,p_buf,p_buf_len);if(!p_raw){out=new TextDecoder("utf-8").decode(out)}return GodotWebSocket.send(p_id,out)}var GodotJSWrapper={proxies:null,cb_ret:null,MyProxy:function(val){const id=IDHandler.add(this);GodotJSWrapper.proxies.set(val,id);let refs=1;this.ref=function(){refs++};this.unref=function(){refs--;if(refs===0){IDHandler.remove(id);GodotJSWrapper.proxies.delete(val)}};this.get_val=function(){return val};this.get_id=function(){return id}},get_proxied:function(val){const id=GodotJSWrapper.proxies.get(val);if(id===undefined){const proxy=new GodotJSWrapper.MyProxy(val);return proxy.get_id()}IDHandler.get(id).ref();return id},get_proxied_value:function(id){const proxy=IDHandler.get(id);if(proxy===undefined){return undefined}return proxy.get_val()},variant2js:function(type,val){switch(type){case 0:return null;case 1:return Boolean(GodotRuntime.getHeapValue(val,"i64"));case 2:{const heap_value=GodotRuntime.getHeapValue(val,"i64");return heap_value>=Number.MIN_SAFE_INTEGER&&heap_value<=Number.MAX_SAFE_INTEGER?Number(heap_value):heap_value}case 3:return Number(GodotRuntime.getHeapValue(val,"double"));case 4:return GodotRuntime.parseString(GodotRuntime.getHeapValue(val,"*"));case 24:return GodotJSWrapper.get_proxied_value(GodotRuntime.getHeapValue(val,"i64"));default:return undefined}},js2variant:function(p_val,p_exchange){if(p_val===undefined||p_val===null){return 0}const type=typeof p_val;if(type==="boolean"){GodotRuntime.setHeapValue(p_exchange,p_val,"i64");return 1}else if(type==="number"){if(Number.isInteger(p_val)){GodotRuntime.setHeapValue(p_exchange,p_val,"i64");return 2}GodotRuntime.setHeapValue(p_exchange,p_val,"double");return 3}else if(type==="bigint"){GodotRuntime.setHeapValue(p_exchange,p_val,"i64");return 2}else if(type==="string"){const c_str=GodotRuntime.allocString(p_val);GodotRuntime.setHeapValue(p_exchange,c_str,"*");return 4}const id=GodotJSWrapper.get_proxied(p_val);GodotRuntime.setHeapValue(p_exchange,id,"i64");return 24},isBuffer:function(obj){return obj instanceof ArrayBuffer||ArrayBuffer.isView(obj)}};function _godot_js_wrapper_create_cb(p_ref,p_func){const func=GodotRuntime.get_func(p_func);let id=0;const cb=function(){if(!GodotJSWrapper.get_proxied_value(id)){return undefined}GodotJSWrapper.cb_ret=null;const args=Array.from(arguments);const argsProxy=new GodotJSWrapper.MyProxy(args);func(p_ref,argsProxy.get_id(),args.length);argsProxy.unref();const ret=GodotJSWrapper.cb_ret;GodotJSWrapper.cb_ret=null;return ret};id=GodotJSWrapper.get_proxied(cb);return id}function _godot_js_wrapper_create_object(p_object,p_args,p_argc,p_convert_callback,p_exchange,p_lock,p_free_lock_callback){const name=GodotRuntime.parseString(p_object);if(typeof window[name]==="undefined"){return-1}const convert=GodotRuntime.get_func(p_convert_callback);const freeLock=GodotRuntime.get_func(p_free_lock_callback);const args=new Array(p_argc);for(let i=0;i<p_argc;i++){const type=convert(p_args,i,p_exchange,p_lock);const lock=GodotRuntime.getHeapValue(p_lock,"*");args[i]=GodotJSWrapper.variant2js(type,p_exchange);if(lock){freeLock(p_lock,type)}}try{const res=new window[name](...args);return GodotJSWrapper.js2variant(res,p_exchange)}catch(e){GodotRuntime.error(`Error calling constructor ${name} with args:`,args,"error:",e);return-1}}function _godot_js_wrapper_interface_get(p_name){const name=GodotRuntime.parseString(p_name);if(typeof window[name]!=="undefined"){return GodotJSWrapper.get_proxied(window[name])}return 0}function _godot_js_wrapper_object_call(p_id,p_method,p_args,p_argc,p_convert_callback,p_exchange,p_lock,p_free_lock_callback){const obj=GodotJSWrapper.get_proxied_value(p_id);if(obj===undefined){return-1}const method=GodotRuntime.parseString(p_method);const convert=GodotRuntime.get_func(p_convert_callback);const freeLock=GodotRuntime.get_func(p_free_lock_callback);const args=new Array(p_argc);for(let i=0;i<p_argc;i++){const type=convert(p_args,i,p_exchange,p_lock);const lock=GodotRuntime.getHeapValue(p_lock,"*");args[i]=GodotJSWrapper.variant2js(type,p_exchange);if(lock){freeLock(p_lock,type)}}try{const res=obj[method](...args);return GodotJSWrapper.js2variant(res,p_exchange)}catch(e){GodotRuntime.error(`Error calling method ${method} on:`,obj,"error:",e);return-1}}function _godot_js_wrapper_object_get(p_id,p_exchange,p_prop){const obj=GodotJSWrapper.get_proxied_value(p_id);if(obj===undefined){return 0}if(p_prop){const prop=GodotRuntime.parseString(p_prop);try{return GodotJSWrapper.js2variant(obj[prop],p_exchange)}catch(e){GodotRuntime.error(`Error getting variable ${prop} on object`,obj);return 0}}return GodotJSWrapper.js2variant(obj,p_exchange)}function _godot_js_wrapper_object_getvar(p_id,p_type,p_exchange){const obj=GodotJSWrapper.get_proxied_value(p_id);if(obj===undefined){return-1}const prop=GodotJSWrapper.variant2js(p_type,p_exchange);if(prop===undefined||prop===null){return-1}try{return GodotJSWrapper.js2variant(obj[prop],p_exchange)}catch(e){GodotRuntime.error(`Error getting variable ${prop} on object`,obj,e);return-1}}function _godot_js_wrapper_object_is_buffer(p_id){const obj=GodotJSWrapper.get_proxied_value(p_id);return GodotJSWrapper.isBuffer(obj)?1:0}function _godot_js_wrapper_object_set(p_id,p_name,p_type,p_exchange){const obj=GodotJSWrapper.get_proxied_value(p_id);if(obj===undefined){return}const name=GodotRuntime.parseString(p_name);try{obj[name]=GodotJSWrapper.variant2js(p_type,p_exchange)}catch(e){GodotRuntime.error(`Error setting variable ${name} on object`,obj)}}function _godot_js_wrapper_object_set_cb_ret(p_val_type,p_val_ex){GodotJSWrapper.cb_ret=GodotJSWrapper.variant2js(p_val_type,p_val_ex)}function _godot_js_wrapper_object_setvar(p_id,p_key_type,p_key_ex,p_val_type,p_val_ex){const obj=GodotJSWrapper.get_proxied_value(p_id);if(obj===undefined){return-1}const key=GodotJSWrapper.variant2js(p_key_type,p_key_ex);try{obj[key]=GodotJSWrapper.variant2js(p_val_type,p_val_ex);return 0}catch(e){GodotRuntime.error(`Error setting variable ${key} on object`,obj);return-1}}function _godot_js_wrapper_object_transfer_buffer(p_id,p_byte_arr,p_byte_arr_write,p_callback){let obj=GodotJSWrapper.get_proxied_value(p_id);if(!GodotJSWrapper.isBuffer(obj)){return}if(ArrayBuffer.isView(obj)&&!(obj instanceof Uint8Array)){obj=new Uint8Array(obj.buffer)}else if(obj instanceof ArrayBuffer){obj=new Uint8Array(obj)}const resizePackedByteArrayAndOpenWrite=GodotRuntime.get_func(p_callback);const bytesPtr=resizePackedByteArrayAndOpenWrite(p_byte_arr,p_byte_arr_write,obj.length);HEAPU8.set(obj,bytesPtr)}function _godot_js_wrapper_object_unref(p_id){const proxy=IDHandler.get(p_id);if(proxy!==undefined){proxy.unref()}}function _godot_webgl2_glFramebufferTextureMultisampleMultiviewOVR(target,attachment,texture,level,samples,base_view_index,num_views){const context=GL.currentContext;if(typeof context.oculusMultiviewExt==="undefined"){const ext=context.GLctx.getExtension("OCULUS_multiview");if(!ext){GodotRuntime.error("Trying to call glFramebufferTextureMultisampleMultiviewOVR() without the OCULUS_multiview extension");return}context.oculusMultiviewExt=ext}const ext=context.oculusMultiviewExt;ext.framebufferTextureMultisampleMultiviewOVR(target,attachment,GL.textures[texture],level,samples,base_view_index,num_views)}function _godot_webgl2_glFramebufferTextureMultiviewOVR(target,attachment,texture,level,base_view_index,num_views){const context=GL.currentContext;if(typeof context.multiviewExt==="undefined"){const ext=context.GLctx.getExtension("OVR_multiview2");if(!ext){GodotRuntime.error("Trying to call glFramebufferTextureMultiviewOVR() without the OVR_multiview2 extension");return}context.multiviewExt=ext}const ext=context.multiviewExt;ext.framebufferTextureMultiviewOVR(target,attachment,GL.textures[texture],level,base_view_index,num_views)}function _godot_webgl2_glGetBufferSubData(target,offset,size,data){const gl_context_handle=_emscripten_webgl_get_current_context();const gl=GL.getContext(gl_context_handle);if(gl){gl.GLctx["getBufferSubData"](target,offset,HEAPU8,data,size)}}var GodotWebXR={gl:null,session:null,gl_binding:null,layer:null,space:null,frame:null,pose:null,view_count:1,input_sources:[,,,,,,,,,,,,,,,],touches:[,,,,],onsimpleevent:null,orig_requestAnimationFrame:null,requestAnimationFrame:callback=>{if(GodotWebXR.session&&GodotWebXR.space){const onFrame=function(time,frame){GodotWebXR.frame=frame;GodotWebXR.pose=frame.getViewerPose(GodotWebXR.space);callback(time);GodotWebXR.frame=null;GodotWebXR.pose=null};GodotWebXR.session.requestAnimationFrame(onFrame)}else{GodotWebXR.orig_requestAnimationFrame(callback)}},monkeyPatchRequestAnimationFrame:enable=>{if(GodotWebXR.orig_requestAnimationFrame===null){GodotWebXR.orig_requestAnimationFrame=MainLoop.requestAnimationFrame}MainLoop.requestAnimationFrame=enable?GodotWebXR.requestAnimationFrame:GodotWebXR.orig_requestAnimationFrame},pauseResumeMainLoop:()=>{MainLoop.pause();runtimeKeepalivePush();window.setTimeout(function(){runtimeKeepalivePop();MainLoop.resume()},0)},getLayer:()=>{const new_view_count=GodotWebXR.pose?GodotWebXR.pose.views.length:1;let layer=GodotWebXR.layer;if(layer&&GodotWebXR.view_count===new_view_count){return layer}if(!GodotWebXR.session||!GodotWebXR.gl_binding||!GodotWebXR.gl_binding.createProjectionLayer){return null}const gl=GodotWebXR.gl;layer=GodotWebXR.gl_binding.createProjectionLayer({textureType:new_view_count>1?"texture-array":"texture",colorFormat:gl.RGBA8,depthFormat:gl.DEPTH_COMPONENT24});GodotWebXR.session.updateRenderState({layers:[layer]});GodotWebXR.layer=layer;GodotWebXR.view_count=new_view_count;return layer},getSubImage:()=>{if(!GodotWebXR.pose){return null}const layer=GodotWebXR.getLayer();if(layer===null){return null}return GodotWebXR.gl_binding.getViewSubImage(layer,GodotWebXR.pose.views[0])},getTextureId:texture=>{if(texture.name!==undefined){return texture.name}const id=GL.getNewId(GL.textures);texture.name=id;GL.textures[id]=texture;return id},addInputSource:input_source=>{let name=-1;if(input_source.targetRayMode==="tracked-pointer"&&input_source.handedness==="left"){name=0}else if(input_source.targetRayMode==="tracked-pointer"&&input_source.handedness==="right"){name=1}else{for(let i=2;i<16;i++){if(!GodotWebXR.input_sources[i]){name=i;break}}}if(name>=0){GodotWebXR.input_sources[name]=input_source;input_source.name=name;if(input_source.targetRayMode==="screen"){let touch_index=-1;for(let i=0;i<5;i++){if(!GodotWebXR.touches[i]){touch_index=i;break}}if(touch_index>=0){GodotWebXR.touches[touch_index]=input_source;input_source.touch_index=touch_index}}}return name},removeInputSource:input_source=>{if(input_source.name!==undefined){const name=input_source.name;if(name>=0&&name<16){GodotWebXR.input_sources[name]=null}if(input_source.touch_index!==undefined){const touch_index=input_source.touch_index;if(touch_index>=0&&touch_index<5){GodotWebXR.touches[touch_index]=null}}return name}return-1},getInputSourceId:input_source=>{if(input_source!==undefined){return input_source.name}return-1},getTouchIndex:input_source=>{if(input_source.touch_index!==undefined){return input_source.touch_index}return-1}};function _godot_webxr_get_bounds_geometry(r_points){if(!GodotWebXR.space||!GodotWebXR.space.boundsGeometry){return 0}const point_count=GodotWebXR.space.boundsGeometry.length;if(point_count===0){return 0}const buf=GodotRuntime.malloc(point_count*3*4);for(let i=0;i<point_count;i++){const point=GodotWebXR.space.boundsGeometry[i];GodotRuntime.setHeapValue(buf+(i*3+0)*4,point.x,"float");GodotRuntime.setHeapValue(buf+(i*3+1)*4,point.y,"float");GodotRuntime.setHeapValue(buf+(i*3+2)*4,point.z,"float")}GodotRuntime.setHeapValue(r_points,buf,"i32");return point_count}function _godot_webxr_get_color_texture(){const subimage=GodotWebXR.getSubImage();if(subimage===null){return 0}return GodotWebXR.getTextureId(subimage.colorTexture)}function _godot_webxr_get_depth_texture(){const subimage=GodotWebXR.getSubImage();if(subimage===null){return 0}if(!subimage.depthStencilTexture){return 0}return GodotWebXR.getTextureId(subimage.depthStencilTexture)}function _godot_webxr_get_frame_rate(){if(!GodotWebXR.session||GodotWebXR.session.frameRate===undefined){return 0}return GodotWebXR.session.frameRate}function _godot_webxr_get_projection_for_view(p_view,r_transform){if(!GodotWebXR.session||!GodotWebXR.pose){return false}const matrix=GodotWebXR.pose.views[p_view].projectionMatrix;for(let i=0;i<16;i++){GodotRuntime.setHeapValue(r_transform+i*4,matrix[i],"float")}return true}function _godot_webxr_get_render_target_size(r_size){const subimage=GodotWebXR.getSubImage();if(subimage===null){return false}GodotRuntime.setHeapValue(r_size+0,subimage.viewport.width,"i32");GodotRuntime.setHeapValue(r_size+4,subimage.viewport.height,"i32");return true}function _godot_webxr_get_supported_frame_rates(r_frame_rates){if(!GodotWebXR.session||GodotWebXR.session.supportedFrameRates===undefined){return 0}const frame_rate_count=GodotWebXR.session.supportedFrameRates.length;if(frame_rate_count===0){return 0}const buf=GodotRuntime.malloc(frame_rate_count*4);for(let i=0;i<frame_rate_count;i++){GodotRuntime.setHeapValue(buf+i*4,GodotWebXR.session.supportedFrameRates[i],"float")}GodotRuntime.setHeapValue(r_frame_rates,buf,"i32");return frame_rate_count}function _godot_webxr_get_transform_for_view(p_view,r_transform){if(!GodotWebXR.session||!GodotWebXR.pose){return false}const views=GodotWebXR.pose.views;let matrix;if(p_view>=0){matrix=views[p_view].transform.matrix}else{matrix=GodotWebXR.pose.transform.matrix}for(let i=0;i<16;i++){GodotRuntime.setHeapValue(r_transform+i*4,matrix[i],"float")}return true}function _godot_webxr_get_velocity_texture(){const subimage=GodotWebXR.getSubImage();if(subimage===null){return 0}if(!subimage.motionVectorTexture){return 0}return GodotWebXR.getTextureId(subimage.motionVectorTexture)}function _godot_webxr_get_view_count(){if(!GodotWebXR.session||!GodotWebXR.pose){return 1}const view_count=GodotWebXR.pose.views.length;return view_count>0?view_count:1}function _godot_webxr_get_visibility_state(){if(!GodotWebXR.session||!GodotWebXR.session.visibilityState){return 0}return GodotRuntime.allocString(GodotWebXR.session.visibilityState)}var _godot_webxr_initialize=function(p_session_mode,p_required_features,p_optional_features,p_requested_reference_spaces,p_on_session_started,p_on_session_ended,p_on_session_failed,p_on_input_event,p_on_simple_event){GodotWebXR.monkeyPatchRequestAnimationFrame(true);const session_mode=GodotRuntime.parseString(p_session_mode);const required_features=GodotRuntime.parseString(p_required_features).split(",").map(s=>s.trim()).filter(s=>s!=="");const optional_features=GodotRuntime.parseString(p_optional_features).split(",").map(s=>s.trim()).filter(s=>s!=="");const requested_reference_space_types=GodotRuntime.parseString(p_requested_reference_spaces).split(",").map(s=>s.trim());const onstarted=GodotRuntime.get_func(p_on_session_started);const onended=GodotRuntime.get_func(p_on_session_ended);const onfailed=GodotRuntime.get_func(p_on_session_failed);const oninputevent=GodotRuntime.get_func(p_on_input_event);const onsimpleevent=GodotRuntime.get_func(p_on_simple_event);const session_init={};if(required_features.length>0){session_init["requiredFeatures"]=required_features}if(optional_features.length>0){session_init["optionalFeatures"]=optional_features}navigator.xr.requestSession(session_mode,session_init).then(function(session){GodotWebXR.session=session;session.addEventListener("end",function(evt){onended()});session.addEventListener("inputsourceschange",function(evt){evt.added.forEach(GodotWebXR.addInputSource);evt.removed.forEach(GodotWebXR.removeInputSource)});["selectstart","selectend","squeezestart","squeezeend"].forEach((input_event,index)=>{session.addEventListener(input_event,function(evt){GodotWebXR.frame=evt.frame;oninputevent(index,GodotWebXR.getInputSourceId(evt.inputSource));GodotWebXR.frame=null})});session.addEventListener("visibilitychange",function(evt){const c_str=GodotRuntime.allocString("visibility_state_changed");onsimpleevent(c_str);GodotRuntime.free(c_str)});GodotWebXR.onsimpleevent=onsimpleevent;const gl_context_handle=_emscripten_webgl_get_current_context();const gl=GL.getContext(gl_context_handle).GLctx;GodotWebXR.gl=gl;gl.makeXRCompatible().then(function(){const throwNoWebXRLayersError=()=>{throw new Error("This browser doesn't support WebXR Layers (which Godot requires) nor is the polyfill in use. If you are the developer of this application, please consider including the polyfill.")};try{GodotWebXR.gl_binding=new XRWebGLBinding(session,gl)}catch(error){throwNoWebXRLayersError()}if(!GodotWebXR.gl_binding.createProjectionLayer){throwNoWebXRLayersError()}const layer=GodotWebXR.getLayer();if(!layer){throw new Error("Unable to create WebXR Layer.")}function onReferenceSpaceSuccess(reference_space,reference_space_type){GodotWebXR.space=reference_space;reference_space.onreset=function(evt){const c_str=GodotRuntime.allocString("reference_space_reset");onsimpleevent(c_str);GodotRuntime.free(c_str)};GodotWebXR.pauseResumeMainLoop();window.setTimeout(function(){const reference_space_c_str=GodotRuntime.allocString(reference_space_type);const enabled_features="enabledFeatures"in session?Array.from(session.enabledFeatures):[];const enabled_features_c_str=GodotRuntime.allocString(enabled_features.join(","));const environment_blend_mode="environmentBlendMode"in session?session.environmentBlendMode:"";const environment_blend_mode_c_str=GodotRuntime.allocString(environment_blend_mode);onstarted(reference_space_c_str,enabled_features_c_str,environment_blend_mode_c_str);GodotRuntime.free(reference_space_c_str);GodotRuntime.free(enabled_features_c_str);GodotRuntime.free(environment_blend_mode_c_str)},0)}function requestReferenceSpace(){const reference_space_type=requested_reference_space_types.shift();session.requestReferenceSpace(reference_space_type).then(refSpace=>{onReferenceSpaceSuccess(refSpace,reference_space_type)}).catch(()=>{if(requested_reference_space_types.length===0){const c_str=GodotRuntime.allocString("Unable to get any of the requested reference space types");onfailed(c_str);GodotRuntime.free(c_str)}else{requestReferenceSpace()}})}requestReferenceSpace()}).catch(function(error){const c_str=GodotRuntime.allocString(`Unable to make WebGL context compatible with WebXR: ${error}`);onfailed(c_str);GodotRuntime.free(c_str)})}).catch(function(error){const c_str=GodotRuntime.allocString(`Unable to start session: ${error}`);onfailed(c_str);GodotRuntime.free(c_str)})};function _godot_webxr_is_session_supported(p_session_mode,p_callback){const session_mode=GodotRuntime.parseString(p_session_mode);const cb=GodotRuntime.get_func(p_callback);if(navigator.xr){navigator.xr.isSessionSupported(session_mode).then(function(supported){const c_str=GodotRuntime.allocString(session_mode);cb(c_str,supported?1:0);GodotRuntime.free(c_str)})}else{const c_str=GodotRuntime.allocString(session_mode);cb(c_str,0);GodotRuntime.free(c_str)}}function _godot_webxr_is_supported(){return!!navigator.xr}var _godot_webxr_uninitialize=function(){if(GodotWebXR.session){GodotWebXR.session.end().catch(e=>{})}GodotWebXR.session=null;GodotWebXR.gl_binding=null;GodotWebXR.layer=null;GodotWebXR.space=null;GodotWebXR.frame=null;GodotWebXR.pose=null;GodotWebXR.view_count=1;GodotWebXR.input_sources=new Array(16);GodotWebXR.touches=new Array(5);GodotWebXR.onsimpleevent=null;GodotWebXR.monkeyPatchRequestAnimationFrame(false);GodotWebXR.pauseResumeMainLoop()};function _godot_webxr_update_input_source(p_input_source_id,r_target_pose,r_target_ray_mode,r_touch_index,r_has_grip_pose,r_grip_pose,r_has_standard_mapping,r_button_count,r_buttons,r_axes_count,r_axes,r_has_hand_data,r_hand_joints,r_hand_radii){if(!GodotWebXR.session||!GodotWebXR.frame){return 0}if(p_input_source_id<0||p_input_source_id>=GodotWebXR.input_sources.length||!GodotWebXR.input_sources[p_input_source_id]){return false}const input_source=GodotWebXR.input_sources[p_input_source_id];const frame=GodotWebXR.frame;const space=GodotWebXR.space;const target_pose=frame.getPose(input_source.targetRaySpace,space);if(!target_pose){return false}const target_pose_matrix=target_pose.transform.matrix;for(let i=0;i<16;i++){GodotRuntime.setHeapValue(r_target_pose+i*4,target_pose_matrix[i],"float")}let target_ray_mode=0;switch(input_source.targetRayMode){case"gaze":target_ray_mode=1;break;case"tracked-pointer":target_ray_mode=2;break;case"screen":target_ray_mode=3;break;default:}GodotRuntime.setHeapValue(r_target_ray_mode,target_ray_mode,"i32");GodotRuntime.setHeapValue(r_touch_index,GodotWebXR.getTouchIndex(input_source),"i32");let has_grip_pose=false;if(input_source.gripSpace){const grip_pose=frame.getPose(input_source.gripSpace,space);if(grip_pose){const grip_pose_matrix=grip_pose.transform.matrix;for(let i=0;i<16;i++){GodotRuntime.setHeapValue(r_grip_pose+i*4,grip_pose_matrix[i],"float")}has_grip_pose=true}}GodotRuntime.setHeapValue(r_has_grip_pose,has_grip_pose?1:0,"i32");let has_standard_mapping=false;let button_count=0;let axes_count=0;if(input_source.gamepad){if(input_source.gamepad.mapping==="xr-standard"){has_standard_mapping=true}button_count=Math.min(input_source.gamepad.buttons.length,10);for(let i=0;i<button_count;i++){GodotRuntime.setHeapValue(r_buttons+i*4,input_source.gamepad.buttons[i].value,"float")}axes_count=Math.min(input_source.gamepad.axes.length,10);for(let i=0;i<axes_count;i++){GodotRuntime.setHeapValue(r_axes+i*4,input_source.gamepad.axes[i],"float")}}GodotRuntime.setHeapValue(r_has_standard_mapping,has_standard_mapping?1:0,"i32");GodotRuntime.setHeapValue(r_button_count,button_count,"i32");GodotRuntime.setHeapValue(r_axes_count,axes_count,"i32");let has_hand_data=false;if(input_source.hand&&r_hand_joints!==0&&r_hand_radii!==0){const hand_joint_array=new Float32Array(25*16);const hand_radii_array=new Float32Array(25);if(frame.fillPoses(input_source.hand.values(),space,hand_joint_array)&&frame.fillJointRadii(input_source.hand.values(),hand_radii_array)){GodotRuntime.heapCopy(HEAPF32,hand_joint_array,r_hand_joints);GodotRuntime.heapCopy(HEAPF32,hand_radii_array,r_hand_radii);has_hand_data=true}}GodotRuntime.setHeapValue(r_has_hand_data,has_hand_data?1:0,"i32");return true}function _godot_webxr_update_target_frame_rate(p_frame_rate){if(!GodotWebXR.session||GodotWebXR.session.updateTargetFrameRate===undefined){return}GodotWebXR.session.updateTargetFrameRate(p_frame_rate).then(()=>{const c_str=GodotRuntime.allocString("display_refresh_rate_changed");GodotWebXR.onsimpleevent(c_str);GodotRuntime.free(c_str)})}var stackAlloc=sz=>__emscripten_stack_alloc(sz);var stringToUTF8OnStack=str=>{var size=lengthBytesUTF8(str)+1;var ret=stackAlloc(size);stringToUTF8(str,ret,size);return ret};var getCFunc=ident=>{var func=Module["_"+ident];return func};var writeArrayToMemory=(array,buffer)=>{HEAP8.set(array,buffer)};var stackSave=()=>_emscripten_stack_get_current();var stackRestore=val=>__emscripten_stack_restore(val);var ccall=(ident,returnType,argTypes,args,opts)=>{var toC={string:str=>{var ret=0;if(str!==null&&str!==undefined&&str!==0){ret=stringToUTF8OnStack(str)}return ret},array:arr=>{var ret=stackAlloc(arr.length);writeArrayToMemory(arr,ret);return ret}};function convertReturnValue(ret){if(returnType==="string"){return UTF8ToString(ret)}if(returnType==="boolean")return Boolean(ret);return ret}var func=getCFunc(ident);var cArgs=[];var stack=0;if(args){for(var i=0;i<args.length;i++){var converter=toC[argTypes[i]];if(converter){if(stack===0)stack=stackSave();cArgs[i]=converter(args[i])}else{cArgs[i]=args[i]}}}var ret=func(...cArgs);function onDone(ret){if(stack!==0)stackRestore(stack);return convertReturnValue(ret)}ret=onDone(ret);return ret};var cwrap=(ident,returnType,argTypes,opts)=>{var numericArgs=!argTypes||argTypes.every(type=>type==="number"||type==="boolean");var numericRet=returnType!=="string";if(numericRet&&numericArgs&&!opts){return getCFunc(ident)}return(...args)=>ccall(ident,returnType,argTypes,args,opts)};FS.createPreloadedFile=FS_createPreloadedFile;FS.preloadFile=FS_preloadFile;FS.staticInit();Module["requestAnimationFrame"]=MainLoop.requestAnimationFrame;Module["pauseMainLoop"]=MainLoop.pause;Module["resumeMainLoop"]=MainLoop.resume;MainLoop.init();for(let i=0;i<32;++i)tempFixedLengthArray.push(new Array(i));var miniTempWebGLIntBuffersStorage=new Int32Array(288);for(var i=0;i<=288;++i){miniTempWebGLIntBuffers[i]=miniTempWebGLIntBuffersStorage.subarray(0,i)}var miniTempWebGLFloatBuffersStorage=new Float32Array(288);for(var i=0;i<=288;++i){miniTempWebGLFloatBuffers[i]=miniTempWebGLFloatBuffersStorage.subarray(0,i)}Module["request_quit"]=function(){GodotOS.request_quit()};Module["onExit"]=GodotOS.cleanup;GodotOS._fs_sync_promise=Promise.resolve();Module["initConfig"]=GodotConfig.init_config;Module["initFS"]=GodotFS.init;Module["copyToFS"]=GodotFS.copy_to_fs;GodotOS.atexit(function(resolve,reject){GodotDisplayCursor.clear();resolve()});GodotOS.atexit(function(resolve,reject){GodotEventListeners.clear();resolve()});GodotOS.atexit(function(resolve,reject){GodotDisplayVK.clear();resolve()});GodotOS.atexit(function(resolve,reject){GodotIME.clear();resolve()});GodotJSWrapper.proxies=new Map;{if(Module["noExitRuntime"])noExitRuntime=Module["noExitRuntime"];if(Module["preloadPlugins"])preloadPlugins=Module["preloadPlugins"];if(Module["print"])out=Module["print"];if(Module["printErr"])err=Module["printErr"];if(Module["wasmBinary"])wasmBinary=Module["wasmBinary"];if(Module["arguments"])arguments_=Module["arguments"];if(Module["thisProgram"])thisProgram=Module["thisProgram"];if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].shift()()}}}Module["callMain"]=callMain;Module["cwrap"]=cwrap;var _free,__Z14godot_web_mainiPPc,_main,_malloc,_fflush,__emwebxr_on_input_event,__emwebxr_on_simple_event,___funcs_on_exit,_emscripten_builtin_memalign,__emscripten_timeout,__emscripten_stack_restore,__emscripten_stack_alloc,_emscripten_stack_get_current,memory,__indirect_function_table,wasmMemory,wasmTable;function assignWasmExports(wasmExports){_free=Module["_free"]=wasmExports["qf"];__Z14godot_web_mainiPPc=Module["__Z14godot_web_mainiPPc"]=wasmExports["rf"];_main=Module["_main"]=wasmExports["sf"];_malloc=Module["_malloc"]=wasmExports["tf"];_fflush=wasmExports["uf"];__emwebxr_on_input_event=Module["__emwebxr_on_input_event"]=wasmExports["vf"];__emwebxr_on_simple_event=Module["__emwebxr_on_simple_event"]=wasmExports["wf"];___funcs_on_exit=wasmExports["yf"];_emscripten_builtin_memalign=wasmExports["zf"];__emscripten_timeout=wasmExports["Af"];__emscripten_stack_restore=wasmExports["Bf"];__emscripten_stack_alloc=wasmExports["Cf"];_emscripten_stack_get_current=wasmExports["Df"];memory=wasmMemory=wasmExports["of"];__indirect_function_table=wasmTable=wasmExports["xf"]}var wasmImports={Pc:___call_sighandler,gd:___syscall_chdir,Ya:___syscall_chmod,hd:___syscall_faccessat,ed:___syscall_fchmod,U:___syscall_fcntl64,dd:___syscall_fstat64,$c:___syscall_ftruncate64,_c:___syscall_getcwd,Oc:___syscall_getdents64,Aa:___syscall_ioctl,bd:___syscall_lstat64,Vc:___syscall_mkdirat,Uc:___syscall_mknodat,ad:___syscall_newfstatat,Wa:___syscall_openat,Nc:___syscall_readlinkat,Lc:___syscall_renameat,Sa:___syscall_rmdir,cd:___syscall_stat64,Kc:___syscall_statfs64,Jc:___syscall_symlinkat,Ta:___syscall_unlinkat,id:__abort_js,Rc:__emscripten_runtime_keepalive_clear,Sc:__gmtime_js,Tc:__localtime_js,Gc:__setitimer_js,jd:__tzset_js,fd:_clock_time_get,wb:_emscripten_cancel_main_loop,Xa:_emscripten_date_now,We:_emscripten_force_exit,Ic:_emscripten_get_heap_max,ka:_emscripten_get_now,Hc:_emscripten_resize_heap,Mc:_emscripten_set_canvas_element_size,Ka:_emscripten_set_main_loop,Oa:_emscripten_webgl_commit_frame,cc:_emscripten_webgl_create_context,Mb:_emscripten_webgl_destroy_context,ac:_emscripten_webgl_enable_extension,wd:_emscripten_webgl_get_supported_extensions,bc:_emscripten_webgl_make_context_current,Yc:_environ_get,Zc:_environ_sizes_get,Ja:_exit,oa:_fd_close,Ua:_fd_fdstat_get,Za:_fd_read,Xc:_fd_seek,za:_fd_write,g:_glActiveTexture,cb:_glAttachShader,ga:_glBeginTransformFeedback,b:_glBindBuffer,y:_glBindBufferBase,Da:_glBindBufferRange,d:_glBindFramebuffer,ta:_glBindRenderbuffer,c:_glBindTexture,f:_glBindVertexArray,Rd:_glBlendColor,G:_glBlendEquation,ja:_glBlendFunc,B:_glBlendFuncSeparate,ia:_glBlitFramebuffer,h:_glBufferData,P:_glBufferSubData,R:_glCheckFramebufferStatus,H:_glClear,kb:_glClearBufferfv,Q:_glClearColor,_:_glClearDepthf,hb:_glClearStencil,S:_glColorMask,eb:_glCompileShader,pd:_glCompressedTexImage2D,rd:_glCompressedTexImage3D,qd:_glCompressedTexSubImage3D,sd:_glCopyBufferSubData,Cd:_glCreateProgram,gb:_glCreateShader,na:_glCullFace,m:_glDeleteBuffers,u:_glDeleteFramebuffers,ha:_glDeleteProgram,md:_glDeleteQueries,pa:_glDeleteRenderbuffers,W:_glDeleteShader,ob:_glDeleteSync,j:_glDeleteTextures,N:_glDeleteVertexArrays,F:_glDepthFunc,x:_glDepthMask,e:_glDisable,n:_glDisableVertexAttribArray,E:_glDrawArrays,T:_glDrawArraysInstanced,da:_glDrawBuffers,K:_glDrawElements,L:_glDrawElementsInstanced,r:_glEnable,o:_glEnableVertexAttribArray,fa:_glEndTransformFeedback,nb:_glFenceSync,Kd:_glFinish,Ha:_glFramebufferRenderbuffer,t:_glFramebufferTexture2D,ca:_glFramebufferTextureLayer,lb:_glFrontFace,k:_glGenBuffers,C:_glGenFramebuffers,nd:_glGenQueries,Ia:_glGenRenderbuffers,v:_glGenTextures,M:_glGenVertexArrays,ld:_glGenerateMipmap,ud:_glGetFloatv,vd:_glGetInteger64v,aa:_glGetIntegerv,xd:_glGetProgramInfoLog,bb:_glGetProgramiv,db:_glGetShaderInfoLog,sa:_glGetShaderiv,Z:_glGetString,Ud:_glGetSynciv,Fd:_glGetUniformBlockIndex,Ea:_glGetUniformLocation,zd:_glLinkProgram,Ba:_glPixelStorei,Id:_glReadBuffer,Ca:_glReadPixels,Nd:_glRenderbufferStorage,$a:_glRenderbufferStorageMultisample,va:_glScissor,fb:_glShaderSource,jb:_glStencilFunc,ba:_glStencilMask,Hd:_glStencilOp,w:_glTexImage2D,Y:_glTexImage3D,Ga:_glTexParameterf,a:_glTexParameteri,Fa:_glTexStorage2D,_a:_glTexSubImage3D,Ad:_glTransformFeedbackVaryings,i:_glUniform1f,D:_glUniform1i,Dd:_glUniform1iv,p:_glUniform1ui,ma:_glUniform1uiv,X:_glUniform2f,I:_glUniform2fv,la:_glUniform2iv,q:_glUniform3fv,O:_glUniform4f,A:_glUniform4fv,Ed:_glUniformBlockBinding,ib:_glUniformMatrix3fv,J:_glUniformMatrix4fv,l:_glUseProgram,ua:_glVertexAttrib4f,$:_glVertexAttribDivisor,mb:_glVertexAttribI4ui,ea:_glVertexAttribIPointer,s:_glVertexAttribPointer,z:_glViewport,Je:_godot_audio_get_sample_playback_position,yd:_godot_audio_has_script_processor,Jd:_godot_audio_has_worklet,mf:_godot_audio_init,zc:_godot_audio_input_start,sc:_godot_audio_input_stop,nf:_godot_audio_is_available,qa:_godot_audio_resume,Td:_godot_audio_sample_bus_add,Sd:_godot_audio_sample_bus_move,_d:_godot_audio_sample_bus_remove,he:_godot_audio_sample_bus_set_count,Ld:_godot_audio_sample_bus_set_mute,Pd:_godot_audio_sample_bus_set_send,Md:_godot_audio_sample_bus_set_solo,Od:_godot_audio_sample_bus_set_volume_db,Ue:_godot_audio_sample_is_active,Zb:_godot_audio_sample_register_stream,Qd:_godot_audio_sample_set_finished_callback,af:_godot_audio_sample_set_pause,qe:_godot_audio_sample_set_volumes_linear,Gb:_godot_audio_sample_start,lf:_godot_audio_sample_stop,ic:_godot_audio_sample_stream_is_registered,Ob:_godot_audio_sample_unregister_stream,Ae:_godot_audio_sample_update_pitch_scale,td:_godot_audio_script_create,od:_godot_audio_script_start,Gd:_godot_audio_worklet_create,Bd:_godot_audio_worklet_start_no_threads,hc:_godot_js_config_canvas_id_get,Le:_godot_js_config_locale_get,Te:_godot_js_display_alert,tc:_godot_js_display_canvas_focus,uc:_godot_js_display_canvas_is_focused,jc:_godot_js_display_clipboard_get,kc:_godot_js_display_clipboard_set,wc:_godot_js_display_cursor_is_hidden,vc:_godot_js_display_cursor_is_locked,xa:_godot_js_display_cursor_lock_set,Ra:_godot_js_display_cursor_set_custom_shape,xc:_godot_js_display_cursor_set_shape,ya:_godot_js_display_cursor_set_visible,Fb:_godot_js_display_desired_size_set,Rb:_godot_js_display_fullscreen_cb,Eb:_godot_js_display_fullscreen_exit,Db:_godot_js_display_fullscreen_request,dc:_godot_js_display_has_webgl,fc:_godot_js_display_is_swap_ok_cancel,Pb:_godot_js_display_notification_cb,Ib:_godot_js_display_pixel_ratio_get,Jb:_godot_js_display_screen_dpi_get,Kb:_godot_js_display_screen_size_get,gc:_godot_js_display_setup_canvas,Wc:_godot_js_display_size_update,rc:_godot_js_display_touchscreen_is_available,Lb:_godot_js_display_tts_available,Na:_godot_js_display_vk_available,Nb:_godot_js_display_vk_cb,pc:_godot_js_display_vk_hide,qc:_godot_js_display_vk_show,Qb:_godot_js_display_window_blur_cb,Pa:_godot_js_display_window_icon_set,Ma:_godot_js_display_window_size_get,Hb:_godot_js_display_window_title_set,Ve:_godot_js_emscripten_get_version,$e:_godot_js_eval,Bb:_godot_js_fetch_create,La:_godot_js_fetch_free,yb:_godot_js_fetch_http_status_get,Ab:_godot_js_fetch_is_chunked,zb:_godot_js_fetch_read_chunk,kf:_godot_js_fetch_read_headers,wa:_godot_js_fetch_state_get,Ub:_godot_js_input_drop_files_cb,Tb:_godot_js_input_gamepad_cb,Cb:_godot_js_input_gamepad_sample,mc:_godot_js_input_gamepad_sample_count,lc:_godot_js_input_gamepad_sample_get,Wb:_godot_js_input_key_cb,$b:_godot_js_input_mouse_button_cb,_b:_godot_js_input_mouse_move_cb,Yb:_godot_js_input_mouse_wheel_cb,Vb:_godot_js_input_paste_cb,Xb:_godot_js_input_touch_cb,Ne:_godot_js_input_vibrate_handheld,Qa:_godot_js_is_ime_focused,Ye:_godot_js_os_download_buffer,Re:_godot_js_os_execute,vb:_godot_js_os_finish_async,Ie:_godot_js_os_fs_is_persistent,Se:_godot_js_os_fs_sync,Pe:_godot_js_os_has_feature,Qe:_godot_js_os_hw_concurrency_get,ec:_godot_js_os_request_quit_cb,Oe:_godot_js_os_shell_open,Ke:_godot_js_pwa_cb,Me:_godot_js_pwa_update,ub:_godot_js_rtc_datachannel_close,ye:_godot_js_rtc_datachannel_connect,ve:_godot_js_rtc_datachannel_destroy,ze:_godot_js_rtc_datachannel_get_buffered_amount,Ee:_godot_js_rtc_datachannel_id_get,Be:_godot_js_rtc_datachannel_is_negotiated,Fe:_godot_js_rtc_datachannel_is_ordered,xe:_godot_js_rtc_datachannel_label_get,De:_godot_js_rtc_datachannel_max_packet_lifetime_get,Ce:_godot_js_rtc_datachannel_max_retransmits_get,we:_godot_js_rtc_datachannel_protocol_get,He:_godot_js_rtc_datachannel_ready_state_get,Ge:_godot_js_rtc_datachannel_send,tb:_godot_js_rtc_pc_close,pe:_godot_js_rtc_pc_create,oe:_godot_js_rtc_pc_datachannel_create,sb:_godot_js_rtc_pc_destroy,re:_godot_js_rtc_pc_ice_candidate_add,te:_godot_js_rtc_pc_local_description_set,ue:_godot_js_rtc_pc_offer_create,se:_godot_js_rtc_pc_remote_description_set,oc:_godot_js_set_ime_active,Sb:_godot_js_set_ime_cb,nc:_godot_js_set_ime_position,Dc:_godot_js_tts_get_voices,Ec:_godot_js_tts_is_paused,Fc:_godot_js_tts_is_speaking,Bc:_godot_js_tts_pause,Ac:_godot_js_tts_resume,Cc:_godot_js_tts_speak,yc:_godot_js_tts_stop,Va:_godot_js_webmidi_close_midi_inputs,kd:_godot_js_webmidi_open_midi_inputs,le:_godot_js_websocket_buffered_amount,ke:_godot_js_websocket_close,ne:_godot_js_websocket_create,rb:_godot_js_websocket_destroy,me:_godot_js_websocket_send,df:_godot_js_wrapper_create_cb,bf:_godot_js_wrapper_create_object,cf:_godot_js_wrapper_interface_get,ff:_godot_js_wrapper_object_call,hf:_godot_js_wrapper_object_get,xb:_godot_js_wrapper_object_getvar,_e:_godot_js_wrapper_object_is_buffer,jf:_godot_js_wrapper_object_set,ef:_godot_js_wrapper_object_set_cb_ret,gf:_godot_js_wrapper_object_setvar,Ze:_godot_js_wrapper_object_transfer_buffer,Xe:_godot_js_wrapper_object_unref,ab:_godot_webgl2_glFramebufferTextureMultisampleMultiviewOVR,V:_godot_webgl2_glFramebufferTextureMultiviewOVR,ra:_godot_webgl2_glGetBufferSubData,ge:_godot_webxr_get_bounds_geometry,Yd:_godot_webxr_get_color_texture,Xd:_godot_webxr_get_depth_texture,fe:_godot_webxr_get_frame_rate,Zd:_godot_webxr_get_projection_for_view,$d:_godot_webxr_get_render_target_size,de:_godot_webxr_get_supported_frame_rates,pb:_godot_webxr_get_transform_for_view,Wd:_godot_webxr_get_velocity_texture,qb:_godot_webxr_get_view_count,ie:_godot_webxr_get_visibility_state,be:_godot_webxr_initialize,je:_godot_webxr_is_session_supported,ce:_godot_webxr_is_supported,ae:_godot_webxr_uninitialize,Vd:_godot_webxr_update_input_source,ee:_godot_webxr_update_target_frame_rate,Qc:_proc_exit};function callMain(args=[]){var entryFunction=_main;args.unshift(thisProgram);var argc=args.length;var argv=stackAlloc((argc+1)*4);var argv_ptr=argv;for(var arg of args){HEAPU32[argv_ptr>>2]=stringToUTF8OnStack(arg);argv_ptr+=4}HEAPU32[argv_ptr>>2]=0;try{var ret=entryFunction(argc,argv);exitJS(ret,true);return ret}catch(e){return handleException(e)}}function run(args=arguments_){if(runDependencies>0){dependenciesFulfilled=run;return}preRun();if(runDependencies>0){dependenciesFulfilled=run;return}function doRun(){Module["calledRun"]=true;if(ABORT)return;initRuntime();preMain();readyPromiseResolve?.(Module);Module["onRuntimeInitialized"]?.();var noInitialRun=Module["noInitialRun"]||true;if(!noInitialRun)callMain(args);postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(()=>{setTimeout(()=>Module["setStatus"](""),1);doRun()},1)}else{doRun()}}var wasmExports;wasmExports=await (createWasm());run();addOnPostRun(function(){GL.getSource=(shader,count,string,length)=>{let source="";for(let i=0;i<count;++i){const ptr=HEAPU32[string+i*4>>2];const len=length?HEAPU32[length+i*4>>2]:undefined;if(len){const endPtr=ptr+len;const slice=HEAPU8.buffer instanceof ArrayBuffer?HEAPU8.subarray(ptr,endPtr):HEAPU8.slice(ptr,endPtr);source+=UTF8Decoder.decode(slice)}else{source+=UTF8ToString(ptr,len)}}return source}});if(runtimeInitialized){moduleRtn=Module}else{moduleRtn=new Promise((resolve,reject)=>{readyPromiseResolve=resolve;readyPromiseReject=reject})} +;return moduleRtn}})();if(typeof exports==="object"&&typeof module==="object"){module.exports=Godot;module.exports.default=Godot}else if(typeof define==="function"&&define["amd"])define([],()=>Godot); + +const Features = { + /** + * Check whether WebGL is available. Optionally, specify a particular version of WebGL to check for. + * + * @param {number=} [majorVersion=1] The major WebGL version to check for. + * @returns {boolean} If the given major version of WebGL is available. + * @function Engine.isWebGLAvailable + */ + isWebGLAvailable: function (majorVersion = 1) { + try { + return !!document.createElement('canvas').getContext(['webgl', 'webgl2'][majorVersion - 1]); + } catch (e) { /* Not available */ } + return false; + }, + + /** + * Check whether the Fetch API available and supports streaming responses. + * + * @returns {boolean} If the Fetch API is available and supports streaming responses. + * @function Engine.isFetchAvailable + */ + isFetchAvailable: function () { + return 'fetch' in window && 'Response' in window && 'body' in window.Response.prototype; + }, + + /** + * Check whether the engine is running in a Secure Context. + * + * @returns {boolean} If the engine is running in a Secure Context. + * @function Engine.isSecureContext + */ + isSecureContext: function () { + return window['isSecureContext'] === true; + }, + + /** + * Check whether the engine is cross origin isolated. + * This value is dependent on Cross-Origin-Opener-Policy and Cross-Origin-Embedder-Policy headers sent by the server. + * + * @returns {boolean} If the engine is running in a Secure Context. + * @function Engine.isSecureContext + */ + isCrossOriginIsolated: function () { + return window['crossOriginIsolated'] === true; + }, + + /** + * Check whether SharedBufferArray is available. + * + * Most browsers require the page to be running in a secure context, and the + * the server to provide specific CORS headers for SharedArrayBuffer to be available. + * + * @returns {boolean} If SharedArrayBuffer is available. + * @function Engine.isSharedArrayBufferAvailable + */ + isSharedArrayBufferAvailable: function () { + return 'SharedArrayBuffer' in window; + }, + + /** + * Check whether the AudioContext supports AudioWorkletNodes. + * + * @returns {boolean} If AudioWorkletNode is available. + * @function Engine.isAudioWorkletAvailable + */ + isAudioWorkletAvailable: function () { + return 'AudioContext' in window && 'audioWorklet' in AudioContext.prototype; + }, + + /** + * Return an array of missing required features (as string). + * + * @returns {Array<string>} A list of human-readable missing features. + * @function Engine.getMissingFeatures + * @param {{threads: (boolean|undefined)}} supportedFeatures + */ + getMissingFeatures: function (supportedFeatures = {}) { + const { + // Quotes are needed for the Closure compiler. + 'threads': supportsThreads = true, + } = supportedFeatures; + + const missing = []; + if (!Features.isWebGLAvailable(2)) { + missing.push('WebGL2 - Check web browser configuration and hardware support'); + } + if (!Features.isFetchAvailable()) { + missing.push('Fetch - Check web browser version'); + } + if (!Features.isSecureContext()) { + missing.push('Secure Context - Check web server configuration (use HTTPS)'); + } + + if (supportsThreads) { + if (!Features.isCrossOriginIsolated()) { + missing.push('Cross-Origin Isolation - Check that the web server configuration sends the correct headers.'); + } + if (!Features.isSharedArrayBufferAvailable()) { + missing.push('SharedArrayBuffer - Check that the web server configuration sends the correct headers.'); + } + } + + // Audio is normally optional since we have a dummy fallback. + return missing; + }, +}; + +const Preloader = /** @constructor */ function () { // eslint-disable-line no-unused-vars + function getTrackedResponse(response, load_status) { + function onloadprogress(reader, controller) { + return reader.read().then(function (result) { + if (load_status.done) { + return Promise.resolve(); + } + if (result.value) { + controller.enqueue(result.value); + load_status.loaded += result.value.length; + } + if (!result.done) { + return onloadprogress(reader, controller); + } + load_status.done = true; + return Promise.resolve(); + }); + } + const reader = response.body.getReader(); + return new Response(new ReadableStream({ + start: function (controller) { + onloadprogress(reader, controller).then(function () { + controller.close(); + }); + }, + }), { headers: response.headers }); + } + + function loadFetch(file, tracker, fileSize, raw) { + tracker[file] = { + total: fileSize || 0, + loaded: 0, + done: false, + }; + return fetch(file).then(function (response) { + if (!response.ok) { + return Promise.reject(new Error(`Failed loading file '${file}'`)); + } + const tr = getTrackedResponse(response, tracker[file]); + if (raw) { + return Promise.resolve(tr); + } + return tr.arrayBuffer(); + }); + } + + function retry(func, attempts = 1) { + function onerror(err) { + if (attempts <= 1) { + return Promise.reject(err); + } + return new Promise(function (resolve, reject) { + setTimeout(function () { + retry(func, attempts - 1).then(resolve).catch(reject); + }, 1000); + }); + } + return func().catch(onerror); + } + + const DOWNLOAD_ATTEMPTS_MAX = 4; + const loadingFiles = {}; + const lastProgress = { loaded: 0, total: 0 }; + let progressFunc = null; + + const animateProgress = function () { + let loaded = 0; + let total = 0; + let totalIsValid = true; + let progressIsFinal = true; + + Object.keys(loadingFiles).forEach(function (file) { + const stat = loadingFiles[file]; + if (!stat.done) { + progressIsFinal = false; + } + if (!totalIsValid || stat.total === 0) { + totalIsValid = false; + total = 0; + } else { + total += stat.total; + } + loaded += stat.loaded; + }); + if (loaded !== lastProgress.loaded || total !== lastProgress.total) { + lastProgress.loaded = loaded; + lastProgress.total = total; + if (typeof progressFunc === 'function') { + progressFunc(loaded, total); + } + } + if (!progressIsFinal) { + requestAnimationFrame(animateProgress); + } + }; + + this.animateProgress = animateProgress; + + this.setProgressFunc = function (callback) { + progressFunc = callback; + }; + + this.loadPromise = function (file, fileSize, raw = false) { + return retry(loadFetch.bind(null, file, loadingFiles, fileSize, raw), DOWNLOAD_ATTEMPTS_MAX); + }; + + this.preloadedFiles = []; + this.preload = function (pathOrBuffer, destPath, fileSize) { + let buffer = null; + if (typeof pathOrBuffer === 'string') { + const me = this; + return this.loadPromise(pathOrBuffer, fileSize).then(function (buf) { + me.preloadedFiles.push({ + path: destPath || pathOrBuffer, + buffer: buf, + }); + return Promise.resolve(); + }); + } else if (pathOrBuffer instanceof ArrayBuffer) { + buffer = new Uint8Array(pathOrBuffer); + } else if (ArrayBuffer.isView(pathOrBuffer)) { + buffer = new Uint8Array(pathOrBuffer.buffer); + } + if (buffer) { + this.preloadedFiles.push({ + path: destPath, + buffer: pathOrBuffer, + }); + return Promise.resolve(); + } + return Promise.reject(new Error('Invalid object for preloading')); + }; +}; + +/** + * An object used to configure the Engine instance based on godot export options, and to override those in custom HTML + * templates if needed. + * + * @header Engine configuration + * @summary The Engine configuration object. This is just a typedef, create it like a regular object, e.g.: + * + * ``const MyConfig = { executable: 'godot', unloadAfterInit: false }`` + * + * @typedef {Object} EngineConfig + */ +const EngineConfig = {}; // eslint-disable-line no-unused-vars + +/** + * @struct + * @constructor + * @ignore + */ +const InternalConfig = function (initConfig) { // eslint-disable-line no-unused-vars + const cfg = /** @lends {InternalConfig.prototype} */ { + /** + * Whether to unload the engine automatically after the instance is initialized. + * + * @memberof EngineConfig + * @default + * @type {boolean} + */ + unloadAfterInit: true, + /** + * The HTML DOM Canvas object to use. + * + * By default, the first canvas element in the document will be used is none is specified. + * + * @memberof EngineConfig + * @default + * @type {?HTMLCanvasElement} + */ + canvas: null, + /** + * The name of the WASM file without the extension. (Set by Godot Editor export process). + * + * @memberof EngineConfig + * @default + * @type {string} + */ + executable: '', + /** + * An alternative name for the game pck to load. The executable name is used otherwise. + * + * @memberof EngineConfig + * @default + * @type {?string} + */ + mainPack: null, + /** + * Specify a language code to select the proper localization for the game. + * + * The browser locale will be used if none is specified. See complete list of + * :ref:`supported locales <doc_locales>`. + * + * @memberof EngineConfig + * @type {?string} + * @default + */ + locale: null, + /** + * The canvas resize policy determines how the canvas should be resized by Godot. + * + * ``0`` means Godot won't do any resizing. This is useful if you want to control the canvas size from + * javascript code in your template. + * + * ``1`` means Godot will resize the canvas on start, and when changing window size via engine functions. + * + * ``2`` means Godot will adapt the canvas size to match the whole browser window. + * + * @memberof EngineConfig + * @type {number} + * @default + */ + canvasResizePolicy: 2, + /** + * The arguments to be passed as command line arguments on startup. + * + * See :ref:`command line tutorial <doc_command_line_tutorial>`. + * + * **Note**: :js:meth:`startGame <Engine.prototype.startGame>` will always add the ``--main-pack`` argument. + * + * @memberof EngineConfig + * @type {Array<string>} + * @default + */ + args: [], + /** + * When enabled, the game canvas will automatically grab the focus when the engine starts. + * + * @memberof EngineConfig + * @type {boolean} + * @default + */ + focusCanvas: true, + /** + * When enabled, this will turn on experimental virtual keyboard support on mobile. + * + * @memberof EngineConfig + * @type {boolean} + * @default + */ + experimentalVK: false, + /** + * The progressive web app service worker to install. + * @memberof EngineConfig + * @default + * @type {string} + */ + serviceWorker: '', + /** + * @ignore + * @type {Array.<string>} + */ + persistentPaths: ['/userfs'], + /** + * @ignore + * @type {boolean} + */ + persistentDrops: false, + /** + * @ignore + * @type {Array.<string>} + */ + gdextensionLibs: [], + /** + * @ignore + * @type {Array.<string>} + */ + fileSizes: [], + /** + * @ignore + * @type {number} + */ + emscriptenPoolSize: 8, + /** + * @ignore + * @type {number} + */ + godotPoolSize: 4, + /** + * A callback function for handling Godot's ``OS.execute`` calls. + * + * This is for example used in the Web Editor template to switch between project manager and editor, and for running the game. + * + * @callback EngineConfig.onExecute + * @param {string} path The path that Godot's wants executed. + * @param {Array.<string>} args The arguments of the "command" to execute. + */ + /** + * @ignore + * @type {?function(string, Array.<string>)} + */ + onExecute: null, + /** + * A callback function for being notified when the Godot instance quits. + * + * **Note**: This function will not be called if the engine crashes or become unresponsive. + * + * @callback EngineConfig.onExit + * @param {number} status_code The status code returned by Godot on exit. + */ + /** + * @ignore + * @type {?function(number)} + */ + onExit: null, + /** + * A callback function for displaying download progress. + * + * The function is called once per frame while downloading files, so the usage of ``requestAnimationFrame()`` + * is not necessary. + * + * If the callback function receives a total amount of bytes as 0, this means that it is impossible to calculate. + * Possible reasons include: + * + * - Files are delivered with server-side chunked compression + * - Files are delivered with server-side compression on Chromium + * - Not all file downloads have started yet (usually on servers without multi-threading) + * + * @callback EngineConfig.onProgress + * @param {number} current The current amount of downloaded bytes so far. + * @param {number} total The total amount of bytes to be downloaded. + */ + /** + * @ignore + * @type {?function(number, number)} + */ + onProgress: null, + /** + * A callback function for handling the standard output stream. This method should usually only be used in debug pages. + * + * By default, ``console.log()`` is used. + * + * @callback EngineConfig.onPrint + * @param {...*} [var_args] A variadic number of arguments to be printed. + */ + /** + * @ignore + * @type {?function(...*)} + */ + onPrint: function () { + console.log.apply(console, Array.from(arguments)); // eslint-disable-line no-console + }, + /** + * A callback function for handling the standard error stream. This method should usually only be used in debug pages. + * + * By default, ``console.error()`` is used. + * + * @callback EngineConfig.onPrintError + * @param {...*} [var_args] A variadic number of arguments to be printed as errors. + */ + /** + * @ignore + * @type {?function(...*)} + */ + onPrintError: function (var_args) { + console.error.apply(console, Array.from(arguments)); // eslint-disable-line no-console + }, + }; + + /** + * @ignore + * @struct + * @constructor + * @param {EngineConfig} opts + */ + function Config(opts) { + this.update(opts); + } + + Config.prototype = cfg; + + /** + * @ignore + * @param {EngineConfig} opts + */ + Config.prototype.update = function (opts) { + const config = opts || {}; + // NOTE: We must explicitly pass the default, accessing it via + // the key will fail due to closure compiler renames. + function parse(key, def) { + if (typeof (config[key]) === 'undefined') { + return def; + } + return config[key]; + } + // Module config + this.unloadAfterInit = parse('unloadAfterInit', this.unloadAfterInit); + this.onPrintError = parse('onPrintError', this.onPrintError); + this.onPrint = parse('onPrint', this.onPrint); + this.onProgress = parse('onProgress', this.onProgress); + + // Godot config + this.canvas = parse('canvas', this.canvas); + this.executable = parse('executable', this.executable); + this.mainPack = parse('mainPack', this.mainPack); + this.locale = parse('locale', this.locale); + this.canvasResizePolicy = parse('canvasResizePolicy', this.canvasResizePolicy); + this.persistentPaths = parse('persistentPaths', this.persistentPaths); + this.persistentDrops = parse('persistentDrops', this.persistentDrops); + this.experimentalVK = parse('experimentalVK', this.experimentalVK); + this.focusCanvas = parse('focusCanvas', this.focusCanvas); + this.serviceWorker = parse('serviceWorker', this.serviceWorker); + this.gdextensionLibs = parse('gdextensionLibs', this.gdextensionLibs); + this.fileSizes = parse('fileSizes', this.fileSizes); + this.emscriptenPoolSize = parse('emscriptenPoolSize', this.emscriptenPoolSize); + this.godotPoolSize = parse('godotPoolSize', this.godotPoolSize); + this.args = parse('args', this.args); + this.onExecute = parse('onExecute', this.onExecute); + this.onExit = parse('onExit', this.onExit); + }; + + /** + * @ignore + * @param {string} loadPath + * @param {Response} response + */ + Config.prototype.getModuleConfig = function (loadPath, response) { + let r = response; + const gdext = this.gdextensionLibs; + return { + 'print': this.onPrint, + 'printErr': this.onPrintError, + 'thisProgram': this.executable, + 'noExitRuntime': false, + 'dynamicLibraries': [`${loadPath}.side.wasm`].concat(this.gdextensionLibs), + 'emscriptenPoolSize': this.emscriptenPoolSize, + 'instantiateWasm': function (imports, onSuccess) { + function done(result) { + onSuccess(result['instance'], result['module']); + } + if (typeof (WebAssembly.instantiateStreaming) !== 'undefined') { + WebAssembly.instantiateStreaming(Promise.resolve(r), imports).then(done); + } else { + r.arrayBuffer().then(function (buffer) { + WebAssembly.instantiate(buffer, imports).then(done); + }); + } + r = null; + return {}; + }, + 'locateFile': function (path) { + if (!path.startsWith('godot.')) { + return path; + } else if (path.endsWith('.audio.worklet.js')) { + return `${loadPath}.audio.worklet.js`; + } else if (path.endsWith('.audio.position.worklet.js')) { + return `${loadPath}.audio.position.worklet.js`; + } else if (path.endsWith('.js')) { + return `${loadPath}.js`; + } else if (path in gdext) { + return path; + } else if (path.endsWith('.side.wasm')) { + return `${loadPath}.side.wasm`; + } else if (path.endsWith('.wasm')) { + return `${loadPath}.wasm`; + } + return path; + }, + }; + }; + + /** + * @ignore + * @param {function()} cleanup + */ + Config.prototype.getGodotConfig = function (cleanup) { + // Try to find a canvas + if (!(this.canvas instanceof HTMLCanvasElement)) { + const nodes = document.getElementsByTagName('canvas'); + if (nodes.length && nodes[0] instanceof HTMLCanvasElement) { + const first = nodes[0]; + this.canvas = /** @type {!HTMLCanvasElement} */ (first); + } + if (!this.canvas) { + throw new Error('No canvas found in page'); + } + } + // Canvas can grab focus on click, or key events won't work. + if (this.canvas.tabIndex < 0) { + this.canvas.tabIndex = 0; + } + + // Browser locale, or custom one if defined. + let locale = this.locale; + if (!locale) { + locale = navigator.languages ? navigator.languages[0] : navigator.language; + locale = locale.split('.')[0]; + } + locale = locale.replace('-', '_'); + const onExit = this.onExit; + + // Godot configuration. + return { + 'canvas': this.canvas, + 'canvasResizePolicy': this.canvasResizePolicy, + 'locale': locale, + 'persistentDrops': this.persistentDrops, + 'virtualKeyboard': this.experimentalVK, + 'godotPoolSize': this.godotPoolSize, + 'focusCanvas': this.focusCanvas, + 'onExecute': this.onExecute, + 'onExit': function (p_code) { + cleanup(); // We always need to call the cleanup callback to free memory. + if (typeof (onExit) === 'function') { + onExit(p_code); + } + }, + }; + }; + return new Config(initConfig); +}; + +/** + * Projects exported for the Web expose the :js:class:`Engine` class to the JavaScript environment, that allows + * fine control over the engine's start-up process. + * + * This API is built in an asynchronous manner and requires basic understanding + * of `Promises <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Using_promises>`__. + * + * @module Engine + * @header Web export JavaScript reference + */ +const Engine = (function () { + const preloader = new Preloader(); + + let loadPromise = null; + let loadPath = ''; + let initPromise = null; + + /** + * @classdesc The ``Engine`` class provides methods for loading and starting exported projects on the Web. For default export + * settings, this is already part of the exported HTML page. To understand practical use of the ``Engine`` class, + * see :ref:`Custom HTML page for Web export <doc_customizing_html5_shell>`. + * + * @description Create a new Engine instance with the given configuration. + * + * @global + * @constructor + * @param {EngineConfig} initConfig The initial config for this instance. + */ + function Engine(initConfig) { // eslint-disable-line no-shadow + this.config = new InternalConfig(initConfig); + this.rtenv = null; + } + + /** + * Load the engine from the specified base path. + * + * @param {string} basePath Base path of the engine to load. + * @param {number=} [size=0] The file size if known. + * @returns {Promise} A Promise that resolves once the engine is loaded. + * + * @function Engine.load + */ + Engine.load = function (basePath, size) { + if (loadPromise == null) { + loadPath = basePath; + loadPromise = preloader.loadPromise(`${loadPath}.wasm`, size, true); + requestAnimationFrame(preloader.animateProgress); + } + return loadPromise; + }; + + /** + * Unload the engine to free memory. + * + * This method will be called automatically depending on the configuration. See :js:attr:`unloadAfterInit`. + * + * @function Engine.unload + */ + Engine.unload = function () { + loadPromise = null; + }; + + /** + * Safe Engine constructor, creates a new prototype for every new instance to avoid prototype pollution. + * @ignore + * @constructor + */ + function SafeEngine(initConfig) { + const proto = /** @lends Engine.prototype */ { + /** + * Initialize the engine instance. Optionally, pass the base path to the engine to load it, + * if it hasn't been loaded yet. See :js:meth:`Engine.load`. + * + * @param {string=} basePath Base path of the engine to load. + * @return {Promise} A ``Promise`` that resolves once the engine is loaded and initialized. + */ + init: function (basePath) { + if (initPromise) { + return initPromise; + } + if (loadPromise == null) { + if (!basePath) { + initPromise = Promise.reject(new Error('A base path must be provided when calling `init` and the engine is not loaded.')); + return initPromise; + } + Engine.load(basePath, this.config.fileSizes[`${basePath}.wasm`]); + } + const me = this; + function doInit(promise) { + // Care! Promise chaining is bogus with old emscripten versions. + // This caused a regression with the Mono build (which uses an older emscripten version). + // Make sure to test that when refactoring. + return new Promise(function (resolve, reject) { + promise.then(function (response) { + const cloned = new Response(response.clone().body, { 'headers': [['content-type', 'application/wasm']] }); + Godot(me.config.getModuleConfig(loadPath, cloned)).then(function (module) { + const paths = me.config.persistentPaths; + module['initFS'](paths).then(function (err) { + me.rtenv = module; + if (me.config.unloadAfterInit) { + Engine.unload(); + } + resolve(); + }); + }); + }); + }); + } + preloader.setProgressFunc(this.config.onProgress); + initPromise = doInit(loadPromise); + return initPromise; + }, + + /** + * Load a file so it is available in the instance's file system once it runs. Must be called **before** starting the + * instance. + * + * If not provided, the ``path`` is derived from the URL of the loaded file. + * + * @param {string|ArrayBuffer} file The file to preload. + * + * If a ``string`` the file will be loaded from that path. + * + * If an ``ArrayBuffer`` or a view on one, the buffer will used as the content of the file. + * + * @param {string=} path Path by which the file will be accessible. Required, if ``file`` is not a string. + * + * @returns {Promise} A Promise that resolves once the file is loaded. + */ + preloadFile: function (file, path) { + return preloader.preload(file, path, this.config.fileSizes[file]); + }, + + /** + * Start the engine instance using the given override configuration (if any). + * :js:meth:`startGame <Engine.prototype.startGame>` can be used in typical cases instead. + * + * This will initialize the instance if it is not initialized. For manual initialization, see :js:meth:`init <Engine.prototype.init>`. + * The engine must be loaded beforehand. + * + * Fails if a canvas cannot be found on the page, or not specified in the configuration. + * + * @param {EngineConfig} override An optional configuration override. + * @return {Promise} Promise that resolves once the engine started. + */ + start: function (override) { + this.config.update(override); + const me = this; + return me.init().then(function () { + if (!me.rtenv) { + return Promise.reject(new Error('The engine must be initialized before it can be started')); + } + + let config = {}; + try { + config = me.config.getGodotConfig(function () { + me.rtenv = null; + }); + } catch (e) { + return Promise.reject(e); + } + // Godot configuration. + me.rtenv['initConfig'](config); + + // Preload GDExtension libraries. + if (me.config.gdextensionLibs.length > 0 && !me.rtenv['loadDynamicLibrary']) { + return Promise.reject(new Error('GDExtension libraries are not supported by this engine version. ' + + 'Enable "Extensions Support" for your export preset and/or build your custom template with "dlink_enabled=yes".')); + } + return new Promise(function (resolve, reject) { + for (const file of preloader.preloadedFiles) { + me.rtenv['copyToFS'](file.path, file.buffer); + } + preloader.preloadedFiles.length = 0; // Clear memory + me.rtenv['callMain'](me.config.args); + initPromise = null; + me.installServiceWorker(); + resolve(); + }); + }); + }, + + /** + * Start the game instance using the given configuration override (if any). + * + * This will initialize the instance if it is not initialized. For manual initialization, see :js:meth:`init <Engine.prototype.init>`. + * + * This will load the engine if it is not loaded, and preload the main pck. + * + * This method expects the initial config (or the override) to have both the :js:attr:`executable` and :js:attr:`mainPack` + * properties set (normally done by the editor during export). + * + * @param {EngineConfig} override An optional configuration override. + * @return {Promise} Promise that resolves once the game started. + */ + startGame: function (override) { + this.config.update(override); + // Add main-pack argument. + const exe = this.config.executable; + const pack = this.config.mainPack || `${exe}.pck`; + this.config.args = ['--main-pack', pack].concat(this.config.args); + // Start and init with execName as loadPath if not inited. + const me = this; + return Promise.all([ + this.init(exe), + this.preloadFile(pack, pack), + ]).then(function () { + return me.start.apply(me); + }); + }, + + /** + * Create a file at the specified ``path`` with the passed as ``buffer`` in the instance's file system. + * + * @param {string} path The location where the file will be created. + * @param {ArrayBuffer} buffer The content of the file. + */ + copyToFS: function (path, buffer) { + if (this.rtenv == null) { + throw new Error('Engine must be inited before copying files'); + } + this.rtenv['copyToFS'](path, buffer); + }, + + /** + * Request that the current instance quit. + * + * This is akin the user pressing the close button in the window manager, and will + * have no effect if the engine has crashed, or is stuck in a loop. + * + */ + requestQuit: function () { + if (this.rtenv) { + this.rtenv['request_quit'](); + } + }, + + /** + * Install the progressive-web app service worker. + * @returns {Promise} The service worker registration promise. + */ + installServiceWorker: function () { + if (this.config.serviceWorker && 'serviceWorker' in navigator) { + try { + return navigator.serviceWorker.register(this.config.serviceWorker); + } catch (e) { + return Promise.reject(e); + } + } + return Promise.resolve(); + }, + }; + + Engine.prototype = proto; + // Closure compiler exported instance methods. + Engine.prototype['init'] = Engine.prototype.init; + Engine.prototype['preloadFile'] = Engine.prototype.preloadFile; + Engine.prototype['start'] = Engine.prototype.start; + Engine.prototype['startGame'] = Engine.prototype.startGame; + Engine.prototype['copyToFS'] = Engine.prototype.copyToFS; + Engine.prototype['requestQuit'] = Engine.prototype.requestQuit; + Engine.prototype['installServiceWorker'] = Engine.prototype.installServiceWorker; + // Also expose static methods as instance methods + Engine.prototype['load'] = Engine.load; + Engine.prototype['unload'] = Engine.unload; + return new Engine(initConfig); + } + + // Closure compiler exported static methods. + SafeEngine['load'] = Engine.load; + SafeEngine['unload'] = Engine.unload; + + // Feature-detection utilities. + SafeEngine['isWebGLAvailable'] = Features.isWebGLAvailable; + SafeEngine['isFetchAvailable'] = Features.isFetchAvailable; + SafeEngine['isSecureContext'] = Features.isSecureContext; + SafeEngine['isCrossOriginIsolated'] = Features.isCrossOriginIsolated; + SafeEngine['isSharedArrayBufferAvailable'] = Features.isSharedArrayBufferAvailable; + SafeEngine['isAudioWorkletAvailable'] = Features.isAudioWorkletAvailable; + SafeEngine['getMissingFeatures'] = Features.getMissingFeatures; + + return SafeEngine; +}()); +if (typeof window !== 'undefined') { + window['Engine'] = Engine; +} diff --git a/2026/games_submissions/bvnanana/index.pck b/2026/games_submissions/bvnanana/index.pck Binary files differnew file mode 100755 index 0000000..6d042c6 --- /dev/null +++ b/2026/games_submissions/bvnanana/index.pck diff --git a/2026/games_submissions/bvnanana/index.png b/2026/games_submissions/bvnanana/index.png Binary files differnew file mode 100755 index 0000000..766b0b6 --- /dev/null +++ b/2026/games_submissions/bvnanana/index.png diff --git a/2026/games_submissions/bvnanana/index.png.import b/2026/games_submissions/bvnanana/index.png.import new file mode 100755 index 0000000..310cf30 --- /dev/null +++ b/2026/games_submissions/bvnanana/index.png.import @@ -0,0 +1,40 @@ +[remap] + +importer="texture" +type="CompressedTexture2D" +uid="uid://bof6sblgdxph0" +path="res://.godot/imported/index.png-de14850a4c2320eaddca8799ea52db2b.ctex" +metadata={ +"vram_texture": false +} + +[deps] + +source_file="res://export/index.png" +dest_files=["res://.godot/imported/index.png-de14850a4c2320eaddca8799ea52db2b.ctex"] + +[params] + +compress/mode=0 +compress/high_quality=false +compress/lossy_quality=0.7 +compress/uastc_level=0 +compress/rdo_quality_loss=0.0 +compress/hdr_compression=1 +compress/normal_map=0 +compress/channel_pack=0 +mipmaps/generate=false +mipmaps/limit=-1 +roughness/mode=0 +roughness/src_normal="" +process/channel_remap/red=0 +process/channel_remap/green=1 +process/channel_remap/blue=2 +process/channel_remap/alpha=3 +process/fix_alpha_border=true +process/premult_alpha=false +process/normal_map_invert_y=false +process/hdr_as_srgb=false +process/hdr_clamp_exposure=false +process/size_limit=0 +detect_3d/compress_to=1 diff --git a/2026/games_submissions/bvnanana/index.wasm b/2026/games_submissions/bvnanana/index.wasm Binary files differnew file mode 100755 index 0000000..2da4bf9 --- /dev/null +++ b/2026/games_submissions/bvnanana/index.wasm diff --git a/2026/games_submissions/bytomancer/index.html b/2026/games_submissions/bytomancer/index.html index 93e15e9..9e487f1 100644 --- a/2026/games_submissions/bytomancer/index.html +++ b/2026/games_submissions/bytomancer/index.html @@ -109,7 +109,7 @@ body { <script src="index.js"></script> <script> -const GODOT_CONFIG = {"args":[],"canvasResizePolicy":0,"emscriptenPoolSize":8,"ensureCrossOriginIsolationHeaders":true,"executable":"index","experimentalVK":false,"fileSizes":{"index.pck":1696608,"index.wasm":37700666},"focusCanvas":true,"gdextensionLibs":[],"godotPoolSize":4}; +const GODOT_CONFIG = {"args":[],"canvasResizePolicy":2,"emscriptenPoolSize":8,"ensureCrossOriginIsolationHeaders":true,"executable":"index","experimentalVK":false,"fileSizes":{"index.pck":1696720,"index.wasm":37700666},"focusCanvas":true,"gdextensionLibs":[],"godotPoolSize":4}; const GODOT_THREADS_ENABLED = false; const engine = new Engine(GODOT_CONFIG); diff --git a/2026/games_submissions/bytomancer/index.pck b/2026/games_submissions/bytomancer/index.pck Binary files differindex 2cd31e3..8563638 100644 --- a/2026/games_submissions/bytomancer/index.pck +++ b/2026/games_submissions/bytomancer/index.pck diff --git a/2026/games_submissions/crm148/LICENSE b/2026/games_submissions/crm148/LICENSE new file mode 100644 index 0000000..af43641 --- /dev/null +++ b/2026/games_submissions/crm148/LICENSE @@ -0,0 +1,8 @@ +Copyright 2026 crm + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + diff --git a/2026/games_submissions/crm148/color.js b/2026/games_submissions/crm148/color.js new file mode 100644 index 0000000..8e8ba11 --- /dev/null +++ b/2026/games_submissions/crm148/color.js @@ -0,0 +1,31 @@ + +const lerp = (start, end, t) => start + (end - start) * t; + +export default class Color { + r = 0; + g = 0; + b = 0; + constructor(r, g, b) { + this.r = r; + this.g = g; + this.b = b; + } + + to_string() { + return `rgb(${this.r}, ${this.g}, ${this.b})`; + + } + + static interpolate(color1, color2, t) { + const r = Math.round(lerp(color1.r, color2.r, t)); + const g = Math.round(lerp(color1.g, color2.g, t)); + const b = Math.round(lerp(color1.b, color2.b, t)); + + return new Color(r,g,b); + } + static PlayerColor = new Color(150, 200, 150); + static StarDim = new Color(0x77, 0x11, 0x11); + static StarColor = new Color(0xbb, 0x33, 0x33); + static StarBright = new Color(0xbb, 0x33, 0x33); + static PulseColor = new Color(0xcc, 0x22, 0x22); +} diff --git a/2026/games_submissions/crm148/control.js b/2026/games_submissions/crm148/control.js new file mode 100644 index 0000000..7e93e13 --- /dev/null +++ b/2026/games_submissions/crm148/control.js @@ -0,0 +1,78 @@ + +import Vec2 from './vec2.js'; +import { globalView } from './view.js'; + +var gCosmos; +var view; + + + +/// Game state +function victory() { + window.parent.postMessage({op: "done", win: true}); + shutdown(); +} + +function death() { + window.parent.postMessage({op: "done", win: false}); + shutdown(); +} + +function shutdown() { + gCosmos.stop(); + gameCanvas.removeEventListener('mousedown', mousedown); + gameCanvas.removeEventListener('mouseup', mouseup); +} + + + +/// Input +function initInput(cosmos) { + gameCanvas.addEventListener('mousedown', mousedown); + gameCanvas.addEventListener('mouseup', mouseup); + gCosmos = cosmos; + view = globalView(); +} + +function mousedown(ev) { + var ship = gCosmos.player; + ship.inputTarget(getMouseCoord(ev)); + ship.inputThrust(1.0); + gameCanvas.addEventListener('mousemove', mousemove); +} + +function mouseup(ev) { + var ship = gCosmos.player; + gameCanvas.removeEventListener('mousemove', mousemove); + ship.inputThrust(0.0); +} + +function mousemove(ev) { + var ship = gCosmos.player; + ship.inputTarget(getMouseCoord(ev)); +} + +function getMouseCoord(ev) { + var coord = view.unproject(new Vec2(ev.clientX, ev.clientY)); + return coord; +} + + +var debugInfo = {}; +function debugKey(k, v) { + debugInfo[k] = v; +} +function getDebugInfo() { + return debugInfo; +} + + + +/// Exports +export { + initInput, + victory, + death, + debugKey, + getDebugInfo, +} diff --git a/2026/games_submissions/crm148/cosmos.js b/2026/games_submissions/crm148/cosmos.js new file mode 100644 index 0000000..0b14946 --- /dev/null +++ b/2026/games_submissions/crm148/cosmos.js @@ -0,0 +1,109 @@ +import { + victory, + getDebugInfo, + debugKey, +} from './control.js'; +import Ship from './ship.js'; +import Star from './star.js'; + +import Vec2 from './vec2.js'; +import { drawSquare } from './util.js'; +import { globalView } from './view.js'; + +var view; + +class Cosmos { + pulses = []; + star; + player; + running; + + dissipated; + dissipated_target; + dissipated_target_base = 50; + + gravity = .008; + thresh_crit = 5.00; + max_size = (Math.min(gameCanvas.width, gameCanvas.height) / 2) + 100; + pulse_min_str = 7; + pulse_max_str = 20; + pulse_vel_base = 70.0; + + angle = 1; + omega = 1.0; + + init(difficulty) { + view = globalView(); + const STRAD = 9; + const DIFFMUL = 3; + var starRadius = STRAD + difficulty * DIFFMUL; + this.star = new Star(starRadius, difficulty); + this.pulses = []; + this.player = Ship.AboveRadius(starRadius, this.max_size); + this.dissipated = 0; + this.dissipated_target = this.dissipated_target_base + 1 * (difficulty * 1.2); + this.omega = 1.0 + (0.2 * difficulty); + this.running = true; + } + + stop() { + this.running = false; + // console.log('stop the world'); + } + + dissipate(energy) { + this.dissipated += energy; + debugKey('dissipated', this.dissipated); + } + + update(dt) { + this.angle = (this.angle + this.omega * dt) % (2 * Math.PI); + this.player.update(dt); + this.star.update(dt); + this.pulses.forEach((p) => p.update(dt)); + this.pulses = this.pulses.filter((p) => { return p.is_alive() }); + if (this.dissipated > this.dissipated_target) { + victory(); + } + } + + render() { + ctx.fillStyle = "#151515"; + ctx.strokeStyle = "#eeeeee"; + ctx.fillRect(0,0, gameCanvas.width, gameCanvas.height); + this.star.render(ctx); + this.pulses.forEach((p) => p.render(ctx)); + this.player.render(ctx); + // debugP.textContent = JSON.stringify(getDebugInfo()); + + // this.renderSpin(); + } + + renderSpin() { + ctx.fillStyle = "#ff1515"; + ctx.strokeStyle = "#ff1515"; + var p = view.project(new Vec2(Math.cos(this.angle), + Math.sin(this.angle)).scale(this.star.radius + 5)); + drawSquare(ctx, p, 4); + var center = view.project(Vec2.zero()); + var radius = center.sub(p).length(); + + ctx.beginPath(); + ctx.arc(center.x, center.y, radius, -this.angle, -this.angle - 0.4, true); + ctx.stroke(); + } +} + +var theCosmos = new Cosmos(); +var ctx = gameCanvas.getContext("2d"); + +window.cosmos = theCosmos; + +function getCosmos() { + return theCosmos; +} + +export { + Cosmos, + getCosmos, +} diff --git a/2026/games_submissions/crm148/game.js b/2026/games_submissions/crm148/game.js new file mode 100644 index 0000000..00f1cc6 --- /dev/null +++ b/2026/games_submissions/crm148/game.js @@ -0,0 +1,101 @@ + +import { View, globalView } from './view.js'; +import { getCosmos } from './cosmos.js'; +import Vec2 from './vec2.js'; + +import { victory, death, initInput, getDebugInfo } from './control.js'; + +startButton.onclick = function (ev) { + window.postMessage({op:"start", difficulty: 1}); +} + +plusButton.onclick = function(ev) { + window.testAngle += 0.1; +} + +minusButton.onclick = function(ev) { + window.testAngle -= 0.1; +} + +testButton.onclick = function (ev) { + if (!cosmos) { + cosmos = getCosmos(); + cosmos.init(1); + initInput(cosmos); + } + + cosmos.running = false; + cosmos.player.state = 'start_testing'; + + cosmos.pulses = [ + new Pulse(Math.PI / 4, Math.PI, 70, 0, 30), + ]; + + cosmos.update(0); + cosmos.render(); + + // if (!cosmos.running) { + // if (lasttime === undefined) { + // render(0); + // lasttime = undefined; + // starttime = undefined; + // } else { + // render(lasttime); + // } + // } +} + +var cosmos; + +function start(difficulty) { + cosmos = getCosmos(); + cosmos.init(difficulty); + initInput(cosmos); + + window.requestAnimationFrame(render); + // TODO: set up mouse input listener, remove it on game over + window.parent.postMessage({op: "started", verb: "dodge!"}); +} + +// input - mouse click +// point the ship and thrust +// add particle (time, position, velocity) +// expire the particles - maybe wait until all of them are over time limit so +// new ones keep the old ones alive +// fade to black and keep it there +// smoke on the grey background of space + +// TODO: game is over after some amount of energy (increases with difficulty) is +// expelled from the star +function nop() { + ; +} + +var starttime; +var lasttime; +// var start = startGame; + +function render(timestamp) { + if (starttime === undefined) { + starttime = timestamp; + lasttime = starttime; + } else { + nop(); + } + // const elapsed = timestamp - starttime; + const dt = (timestamp - lasttime) / 1000.0; + cosmos.update(dt); + cosmos.render(); + lasttime = timestamp; + if (cosmos.running) { + window.requestAnimationFrame(render); + } else { + // console.log('over'); + } +} + + +export { + start, +} + diff --git a/2026/games_submissions/crm148/index.html b/2026/games_submissions/crm148/index.html new file mode 100644 index 0000000..b4364ca --- /dev/null +++ b/2026/games_submissions/crm148/index.html @@ -0,0 +1,49 @@ +<!DOCTYPE html> +<html lang="en"> + <head> + <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/> + <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no"> + <title>In Between The Iframes</title> + <style> + * { + margin: 0px; + padding: 0px; + } + body { + font-size: 10px; + } + #game-test { + width: 100%; + height: 100%; + } + .debugStuff { + display: none; + } + </style> + <script type="module"> + import * as game from './game.js'; + // console.log(window.innerWidth); + window.addEventListener("message", ev => { + switch (ev.data.op) { + case "start": + game.start(ev.data.difficulty); + break; + default: console.log(`unknown event: ${ev}`); break; + } + });; + window.parent.postMessage({op: "ready"}); + </script> + </head> + <body> + <canvas id="gameCanvas" width="240" height="160"></canvas> + <p class="debugStuff"> + <a href="#" id="startButton">Start</a> + </p> + <p class="debugStuff"> + <a href="#" id="testButton">Test</a> + <a href="#" id="plusButton">+</a> + <a href="#" id="minusButton">–</a> + </p> + <p id="debugP"></p> + </body> +</html> diff --git a/2026/games_submissions/crm148/pulse.js b/2026/games_submissions/crm148/pulse.js new file mode 100644 index 0000000..3a0b951 --- /dev/null +++ b/2026/games_submissions/crm148/pulse.js @@ -0,0 +1,105 @@ + +import { getCosmos } from './cosmos.js'; +import { randomAngle, toDegreesInt, normalizeAngle } from './util.js'; +import { globalView } from './view.js'; +import Vec2 from './vec2.js'; +import Color from './color.js'; + +var cosmos; + +export default class Pulse { + angle0; + angle1; + radius; + maxradius = Math.sqrt((gameCanvas.width * gameCanvas.width) + + (gameCanvas.height * gameCanvas.height)) / 2; + velocity; + state = 'state_growing'; + energy; + + constructor(angle0, arcLength, radius, velocity, energy) { + this.angle0 = normalizeAngle(angle0); + this.angle1 = normalizeAngle(angle0 + arcLength); + this.radius = radius; + this.velocity = velocity; + this.energy = energy; + if (!cosmos) { + cosmos = getCosmos(); + } + } + + static StrengthPulse(radius, strength) { + if (!cosmos) { + cosmos = getCosmos(); + } + // console.log('pulse strength',strength); + var str_factor = 0.8 * (strength / cosmos.pulse_max_str); + return new Pulse(cosmos.angle, + (2 * Math.PI) * str_factor, + radius, + cosmos.pulse_vel_base * str_factor, + strength + ); + } + + + contains(p, tolerance) { + var angle = Math.atan2(p.y, p.x); + if (Math.abs(p.length() - this.radius) < 2) { + var da1 = toDegreesInt(normalizeAngle(angle - this.angle0)); + var da2 = toDegreesInt(normalizeAngle(this.angle1 - angle)); + // console.log('da1:', da1, 'da2:', da2); + if (da1 > 0 && da2 > 0) { + return true; + } + } + return false; + } + + + render(ctx) { + const view = globalView(); + const center = view.project(Vec2.zero()); + ctx.strokeStyle = Color.PulseColor.to_string(); + ctx.beginPath(); + ctx.arc(center.x, center.y, this.radius, -this.angle0, -this.angle1, true); + ctx.stroke(); + } + + update(dt) { + if (this[this.state]) { + this[this.state](dt); + } + } + + intensity = 0; + launch_intensity = 2; + + state_birth(dt) { + this.intensity += dt; + if (this.intensity > this.launch_intensity) { + this.state = 'state_growing'; + } + } + + state_growing(dt) { + this.radius += this.velocity * dt; + if (this.radius > this.maxradius) { + this.state = 'state_dying'; + } + } + + state_dying(dt) { + cosmos.dissipate(this.energy); + this.state = 'state_dead'; + } + + state_dead(dt) { + } + + is_alive() { + return this.state !== 'state_dead'; + } +} + +window.Pulse = Pulse; diff --git a/2026/games_submissions/crm148/ship.js b/2026/games_submissions/crm148/ship.js new file mode 100644 index 0000000..cc9d571 --- /dev/null +++ b/2026/games_submissions/crm148/ship.js @@ -0,0 +1,178 @@ + +import Vec2 from './vec2.js'; +import { randomAngle, toDegreesInt, normalizeAngle, drawSquare } from './util.js'; +import { getCosmos } from './cosmos.js'; +import { globalView } from './view.js'; +import Color from './color.js'; +import { death, debugKey } from './control.js'; + +var cosmos; +var view; + +window.testAngle = Math.PI / 4; + +const max_thrust_factor = 6; + +class Ship { + pos; + vel; + thrust = 0; + max_thrust; + heading = 0; + + state = 'state_living'; + death_counter = 0; + death_thresh = 0.3; + + constructor(pos, vel, heading) { + cosmos = getCosmos(); + view = globalView(); + this.pos = pos; + this.heading = heading; + this.vel = vel; + this.max_thrust = cosmos.gravity * max_thrust_factor; + debugKey('ship', this); + } + + static AboveRadius(radius, max_size) { + cosmos = getCosmos(); + // var altitude = radius + Math.random() * (max_size - radius) + var altitude = radius + (0.25 + Math.random() * 0.125) * (max_size - radius) + var angle = randomAngle(); + // var angle = Math.PI / 2; + var pos = Vec2.fromHeadingLength(angle, altitude); + var vel = pos.ofLength(cosmos.gravity * 70.0); + var ship = new Ship(pos, vel, angle); + return ship; + } + + + + /// Behavior + update(dt) { + if (this[this.state]) { + this[this.state](dt); + } + } + + state_living(dt) { + this.applyPhysics(dt); + var death = this.checkDeath(); + if (death) { + this.state = 'state_dying'; + } + } + + state_dying(dt) { + this.death_counter += dt; + // console.log('death_counter', this.death_counter); + if (this.death_counter > this.death_thresh) { + this.state = 'state_dead'; + } + } + + state_dead(dt) { + death(); + } + + + start_testing(dt) { + this.state = 'state_testing'; + this.pos = Vec2.fromHeadingLength(window.testAngle, 70); + // this.pos = view.unproject(new Vec2(3 / 4 * gameCanvas.width, gameCanvas.height / 2)); + this.state_testing(dt); + } + + state_testing(dt) { + debugKey('ship', this); + var death = this.checkDeath(); + debugKey('death', death); + } + + + + /// Physics + applyPhysics(dt) { + var grav = this.pos.ofLength(-cosmos.gravity); + var thrust = Vec2.fromHeadingLength(this.heading, this.thrust * this.max_thrust); + var forces = grav.add(thrust); + this.pos = this.pos.add(this.vel); + this.vel = this.vel.add(forces); + } + + checkDeath() { + return this.checkBoundary() || + this.checkStar() || + this.checkPulses(); + } + + checkBoundary() { + if (Math.max(Math.abs(this.pos.x), Math.abs(this.pos.y)) > cosmos.max_size) { + return true; + } + return false; + } + + checkStar() { + const altitude = this.pos.length(); + if (altitude < cosmos.star.radius) { + return true; + } + return false; + } + + checkPulses() { + var angle = this.pos.heading(); + var altitude = this.pos.length(); + for (var p of cosmos.pulses) { + if (p.contains(this.pos, 2)) { + return true; + } + } + return false; + } + + + + /// Control + inputTarget(coord) { + var rel = coord.sub(this.pos); + debugKey('rel', rel); + this.heading = rel.heading(); + } + + inputThrust(thrust) { + this.thrust = thrust; + } + + + + /// Rendering + getColor() { + var color = Color.PlayerColor.to_string(); + if (this.state === 'state_dying') { + color = '#ff1515'; + } + return color; + } + + render(ctx) { + var sPos = view.project(this.pos); + var color = this.getColor(); + ctx.fillStyle = color; + ctx.strokeStyle = color; + + drawSquare(ctx, sPos, 3); + + var sHeading = new Vec2(Math.cos(this.heading), Math.sin(this.heading)).add(sPos); + drawSquare(ctx, sHeading, 2); + ctx.beginPath(); + ctx.moveTo(sPos.x, sPos.y); + ctx.lineTo(sHeading.x, sHeading.y); + ctx.stroke(); + } +} + + + +export default Ship; diff --git a/2026/games_submissions/crm148/star.js b/2026/games_submissions/crm148/star.js new file mode 100644 index 0000000..78173a8 --- /dev/null +++ b/2026/games_submissions/crm148/star.js @@ -0,0 +1,79 @@ + +import { getCosmos } from './cosmos.js'; +import { globalView } from './view.js'; +import Vec2 from './vec2.js'; +import Color from './color.js'; +import Pulse from './pulse.js'; + +var cosmos; + +export default class Star { + pos = Vec2.zero(); + radius; + + difficulty_mult = 0.2; + growth_base = 3; + + pulses = []; + state = 'state_glowing'; + + energy = 5; + growth_rate; + + constructor(radius, difficulty) { + cosmos = getCosmos(); + this.radius = radius; + const diff_adjust = 1.0 + difficulty * this.difficulty_mult; + this.growth_rate = this.growth_base + diff_adjust; + } + + update(dt) { + this.energy += dt * this. growth_rate; + if (this[this.state]) { + this[this.state](dt); + } + } + + state_glowing(dt) { + if (this.energy > cosmos.thresh_crit) { + this.state = 'state_critical'; + } + } + + // Multiply the energy by a random value + // If the result is over the threshold, dump that energy into a pulse + state_critical(dt) { + var rand = 0.1 + 0.8 * Math.random(); + var strength = Math.min(rand * this.energy, cosmos.pulse_max_str); + if (strength > cosmos.pulse_min_str) { + this.energy -= strength; + cosmos.pulses.push(Pulse.StrengthPulse(this.radius, strength)); + } + } + + getColor() { + var color = Color.StarColor; + switch (this.state) { + case 'state_glowing': + color = Color.interpolate(Color.StarDim, + Color.StarBright, + this.energy / cosmos.thresh_crit); + break; + case 'state_critical': + color = Color.StarBright; + break; + } + return color.to_string(); + } + + render(ctx) { + const view = globalView(); + var s_pos = view.project(this.pos); + var surface_vec = view.project(new Vec2(this.radius, this.pos.y)); + var s_rad = surface_vec.x - s_pos.x; + ctx.fillStyle = this.getColor(); + ctx.beginPath(); + ctx.arc(s_pos.x, s_pos.y, s_rad, 0, 2 * Math.PI); + ctx.fill(); + } +} diff --git a/2026/games_submissions/crm148/util.js b/2026/games_submissions/crm148/util.js new file mode 100644 index 0000000..e91c5e4 --- /dev/null +++ b/2026/games_submissions/crm148/util.js @@ -0,0 +1,28 @@ +function randomAngle() { + return Math.random() * Math.PI * 2; +} + +function toDegrees(radians) { + return radians * 180 / Math.PI; +} + +function toDegreesInt(radians) { + return Math.floor(toDegrees(radians)); +} + +function normalizeAngle(radians) { + return (radians + Math.PI) % (2 * Math.PI) - Math.PI; +} + +function drawSquare(ctx, v2, size) { + const off = size / 2; + ctx.fillRect(v2.x - off, v2.y - off, size, size); +} + +export { + randomAngle, + toDegrees, + toDegreesInt, + normalizeAngle, + drawSquare, +} diff --git a/2026/games_submissions/crm148/vec2.js b/2026/games_submissions/crm148/vec2.js new file mode 100644 index 0000000..230dad9 --- /dev/null +++ b/2026/games_submissions/crm148/vec2.js @@ -0,0 +1,61 @@ + +export default class Vec2 { + constructor(x, y) { + this.x = x; + this.y = y; + } + + static zero() { + return new Vec2(0, 0); + } + + static fromHeading(radians) { + return new Vec2(Math.cos(radians), Math.sin(radians)); + } + + static fromHeadingLength(radians, length) { + return Vec2.fromHeading(radians).scale(length); + } + + length() { + return Math.sqrt(Math.pow(this.x, 2) + Math.pow(this.y, 2)); + } + + heading() { + return Math.atan2(this.y, this.x); + } + + scale(factor) { + this.x *= factor; + this.y *= factor; + return this; + } + + scaled(factor) { + return new Vec2(this.x * factor, this.y * factor); + } + + ofLength(newLength) { + return this.normalized().scale(newLength); + } + + add(v2) { + return new Vec2(this.x + v2.x, this.y + v2.y); + } + + sub(v2) { + return new Vec2(this.x - v2.x, this.y - v2.y); + } + + normalize() { + var len = this.length(); + this.x = this.x / len; + this.y = this.y / len; + return this; + } + + normalized() { + var len = this.length(); + return new Vec2(this.x / len, this.y / len); + } +} diff --git a/2026/games_submissions/crm148/view.js b/2026/games_submissions/crm148/view.js new file mode 100644 index 0000000..1d2fb5c --- /dev/null +++ b/2026/games_submissions/crm148/view.js @@ -0,0 +1,32 @@ + +import Vec2 from './vec2.js'; + +class View { + center = Vec2.zero(); + zoom = 1.0; + + // Convert game coordinate to canvas coordinate + project(vec2) { + return new Vec2( + (gameCanvas.width / 2) + ((vec2.x - this.center.x) * this.zoom), + (gameCanvas.height / 2) - ((vec2.y - this.center.y) * this.zoom)); + } + // Covert canvas coordinate to game coordinate + unproject(vec2) { + return new Vec2( + this.center.x + (vec2.x - (gameCanvas.width / 2)) / this.zoom, + this.center.y - (vec2.y - (gameCanvas.height/2)) / this.zoom); + } +} + +function globalView() { + return gView; +} + +var gView = new View(); +window.view = gView; + +export { + View, + globalView, +} diff --git a/2026/games_submissions/doceys/main.wasm b/2026/games_submissions/doceys/main.wasm Binary files differindex 5b510b5..20b187a 100755 --- a/2026/games_submissions/doceys/main.wasm +++ b/2026/games_submissions/doceys/main.wasm diff --git a/2026/games_submissions/doceys/runtime.js b/2026/games_submissions/doceys/runtime.js index 7dc2ca7..2d13bb1 100644 --- a/2026/games_submissions/doceys/runtime.js +++ b/2026/games_submissions/doceys/runtime.js @@ -43,6 +43,14 @@ function init_canvas() { // They let you interact with the JS and DOM world from within Jai. // If you forget to implement one, the Proxy below will log a nice error. const exported_js_functions = { + play_sound: (file_ptr, volume) => { + volume = Number(volume); + const file = js_string_from_jai_string(file_ptr); + const audio_element = new Audio(file); + audio_element.volume = volume; + audio_element.play(); + }, + signal_done: (win) => { window.parent.postMessage({op: "done", win}); }, @@ -179,7 +187,7 @@ function init_message_listener() { switch (event.data.op) { case "start": wasm_instance.exports.on_signal_start(BigInt(event.data.difficulty)); - window.parent.postMessage({ op: "started", verb: "chinese gopher time (bad)" }); + window.parent.postMessage({ op: "started", verb: "Catch MrGreen" }); break; default: console.log(`Unexpected event: ${event}`); diff --git a/2026/games_submissions/doceys/sounds/hit.wav b/2026/games_submissions/doceys/sounds/hit.wav Binary files differnew file mode 100644 index 0000000..7bb9bbd --- /dev/null +++ b/2026/games_submissions/doceys/sounds/hit.wav diff --git a/2026/games_submissions/doceys/sounds/lose.wav b/2026/games_submissions/doceys/sounds/lose.wav Binary files differnew file mode 100644 index 0000000..6fc5dc8 --- /dev/null +++ b/2026/games_submissions/doceys/sounds/lose.wav diff --git a/2026/games_submissions/doceys/sounds/win1.wav b/2026/games_submissions/doceys/sounds/win1.wav Binary files differnew file mode 100644 index 0000000..04f0860 --- /dev/null +++ b/2026/games_submissions/doceys/sounds/win1.wav diff --git a/2026/games_submissions/doceys/sounds/win2.wav b/2026/games_submissions/doceys/sounds/win2.wav Binary files differnew file mode 100644 index 0000000..8169523 --- /dev/null +++ b/2026/games_submissions/doceys/sounds/win2.wav diff --git a/2026/games_submissions/mankeymaster18/index.144x144.png b/2026/games_submissions/mankeymaster18/index.144x144.png Binary files differnew file mode 100644 index 0000000..8b5ecd5 --- /dev/null +++ b/2026/games_submissions/mankeymaster18/index.144x144.png diff --git a/2026/games_submissions/mankeymaster18/index.180x180.png b/2026/games_submissions/mankeymaster18/index.180x180.png Binary files differnew file mode 100644 index 0000000..4dbb176 --- /dev/null +++ b/2026/games_submissions/mankeymaster18/index.180x180.png diff --git a/2026/games_submissions/mankeymaster18/index.512x512.png b/2026/games_submissions/mankeymaster18/index.512x512.png Binary files differnew file mode 100644 index 0000000..b49d914 --- /dev/null +++ b/2026/games_submissions/mankeymaster18/index.512x512.png diff --git a/2026/games_submissions/mankeymaster18/index.apple-touch-icon.png b/2026/games_submissions/mankeymaster18/index.apple-touch-icon.png Binary files differnew file mode 100644 index 0000000..4dbb176 --- /dev/null +++ b/2026/games_submissions/mankeymaster18/index.apple-touch-icon.png diff --git a/2026/games_submissions/mankeymaster18/index.audio.position.worklet.js b/2026/games_submissions/mankeymaster18/index.audio.position.worklet.js new file mode 100644 index 0000000..4e512c1 --- /dev/null +++ b/2026/games_submissions/mankeymaster18/index.audio.position.worklet.js @@ -0,0 +1,66 @@ +/**************************************************************************/ +/* godot.audio.position.worklet.js */ +/**************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/**************************************************************************/ +/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/**************************************************************************/ + +class GodotPositionReportingProcessor extends AudioWorkletProcessor { + static get parameterDescriptors() { + return [ + { + name: 'reset', + defaultValue: 0, + minValue: 0, + maxValue: 1, + automationRate: 'k-rate', + }, + ]; + } + + constructor(...args) { + super(...args); + this.position = 0; + } + + process(inputs, _outputs, parameters) { + if (parameters['reset'][0] > 0) { + this.position = 0; + } + + if (inputs.length > 0) { + const input = inputs[0]; + if (input.length > 0) { + this.position += input[0].length; + this.port.postMessage({ type: 'position', data: this.position }); + } + } + + return true; + } +} + +registerProcessor('godot-position-reporting-processor', GodotPositionReportingProcessor); diff --git a/2026/games_submissions/mankeymaster18/index.audio.worklet.js b/2026/games_submissions/mankeymaster18/index.audio.worklet.js new file mode 100644 index 0000000..3b94cab --- /dev/null +++ b/2026/games_submissions/mankeymaster18/index.audio.worklet.js @@ -0,0 +1,213 @@ +/**************************************************************************/ +/* audio.worklet.js */ +/**************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/**************************************************************************/ +/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/**************************************************************************/ + +class RingBuffer { + constructor(p_buffer, p_state, p_threads) { + this.buffer = p_buffer; + this.avail = p_state; + this.threads = p_threads; + this.rpos = 0; + this.wpos = 0; + } + + data_left() { + return this.threads ? Atomics.load(this.avail, 0) : this.avail; + } + + space_left() { + return this.buffer.length - this.data_left(); + } + + read(output) { + const size = this.buffer.length; + let from = 0; + let to_write = output.length; + if (this.rpos + to_write > size) { + const high = size - this.rpos; + output.set(this.buffer.subarray(this.rpos, size)); + from = high; + to_write -= high; + this.rpos = 0; + } + if (to_write) { + output.set(this.buffer.subarray(this.rpos, this.rpos + to_write), from); + } + this.rpos += to_write; + if (this.threads) { + Atomics.add(this.avail, 0, -output.length); + Atomics.notify(this.avail, 0); + } else { + this.avail -= output.length; + } + } + + write(p_buffer) { + const to_write = p_buffer.length; + const mw = this.buffer.length - this.wpos; + if (mw >= to_write) { + this.buffer.set(p_buffer, this.wpos); + this.wpos += to_write; + if (mw === to_write) { + this.wpos = 0; + } + } else { + const high = p_buffer.subarray(0, mw); + const low = p_buffer.subarray(mw); + this.buffer.set(high, this.wpos); + this.buffer.set(low); + this.wpos = low.length; + } + if (this.threads) { + Atomics.add(this.avail, 0, to_write); + Atomics.notify(this.avail, 0); + } else { + this.avail += to_write; + } + } +} + +class GodotProcessor extends AudioWorkletProcessor { + constructor() { + super(); + this.threads = false; + this.running = true; + this.lock = null; + this.notifier = null; + this.output = null; + this.output_buffer = new Float32Array(); + this.input = null; + this.input_buffer = new Float32Array(); + this.port.onmessage = (event) => { + const cmd = event.data['cmd']; + const data = event.data['data']; + this.parse_message(cmd, data); + }; + } + + process_notify() { + if (this.notifier) { + Atomics.add(this.notifier, 0, 1); + Atomics.notify(this.notifier, 0); + } + } + + parse_message(p_cmd, p_data) { + if (p_cmd === 'start' && p_data) { + const state = p_data[0]; + let idx = 0; + this.threads = true; + this.lock = state.subarray(idx, ++idx); + this.notifier = state.subarray(idx, ++idx); + const avail_in = state.subarray(idx, ++idx); + const avail_out = state.subarray(idx, ++idx); + this.input = new RingBuffer(p_data[1], avail_in, true); + this.output = new RingBuffer(p_data[2], avail_out, true); + } else if (p_cmd === 'stop') { + this.running = false; + this.output = null; + this.input = null; + this.lock = null; + this.notifier = null; + } else if (p_cmd === 'start_nothreads') { + this.output = new RingBuffer(p_data[0], p_data[0].length, false); + } else if (p_cmd === 'chunk') { + this.output.write(p_data); + } + } + + static array_has_data(arr) { + return arr.length && arr[0].length && arr[0][0].length; + } + + process(inputs, outputs, parameters) { + if (!this.running) { + return false; // Stop processing. + } + if (this.output === null) { + return true; // Not ready yet, keep processing. + } + const process_input = GodotProcessor.array_has_data(inputs); + if (process_input) { + const input = inputs[0]; + const chunk = input[0].length * input.length; + if (this.input_buffer.length !== chunk) { + this.input_buffer = new Float32Array(chunk); + } + if (!this.threads) { + GodotProcessor.write_input(this.input_buffer, input); + this.port.postMessage({ 'cmd': 'input', 'data': this.input_buffer }); + } else if (this.input.space_left() >= chunk) { + GodotProcessor.write_input(this.input_buffer, input); + this.input.write(this.input_buffer); + } else { + // this.port.postMessage('Input buffer is full! Skipping input frame.'); // Uncomment this line to debug input buffer. + } + } + const process_output = GodotProcessor.array_has_data(outputs); + if (process_output) { + const output = outputs[0]; + const chunk = output[0].length * output.length; + if (this.output_buffer.length !== chunk) { + this.output_buffer = new Float32Array(chunk); + } + if (this.output.data_left() >= chunk) { + this.output.read(this.output_buffer); + GodotProcessor.write_output(output, this.output_buffer); + if (!this.threads) { + this.port.postMessage({ 'cmd': 'read', 'data': chunk }); + } + } else { + // this.port.postMessage('Output buffer has not enough frames! Skipping output frame.'); // Uncomment this line to debug output buffer. + } + } + this.process_notify(); + return true; + } + + static write_output(dest, source) { + const channels = dest.length; + for (let ch = 0; ch < channels; ch++) { + for (let sample = 0; sample < dest[ch].length; sample++) { + dest[ch][sample] = source[sample * channels + ch]; + } + } + } + + static write_input(dest, source) { + const channels = source.length; + for (let ch = 0; ch < channels; ch++) { + for (let sample = 0; sample < source[ch].length; sample++) { + dest[sample * channels + ch] = source[ch][sample]; + } + } + } +} + +registerProcessor('godot-processor', GodotProcessor); diff --git a/2026/games_submissions/mankeymaster18/index.html b/2026/games_submissions/mankeymaster18/index.html new file mode 100644 index 0000000..6055146 --- /dev/null +++ b/2026/games_submissions/mankeymaster18/index.html @@ -0,0 +1,221 @@ +<!DOCTYPE html> +<html lang="en"> + <head> + <meta charset="utf-8"> + <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0"> + <title>Crimes against Ratmanity</title> + <style> +html, body, #canvas { + margin: 0; + padding: 0; + border: 0; +} + +body { + color: white; + background-color: black; + overflow: hidden; + touch-action: none; +} + +#canvas { + display: block; +} + +#canvas:focus { + outline: none; +} + +#status, #status-splash, #status-progress { + position: absolute; + left: 0; + right: 0; +} + +#status, #status-splash { + top: 0; + bottom: 0; +} + +#status { + background-color: #242424; + display: flex; + flex-direction: column; + justify-content: center; + align-items: center; + visibility: hidden; +} + +#status-splash { + max-height: 100%; + max-width: 100%; + margin: auto; +} + +#status-splash.show-image--false { + display: none; +} + +#status-splash.fullsize--true { + height: 100%; + width: 100%; + object-fit: contain; +} + +#status-splash.use-filter--false { + image-rendering: pixelated; +} + +#status-progress, #status-notice { + display: none; +} + +#status-progress { + bottom: 10%; + width: 50%; + margin: 0 auto; +} + +#status-notice { + background-color: #5b3943; + border-radius: 0.5rem; + border: 1px solid #9b3943; + color: #e0e0e0; + font-family: 'Noto Sans', 'Droid Sans', Arial, sans-serif; + line-height: 1.3; + margin: 0 2rem; + overflow: hidden; + padding: 1rem; + text-align: center; + z-index: 1; +} + </style> + <link id="-gd-engine-icon" rel="icon" type="image/png" href="index.icon.png" /> +<link rel="apple-touch-icon" href="index.apple-touch-icon.png"/> +<link rel="manifest" href="index.manifest.json"> + + </head> + <body> + <canvas id="canvas"> + Your browser does not support the canvas tag. + </canvas> + + <noscript> + Your browser does not support JavaScript. + </noscript> + + <div id="status"> + <img id="status-splash" class="show-image--true fullsize--true use-filter--true" src="index.png" alt=""> + <progress id="status-progress"></progress> + <div id="status-notice"></div> + </div> + + <script src="index.js"></script> + <script> +const GODOT_CONFIG = {"args":[],"canvasResizePolicy":2,"emscriptenPoolSize":8,"ensureCrossOriginIsolationHeaders":true,"executable":"index","experimentalVK":false,"fileSizes":{"index.pck":12033420,"index.wasm":39513091},"focusCanvas":true,"gdextensionLibs":[],"godotPoolSize":4,"serviceWorker":"index.service.worker.js"}; +const GODOT_THREADS_ENABLED = false; +const engine = new Engine(GODOT_CONFIG); + +(function () { + const statusOverlay = document.getElementById('status'); + const statusProgress = document.getElementById('status-progress'); + const statusNotice = document.getElementById('status-notice'); + + let initializing = true; + let statusMode = ''; + + function setStatusMode(mode) { + if (statusMode === mode || !initializing) { + return; + } + if (mode === 'hidden') { + statusOverlay.remove(); + initializing = false; + return; + } + statusOverlay.style.visibility = 'visible'; + statusProgress.style.display = mode === 'progress' ? 'block' : 'none'; + statusNotice.style.display = mode === 'notice' ? 'block' : 'none'; + statusMode = mode; + } + + function setStatusNotice(text) { + while (statusNotice.lastChild) { + statusNotice.removeChild(statusNotice.lastChild); + } + const lines = text.split('\n'); + lines.forEach((line) => { + statusNotice.appendChild(document.createTextNode(line)); + statusNotice.appendChild(document.createElement('br')); + }); + } + + function displayFailureNotice(err) { + console.error(err); + if (err instanceof Error) { + setStatusNotice(err.message); + } else if (typeof err === 'string') { + setStatusNotice(err); + } else { + setStatusNotice('An unknown error occurred.'); + } + setStatusMode('notice'); + initializing = false; + } + + const missing = Engine.getMissingFeatures({ + threads: GODOT_THREADS_ENABLED, + }); + + if (missing.length !== 0) { + if (GODOT_CONFIG['serviceWorker'] && GODOT_CONFIG['ensureCrossOriginIsolationHeaders'] && 'serviceWorker' in navigator) { + let serviceWorkerRegistrationPromise; + try { + serviceWorkerRegistrationPromise = navigator.serviceWorker.getRegistration(); + } catch (err) { + serviceWorkerRegistrationPromise = Promise.reject(new Error('Service worker registration failed.')); + } + // There's a chance that installing the service worker would fix the issue + Promise.race([ + serviceWorkerRegistrationPromise.then((registration) => { + if (registration != null) { + return Promise.reject(new Error('Service worker already exists.')); + } + return registration; + }).then(() => engine.installServiceWorker()), + // For some reason, `getRegistration()` can stall + new Promise((resolve) => { + setTimeout(() => resolve(), 2000); + }), + ]).then(() => { + // Reload if there was no error. + window.location.reload(); + }).catch((err) => { + console.error('Error while registering service worker:', err); + }); + } else { + // Display the message as usual + const missingMsg = 'Error\nThe following features required to run Godot projects on the Web are missing:\n'; + displayFailureNotice(missingMsg + missing.join('\n')); + } + } else { + setStatusMode('progress'); + engine.startGame({ + 'onProgress': function (current, total) { + if (current > 0 && total > 0) { + statusProgress.value = current; + statusProgress.max = total; + } else { + statusProgress.removeAttribute('value'); + statusProgress.removeAttribute('max'); + } + }, + }).then(() => { + setStatusMode('hidden'); + }, displayFailureNotice); + } +}()); + </script> + </body> +</html> + diff --git a/2026/games_submissions/mankeymaster18/index.icon.png b/2026/games_submissions/mankeymaster18/index.icon.png Binary files differnew file mode 100644 index 0000000..81115be --- /dev/null +++ b/2026/games_submissions/mankeymaster18/index.icon.png diff --git a/2026/games_submissions/mankeymaster18/index.js b/2026/games_submissions/mankeymaster18/index.js new file mode 100644 index 0000000..6ad78a7 --- /dev/null +++ b/2026/games_submissions/mankeymaster18/index.js @@ -0,0 +1,909 @@ +var Godot=(()=>{var _scriptName=globalThis.document?.currentScript?.src;return async function(moduleArg={}){var moduleRtn;var Module=moduleArg;var ENVIRONMENT_IS_WEB=!!globalThis.window;var ENVIRONMENT_IS_WORKER=!!globalThis.WorkerGlobalScope;var ENVIRONMENT_IS_NODE=globalThis.process?.versions?.node&&globalThis.process?.type!="renderer";var arguments_=[];var thisProgram="./this.program";var quit_=(status,toThrow)=>{throw toThrow};if(ENVIRONMENT_IS_WORKER){_scriptName=self.location.href}var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var readAsync,readBinary;if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){try{scriptDirectory=new URL(".",_scriptName).href}catch{}{if(ENVIRONMENT_IS_WORKER){readBinary=url=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)}}readAsync=async url=>{var response=await fetch(url,{credentials:"same-origin"});if(response.ok){return response.arrayBuffer()}throw new Error(response.status+" : "+response.url)}}}else{}var out=console.log.bind(console);var err=console.error.bind(console);var wasmBinary;var ABORT=false;var EXITSTATUS;var readyPromiseResolve,readyPromiseReject;var HEAP8,HEAPU8,HEAP16,HEAPU16,HEAP32,HEAPU32,HEAPF32,HEAPF64;var HEAP64,HEAPU64;var runtimeInitialized=false;var runtimeExited=false;function updateMemoryViews(){var b=wasmMemory.buffer;Module["HEAP8"]=HEAP8=new Int8Array(b);Module["HEAP16"]=HEAP16=new Int16Array(b);Module["HEAPU8"]=HEAPU8=new Uint8Array(b);Module["HEAPU16"]=HEAPU16=new Uint16Array(b);Module["HEAP32"]=HEAP32=new Int32Array(b);Module["HEAPU32"]=HEAPU32=new Uint32Array(b);Module["HEAPF32"]=HEAPF32=new Float32Array(b);Module["HEAPF64"]=HEAPF64=new Float64Array(b);Module["HEAP64"]=HEAP64=new BigInt64Array(b);Module["HEAPU64"]=HEAPU64=new BigUint64Array(b)}function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift())}}callRuntimeCallbacks(onPreRuns)}function initRuntime(){runtimeInitialized=true;if(!Module["noFSInit"]&&!FS.initialized)FS.init();TTY.init();wasmExports["pf"]();FS.ignorePermissions=false}function preMain(){}function exitRuntime(){___funcs_on_exit();FS.quit();TTY.shutdown();IDBFS.quit();runtimeExited=true}function postRun(){if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift())}}callRuntimeCallbacks(onPostRuns)}function abort(what){Module["onAbort"]?.(what);what="Aborted("+what+")";err(what);ABORT=true;what+=". Build with -sASSERTIONS for more info.";var e=new WebAssembly.RuntimeError(what);readyPromiseReject?.(e);throw e}var wasmBinaryFile;function findWasmBinary(){return locateFile("godot.web.template_release.wasm32.nothreads.wasm")}function getBinarySync(file){if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}if(readBinary){return readBinary(file)}throw"both async and sync fetching of the wasm failed"}async function getWasmBinary(binaryFile){if(!wasmBinary){try{var response=await readAsync(binaryFile);return new Uint8Array(response)}catch{}}return getBinarySync(binaryFile)}async function instantiateArrayBuffer(binaryFile,imports){try{var binary=await getWasmBinary(binaryFile);var instance=await WebAssembly.instantiate(binary,imports);return instance}catch(reason){err(`failed to asynchronously prepare wasm: ${reason}`);abort(reason)}}async function instantiateAsync(binary,binaryFile,imports){if(!binary){try{var response=fetch(binaryFile,{credentials:"same-origin"});var instantiationResult=await WebAssembly.instantiateStreaming(response,imports);return instantiationResult}catch(reason){err(`wasm streaming compile failed: ${reason}`);err("falling back to ArrayBuffer instantiation")}}return instantiateArrayBuffer(binaryFile,imports)}function getWasmImports(){var imports={a:wasmImports};return imports}async function createWasm(){function receiveInstance(instance,module){wasmExports=instance.exports;assignWasmExports(wasmExports);updateMemoryViews();return wasmExports}function receiveInstantiationResult(result){return receiveInstance(result["instance"])}var info=getWasmImports();if(Module["instantiateWasm"]){return new Promise((resolve,reject)=>{Module["instantiateWasm"](info,(inst,mod)=>{resolve(receiveInstance(inst,mod))})})}wasmBinaryFile??=findWasmBinary();var result=await instantiateAsync(wasmBinary,wasmBinaryFile,info);var exports=receiveInstantiationResult(result);return exports}class ExitStatus{name="ExitStatus";constructor(status){this.message=`Program terminated with exit(${status})`;this.status=status}}var callRuntimeCallbacks=callbacks=>{while(callbacks.length>0){callbacks.shift()(Module)}};var onPostRuns=[];var addOnPostRun=cb=>onPostRuns.push(cb);var onPreRuns=[];var addOnPreRun=cb=>onPreRuns.push(cb);function getValue(ptr,type="i8"){if(type.endsWith("*"))type="*";switch(type){case"i1":return HEAP8[ptr];case"i8":return HEAP8[ptr];case"i16":return HEAP16[ptr>>1];case"i32":return HEAP32[ptr>>2];case"i64":return HEAP64[ptr>>3];case"float":return HEAPF32[ptr>>2];case"double":return HEAPF64[ptr>>3];case"*":return HEAPU32[ptr>>2];default:abort(`invalid type for getValue: ${type}`)}}var noExitRuntime=false;function setValue(ptr,value,type="i8"){if(type.endsWith("*"))type="*";switch(type){case"i1":HEAP8[ptr]=value;break;case"i8":HEAP8[ptr]=value;break;case"i16":HEAP16[ptr>>1]=value;break;case"i32":HEAP32[ptr>>2]=value;break;case"i64":HEAP64[ptr>>3]=BigInt(value);break;case"float":HEAPF32[ptr>>2]=value;break;case"double":HEAPF64[ptr>>3]=value;break;case"*":HEAPU32[ptr>>2]=value;break;default:abort(`invalid type for setValue: ${type}`)}}var getWasmTableEntry=funcPtr=>wasmTable.get(funcPtr);var ___call_sighandler=(fp,sig)=>getWasmTableEntry(fp)(sig);var PATH={isAbs:path=>path.charAt(0)==="/",splitPath:filename=>{var splitPathRe=/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;return splitPathRe.exec(filename).slice(1)},normalizeArray:(parts,allowAboveRoot)=>{var up=0;for(var i=parts.length-1;i>=0;i--){var last=parts[i];if(last==="."){parts.splice(i,1)}else if(last===".."){parts.splice(i,1);up++}else if(up){parts.splice(i,1);up--}}if(allowAboveRoot){for(;up;up--){parts.unshift("..")}}return parts},normalize:path=>{var isAbsolute=PATH.isAbs(path),trailingSlash=path.slice(-1)==="/";path=PATH.normalizeArray(path.split("/").filter(p=>!!p),!isAbsolute).join("/");if(!path&&!isAbsolute){path="."}if(path&&trailingSlash){path+="/"}return(isAbsolute?"/":"")+path},dirname:path=>{var result=PATH.splitPath(path),root=result[0],dir=result[1];if(!root&&!dir){return"."}if(dir){dir=dir.slice(0,-1)}return root+dir},basename:path=>path&&path.match(/([^\/]+|\/)\/*$/)[1],join:(...paths)=>PATH.normalize(paths.join("/")),join2:(l,r)=>PATH.normalize(l+"/"+r)};var initRandomFill=()=>view=>crypto.getRandomValues(view);var randomFill=view=>{(randomFill=initRandomFill())(view)};var PATH_FS={resolve:(...args)=>{var resolvedPath="",resolvedAbsolute=false;for(var i=args.length-1;i>=-1&&!resolvedAbsolute;i--){var path=i>=0?args[i]:FS.cwd();if(typeof path!="string"){throw new TypeError("Arguments to path.resolve must be strings")}else if(!path){return""}resolvedPath=path+"/"+resolvedPath;resolvedAbsolute=PATH.isAbs(path)}resolvedPath=PATH.normalizeArray(resolvedPath.split("/").filter(p=>!!p),!resolvedAbsolute).join("/");return(resolvedAbsolute?"/":"")+resolvedPath||"."},relative:(from,to)=>{from=PATH_FS.resolve(from).slice(1);to=PATH_FS.resolve(to).slice(1);function trim(arr){var start=0;for(;start<arr.length;start++){if(arr[start]!=="")break}var end=arr.length-1;for(;end>=0;end--){if(arr[end]!=="")break}if(start>end)return[];return arr.slice(start,end-start+1)}var fromParts=trim(from.split("/"));var toParts=trim(to.split("/"));var length=Math.min(fromParts.length,toParts.length);var samePartsLength=length;for(var i=0;i<length;i++){if(fromParts[i]!==toParts[i]){samePartsLength=i;break}}var outputParts=[];for(var i=samePartsLength;i<fromParts.length;i++){outputParts.push("..")}outputParts=outputParts.concat(toParts.slice(samePartsLength));return outputParts.join("/")}};var UTF8Decoder=globalThis.TextDecoder&&new TextDecoder;var findStringEnd=(heapOrArray,idx,maxBytesToRead,ignoreNul)=>{var maxIdx=idx+maxBytesToRead;if(ignoreNul)return maxIdx;while(heapOrArray[idx]&&!(idx>=maxIdx))++idx;return idx};var UTF8ArrayToString=(heapOrArray,idx=0,maxBytesToRead,ignoreNul)=>{var endPtr=findStringEnd(heapOrArray,idx,maxBytesToRead,ignoreNul);if(endPtr-idx>16&&heapOrArray.buffer&&UTF8Decoder){return UTF8Decoder.decode(heapOrArray.subarray(idx,endPtr))}var str="";while(idx<endPtr){var u0=heapOrArray[idx++];if(!(u0&128)){str+=String.fromCharCode(u0);continue}var u1=heapOrArray[idx++]&63;if((u0&224)==192){str+=String.fromCharCode((u0&31)<<6|u1);continue}var u2=heapOrArray[idx++]&63;if((u0&240)==224){u0=(u0&15)<<12|u1<<6|u2}else{u0=(u0&7)<<18|u1<<12|u2<<6|heapOrArray[idx++]&63}if(u0<65536){str+=String.fromCharCode(u0)}else{var ch=u0-65536;str+=String.fromCharCode(55296|ch>>10,56320|ch&1023)}}return str};var FS_stdin_getChar_buffer=[];var lengthBytesUTF8=str=>{var len=0;for(var i=0;i<str.length;++i){var c=str.charCodeAt(i);if(c<=127){len++}else if(c<=2047){len+=2}else if(c>=55296&&c<=57343){len+=4;++i}else{len+=3}}return len};var stringToUTF8Array=(str,heap,outIdx,maxBytesToWrite)=>{if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i<str.length;++i){var u=str.codePointAt(i);if(u<=127){if(outIdx>=endIdx)break;heap[outIdx++]=u}else if(u<=2047){if(outIdx+1>=endIdx)break;heap[outIdx++]=192|u>>6;heap[outIdx++]=128|u&63}else if(u<=65535){if(outIdx+2>=endIdx)break;heap[outIdx++]=224|u>>12;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}else{if(outIdx+3>=endIdx)break;heap[outIdx++]=240|u>>18;heap[outIdx++]=128|u>>12&63;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63;i++}}heap[outIdx]=0;return outIdx-startIdx};var intArrayFromString=(stringy,dontAddNull,length)=>{var len=length>0?length:lengthBytesUTF8(stringy)+1;var u8array=new Array(len);var numBytesWritten=stringToUTF8Array(stringy,u8array,0,u8array.length);if(dontAddNull)u8array.length=numBytesWritten;return u8array};var FS_stdin_getChar=()=>{if(!FS_stdin_getChar_buffer.length){var result=null;if(globalThis.window?.prompt){result=window.prompt("Input: ");if(result!==null){result+="\n"}}else{}if(!result){return null}FS_stdin_getChar_buffer=intArrayFromString(result,true)}return FS_stdin_getChar_buffer.shift()};var TTY={ttys:[],init(){},shutdown(){},register(dev,ops){TTY.ttys[dev]={input:[],output:[],ops};FS.registerDevice(dev,TTY.stream_ops)},stream_ops:{open(stream){var tty=TTY.ttys[stream.node.rdev];if(!tty){throw new FS.ErrnoError(43)}stream.tty=tty;stream.seekable=false},close(stream){stream.tty.ops.fsync(stream.tty)},fsync(stream){stream.tty.ops.fsync(stream.tty)},read(stream,buffer,offset,length,pos){if(!stream.tty||!stream.tty.ops.get_char){throw new FS.ErrnoError(60)}var bytesRead=0;for(var i=0;i<length;i++){var result;try{result=stream.tty.ops.get_char(stream.tty)}catch(e){throw new FS.ErrnoError(29)}if(result===undefined&&bytesRead===0){throw new FS.ErrnoError(6)}if(result===null||result===undefined)break;bytesRead++;buffer[offset+i]=result}if(bytesRead){stream.node.atime=Date.now()}return bytesRead},write(stream,buffer,offset,length,pos){if(!stream.tty||!stream.tty.ops.put_char){throw new FS.ErrnoError(60)}try{for(var i=0;i<length;i++){stream.tty.ops.put_char(stream.tty,buffer[offset+i])}}catch(e){throw new FS.ErrnoError(29)}if(length){stream.node.mtime=stream.node.ctime=Date.now()}return i}},default_tty_ops:{get_char(tty){return FS_stdin_getChar()},put_char(tty,val){if(val===null||val===10){out(UTF8ArrayToString(tty.output));tty.output=[]}else{if(val!=0)tty.output.push(val)}},fsync(tty){if(tty.output?.length>0){out(UTF8ArrayToString(tty.output));tty.output=[]}},ioctl_tcgets(tty){return{c_iflag:25856,c_oflag:5,c_cflag:191,c_lflag:35387,c_cc:[3,28,127,21,4,0,1,0,17,19,26,0,18,15,23,22,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},ioctl_tcsets(tty,optional_actions,data){return 0},ioctl_tiocgwinsz(tty){return[24,80]}},default_tty1_ops:{put_char(tty,val){if(val===null||val===10){err(UTF8ArrayToString(tty.output));tty.output=[]}else{if(val!=0)tty.output.push(val)}},fsync(tty){if(tty.output?.length>0){err(UTF8ArrayToString(tty.output));tty.output=[]}}}};var zeroMemory=(ptr,size)=>HEAPU8.fill(0,ptr,ptr+size);var alignMemory=(size,alignment)=>Math.ceil(size/alignment)*alignment;var mmapAlloc=size=>{size=alignMemory(size,65536);var ptr=_emscripten_builtin_memalign(65536,size);if(ptr)zeroMemory(ptr,size);return ptr};var MEMFS={ops_table:null,mount(mount){return MEMFS.createNode(null,"/",16895,0)},createNode(parent,name,mode,dev){if(FS.isBlkdev(mode)||FS.isFIFO(mode)){throw new FS.ErrnoError(63)}MEMFS.ops_table||={dir:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr,lookup:MEMFS.node_ops.lookup,mknod:MEMFS.node_ops.mknod,rename:MEMFS.node_ops.rename,unlink:MEMFS.node_ops.unlink,rmdir:MEMFS.node_ops.rmdir,readdir:MEMFS.node_ops.readdir,symlink:MEMFS.node_ops.symlink},stream:{llseek:MEMFS.stream_ops.llseek}},file:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr},stream:{llseek:MEMFS.stream_ops.llseek,read:MEMFS.stream_ops.read,write:MEMFS.stream_ops.write,mmap:MEMFS.stream_ops.mmap,msync:MEMFS.stream_ops.msync}},link:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr,readlink:MEMFS.node_ops.readlink},stream:{}},chrdev:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr},stream:FS.chrdev_stream_ops}};var node=FS.createNode(parent,name,mode,dev);if(FS.isDir(node.mode)){node.node_ops=MEMFS.ops_table.dir.node;node.stream_ops=MEMFS.ops_table.dir.stream;node.contents={}}else if(FS.isFile(node.mode)){node.node_ops=MEMFS.ops_table.file.node;node.stream_ops=MEMFS.ops_table.file.stream;node.usedBytes=0;node.contents=null}else if(FS.isLink(node.mode)){node.node_ops=MEMFS.ops_table.link.node;node.stream_ops=MEMFS.ops_table.link.stream}else if(FS.isChrdev(node.mode)){node.node_ops=MEMFS.ops_table.chrdev.node;node.stream_ops=MEMFS.ops_table.chrdev.stream}node.atime=node.mtime=node.ctime=Date.now();if(parent){parent.contents[name]=node;parent.atime=parent.mtime=parent.ctime=node.atime}return node},getFileDataAsTypedArray(node){if(!node.contents)return new Uint8Array(0);if(node.contents.subarray)return node.contents.subarray(0,node.usedBytes);return new Uint8Array(node.contents)},expandFileStorage(node,newCapacity){var prevCapacity=node.contents?node.contents.length:0;if(prevCapacity>=newCapacity)return;var CAPACITY_DOUBLING_MAX=1024*1024;newCapacity=Math.max(newCapacity,prevCapacity*(prevCapacity<CAPACITY_DOUBLING_MAX?2:1.125)>>>0);if(prevCapacity!=0)newCapacity=Math.max(newCapacity,256);var oldContents=node.contents;node.contents=new Uint8Array(newCapacity);if(node.usedBytes>0)node.contents.set(oldContents.subarray(0,node.usedBytes),0)},resizeFileStorage(node,newSize){if(node.usedBytes==newSize)return;if(newSize==0){node.contents=null;node.usedBytes=0}else{var oldContents=node.contents;node.contents=new Uint8Array(newSize);if(oldContents){node.contents.set(oldContents.subarray(0,Math.min(newSize,node.usedBytes)))}node.usedBytes=newSize}},node_ops:{getattr(node){var attr={};attr.dev=FS.isChrdev(node.mode)?node.id:1;attr.ino=node.id;attr.mode=node.mode;attr.nlink=1;attr.uid=0;attr.gid=0;attr.rdev=node.rdev;if(FS.isDir(node.mode)){attr.size=4096}else if(FS.isFile(node.mode)){attr.size=node.usedBytes}else if(FS.isLink(node.mode)){attr.size=node.link.length}else{attr.size=0}attr.atime=new Date(node.atime);attr.mtime=new Date(node.mtime);attr.ctime=new Date(node.ctime);attr.blksize=4096;attr.blocks=Math.ceil(attr.size/attr.blksize);return attr},setattr(node,attr){for(const key of["mode","atime","mtime","ctime"]){if(attr[key]!=null){node[key]=attr[key]}}if(attr.size!==undefined){MEMFS.resizeFileStorage(node,attr.size)}},lookup(parent,name){if(!MEMFS.doesNotExistError){MEMFS.doesNotExistError=new FS.ErrnoError(44);MEMFS.doesNotExistError.stack="<generic error, no stack>"}throw MEMFS.doesNotExistError},mknod(parent,name,mode,dev){return MEMFS.createNode(parent,name,mode,dev)},rename(old_node,new_dir,new_name){var new_node;try{new_node=FS.lookupNode(new_dir,new_name)}catch(e){}if(new_node){if(FS.isDir(old_node.mode)){for(var i in new_node.contents){throw new FS.ErrnoError(55)}}FS.hashRemoveNode(new_node)}delete old_node.parent.contents[old_node.name];new_dir.contents[new_name]=old_node;old_node.name=new_name;new_dir.ctime=new_dir.mtime=old_node.parent.ctime=old_node.parent.mtime=Date.now()},unlink(parent,name){delete parent.contents[name];parent.ctime=parent.mtime=Date.now()},rmdir(parent,name){var node=FS.lookupNode(parent,name);for(var i in node.contents){throw new FS.ErrnoError(55)}delete parent.contents[name];parent.ctime=parent.mtime=Date.now()},readdir(node){return[".","..",...Object.keys(node.contents)]},symlink(parent,newname,oldpath){var node=MEMFS.createNode(parent,newname,511|40960,0);node.link=oldpath;return node},readlink(node){if(!FS.isLink(node.mode)){throw new FS.ErrnoError(28)}return node.link}},stream_ops:{read(stream,buffer,offset,length,position){var contents=stream.node.contents;if(position>=stream.node.usedBytes)return 0;var size=Math.min(stream.node.usedBytes-position,length);if(size>8&&contents.subarray){buffer.set(contents.subarray(position,position+size),offset)}else{for(var i=0;i<size;i++)buffer[offset+i]=contents[position+i]}return size},write(stream,buffer,offset,length,position,canOwn){if(buffer.buffer===HEAP8.buffer){canOwn=false}if(!length)return 0;var node=stream.node;node.mtime=node.ctime=Date.now();if(buffer.subarray&&(!node.contents||node.contents.subarray)){if(canOwn){node.contents=buffer.subarray(offset,offset+length);node.usedBytes=length;return length}else if(node.usedBytes===0&&position===0){node.contents=buffer.slice(offset,offset+length);node.usedBytes=length;return length}else if(position+length<=node.usedBytes){node.contents.set(buffer.subarray(offset,offset+length),position);return length}}MEMFS.expandFileStorage(node,position+length);if(node.contents.subarray&&buffer.subarray){node.contents.set(buffer.subarray(offset,offset+length),position)}else{for(var i=0;i<length;i++){node.contents[position+i]=buffer[offset+i]}}node.usedBytes=Math.max(node.usedBytes,position+length);return length},llseek(stream,offset,whence){var position=offset;if(whence===1){position+=stream.position}else if(whence===2){if(FS.isFile(stream.node.mode)){position+=stream.node.usedBytes}}if(position<0){throw new FS.ErrnoError(28)}return position},mmap(stream,length,position,prot,flags){if(!FS.isFile(stream.node.mode)){throw new FS.ErrnoError(43)}var ptr;var allocated;var contents=stream.node.contents;if(!(flags&2)&&contents&&contents.buffer===HEAP8.buffer){allocated=false;ptr=contents.byteOffset}else{allocated=true;ptr=mmapAlloc(length);if(!ptr){throw new FS.ErrnoError(48)}if(contents){if(position>0||position+length<contents.length){if(contents.subarray){contents=contents.subarray(position,position+length)}else{contents=Array.prototype.slice.call(contents,position,position+length)}}HEAP8.set(contents,ptr)}}return{ptr,allocated}},msync(stream,buffer,offset,length,mmapFlags){MEMFS.stream_ops.write(stream,buffer,0,length,offset,false);return 0}}};var FS_modeStringToFlags=str=>{var flagModes={r:0,"r+":2,w:512|64|1,"w+":512|64|2,a:1024|64|1,"a+":1024|64|2};var flags=flagModes[str];if(typeof flags=="undefined"){throw new Error(`Unknown file open mode: ${str}`)}return flags};var FS_getMode=(canRead,canWrite)=>{var mode=0;if(canRead)mode|=292|73;if(canWrite)mode|=146;return mode};var IDBFS={dbs:{},indexedDB:()=>indexedDB,DB_VERSION:21,DB_STORE_NAME:"FILE_DATA",queuePersist:mount=>{function onPersistComplete(){if(mount.idbPersistState==="again")startPersist();else mount.idbPersistState=0}function startPersist(){mount.idbPersistState="idb";IDBFS.syncfs(mount,false,onPersistComplete)}if(!mount.idbPersistState){mount.idbPersistState=setTimeout(startPersist,0)}else if(mount.idbPersistState==="idb"){mount.idbPersistState="again"}},mount:mount=>{var mnt=MEMFS.mount(mount);if(mount?.opts?.autoPersist){mount.idbPersistState=0;var memfs_node_ops=mnt.node_ops;mnt.node_ops={...mnt.node_ops};mnt.node_ops.mknod=(parent,name,mode,dev)=>{var node=memfs_node_ops.mknod(parent,name,mode,dev);node.node_ops=mnt.node_ops;node.idbfs_mount=mnt.mount;node.memfs_stream_ops=node.stream_ops;node.stream_ops={...node.stream_ops};node.stream_ops.write=(stream,buffer,offset,length,position,canOwn)=>{stream.node.isModified=true;return node.memfs_stream_ops.write(stream,buffer,offset,length,position,canOwn)};node.stream_ops.close=stream=>{var n=stream.node;if(n.isModified){IDBFS.queuePersist(n.idbfs_mount);n.isModified=false}if(n.memfs_stream_ops.close)return n.memfs_stream_ops.close(stream)};IDBFS.queuePersist(mnt.mount);return node};mnt.node_ops.rmdir=(...args)=>(IDBFS.queuePersist(mnt.mount),memfs_node_ops.rmdir(...args));mnt.node_ops.symlink=(...args)=>(IDBFS.queuePersist(mnt.mount),memfs_node_ops.symlink(...args));mnt.node_ops.unlink=(...args)=>(IDBFS.queuePersist(mnt.mount),memfs_node_ops.unlink(...args));mnt.node_ops.rename=(...args)=>(IDBFS.queuePersist(mnt.mount),memfs_node_ops.rename(...args))}return mnt},syncfs:(mount,populate,callback)=>{IDBFS.getLocalSet(mount,(err,local)=>{if(err)return callback(err);IDBFS.getRemoteSet(mount,(err,remote)=>{if(err)return callback(err);var src=populate?remote:local;var dst=populate?local:remote;IDBFS.reconcile(src,dst,callback)})})},quit:()=>{for(var value of Object.values(IDBFS.dbs)){value.close()}IDBFS.dbs={}},getDB:(name,callback)=>{var db=IDBFS.dbs[name];if(db){return callback(null,db)}var req;try{req=IDBFS.indexedDB().open(name,IDBFS.DB_VERSION)}catch(e){return callback(e)}if(!req){return callback("Unable to connect to IndexedDB")}req.onupgradeneeded=e=>{var db=e.target.result;var transaction=e.target.transaction;var fileStore;if(db.objectStoreNames.contains(IDBFS.DB_STORE_NAME)){fileStore=transaction.objectStore(IDBFS.DB_STORE_NAME)}else{fileStore=db.createObjectStore(IDBFS.DB_STORE_NAME)}if(!fileStore.indexNames.contains("timestamp")){fileStore.createIndex("timestamp","timestamp",{unique:false})}};req.onsuccess=()=>{db=req.result;IDBFS.dbs[name]=db;callback(null,db)};req.onerror=e=>{callback(e.target.error);e.preventDefault()}},getLocalSet:(mount,callback)=>{var entries={};function isRealDir(p){return p!=="."&&p!==".."}function toAbsolute(root){return p=>PATH.join2(root,p)}var check=FS.readdir(mount.mountpoint).filter(isRealDir).map(toAbsolute(mount.mountpoint));while(check.length){var path=check.pop();var stat;try{stat=FS.stat(path)}catch(e){return callback(e)}if(FS.isDir(stat.mode)){check.push(...FS.readdir(path).filter(isRealDir).map(toAbsolute(path)))}entries[path]={timestamp:stat.mtime}}return callback(null,{type:"local",entries})},getRemoteSet:(mount,callback)=>{var entries={};IDBFS.getDB(mount.mountpoint,(err,db)=>{if(err)return callback(err);try{var transaction=db.transaction([IDBFS.DB_STORE_NAME],"readonly");transaction.onerror=e=>{callback(e.target.error);e.preventDefault()};var store=transaction.objectStore(IDBFS.DB_STORE_NAME);var index=store.index("timestamp");index.openKeyCursor().onsuccess=event=>{var cursor=event.target.result;if(!cursor){return callback(null,{type:"remote",db,entries})}entries[cursor.primaryKey]={timestamp:cursor.key};cursor.continue()}}catch(e){return callback(e)}})},loadLocalEntry:(path,callback)=>{var stat,node;try{var lookup=FS.lookupPath(path);node=lookup.node;stat=FS.stat(path)}catch(e){return callback(e)}if(FS.isDir(stat.mode)){return callback(null,{timestamp:stat.mtime,mode:stat.mode})}else if(FS.isFile(stat.mode)){node.contents=MEMFS.getFileDataAsTypedArray(node);return callback(null,{timestamp:stat.mtime,mode:stat.mode,contents:node.contents})}else{return callback(new Error("node type not supported"))}},storeLocalEntry:(path,entry,callback)=>{try{if(FS.isDir(entry["mode"])){FS.mkdirTree(path,entry["mode"])}else if(FS.isFile(entry["mode"])){FS.writeFile(path,entry["contents"],{canOwn:true})}else{return callback(new Error("node type not supported"))}FS.chmod(path,entry["mode"]);FS.utime(path,entry["timestamp"],entry["timestamp"])}catch(e){return callback(e)}callback(null)},removeLocalEntry:(path,callback)=>{try{var stat=FS.stat(path);if(FS.isDir(stat.mode)){FS.rmdir(path)}else if(FS.isFile(stat.mode)){FS.unlink(path)}}catch(e){return callback(e)}callback(null)},loadRemoteEntry:(store,path,callback)=>{var req=store.get(path);req.onsuccess=event=>callback(null,event.target.result);req.onerror=e=>{callback(e.target.error);e.preventDefault()}},storeRemoteEntry:(store,path,entry,callback)=>{try{var req=store.put(entry,path)}catch(e){callback(e);return}req.onsuccess=event=>callback();req.onerror=e=>{callback(e.target.error);e.preventDefault()}},removeRemoteEntry:(store,path,callback)=>{var req=store.delete(path);req.onsuccess=event=>callback();req.onerror=e=>{callback(e.target.error);e.preventDefault()}},reconcile:(src,dst,callback)=>{var total=0;var create=[];for(var[key,e]of Object.entries(src.entries)){var e2=dst.entries[key];if(!e2||e["timestamp"].getTime()!=e2["timestamp"].getTime()){create.push(key);total++}}var remove=[];for(var key of Object.keys(dst.entries)){if(!src.entries[key]){remove.push(key);total++}}if(!total){return callback(null)}var errored=false;var db=src.type==="remote"?src.db:dst.db;var transaction=db.transaction([IDBFS.DB_STORE_NAME],"readwrite");var store=transaction.objectStore(IDBFS.DB_STORE_NAME);function done(err){if(err&&!errored){errored=true;return callback(err)}}transaction.onerror=transaction.onabort=e=>{done(e.target.error);e.preventDefault()};transaction.oncomplete=e=>{if(!errored){callback(null)}};for(const path of create.sort()){if(dst.type==="local"){IDBFS.loadRemoteEntry(store,path,(err,entry)=>{if(err)return done(err);IDBFS.storeLocalEntry(path,entry,done)})}else{IDBFS.loadLocalEntry(path,(err,entry)=>{if(err)return done(err);IDBFS.storeRemoteEntry(store,path,entry,done)})}}for(var path of remove.sort().reverse()){if(dst.type==="local"){IDBFS.removeLocalEntry(path,done)}else{IDBFS.removeRemoteEntry(store,path,done)}}}};var asyncLoad=async url=>{var arrayBuffer=await readAsync(url);return new Uint8Array(arrayBuffer)};var FS_createDataFile=(...args)=>FS.createDataFile(...args);var getUniqueRunDependency=id=>id;var runDependencies=0;var dependenciesFulfilled=null;var removeRunDependency=id=>{runDependencies--;Module["monitorRunDependencies"]?.(runDependencies);if(runDependencies==0){if(dependenciesFulfilled){var callback=dependenciesFulfilled;dependenciesFulfilled=null;callback()}}};var addRunDependency=id=>{runDependencies++;Module["monitorRunDependencies"]?.(runDependencies)};var preloadPlugins=[];var FS_handledByPreloadPlugin=async(byteArray,fullname)=>{if(typeof Browser!="undefined")Browser.init();for(var plugin of preloadPlugins){if(plugin["canHandle"](fullname)){return plugin["handle"](byteArray,fullname)}}return byteArray};var FS_preloadFile=async(parent,name,url,canRead,canWrite,dontCreateFile,canOwn,preFinish)=>{var fullname=name?PATH_FS.resolve(PATH.join2(parent,name)):parent;var dep=getUniqueRunDependency(`cp ${fullname}`);addRunDependency(dep);try{var byteArray=url;if(typeof url=="string"){byteArray=await asyncLoad(url)}byteArray=await FS_handledByPreloadPlugin(byteArray,fullname);preFinish?.();if(!dontCreateFile){FS_createDataFile(parent,name,byteArray,canRead,canWrite,canOwn)}}finally{removeRunDependency(dep)}};var FS_createPreloadedFile=(parent,name,url,canRead,canWrite,onload,onerror,dontCreateFile,canOwn,preFinish)=>{FS_preloadFile(parent,name,url,canRead,canWrite,dontCreateFile,canOwn,preFinish).then(onload).catch(onerror)};var FS={root:null,mounts:[],devices:{},streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,filesystems:null,syncFSRequests:0,readFiles:{},ErrnoError:class{name="ErrnoError";constructor(errno){this.errno=errno}},FSStream:class{shared={};get object(){return this.node}set object(val){this.node=val}get isRead(){return(this.flags&2097155)!==1}get isWrite(){return(this.flags&2097155)!==0}get isAppend(){return this.flags&1024}get flags(){return this.shared.flags}set flags(val){this.shared.flags=val}get position(){return this.shared.position}set position(val){this.shared.position=val}},FSNode:class{node_ops={};stream_ops={};readMode=292|73;writeMode=146;mounted=null;constructor(parent,name,mode,rdev){if(!parent){parent=this}this.parent=parent;this.mount=parent.mount;this.id=FS.nextInode++;this.name=name;this.mode=mode;this.rdev=rdev;this.atime=this.mtime=this.ctime=Date.now()}get read(){return(this.mode&this.readMode)===this.readMode}set read(val){val?this.mode|=this.readMode:this.mode&=~this.readMode}get write(){return(this.mode&this.writeMode)===this.writeMode}set write(val){val?this.mode|=this.writeMode:this.mode&=~this.writeMode}get isFolder(){return FS.isDir(this.mode)}get isDevice(){return FS.isChrdev(this.mode)}},lookupPath(path,opts={}){if(!path){throw new FS.ErrnoError(44)}opts.follow_mount??=true;if(!PATH.isAbs(path)){path=FS.cwd()+"/"+path}linkloop:for(var nlinks=0;nlinks<40;nlinks++){var parts=path.split("/").filter(p=>!!p);var current=FS.root;var current_path="/";for(var i=0;i<parts.length;i++){var islast=i===parts.length-1;if(islast&&opts.parent){break}if(parts[i]==="."){continue}if(parts[i]===".."){current_path=PATH.dirname(current_path);if(FS.isRoot(current)){path=current_path+"/"+parts.slice(i+1).join("/");nlinks--;continue linkloop}else{current=current.parent}continue}current_path=PATH.join2(current_path,parts[i]);try{current=FS.lookupNode(current,parts[i])}catch(e){if(e?.errno===44&&islast&&opts.noent_okay){return{path:current_path}}throw e}if(FS.isMountpoint(current)&&(!islast||opts.follow_mount)){current=current.mounted.root}if(FS.isLink(current.mode)&&(!islast||opts.follow)){if(!current.node_ops.readlink){throw new FS.ErrnoError(52)}var link=current.node_ops.readlink(current);if(!PATH.isAbs(link)){link=PATH.dirname(current_path)+"/"+link}path=link+"/"+parts.slice(i+1).join("/");continue linkloop}}return{path:current_path,node:current}}throw new FS.ErrnoError(32)},getPath(node){var path;while(true){if(FS.isRoot(node)){var mount=node.mount.mountpoint;if(!path)return mount;return mount[mount.length-1]!=="/"?`${mount}/${path}`:mount+path}path=path?`${node.name}/${path}`:node.name;node=node.parent}},hashName(parentid,name){var hash=0;for(var i=0;i<name.length;i++){hash=(hash<<5)-hash+name.charCodeAt(i)|0}return(parentid+hash>>>0)%FS.nameTable.length},hashAddNode(node){var hash=FS.hashName(node.parent.id,node.name);node.name_next=FS.nameTable[hash];FS.nameTable[hash]=node},hashRemoveNode(node){var hash=FS.hashName(node.parent.id,node.name);if(FS.nameTable[hash]===node){FS.nameTable[hash]=node.name_next}else{var current=FS.nameTable[hash];while(current){if(current.name_next===node){current.name_next=node.name_next;break}current=current.name_next}}},lookupNode(parent,name){var errCode=FS.mayLookup(parent);if(errCode){throw new FS.ErrnoError(errCode)}var hash=FS.hashName(parent.id,name);for(var node=FS.nameTable[hash];node;node=node.name_next){var nodeName=node.name;if(node.parent.id===parent.id&&nodeName===name){return node}}return FS.lookup(parent,name)},createNode(parent,name,mode,rdev){var node=new FS.FSNode(parent,name,mode,rdev);FS.hashAddNode(node);return node},destroyNode(node){FS.hashRemoveNode(node)},isRoot(node){return node===node.parent},isMountpoint(node){return!!node.mounted},isFile(mode){return(mode&61440)===32768},isDir(mode){return(mode&61440)===16384},isLink(mode){return(mode&61440)===40960},isChrdev(mode){return(mode&61440)===8192},isBlkdev(mode){return(mode&61440)===24576},isFIFO(mode){return(mode&61440)===4096},isSocket(mode){return(mode&49152)===49152},flagsToPermissionString(flag){var perms=["r","w","rw"][flag&3];if(flag&512){perms+="w"}return perms},nodePermissions(node,perms){if(FS.ignorePermissions){return 0}if(perms.includes("r")&&!(node.mode&292)){return 2}else if(perms.includes("w")&&!(node.mode&146)){return 2}else if(perms.includes("x")&&!(node.mode&73)){return 2}return 0},mayLookup(dir){if(!FS.isDir(dir.mode))return 54;var errCode=FS.nodePermissions(dir,"x");if(errCode)return errCode;if(!dir.node_ops.lookup)return 2;return 0},mayCreate(dir,name){if(!FS.isDir(dir.mode)){return 54}try{var node=FS.lookupNode(dir,name);return 20}catch(e){}return FS.nodePermissions(dir,"wx")},mayDelete(dir,name,isdir){var node;try{node=FS.lookupNode(dir,name)}catch(e){return e.errno}var errCode=FS.nodePermissions(dir,"wx");if(errCode){return errCode}if(isdir){if(!FS.isDir(node.mode)){return 54}if(FS.isRoot(node)||FS.getPath(node)===FS.cwd()){return 10}}else{if(FS.isDir(node.mode)){return 31}}return 0},mayOpen(node,flags){if(!node){return 44}if(FS.isLink(node.mode)){return 32}else if(FS.isDir(node.mode)){if(FS.flagsToPermissionString(flags)!=="r"||flags&(512|64)){return 31}}return FS.nodePermissions(node,FS.flagsToPermissionString(flags))},checkOpExists(op,err){if(!op){throw new FS.ErrnoError(err)}return op},MAX_OPEN_FDS:4096,nextfd(){for(var fd=0;fd<=FS.MAX_OPEN_FDS;fd++){if(!FS.streams[fd]){return fd}}throw new FS.ErrnoError(33)},getStreamChecked(fd){var stream=FS.getStream(fd);if(!stream){throw new FS.ErrnoError(8)}return stream},getStream:fd=>FS.streams[fd],createStream(stream,fd=-1){stream=Object.assign(new FS.FSStream,stream);if(fd==-1){fd=FS.nextfd()}stream.fd=fd;FS.streams[fd]=stream;return stream},closeStream(fd){FS.streams[fd]=null},dupStream(origStream,fd=-1){var stream=FS.createStream(origStream,fd);stream.stream_ops?.dup?.(stream);return stream},doSetAttr(stream,node,attr){var setattr=stream?.stream_ops.setattr;var arg=setattr?stream:node;setattr??=node.node_ops.setattr;FS.checkOpExists(setattr,63);setattr(arg,attr)},chrdev_stream_ops:{open(stream){var device=FS.getDevice(stream.node.rdev);stream.stream_ops=device.stream_ops;stream.stream_ops.open?.(stream)},llseek(){throw new FS.ErrnoError(70)}},major:dev=>dev>>8,minor:dev=>dev&255,makedev:(ma,mi)=>ma<<8|mi,registerDevice(dev,ops){FS.devices[dev]={stream_ops:ops}},getDevice:dev=>FS.devices[dev],getMounts(mount){var mounts=[];var check=[mount];while(check.length){var m=check.pop();mounts.push(m);check.push(...m.mounts)}return mounts},syncfs(populate,callback){if(typeof populate=="function"){callback=populate;populate=false}FS.syncFSRequests++;if(FS.syncFSRequests>1){err(`warning: ${FS.syncFSRequests} FS.syncfs operations in flight at once, probably just doing extra work`)}var mounts=FS.getMounts(FS.root.mount);var completed=0;function doCallback(errCode){FS.syncFSRequests--;return callback(errCode)}function done(errCode){if(errCode){if(!done.errored){done.errored=true;return doCallback(errCode)}return}if(++completed>=mounts.length){doCallback(null)}}for(var mount of mounts){if(mount.type.syncfs){mount.type.syncfs(mount,populate,done)}else{done(null)}}},mount(type,opts,mountpoint){var root=mountpoint==="/";var pseudo=!mountpoint;var node;if(root&&FS.root){throw new FS.ErrnoError(10)}else if(!root&&!pseudo){var lookup=FS.lookupPath(mountpoint,{follow_mount:false});mountpoint=lookup.path;node=lookup.node;if(FS.isMountpoint(node)){throw new FS.ErrnoError(10)}if(!FS.isDir(node.mode)){throw new FS.ErrnoError(54)}}var mount={type,opts,mountpoint,mounts:[]};var mountRoot=type.mount(mount);mountRoot.mount=mount;mount.root=mountRoot;if(root){FS.root=mountRoot}else if(node){node.mounted=mount;if(node.mount){node.mount.mounts.push(mount)}}return mountRoot},unmount(mountpoint){var lookup=FS.lookupPath(mountpoint,{follow_mount:false});if(!FS.isMountpoint(lookup.node)){throw new FS.ErrnoError(28)}var node=lookup.node;var mount=node.mounted;var mounts=FS.getMounts(mount);for(var[hash,current]of Object.entries(FS.nameTable)){while(current){var next=current.name_next;if(mounts.includes(current.mount)){FS.destroyNode(current)}current=next}}node.mounted=null;var idx=node.mount.mounts.indexOf(mount);node.mount.mounts.splice(idx,1)},lookup(parent,name){return parent.node_ops.lookup(parent,name)},mknod(path,mode,dev){var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;var name=PATH.basename(path);if(!name){throw new FS.ErrnoError(28)}if(name==="."||name===".."){throw new FS.ErrnoError(20)}var errCode=FS.mayCreate(parent,name);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.mknod){throw new FS.ErrnoError(63)}return parent.node_ops.mknod(parent,name,mode,dev)},statfs(path){return FS.statfsNode(FS.lookupPath(path,{follow:true}).node)},statfsStream(stream){return FS.statfsNode(stream.node)},statfsNode(node){var rtn={bsize:4096,frsize:4096,blocks:1e6,bfree:5e5,bavail:5e5,files:FS.nextInode,ffree:FS.nextInode-1,fsid:42,flags:2,namelen:255};if(node.node_ops.statfs){Object.assign(rtn,node.node_ops.statfs(node.mount.opts.root))}return rtn},create(path,mode=438){mode&=4095;mode|=32768;return FS.mknod(path,mode,0)},mkdir(path,mode=511){mode&=511|512;mode|=16384;return FS.mknod(path,mode,0)},mkdirTree(path,mode){var dirs=path.split("/");var d="";for(var dir of dirs){if(!dir)continue;if(d||PATH.isAbs(path))d+="/";d+=dir;try{FS.mkdir(d,mode)}catch(e){if(e.errno!=20)throw e}}},mkdev(path,mode,dev){if(typeof dev=="undefined"){dev=mode;mode=438}mode|=8192;return FS.mknod(path,mode,dev)},symlink(oldpath,newpath){if(!PATH_FS.resolve(oldpath)){throw new FS.ErrnoError(44)}var lookup=FS.lookupPath(newpath,{parent:true});var parent=lookup.node;if(!parent){throw new FS.ErrnoError(44)}var newname=PATH.basename(newpath);var errCode=FS.mayCreate(parent,newname);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.symlink){throw new FS.ErrnoError(63)}return parent.node_ops.symlink(parent,newname,oldpath)},rename(old_path,new_path){var old_dirname=PATH.dirname(old_path);var new_dirname=PATH.dirname(new_path);var old_name=PATH.basename(old_path);var new_name=PATH.basename(new_path);var lookup,old_dir,new_dir;lookup=FS.lookupPath(old_path,{parent:true});old_dir=lookup.node;lookup=FS.lookupPath(new_path,{parent:true});new_dir=lookup.node;if(!old_dir||!new_dir)throw new FS.ErrnoError(44);if(old_dir.mount!==new_dir.mount){throw new FS.ErrnoError(75)}var old_node=FS.lookupNode(old_dir,old_name);var relative=PATH_FS.relative(old_path,new_dirname);if(relative.charAt(0)!=="."){throw new FS.ErrnoError(28)}relative=PATH_FS.relative(new_path,old_dirname);if(relative.charAt(0)!=="."){throw new FS.ErrnoError(55)}var new_node;try{new_node=FS.lookupNode(new_dir,new_name)}catch(e){}if(old_node===new_node){return}var isdir=FS.isDir(old_node.mode);var errCode=FS.mayDelete(old_dir,old_name,isdir);if(errCode){throw new FS.ErrnoError(errCode)}errCode=new_node?FS.mayDelete(new_dir,new_name,isdir):FS.mayCreate(new_dir,new_name);if(errCode){throw new FS.ErrnoError(errCode)}if(!old_dir.node_ops.rename){throw new FS.ErrnoError(63)}if(FS.isMountpoint(old_node)||new_node&&FS.isMountpoint(new_node)){throw new FS.ErrnoError(10)}if(new_dir!==old_dir){errCode=FS.nodePermissions(old_dir,"w");if(errCode){throw new FS.ErrnoError(errCode)}}FS.hashRemoveNode(old_node);try{old_dir.node_ops.rename(old_node,new_dir,new_name);old_node.parent=new_dir}catch(e){throw e}finally{FS.hashAddNode(old_node)}},rmdir(path){var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;var name=PATH.basename(path);var node=FS.lookupNode(parent,name);var errCode=FS.mayDelete(parent,name,true);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.rmdir){throw new FS.ErrnoError(63)}if(FS.isMountpoint(node)){throw new FS.ErrnoError(10)}parent.node_ops.rmdir(parent,name);FS.destroyNode(node)},readdir(path){var lookup=FS.lookupPath(path,{follow:true});var node=lookup.node;var readdir=FS.checkOpExists(node.node_ops.readdir,54);return readdir(node)},unlink(path){var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;if(!parent){throw new FS.ErrnoError(44)}var name=PATH.basename(path);var node=FS.lookupNode(parent,name);var errCode=FS.mayDelete(parent,name,false);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.unlink){throw new FS.ErrnoError(63)}if(FS.isMountpoint(node)){throw new FS.ErrnoError(10)}parent.node_ops.unlink(parent,name);FS.destroyNode(node)},readlink(path){var lookup=FS.lookupPath(path);var link=lookup.node;if(!link){throw new FS.ErrnoError(44)}if(!link.node_ops.readlink){throw new FS.ErrnoError(28)}return link.node_ops.readlink(link)},stat(path,dontFollow){var lookup=FS.lookupPath(path,{follow:!dontFollow});var node=lookup.node;var getattr=FS.checkOpExists(node.node_ops.getattr,63);return getattr(node)},fstat(fd){var stream=FS.getStreamChecked(fd);var node=stream.node;var getattr=stream.stream_ops.getattr;var arg=getattr?stream:node;getattr??=node.node_ops.getattr;FS.checkOpExists(getattr,63);return getattr(arg)},lstat(path){return FS.stat(path,true)},doChmod(stream,node,mode,dontFollow){FS.doSetAttr(stream,node,{mode:mode&4095|node.mode&~4095,ctime:Date.now(),dontFollow})},chmod(path,mode,dontFollow){var node;if(typeof path=="string"){var lookup=FS.lookupPath(path,{follow:!dontFollow});node=lookup.node}else{node=path}FS.doChmod(null,node,mode,dontFollow)},lchmod(path,mode){FS.chmod(path,mode,true)},fchmod(fd,mode){var stream=FS.getStreamChecked(fd);FS.doChmod(stream,stream.node,mode,false)},doChown(stream,node,dontFollow){FS.doSetAttr(stream,node,{timestamp:Date.now(),dontFollow})},chown(path,uid,gid,dontFollow){var node;if(typeof path=="string"){var lookup=FS.lookupPath(path,{follow:!dontFollow});node=lookup.node}else{node=path}FS.doChown(null,node,dontFollow)},lchown(path,uid,gid){FS.chown(path,uid,gid,true)},fchown(fd,uid,gid){var stream=FS.getStreamChecked(fd);FS.doChown(stream,stream.node,false)},doTruncate(stream,node,len){if(FS.isDir(node.mode)){throw new FS.ErrnoError(31)}if(!FS.isFile(node.mode)){throw new FS.ErrnoError(28)}var errCode=FS.nodePermissions(node,"w");if(errCode){throw new FS.ErrnoError(errCode)}FS.doSetAttr(stream,node,{size:len,timestamp:Date.now()})},truncate(path,len){if(len<0){throw new FS.ErrnoError(28)}var node;if(typeof path=="string"){var lookup=FS.lookupPath(path,{follow:true});node=lookup.node}else{node=path}FS.doTruncate(null,node,len)},ftruncate(fd,len){var stream=FS.getStreamChecked(fd);if(len<0||(stream.flags&2097155)===0){throw new FS.ErrnoError(28)}FS.doTruncate(stream,stream.node,len)},utime(path,atime,mtime){var lookup=FS.lookupPath(path,{follow:true});var node=lookup.node;var setattr=FS.checkOpExists(node.node_ops.setattr,63);setattr(node,{atime,mtime})},open(path,flags,mode=438){if(path===""){throw new FS.ErrnoError(44)}flags=typeof flags=="string"?FS_modeStringToFlags(flags):flags;if(flags&64){mode=mode&4095|32768}else{mode=0}var node;var isDirPath;if(typeof path=="object"){node=path}else{isDirPath=path.endsWith("/");var lookup=FS.lookupPath(path,{follow:!(flags&131072),noent_okay:true});node=lookup.node;path=lookup.path}var created=false;if(flags&64){if(node){if(flags&128){throw new FS.ErrnoError(20)}}else if(isDirPath){throw new FS.ErrnoError(31)}else{node=FS.mknod(path,mode|511,0);created=true}}if(!node){throw new FS.ErrnoError(44)}if(FS.isChrdev(node.mode)){flags&=~512}if(flags&65536&&!FS.isDir(node.mode)){throw new FS.ErrnoError(54)}if(!created){var errCode=FS.mayOpen(node,flags);if(errCode){throw new FS.ErrnoError(errCode)}}if(flags&512&&!created){FS.truncate(node,0)}flags&=~(128|512|131072);var stream=FS.createStream({node,path:FS.getPath(node),flags,seekable:true,position:0,stream_ops:node.stream_ops,ungotten:[],error:false});if(stream.stream_ops.open){stream.stream_ops.open(stream)}if(created){FS.chmod(node,mode&511)}if(Module["logReadFiles"]&&!(flags&1)){if(!(path in FS.readFiles)){FS.readFiles[path]=1}}return stream},close(stream){if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if(stream.getdents)stream.getdents=null;try{if(stream.stream_ops.close){stream.stream_ops.close(stream)}}catch(e){throw e}finally{FS.closeStream(stream.fd)}stream.fd=null},isClosed(stream){return stream.fd===null},llseek(stream,offset,whence){if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if(!stream.seekable||!stream.stream_ops.llseek){throw new FS.ErrnoError(70)}if(whence!=0&&whence!=1&&whence!=2){throw new FS.ErrnoError(28)}stream.position=stream.stream_ops.llseek(stream,offset,whence);stream.ungotten=[];return stream.position},read(stream,buffer,offset,length,position){if(length<0||position<0){throw new FS.ErrnoError(28)}if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if((stream.flags&2097155)===1){throw new FS.ErrnoError(8)}if(FS.isDir(stream.node.mode)){throw new FS.ErrnoError(31)}if(!stream.stream_ops.read){throw new FS.ErrnoError(28)}var seeking=typeof position!="undefined";if(!seeking){position=stream.position}else if(!stream.seekable){throw new FS.ErrnoError(70)}var bytesRead=stream.stream_ops.read(stream,buffer,offset,length,position);if(!seeking)stream.position+=bytesRead;return bytesRead},write(stream,buffer,offset,length,position,canOwn){if(length<0||position<0){throw new FS.ErrnoError(28)}if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if((stream.flags&2097155)===0){throw new FS.ErrnoError(8)}if(FS.isDir(stream.node.mode)){throw new FS.ErrnoError(31)}if(!stream.stream_ops.write){throw new FS.ErrnoError(28)}if(stream.seekable&&stream.flags&1024){FS.llseek(stream,0,2)}var seeking=typeof position!="undefined";if(!seeking){position=stream.position}else if(!stream.seekable){throw new FS.ErrnoError(70)}var bytesWritten=stream.stream_ops.write(stream,buffer,offset,length,position,canOwn);if(!seeking)stream.position+=bytesWritten;return bytesWritten},mmap(stream,length,position,prot,flags){if((prot&2)!==0&&(flags&2)===0&&(stream.flags&2097155)!==2){throw new FS.ErrnoError(2)}if((stream.flags&2097155)===1){throw new FS.ErrnoError(2)}if(!stream.stream_ops.mmap){throw new FS.ErrnoError(43)}if(!length){throw new FS.ErrnoError(28)}return stream.stream_ops.mmap(stream,length,position,prot,flags)},msync(stream,buffer,offset,length,mmapFlags){if(!stream.stream_ops.msync){return 0}return stream.stream_ops.msync(stream,buffer,offset,length,mmapFlags)},ioctl(stream,cmd,arg){if(!stream.stream_ops.ioctl){throw new FS.ErrnoError(59)}return stream.stream_ops.ioctl(stream,cmd,arg)},readFile(path,opts={}){opts.flags=opts.flags||0;opts.encoding=opts.encoding||"binary";if(opts.encoding!=="utf8"&&opts.encoding!=="binary"){abort(`Invalid encoding type "${opts.encoding}"`)}var stream=FS.open(path,opts.flags);var stat=FS.stat(path);var length=stat.size;var buf=new Uint8Array(length);FS.read(stream,buf,0,length,0);if(opts.encoding==="utf8"){buf=UTF8ArrayToString(buf)}FS.close(stream);return buf},writeFile(path,data,opts={}){opts.flags=opts.flags||577;var stream=FS.open(path,opts.flags,opts.mode);if(typeof data=="string"){data=new Uint8Array(intArrayFromString(data,true))}if(ArrayBuffer.isView(data)){FS.write(stream,data,0,data.byteLength,undefined,opts.canOwn)}else{abort("Unsupported data type")}FS.close(stream)},cwd:()=>FS.currentPath,chdir(path){var lookup=FS.lookupPath(path,{follow:true});if(lookup.node===null){throw new FS.ErrnoError(44)}if(!FS.isDir(lookup.node.mode)){throw new FS.ErrnoError(54)}var errCode=FS.nodePermissions(lookup.node,"x");if(errCode){throw new FS.ErrnoError(errCode)}FS.currentPath=lookup.path},createDefaultDirectories(){FS.mkdir("/tmp");FS.mkdir("/home");FS.mkdir("/home/web_user")},createDefaultDevices(){FS.mkdir("/dev");FS.registerDevice(FS.makedev(1,3),{read:()=>0,write:(stream,buffer,offset,length,pos)=>length,llseek:()=>0});FS.mkdev("/dev/null",FS.makedev(1,3));TTY.register(FS.makedev(5,0),TTY.default_tty_ops);TTY.register(FS.makedev(6,0),TTY.default_tty1_ops);FS.mkdev("/dev/tty",FS.makedev(5,0));FS.mkdev("/dev/tty1",FS.makedev(6,0));var randomBuffer=new Uint8Array(1024),randomLeft=0;var randomByte=()=>{if(randomLeft===0){randomFill(randomBuffer);randomLeft=randomBuffer.byteLength}return randomBuffer[--randomLeft]};FS.createDevice("/dev","random",randomByte);FS.createDevice("/dev","urandom",randomByte);FS.mkdir("/dev/shm");FS.mkdir("/dev/shm/tmp")},createSpecialDirectories(){FS.mkdir("/proc");var proc_self=FS.mkdir("/proc/self");FS.mkdir("/proc/self/fd");FS.mount({mount(){var node=FS.createNode(proc_self,"fd",16895,73);node.stream_ops={llseek:MEMFS.stream_ops.llseek};node.node_ops={lookup(parent,name){var fd=+name;var stream=FS.getStreamChecked(fd);var ret={parent:null,mount:{mountpoint:"fake"},node_ops:{readlink:()=>stream.path},id:fd+1};ret.parent=ret;return ret},readdir(){return Array.from(FS.streams.entries()).filter(([k,v])=>v).map(([k,v])=>k.toString())}};return node}},{},"/proc/self/fd")},createStandardStreams(input,output,error){if(input){FS.createDevice("/dev","stdin",input)}else{FS.symlink("/dev/tty","/dev/stdin")}if(output){FS.createDevice("/dev","stdout",null,output)}else{FS.symlink("/dev/tty","/dev/stdout")}if(error){FS.createDevice("/dev","stderr",null,error)}else{FS.symlink("/dev/tty1","/dev/stderr")}var stdin=FS.open("/dev/stdin",0);var stdout=FS.open("/dev/stdout",1);var stderr=FS.open("/dev/stderr",1)},staticInit(){FS.nameTable=new Array(4096);FS.mount(MEMFS,{},"/");FS.createDefaultDirectories();FS.createDefaultDevices();FS.createSpecialDirectories();FS.filesystems={MEMFS,IDBFS}},init(input,output,error){FS.initialized=true;input??=Module["stdin"];output??=Module["stdout"];error??=Module["stderr"];FS.createStandardStreams(input,output,error)},quit(){FS.initialized=false;_fflush(0);for(var stream of FS.streams){if(stream){FS.close(stream)}}},findObject(path,dontResolveLastLink){var ret=FS.analyzePath(path,dontResolveLastLink);if(!ret.exists){return null}return ret.object},analyzePath(path,dontResolveLastLink){try{var lookup=FS.lookupPath(path,{follow:!dontResolveLastLink});path=lookup.path}catch(e){}var ret={isRoot:false,exists:false,error:0,name:null,path:null,object:null,parentExists:false,parentPath:null,parentObject:null};try{var lookup=FS.lookupPath(path,{parent:true});ret.parentExists=true;ret.parentPath=lookup.path;ret.parentObject=lookup.node;ret.name=PATH.basename(path);lookup=FS.lookupPath(path,{follow:!dontResolveLastLink});ret.exists=true;ret.path=lookup.path;ret.object=lookup.node;ret.name=lookup.node.name;ret.isRoot=lookup.path==="/"}catch(e){ret.error=e.errno}return ret},createPath(parent,path,canRead,canWrite){parent=typeof parent=="string"?parent:FS.getPath(parent);var parts=path.split("/").reverse();while(parts.length){var part=parts.pop();if(!part)continue;var current=PATH.join2(parent,part);try{FS.mkdir(current)}catch(e){if(e.errno!=20)throw e}parent=current}return current},createFile(parent,name,properties,canRead,canWrite){var path=PATH.join2(typeof parent=="string"?parent:FS.getPath(parent),name);var mode=FS_getMode(canRead,canWrite);return FS.create(path,mode)},createDataFile(parent,name,data,canRead,canWrite,canOwn){var path=name;if(parent){parent=typeof parent=="string"?parent:FS.getPath(parent);path=name?PATH.join2(parent,name):parent}var mode=FS_getMode(canRead,canWrite);var node=FS.create(path,mode);if(data){if(typeof data=="string"){var arr=new Array(data.length);for(var i=0,len=data.length;i<len;++i)arr[i]=data.charCodeAt(i);data=arr}FS.chmod(node,mode|146);var stream=FS.open(node,577);FS.write(stream,data,0,data.length,0,canOwn);FS.close(stream);FS.chmod(node,mode)}},createDevice(parent,name,input,output){var path=PATH.join2(typeof parent=="string"?parent:FS.getPath(parent),name);var mode=FS_getMode(!!input,!!output);FS.createDevice.major??=64;var dev=FS.makedev(FS.createDevice.major++,0);FS.registerDevice(dev,{open(stream){stream.seekable=false},close(stream){if(output?.buffer?.length){output(10)}},read(stream,buffer,offset,length,pos){var bytesRead=0;for(var i=0;i<length;i++){var result;try{result=input()}catch(e){throw new FS.ErrnoError(29)}if(result===undefined&&bytesRead===0){throw new FS.ErrnoError(6)}if(result===null||result===undefined)break;bytesRead++;buffer[offset+i]=result}if(bytesRead){stream.node.atime=Date.now()}return bytesRead},write(stream,buffer,offset,length,pos){for(var i=0;i<length;i++){try{output(buffer[offset+i])}catch(e){throw new FS.ErrnoError(29)}}if(length){stream.node.mtime=stream.node.ctime=Date.now()}return i}});return FS.mkdev(path,mode,dev)},forceLoadFile(obj){if(obj.isDevice||obj.isFolder||obj.link||obj.contents)return true;if(globalThis.XMLHttpRequest){abort("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.")}else{try{obj.contents=readBinary(obj.url)}catch(e){throw new FS.ErrnoError(29)}}},createLazyFile(parent,name,url,canRead,canWrite){class LazyUint8Array{lengthKnown=false;chunks=[];get(idx){if(idx>this.length-1||idx<0){return undefined}var chunkOffset=idx%this.chunkSize;var chunkNum=idx/this.chunkSize|0;return this.getter(chunkNum)[chunkOffset]}setDataGetter(getter){this.getter=getter}cacheLength(){var xhr=new XMLHttpRequest;xhr.open("HEAD",url,false);xhr.send(null);if(!(xhr.status>=200&&xhr.status<300||xhr.status===304))abort("Couldn't load "+url+". Status: "+xhr.status);var datalength=Number(xhr.getResponseHeader("Content-length"));var header;var hasByteServing=(header=xhr.getResponseHeader("Accept-Ranges"))&&header==="bytes";var usesGzip=(header=xhr.getResponseHeader("Content-Encoding"))&&header==="gzip";var chunkSize=1024*1024;if(!hasByteServing)chunkSize=datalength;var doXHR=(from,to)=>{if(from>to)abort("invalid range ("+from+", "+to+") or no bytes requested!");if(to>datalength-1)abort("only "+datalength+" bytes available! programmer error!");var xhr=new XMLHttpRequest;xhr.open("GET",url,false);if(datalength!==chunkSize)xhr.setRequestHeader("Range","bytes="+from+"-"+to);xhr.responseType="arraybuffer";if(xhr.overrideMimeType){xhr.overrideMimeType("text/plain; charset=x-user-defined")}xhr.send(null);if(!(xhr.status>=200&&xhr.status<300||xhr.status===304))abort("Couldn't load "+url+". Status: "+xhr.status);if(xhr.response!==undefined){return new Uint8Array(xhr.response||[])}return intArrayFromString(xhr.responseText||"",true)};var lazyArray=this;lazyArray.setDataGetter(chunkNum=>{var start=chunkNum*chunkSize;var end=(chunkNum+1)*chunkSize-1;end=Math.min(end,datalength-1);if(typeof lazyArray.chunks[chunkNum]=="undefined"){lazyArray.chunks[chunkNum]=doXHR(start,end)}if(typeof lazyArray.chunks[chunkNum]=="undefined")abort("doXHR failed!");return lazyArray.chunks[chunkNum]});if(usesGzip||!datalength){chunkSize=datalength=1;datalength=this.getter(0).length;chunkSize=datalength;out("LazyFiles on gzip forces download of the whole file when length is accessed")}this._length=datalength;this._chunkSize=chunkSize;this.lengthKnown=true}get length(){if(!this.lengthKnown){this.cacheLength()}return this._length}get chunkSize(){if(!this.lengthKnown){this.cacheLength()}return this._chunkSize}}if(globalThis.XMLHttpRequest){if(!ENVIRONMENT_IS_WORKER)abort("Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc");var lazyArray=new LazyUint8Array;var properties={isDevice:false,contents:lazyArray}}else{var properties={isDevice:false,url}}var node=FS.createFile(parent,name,properties,canRead,canWrite);if(properties.contents){node.contents=properties.contents}else if(properties.url){node.contents=null;node.url=properties.url}Object.defineProperties(node,{usedBytes:{get:function(){return this.contents.length}}});var stream_ops={};for(const[key,fn]of Object.entries(node.stream_ops)){stream_ops[key]=(...args)=>{FS.forceLoadFile(node);return fn(...args)}}function writeChunks(stream,buffer,offset,length,position){var contents=stream.node.contents;if(position>=contents.length)return 0;var size=Math.min(contents.length-position,length);if(contents.slice){for(var i=0;i<size;i++){buffer[offset+i]=contents[position+i]}}else{for(var i=0;i<size;i++){buffer[offset+i]=contents.get(position+i)}}return size}stream_ops.read=(stream,buffer,offset,length,position)=>{FS.forceLoadFile(node);return writeChunks(stream,buffer,offset,length,position)};stream_ops.mmap=(stream,length,position,prot,flags)=>{FS.forceLoadFile(node);var ptr=mmapAlloc(length);if(!ptr){throw new FS.ErrnoError(48)}writeChunks(stream,HEAP8,ptr,length,position);return{ptr,allocated:true}};node.stream_ops=stream_ops;return node}};var UTF8ToString=(ptr,maxBytesToRead,ignoreNul)=>ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead,ignoreNul):"";var SYSCALLS={DEFAULT_POLLMASK:5,calculateAt(dirfd,path,allowEmpty){if(PATH.isAbs(path)){return path}var dir;if(dirfd===-100){dir=FS.cwd()}else{var dirstream=SYSCALLS.getStreamFromFD(dirfd);dir=dirstream.path}if(path.length==0){if(!allowEmpty){throw new FS.ErrnoError(44)}return dir}return dir+"/"+path},writeStat(buf,stat){HEAPU32[buf>>2]=stat.dev;HEAPU32[buf+4>>2]=stat.mode;HEAPU32[buf+8>>2]=stat.nlink;HEAPU32[buf+12>>2]=stat.uid;HEAPU32[buf+16>>2]=stat.gid;HEAPU32[buf+20>>2]=stat.rdev;HEAP64[buf+24>>3]=BigInt(stat.size);HEAP32[buf+32>>2]=4096;HEAP32[buf+36>>2]=stat.blocks;var atime=stat.atime.getTime();var mtime=stat.mtime.getTime();var ctime=stat.ctime.getTime();HEAP64[buf+40>>3]=BigInt(Math.floor(atime/1e3));HEAPU32[buf+48>>2]=atime%1e3*1e3*1e3;HEAP64[buf+56>>3]=BigInt(Math.floor(mtime/1e3));HEAPU32[buf+64>>2]=mtime%1e3*1e3*1e3;HEAP64[buf+72>>3]=BigInt(Math.floor(ctime/1e3));HEAPU32[buf+80>>2]=ctime%1e3*1e3*1e3;HEAP64[buf+88>>3]=BigInt(stat.ino);return 0},writeStatFs(buf,stats){HEAPU32[buf+4>>2]=stats.bsize;HEAPU32[buf+60>>2]=stats.bsize;HEAP64[buf+8>>3]=BigInt(stats.blocks);HEAP64[buf+16>>3]=BigInt(stats.bfree);HEAP64[buf+24>>3]=BigInt(stats.bavail);HEAP64[buf+32>>3]=BigInt(stats.files);HEAP64[buf+40>>3]=BigInt(stats.ffree);HEAPU32[buf+48>>2]=stats.fsid;HEAPU32[buf+64>>2]=stats.flags;HEAPU32[buf+56>>2]=stats.namelen},doMsync(addr,stream,len,flags,offset){if(!FS.isFile(stream.node.mode)){throw new FS.ErrnoError(43)}if(flags&2){return 0}var buffer=HEAPU8.slice(addr,addr+len);FS.msync(stream,buffer,offset,len,flags)},getStreamFromFD(fd){var stream=FS.getStreamChecked(fd);return stream},varargs:undefined,getStr(ptr){var ret=UTF8ToString(ptr);return ret}};function ___syscall_chdir(path){try{path=SYSCALLS.getStr(path);FS.chdir(path);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_chmod(path,mode){try{path=SYSCALLS.getStr(path);FS.chmod(path,mode);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_faccessat(dirfd,path,amode,flags){try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);if(amode&~7){return-28}var lookup=FS.lookupPath(path,{follow:true});var node=lookup.node;if(!node){return-44}var perms="";if(amode&4)perms+="r";if(amode&2)perms+="w";if(amode&1)perms+="x";if(perms&&FS.nodePermissions(node,perms)){return-2}return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_fchmod(fd,mode){try{FS.fchmod(fd,mode);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}var syscallGetVarargI=()=>{var ret=HEAP32[+SYSCALLS.varargs>>2];SYSCALLS.varargs+=4;return ret};var syscallGetVarargP=syscallGetVarargI;function ___syscall_fcntl64(fd,cmd,varargs){SYSCALLS.varargs=varargs;try{var stream=SYSCALLS.getStreamFromFD(fd);switch(cmd){case 0:{var arg=syscallGetVarargI();if(arg<0){return-28}while(FS.streams[arg]){arg++}var newStream;newStream=FS.dupStream(stream,arg);return newStream.fd}case 1:case 2:return 0;case 3:return stream.flags;case 4:{var arg=syscallGetVarargI();stream.flags|=arg;return 0}case 12:{var arg=syscallGetVarargP();var offset=0;HEAP16[arg+offset>>1]=2;return 0}case 13:case 14:return 0}return-28}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_fstat64(fd,buf){try{return SYSCALLS.writeStat(buf,FS.fstat(fd))}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}var INT53_MAX=9007199254740992;var INT53_MIN=-9007199254740992;var bigintToI53Checked=num=>num<INT53_MIN||num>INT53_MAX?NaN:Number(num);function ___syscall_ftruncate64(fd,length){length=bigintToI53Checked(length);try{if(isNaN(length))return-61;FS.ftruncate(fd,length);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}var stringToUTF8=(str,outPtr,maxBytesToWrite)=>stringToUTF8Array(str,HEAPU8,outPtr,maxBytesToWrite);function ___syscall_getcwd(buf,size){try{if(size===0)return-28;var cwd=FS.cwd();var cwdLengthInBytes=lengthBytesUTF8(cwd)+1;if(size<cwdLengthInBytes)return-68;stringToUTF8(cwd,buf,size);return cwdLengthInBytes}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_getdents64(fd,dirp,count){try{var stream=SYSCALLS.getStreamFromFD(fd);stream.getdents||=FS.readdir(stream.path);var struct_size=280;var pos=0;var off=FS.llseek(stream,0,1);var startIdx=Math.floor(off/struct_size);var endIdx=Math.min(stream.getdents.length,startIdx+Math.floor(count/struct_size));for(var idx=startIdx;idx<endIdx;idx++){var id;var type;var name=stream.getdents[idx];if(name==="."){id=stream.node.id;type=4}else if(name===".."){var lookup=FS.lookupPath(stream.path,{parent:true});id=lookup.node.id;type=4}else{var child;try{child=FS.lookupNode(stream.node,name)}catch(e){if(e?.errno===28){continue}throw e}id=child.id;type=FS.isChrdev(child.mode)?2:FS.isDir(child.mode)?4:FS.isLink(child.mode)?10:8}HEAP64[dirp+pos>>3]=BigInt(id);HEAP64[dirp+pos+8>>3]=BigInt((idx+1)*struct_size);HEAP16[dirp+pos+16>>1]=280;HEAP8[dirp+pos+18]=type;stringToUTF8(name,dirp+pos+19,256);pos+=struct_size}FS.llseek(stream,idx*struct_size,0);return pos}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_ioctl(fd,op,varargs){SYSCALLS.varargs=varargs;try{var stream=SYSCALLS.getStreamFromFD(fd);switch(op){case 21509:{if(!stream.tty)return-59;return 0}case 21505:{if(!stream.tty)return-59;if(stream.tty.ops.ioctl_tcgets){var termios=stream.tty.ops.ioctl_tcgets(stream);var argp=syscallGetVarargP();HEAP32[argp>>2]=termios.c_iflag||0;HEAP32[argp+4>>2]=termios.c_oflag||0;HEAP32[argp+8>>2]=termios.c_cflag||0;HEAP32[argp+12>>2]=termios.c_lflag||0;for(var i=0;i<32;i++){HEAP8[argp+i+17]=termios.c_cc[i]||0}return 0}return 0}case 21510:case 21511:case 21512:{if(!stream.tty)return-59;return 0}case 21506:case 21507:case 21508:{if(!stream.tty)return-59;if(stream.tty.ops.ioctl_tcsets){var argp=syscallGetVarargP();var c_iflag=HEAP32[argp>>2];var c_oflag=HEAP32[argp+4>>2];var c_cflag=HEAP32[argp+8>>2];var c_lflag=HEAP32[argp+12>>2];var c_cc=[];for(var i=0;i<32;i++){c_cc.push(HEAP8[argp+i+17])}return stream.tty.ops.ioctl_tcsets(stream.tty,op,{c_iflag,c_oflag,c_cflag,c_lflag,c_cc})}return 0}case 21519:{if(!stream.tty)return-59;var argp=syscallGetVarargP();HEAP32[argp>>2]=0;return 0}case 21520:{if(!stream.tty)return-59;return-28}case 21537:case 21531:{var argp=syscallGetVarargP();return FS.ioctl(stream,op,argp)}case 21523:{if(!stream.tty)return-59;if(stream.tty.ops.ioctl_tiocgwinsz){var winsize=stream.tty.ops.ioctl_tiocgwinsz(stream.tty);var argp=syscallGetVarargP();HEAP16[argp>>1]=winsize[0];HEAP16[argp+2>>1]=winsize[1]}return 0}case 21524:{if(!stream.tty)return-59;return 0}case 21515:{if(!stream.tty)return-59;return 0}default:return-28}}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_lstat64(path,buf){try{path=SYSCALLS.getStr(path);return SYSCALLS.writeStat(buf,FS.lstat(path))}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_mkdirat(dirfd,path,mode){try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);FS.mkdir(path,mode,0);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_mknodat(dirfd,path,mode,dev){try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);switch(mode&61440){case 32768:case 8192:case 24576:case 4096:case 49152:break;default:return-28}FS.mknod(path,mode,dev);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_newfstatat(dirfd,path,buf,flags){try{path=SYSCALLS.getStr(path);var nofollow=flags&256;var allowEmpty=flags&4096;flags=flags&~6400;path=SYSCALLS.calculateAt(dirfd,path,allowEmpty);return SYSCALLS.writeStat(buf,nofollow?FS.lstat(path):FS.stat(path))}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_openat(dirfd,path,flags,varargs){SYSCALLS.varargs=varargs;try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);var mode=varargs?syscallGetVarargI():0;return FS.open(path,flags,mode).fd}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_readlinkat(dirfd,path,buf,bufsize){try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);if(bufsize<=0)return-28;var ret=FS.readlink(path);var len=Math.min(bufsize,lengthBytesUTF8(ret));var endChar=HEAP8[buf+len];stringToUTF8(ret,buf,bufsize+1);HEAP8[buf+len]=endChar;return len}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_renameat(olddirfd,oldpath,newdirfd,newpath){try{oldpath=SYSCALLS.getStr(oldpath);newpath=SYSCALLS.getStr(newpath);oldpath=SYSCALLS.calculateAt(olddirfd,oldpath);newpath=SYSCALLS.calculateAt(newdirfd,newpath);FS.rename(oldpath,newpath);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_rmdir(path){try{path=SYSCALLS.getStr(path);FS.rmdir(path);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_stat64(path,buf){try{path=SYSCALLS.getStr(path);return SYSCALLS.writeStat(buf,FS.stat(path))}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_statfs64(path,size,buf){try{SYSCALLS.writeStatFs(buf,FS.statfs(SYSCALLS.getStr(path)));return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_symlinkat(target,dirfd,linkpath){try{target=SYSCALLS.getStr(target);linkpath=SYSCALLS.getStr(linkpath);linkpath=SYSCALLS.calculateAt(dirfd,linkpath);FS.symlink(target,linkpath);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_unlinkat(dirfd,path,flags){try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);if(!flags){FS.unlink(path)}else if(flags===512){FS.rmdir(path)}else{return-28}return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}var __abort_js=()=>abort("");var runtimeKeepaliveCounter=0;var __emscripten_runtime_keepalive_clear=()=>{noExitRuntime=false;runtimeKeepaliveCounter=0};function __gmtime_js(time,tmPtr){time=bigintToI53Checked(time);var date=new Date(time*1e3);HEAP32[tmPtr>>2]=date.getUTCSeconds();HEAP32[tmPtr+4>>2]=date.getUTCMinutes();HEAP32[tmPtr+8>>2]=date.getUTCHours();HEAP32[tmPtr+12>>2]=date.getUTCDate();HEAP32[tmPtr+16>>2]=date.getUTCMonth();HEAP32[tmPtr+20>>2]=date.getUTCFullYear()-1900;HEAP32[tmPtr+24>>2]=date.getUTCDay();var start=Date.UTC(date.getUTCFullYear(),0,1,0,0,0,0);var yday=(date.getTime()-start)/(1e3*60*60*24)|0;HEAP32[tmPtr+28>>2]=yday}var isLeapYear=year=>year%4===0&&(year%100!==0||year%400===0);var MONTH_DAYS_LEAP_CUMULATIVE=[0,31,60,91,121,152,182,213,244,274,305,335];var MONTH_DAYS_REGULAR_CUMULATIVE=[0,31,59,90,120,151,181,212,243,273,304,334];var ydayFromDate=date=>{var leap=isLeapYear(date.getFullYear());var monthDaysCumulative=leap?MONTH_DAYS_LEAP_CUMULATIVE:MONTH_DAYS_REGULAR_CUMULATIVE;var yday=monthDaysCumulative[date.getMonth()]+date.getDate()-1;return yday};function __localtime_js(time,tmPtr){time=bigintToI53Checked(time);var date=new Date(time*1e3);HEAP32[tmPtr>>2]=date.getSeconds();HEAP32[tmPtr+4>>2]=date.getMinutes();HEAP32[tmPtr+8>>2]=date.getHours();HEAP32[tmPtr+12>>2]=date.getDate();HEAP32[tmPtr+16>>2]=date.getMonth();HEAP32[tmPtr+20>>2]=date.getFullYear()-1900;HEAP32[tmPtr+24>>2]=date.getDay();var yday=ydayFromDate(date)|0;HEAP32[tmPtr+28>>2]=yday;HEAP32[tmPtr+36>>2]=-(date.getTimezoneOffset()*60);var start=new Date(date.getFullYear(),0,1);var summerOffset=new Date(date.getFullYear(),6,1).getTimezoneOffset();var winterOffset=start.getTimezoneOffset();var dst=(summerOffset!=winterOffset&&date.getTimezoneOffset()==Math.min(winterOffset,summerOffset))|0;HEAP32[tmPtr+32>>2]=dst}var timers={};var handleException=e=>{if(e instanceof ExitStatus||e=="unwind"){return EXITSTATUS}quit_(1,e)};var keepRuntimeAlive=()=>noExitRuntime||runtimeKeepaliveCounter>0;var _proc_exit=code=>{EXITSTATUS=code;if(!keepRuntimeAlive()){Module["onExit"]?.(code);ABORT=true}quit_(code,new ExitStatus(code))};var exitJS=(status,implicit)=>{EXITSTATUS=status;if(!keepRuntimeAlive()){exitRuntime()}_proc_exit(status)};var _exit=exitJS;var maybeExit=()=>{if(runtimeExited){return}if(!keepRuntimeAlive()){try{_exit(EXITSTATUS)}catch(e){handleException(e)}}};var callUserCallback=func=>{if(runtimeExited||ABORT){return}try{func();maybeExit()}catch(e){handleException(e)}};var _emscripten_get_now=()=>performance.now();var __setitimer_js=(which,timeout_ms)=>{if(timers[which]){clearTimeout(timers[which].id);delete timers[which]}if(!timeout_ms)return 0;var id=setTimeout(()=>{delete timers[which];callUserCallback(()=>__emscripten_timeout(which,_emscripten_get_now()))},timeout_ms);timers[which]={id,timeout_ms};return 0};var __tzset_js=(timezone,daylight,std_name,dst_name)=>{var currentYear=(new Date).getFullYear();var winter=new Date(currentYear,0,1);var summer=new Date(currentYear,6,1);var winterOffset=winter.getTimezoneOffset();var summerOffset=summer.getTimezoneOffset();var stdTimezoneOffset=Math.max(winterOffset,summerOffset);HEAPU32[timezone>>2]=stdTimezoneOffset*60;HEAP32[daylight>>2]=Number(winterOffset!=summerOffset);var extractZone=timezoneOffset=>{var sign=timezoneOffset>=0?"-":"+";var absOffset=Math.abs(timezoneOffset);var hours=String(Math.floor(absOffset/60)).padStart(2,"0");var minutes=String(absOffset%60).padStart(2,"0");return`UTC${sign}${hours}${minutes}`};var winterName=extractZone(winterOffset);var summerName=extractZone(summerOffset);if(summerOffset<winterOffset){stringToUTF8(winterName,std_name,17);stringToUTF8(summerName,dst_name,17)}else{stringToUTF8(winterName,dst_name,17);stringToUTF8(summerName,std_name,17)}};var _emscripten_date_now=()=>Date.now();var nowIsMonotonic=1;var checkWasiClock=clock_id=>clock_id>=0&&clock_id<=3;function _clock_time_get(clk_id,ignored_precision,ptime){ignored_precision=bigintToI53Checked(ignored_precision);if(!checkWasiClock(clk_id)){return 28}var now;if(clk_id===0){now=_emscripten_date_now()}else if(nowIsMonotonic){now=_emscripten_get_now()}else{return 52}var nsec=Math.round(now*1e3*1e3);HEAP64[ptime>>3]=BigInt(nsec);return 0}var runtimeKeepalivePush=()=>{runtimeKeepaliveCounter+=1};var _emscripten_set_main_loop_timing=(mode,value)=>{MainLoop.timingMode=mode;MainLoop.timingValue=value;if(!MainLoop.func){return 1}if(!MainLoop.running){runtimeKeepalivePush();MainLoop.running=true}if(mode==0){MainLoop.scheduler=function MainLoop_scheduler_setTimeout(){var timeUntilNextTick=Math.max(0,MainLoop.tickStartTime+value-_emscripten_get_now())|0;setTimeout(MainLoop.runner,timeUntilNextTick)};MainLoop.method="timeout"}else if(mode==1){MainLoop.scheduler=function MainLoop_scheduler_rAF(){MainLoop.requestAnimationFrame(MainLoop.runner)};MainLoop.method="rAF"}else if(mode==2){if(!MainLoop.setImmediate){if(globalThis.setImmediate){MainLoop.setImmediate=setImmediate}else{var setImmediates=[];var emscriptenMainLoopMessageId="setimmediate";var MainLoop_setImmediate_messageHandler=event=>{if(event.data===emscriptenMainLoopMessageId||event.data.target===emscriptenMainLoopMessageId){event.stopPropagation();setImmediates.shift()()}};addEventListener("message",MainLoop_setImmediate_messageHandler,true);MainLoop.setImmediate=func=>{setImmediates.push(func);if(ENVIRONMENT_IS_WORKER){Module["setImmediates"]??=[];Module["setImmediates"].push(func);postMessage({target:emscriptenMainLoopMessageId})}else postMessage(emscriptenMainLoopMessageId,"*")}}}MainLoop.scheduler=function MainLoop_scheduler_setImmediate(){MainLoop.setImmediate(MainLoop.runner)};MainLoop.method="immediate"}return 0};var runtimeKeepalivePop=()=>{runtimeKeepaliveCounter-=1};var setMainLoop=(iterFunc,fps,simulateInfiniteLoop,arg,noSetTiming)=>{MainLoop.func=iterFunc;MainLoop.arg=arg;var thisMainLoopId=MainLoop.currentlyRunningMainloop;function checkIsRunning(){if(thisMainLoopId<MainLoop.currentlyRunningMainloop){runtimeKeepalivePop();maybeExit();return false}return true}MainLoop.running=false;MainLoop.runner=function MainLoop_runner(){if(ABORT)return;if(MainLoop.queue.length>0){var start=Date.now();var blocker=MainLoop.queue.shift();blocker.func(blocker.arg);if(MainLoop.remainingBlockers){var remaining=MainLoop.remainingBlockers;var next=remaining%1==0?remaining-1:Math.floor(remaining);if(blocker.counted){MainLoop.remainingBlockers=next}else{next=next+.5;MainLoop.remainingBlockers=(8*remaining+next)/9}}MainLoop.updateStatus();if(!checkIsRunning())return;setTimeout(MainLoop.runner,0);return}if(!checkIsRunning())return;MainLoop.currentFrameNumber=MainLoop.currentFrameNumber+1|0;if(MainLoop.timingMode==1&&MainLoop.timingValue>1&&MainLoop.currentFrameNumber%MainLoop.timingValue!=0){MainLoop.scheduler();return}else if(MainLoop.timingMode==0){MainLoop.tickStartTime=_emscripten_get_now()}MainLoop.runIter(iterFunc);if(!checkIsRunning())return;MainLoop.scheduler()};if(!noSetTiming){if(fps>0){_emscripten_set_main_loop_timing(0,1e3/fps)}else{_emscripten_set_main_loop_timing(1,1)}MainLoop.scheduler()}if(simulateInfiniteLoop){throw"unwind"}};var MainLoop={running:false,scheduler:null,method:"",currentlyRunningMainloop:0,func:null,arg:0,timingMode:0,timingValue:0,currentFrameNumber:0,queue:[],preMainLoop:[],postMainLoop:[],pause(){MainLoop.scheduler=null;MainLoop.currentlyRunningMainloop++},resume(){MainLoop.currentlyRunningMainloop++;var timingMode=MainLoop.timingMode;var timingValue=MainLoop.timingValue;var func=MainLoop.func;MainLoop.func=null;setMainLoop(func,0,false,MainLoop.arg,true);_emscripten_set_main_loop_timing(timingMode,timingValue);MainLoop.scheduler()},updateStatus(){if(Module["setStatus"]){var message=Module["statusMessage"]||"Please wait...";var remaining=MainLoop.remainingBlockers??0;var expected=MainLoop.expectedBlockers??0;if(remaining){if(remaining<expected){Module["setStatus"](`{message} ({expected - remaining}/{expected})`)}else{Module["setStatus"](message)}}else{Module["setStatus"]("")}}},init(){Module["preMainLoop"]&&MainLoop.preMainLoop.push(Module["preMainLoop"]);Module["postMainLoop"]&&MainLoop.postMainLoop.push(Module["postMainLoop"])},runIter(func){if(ABORT)return;for(var pre of MainLoop.preMainLoop){if(pre()===false){return}}callUserCallback(func);for(var post of MainLoop.postMainLoop){post()}},nextRAF:0,fakeRequestAnimationFrame(func){var now=Date.now();if(MainLoop.nextRAF===0){MainLoop.nextRAF=now+1e3/60}else{while(now+2>=MainLoop.nextRAF){MainLoop.nextRAF+=1e3/60}}var delay=Math.max(MainLoop.nextRAF-now,0);setTimeout(func,delay)},requestAnimationFrame(func){if(globalThis.requestAnimationFrame){requestAnimationFrame(func)}else{MainLoop.fakeRequestAnimationFrame(func)}}};var _emscripten_cancel_main_loop=()=>{MainLoop.pause();MainLoop.func=null};var _emscripten_force_exit=status=>{__emscripten_runtime_keepalive_clear();_exit(status)};var getHeapMax=()=>2147483648;var _emscripten_get_heap_max=()=>getHeapMax();var growMemory=size=>{var oldHeapSize=wasmMemory.buffer.byteLength;var pages=(size-oldHeapSize+65535)/65536|0;try{wasmMemory.grow(pages);updateMemoryViews();return 1}catch(e){}};var _emscripten_resize_heap=requestedSize=>{var oldSize=HEAPU8.length;requestedSize>>>=0;var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignMemory(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=growMemory(newSize);if(replacement){return true}}return false};var maybeCStringToJsString=cString=>cString>2?UTF8ToString(cString):cString;var specialHTMLTargets=[0,typeof document!="undefined"?document:0,typeof window!="undefined"?window:0];var findEventTarget=target=>{target=maybeCStringToJsString(target);var domElement=specialHTMLTargets[target]||(typeof document!="undefined"?document.querySelector(target):null);return domElement};var findCanvasEventTarget=findEventTarget;var _emscripten_set_canvas_element_size=(target,width,height)=>{var canvas=findCanvasEventTarget(target);if(!canvas)return-4;canvas.width=width;canvas.height=height;if(canvas.GLctxObject)GL.resizeOffscreenFramebuffer(canvas.GLctxObject);return 0};var _emscripten_set_main_loop=(func,fps,simulateInfiniteLoop)=>{var iterFunc=getWasmTableEntry(func);setMainLoop(iterFunc,fps,simulateInfiniteLoop)};var GLctx;var webgl_enable_ANGLE_instanced_arrays=ctx=>{var ext=ctx.getExtension("ANGLE_instanced_arrays");if(ext){ctx["vertexAttribDivisor"]=(index,divisor)=>ext["vertexAttribDivisorANGLE"](index,divisor);ctx["drawArraysInstanced"]=(mode,first,count,primcount)=>ext["drawArraysInstancedANGLE"](mode,first,count,primcount);ctx["drawElementsInstanced"]=(mode,count,type,indices,primcount)=>ext["drawElementsInstancedANGLE"](mode,count,type,indices,primcount);return 1}};var webgl_enable_OES_vertex_array_object=ctx=>{var ext=ctx.getExtension("OES_vertex_array_object");if(ext){ctx["createVertexArray"]=()=>ext["createVertexArrayOES"]();ctx["deleteVertexArray"]=vao=>ext["deleteVertexArrayOES"](vao);ctx["bindVertexArray"]=vao=>ext["bindVertexArrayOES"](vao);ctx["isVertexArray"]=vao=>ext["isVertexArrayOES"](vao);return 1}};var webgl_enable_WEBGL_draw_buffers=ctx=>{var ext=ctx.getExtension("WEBGL_draw_buffers");if(ext){ctx["drawBuffers"]=(n,bufs)=>ext["drawBuffersWEBGL"](n,bufs);return 1}};var webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance=ctx=>!!(ctx.dibvbi=ctx.getExtension("WEBGL_draw_instanced_base_vertex_base_instance"));var webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance=ctx=>!!(ctx.mdibvbi=ctx.getExtension("WEBGL_multi_draw_instanced_base_vertex_base_instance"));var webgl_enable_EXT_polygon_offset_clamp=ctx=>!!(ctx.extPolygonOffsetClamp=ctx.getExtension("EXT_polygon_offset_clamp"));var webgl_enable_EXT_clip_control=ctx=>!!(ctx.extClipControl=ctx.getExtension("EXT_clip_control"));var webgl_enable_WEBGL_polygon_mode=ctx=>!!(ctx.webglPolygonMode=ctx.getExtension("WEBGL_polygon_mode"));var webgl_enable_WEBGL_multi_draw=ctx=>!!(ctx.multiDrawWebgl=ctx.getExtension("WEBGL_multi_draw"));var getEmscriptenSupportedExtensions=ctx=>{var supportedExtensions=["ANGLE_instanced_arrays","EXT_blend_minmax","EXT_disjoint_timer_query","EXT_frag_depth","EXT_shader_texture_lod","EXT_sRGB","OES_element_index_uint","OES_fbo_render_mipmap","OES_standard_derivatives","OES_texture_float","OES_texture_half_float","OES_texture_half_float_linear","OES_vertex_array_object","WEBGL_color_buffer_float","WEBGL_depth_texture","WEBGL_draw_buffers","EXT_color_buffer_float","EXT_conservative_depth","EXT_disjoint_timer_query_webgl2","EXT_texture_norm16","NV_shader_noperspective_interpolation","WEBGL_clip_cull_distance","EXT_clip_control","EXT_color_buffer_half_float","EXT_depth_clamp","EXT_float_blend","EXT_polygon_offset_clamp","EXT_texture_compression_bptc","EXT_texture_compression_rgtc","EXT_texture_filter_anisotropic","KHR_parallel_shader_compile","OES_texture_float_linear","WEBGL_blend_func_extended","WEBGL_compressed_texture_astc","WEBGL_compressed_texture_etc","WEBGL_compressed_texture_etc1","WEBGL_compressed_texture_s3tc","WEBGL_compressed_texture_s3tc_srgb","WEBGL_debug_renderer_info","WEBGL_debug_shaders","WEBGL_lose_context","WEBGL_multi_draw","WEBGL_polygon_mode"];return(ctx.getSupportedExtensions()||[]).filter(ext=>supportedExtensions.includes(ext))};var GL={counter:1,buffers:[],programs:[],framebuffers:[],renderbuffers:[],textures:[],shaders:[],vaos:[],contexts:[],offscreenCanvases:{},queries:[],samplers:[],transformFeedbacks:[],syncs:[],stringCache:{},stringiCache:{},unpackAlignment:4,unpackRowLength:0,recordError:errorCode=>{if(!GL.lastError){GL.lastError=errorCode}},getNewId:table=>{var ret=GL.counter++;for(var i=table.length;i<ret;i++){table[i]=null}return ret},genObject:(n,buffers,createFunction,objectTable)=>{for(var i=0;i<n;i++){var buffer=GLctx[createFunction]();var id=buffer&&GL.getNewId(objectTable);if(buffer){buffer.name=id;objectTable[id]=buffer}else{GL.recordError(1282)}HEAP32[buffers+i*4>>2]=id}},getSource:(shader,count,string,length)=>{var source="";for(var i=0;i<count;++i){var len=length?HEAPU32[length+i*4>>2]:undefined;source+=UTF8ToString(HEAPU32[string+i*4>>2],len)}return source},createContext:(canvas,webGLContextAttributes)=>{if(webGLContextAttributes.renderViaOffscreenBackBuffer)webGLContextAttributes["preserveDrawingBuffer"]=true;var ctx=webGLContextAttributes.majorVersion>1?canvas.getContext("webgl2",webGLContextAttributes):canvas.getContext("webgl",webGLContextAttributes);if(!ctx)return 0;var handle=GL.registerContext(ctx,webGLContextAttributes);return handle},enableOffscreenFramebufferAttributes:webGLContextAttributes=>{webGLContextAttributes.renderViaOffscreenBackBuffer=true;webGLContextAttributes.preserveDrawingBuffer=true},createOffscreenFramebuffer:context=>{var gl=context.GLctx;var fbo=gl.createFramebuffer();gl.bindFramebuffer(36160,fbo);context.defaultFbo=fbo;context.defaultFboForbidBlitFramebuffer=false;if(gl.getContextAttributes().antialias){context.defaultFboForbidBlitFramebuffer=true}context.defaultColorTarget=gl.createTexture();context.defaultDepthTarget=gl.createRenderbuffer();GL.resizeOffscreenFramebuffer(context);gl.bindTexture(3553,context.defaultColorTarget);gl.texParameteri(3553,10241,9728);gl.texParameteri(3553,10240,9728);gl.texParameteri(3553,10242,33071);gl.texParameteri(3553,10243,33071);gl.texImage2D(3553,0,6408,gl.canvas.width,gl.canvas.height,0,6408,5121,null);gl.framebufferTexture2D(36160,36064,3553,context.defaultColorTarget,0);gl.bindTexture(3553,null);var depthTarget=gl.createRenderbuffer();gl.bindRenderbuffer(36161,context.defaultDepthTarget);gl.renderbufferStorage(36161,33189,gl.canvas.width,gl.canvas.height);gl.framebufferRenderbuffer(36160,36096,36161,context.defaultDepthTarget);gl.bindRenderbuffer(36161,null);var vertices=[-1,-1,-1,1,1,-1,1,1];var vb=gl.createBuffer();gl.bindBuffer(34962,vb);gl.bufferData(34962,new Float32Array(vertices),35044);gl.bindBuffer(34962,null);context.blitVB=vb;var vsCode="attribute vec2 pos;"+"varying lowp vec2 tex;"+"void main() { tex = pos * 0.5 + vec2(0.5,0.5); gl_Position = vec4(pos, 0.0, 1.0); }";var vs=gl.createShader(35633);gl.shaderSource(vs,vsCode);gl.compileShader(vs);var fsCode="varying lowp vec2 tex;"+"uniform sampler2D sampler;"+"void main() { gl_FragColor = texture2D(sampler, tex); }";var fs=gl.createShader(35632);gl.shaderSource(fs,fsCode);gl.compileShader(fs);var blitProgram=gl.createProgram();gl.attachShader(blitProgram,vs);gl.attachShader(blitProgram,fs);gl.linkProgram(blitProgram);context.blitProgram=blitProgram;context.blitPosLoc=gl.getAttribLocation(blitProgram,"pos");gl.useProgram(blitProgram);gl.uniform1i(gl.getUniformLocation(blitProgram,"sampler"),0);gl.useProgram(null);if(gl.createVertexArray){context.defaultVao=gl.createVertexArray();gl.bindVertexArray(context.defaultVao);gl.enableVertexAttribArray(context.blitPosLoc);gl.bindVertexArray(null)}},resizeOffscreenFramebuffer:context=>{var gl=context.GLctx;if(context.defaultColorTarget){var prevTextureBinding=gl.getParameter(32873);gl.bindTexture(3553,context.defaultColorTarget);gl.texImage2D(3553,0,6408,gl.drawingBufferWidth,gl.drawingBufferHeight,0,6408,5121,null);gl.bindTexture(3553,prevTextureBinding)}if(context.defaultDepthTarget){var prevRenderBufferBinding=gl.getParameter(36007);gl.bindRenderbuffer(36161,context.defaultDepthTarget);gl.renderbufferStorage(36161,33189,gl.drawingBufferWidth,gl.drawingBufferHeight);gl.bindRenderbuffer(36161,prevRenderBufferBinding)}},blitOffscreenFramebuffer:context=>{var gl=context.GLctx;var prevScissorTest=gl.getParameter(3089);if(prevScissorTest)gl.disable(3089);var prevFbo=gl.getParameter(36006);if(gl.blitFramebuffer&&!context.defaultFboForbidBlitFramebuffer){gl.bindFramebuffer(36008,context.defaultFbo);gl.bindFramebuffer(36009,null);gl.blitFramebuffer(0,0,gl.canvas.width,gl.canvas.height,0,0,gl.canvas.width,gl.canvas.height,16384,9728)}else{gl.bindFramebuffer(36160,null);var prevProgram=gl.getParameter(35725);gl.useProgram(context.blitProgram);if(!gl.isProgram(prevProgram))prevProgram=null;var prevVB=gl.getParameter(34964);gl.bindBuffer(34962,context.blitVB);var prevActiveTexture=gl.getParameter(34016);gl.activeTexture(33984);var prevTextureBinding=gl.getParameter(32873);gl.bindTexture(3553,context.defaultColorTarget);var prevBlend=gl.getParameter(3042);if(prevBlend)gl.disable(3042);var prevCullFace=gl.getParameter(2884);if(prevCullFace)gl.disable(2884);var prevDepthTest=gl.getParameter(2929);if(prevDepthTest)gl.disable(2929);var prevStencilTest=gl.getParameter(2960);if(prevStencilTest)gl.disable(2960);function draw(){gl.vertexAttribPointer(context.blitPosLoc,2,5126,false,0,0);gl.drawArrays(5,0,4)}if(context.defaultVao){var prevVAO=gl.getParameter(34229);gl.bindVertexArray(context.defaultVao);draw();gl.bindVertexArray(prevVAO)}else{var prevVertexAttribPointer={buffer:gl.getVertexAttrib(context.blitPosLoc,34975),size:gl.getVertexAttrib(context.blitPosLoc,34339),stride:gl.getVertexAttrib(context.blitPosLoc,34340),type:gl.getVertexAttrib(context.blitPosLoc,34341),normalized:gl.getVertexAttrib(context.blitPosLoc,34922),pointer:gl.getVertexAttribOffset(context.blitPosLoc,34373)};var maxVertexAttribs=gl.getParameter(34921);var prevVertexAttribEnables=[];for(var i=0;i<maxVertexAttribs;++i){var prevEnabled=gl.getVertexAttrib(i,34338);var wantEnabled=i==context.blitPosLoc;if(prevEnabled&&!wantEnabled){gl.disableVertexAttribArray(i)}if(!prevEnabled&&wantEnabled){gl.enableVertexAttribArray(i)}prevVertexAttribEnables[i]=prevEnabled}draw();for(var i=0;i<maxVertexAttribs;++i){var prevEnabled=prevVertexAttribEnables[i];var nowEnabled=i==context.blitPosLoc;if(prevEnabled&&!nowEnabled){gl.enableVertexAttribArray(i)}if(!prevEnabled&&nowEnabled){gl.disableVertexAttribArray(i)}}gl.bindBuffer(34962,prevVertexAttribPointer.buffer);gl.vertexAttribPointer(context.blitPosLoc,prevVertexAttribPointer.size,prevVertexAttribPointer.type,prevVertexAttribPointer.normalized,prevVertexAttribPointer.stride,prevVertexAttribPointer.offset)}if(prevStencilTest)gl.enable(2960);if(prevDepthTest)gl.enable(2929);if(prevCullFace)gl.enable(2884);if(prevBlend)gl.enable(3042);gl.bindTexture(3553,prevTextureBinding);gl.activeTexture(prevActiveTexture);gl.bindBuffer(34962,prevVB);gl.useProgram(prevProgram)}gl.bindFramebuffer(36160,prevFbo);if(prevScissorTest)gl.enable(3089)},registerContext:(ctx,webGLContextAttributes)=>{var handle=GL.getNewId(GL.contexts);var context={handle,attributes:webGLContextAttributes,version:webGLContextAttributes.majorVersion,GLctx:ctx};if(ctx.canvas)ctx.canvas.GLctxObject=context;GL.contexts[handle]=context;if(typeof webGLContextAttributes.enableExtensionsByDefault=="undefined"||webGLContextAttributes.enableExtensionsByDefault){GL.initExtensions(context)}if(webGLContextAttributes.renderViaOffscreenBackBuffer)GL.createOffscreenFramebuffer(context);return handle},makeContextCurrent:contextHandle=>{GL.currentContext=GL.contexts[contextHandle];Module["ctx"]=GLctx=GL.currentContext?.GLctx;return!(contextHandle&&!GLctx)},getContext:contextHandle=>GL.contexts[contextHandle],deleteContext:contextHandle=>{if(GL.currentContext===GL.contexts[contextHandle]){GL.currentContext=null}if(typeof JSEvents=="object"){JSEvents.removeAllHandlersOnTarget(GL.contexts[contextHandle].GLctx.canvas)}if(GL.contexts[contextHandle]?.GLctx.canvas){GL.contexts[contextHandle].GLctx.canvas.GLctxObject=undefined}GL.contexts[contextHandle]=null},initExtensions:context=>{context||=GL.currentContext;if(context.initExtensionsDone)return;context.initExtensionsDone=true;var GLctx=context.GLctx;webgl_enable_WEBGL_multi_draw(GLctx);webgl_enable_EXT_polygon_offset_clamp(GLctx);webgl_enable_EXT_clip_control(GLctx);webgl_enable_WEBGL_polygon_mode(GLctx);webgl_enable_ANGLE_instanced_arrays(GLctx);webgl_enable_OES_vertex_array_object(GLctx);webgl_enable_WEBGL_draw_buffers(GLctx);webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance(GLctx);webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance(GLctx);if(context.version>=2){GLctx.disjointTimerQueryExt=GLctx.getExtension("EXT_disjoint_timer_query_webgl2")}if(context.version<2||!GLctx.disjointTimerQueryExt){GLctx.disjointTimerQueryExt=GLctx.getExtension("EXT_disjoint_timer_query")}for(var ext of getEmscriptenSupportedExtensions(GLctx)){if(!ext.includes("lose_context")&&!ext.includes("debug")){GLctx.getExtension(ext)}}}};var _emscripten_webgl_do_commit_frame=()=>{if(!GL.currentContext||!GL.currentContext.GLctx){return-3}if(GL.currentContext.defaultFbo){GL.blitOffscreenFramebuffer(GL.currentContext);return 0}if(!GL.currentContext.attributes.explicitSwapControl){return-3}return 0};var _emscripten_webgl_commit_frame=_emscripten_webgl_do_commit_frame;var webglPowerPreferences=["default","low-power","high-performance"];var _emscripten_webgl_do_create_context=(target,attributes)=>{var attr32=attributes>>2;var powerPreference=HEAP32[attr32+(8>>2)];var contextAttributes={alpha:!!HEAP8[attributes+0],depth:!!HEAP8[attributes+1],stencil:!!HEAP8[attributes+2],antialias:!!HEAP8[attributes+3],premultipliedAlpha:!!HEAP8[attributes+4],preserveDrawingBuffer:!!HEAP8[attributes+5],powerPreference:webglPowerPreferences[powerPreference],failIfMajorPerformanceCaveat:!!HEAP8[attributes+12],majorVersion:HEAP32[attr32+(16>>2)],minorVersion:HEAP32[attr32+(20>>2)],enableExtensionsByDefault:HEAP8[attributes+24],explicitSwapControl:HEAP8[attributes+25],proxyContextToMainThread:HEAP32[attr32+(28>>2)],renderViaOffscreenBackBuffer:HEAP8[attributes+32]};var canvas=findCanvasEventTarget(target);if(!canvas){return 0}if(contextAttributes.explicitSwapControl&&!contextAttributes.renderViaOffscreenBackBuffer){contextAttributes.renderViaOffscreenBackBuffer=true}var contextHandle=GL.createContext(canvas,contextAttributes);return contextHandle};var _emscripten_webgl_create_context=_emscripten_webgl_do_create_context;var _emscripten_webgl_destroy_context=contextHandle=>{if(GL.currentContext==contextHandle)GL.currentContext=0;GL.deleteContext(contextHandle)};var _emscripten_webgl_enable_extension=(contextHandle,extension)=>{var context=GL.getContext(contextHandle);var extString=UTF8ToString(extension);if(extString.startsWith("GL_"))extString=extString.slice(3);if(extString=="ANGLE_instanced_arrays")webgl_enable_ANGLE_instanced_arrays(GLctx);if(extString=="OES_vertex_array_object")webgl_enable_OES_vertex_array_object(GLctx);if(extString=="WEBGL_draw_buffers")webgl_enable_WEBGL_draw_buffers(GLctx);if(extString=="WEBGL_draw_instanced_base_vertex_base_instance")webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance(GLctx);if(extString=="WEBGL_multi_draw_instanced_base_vertex_base_instance")webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance(GLctx);if(extString=="WEBGL_multi_draw")webgl_enable_WEBGL_multi_draw(GLctx);if(extString=="EXT_polygon_offset_clamp")webgl_enable_EXT_polygon_offset_clamp(GLctx);if(extString=="EXT_clip_control")webgl_enable_EXT_clip_control(GLctx);if(extString=="WEBGL_polygon_mode")webgl_enable_WEBGL_polygon_mode(GLctx);var ext=context.GLctx.getExtension(extString);return!!ext};var stringToNewUTF8=str=>{var size=lengthBytesUTF8(str)+1;var ret=_malloc(size);if(ret)stringToUTF8(str,ret,size);return ret};var _emscripten_webgl_get_supported_extensions=()=>stringToNewUTF8(GLctx.getSupportedExtensions().join(" "));var _emscripten_webgl_make_context_current=contextHandle=>{var success=GL.makeContextCurrent(contextHandle);return success?0:-5};var ENV={};var getExecutableName=()=>thisProgram||"./this.program";var getEnvStrings=()=>{if(!getEnvStrings.strings){var lang=(typeof navigator=="object"&&navigator.language||"C").replace("-","_")+".UTF-8";var env={USER:"web_user",LOGNAME:"web_user",PATH:"/",PWD:"/",HOME:"/home/web_user",LANG:lang,_:getExecutableName()};for(var x in ENV){if(ENV[x]===undefined)delete env[x];else env[x]=ENV[x]}var strings=[];for(var x in env){strings.push(`${x}=${env[x]}`)}getEnvStrings.strings=strings}return getEnvStrings.strings};var _environ_get=(__environ,environ_buf)=>{var bufSize=0;var envp=0;for(var string of getEnvStrings()){var ptr=environ_buf+bufSize;HEAPU32[__environ+envp>>2]=ptr;bufSize+=stringToUTF8(string,ptr,Infinity)+1;envp+=4}return 0};var _environ_sizes_get=(penviron_count,penviron_buf_size)=>{var strings=getEnvStrings();HEAPU32[penviron_count>>2]=strings.length;var bufSize=0;for(var string of strings){bufSize+=lengthBytesUTF8(string)+1}HEAPU32[penviron_buf_size>>2]=bufSize;return 0};function _fd_close(fd){try{var stream=SYSCALLS.getStreamFromFD(fd);FS.close(stream);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}function _fd_fdstat_get(fd,pbuf){try{var rightsBase=0;var rightsInheriting=0;var flags=0;{var stream=SYSCALLS.getStreamFromFD(fd);var type=stream.tty?2:FS.isDir(stream.mode)?3:FS.isLink(stream.mode)?7:4}HEAP8[pbuf]=type;HEAP16[pbuf+2>>1]=flags;HEAP64[pbuf+8>>3]=BigInt(rightsBase);HEAP64[pbuf+16>>3]=BigInt(rightsInheriting);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}var doReadv=(stream,iov,iovcnt,offset)=>{var ret=0;for(var i=0;i<iovcnt;i++){var ptr=HEAPU32[iov>>2];var len=HEAPU32[iov+4>>2];iov+=8;var curr=FS.read(stream,HEAP8,ptr,len,offset);if(curr<0)return-1;ret+=curr;if(curr<len)break;if(typeof offset!="undefined"){offset+=curr}}return ret};function _fd_read(fd,iov,iovcnt,pnum){try{var stream=SYSCALLS.getStreamFromFD(fd);var num=doReadv(stream,iov,iovcnt);HEAPU32[pnum>>2]=num;return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}function _fd_seek(fd,offset,whence,newOffset){offset=bigintToI53Checked(offset);try{if(isNaN(offset))return 61;var stream=SYSCALLS.getStreamFromFD(fd);FS.llseek(stream,offset,whence);HEAP64[newOffset>>3]=BigInt(stream.position);if(stream.getdents&&offset===0&&whence===0)stream.getdents=null;return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}var doWritev=(stream,iov,iovcnt,offset)=>{var ret=0;for(var i=0;i<iovcnt;i++){var ptr=HEAPU32[iov>>2];var len=HEAPU32[iov+4>>2];iov+=8;var curr=FS.write(stream,HEAP8,ptr,len,offset);if(curr<0)return-1;ret+=curr;if(curr<len){break}if(typeof offset!="undefined"){offset+=curr}}return ret};function _fd_write(fd,iov,iovcnt,pnum){try{var stream=SYSCALLS.getStreamFromFD(fd);var num=doWritev(stream,iov,iovcnt);HEAPU32[pnum>>2]=num;return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}var _emscripten_glActiveTexture=x0=>GLctx.activeTexture(x0);var _glActiveTexture=_emscripten_glActiveTexture;var _emscripten_glAttachShader=(program,shader)=>{GLctx.attachShader(GL.programs[program],GL.shaders[shader])};var _glAttachShader=_emscripten_glAttachShader;var _emscripten_glBeginTransformFeedback=x0=>GLctx.beginTransformFeedback(x0);var _glBeginTransformFeedback=_emscripten_glBeginTransformFeedback;var _emscripten_glBindBuffer=(target,buffer)=>{if(target==35051){GLctx.currentPixelPackBufferBinding=buffer}else if(target==35052){GLctx.currentPixelUnpackBufferBinding=buffer}GLctx.bindBuffer(target,GL.buffers[buffer])};var _glBindBuffer=_emscripten_glBindBuffer;var _emscripten_glBindBufferBase=(target,index,buffer)=>{GLctx.bindBufferBase(target,index,GL.buffers[buffer])};var _glBindBufferBase=_emscripten_glBindBufferBase;var _emscripten_glBindBufferRange=(target,index,buffer,offset,ptrsize)=>{GLctx.bindBufferRange(target,index,GL.buffers[buffer],offset,ptrsize)};var _glBindBufferRange=_emscripten_glBindBufferRange;var _emscripten_glBindFramebuffer=(target,framebuffer)=>{GLctx.bindFramebuffer(target,framebuffer?GL.framebuffers[framebuffer]:GL.currentContext.defaultFbo)};var _glBindFramebuffer=_emscripten_glBindFramebuffer;var _emscripten_glBindRenderbuffer=(target,renderbuffer)=>{GLctx.bindRenderbuffer(target,GL.renderbuffers[renderbuffer])};var _glBindRenderbuffer=_emscripten_glBindRenderbuffer;var _emscripten_glBindTexture=(target,texture)=>{GLctx.bindTexture(target,GL.textures[texture])};var _glBindTexture=_emscripten_glBindTexture;var _emscripten_glBindVertexArray=vao=>{GLctx.bindVertexArray(GL.vaos[vao])};var _glBindVertexArray=_emscripten_glBindVertexArray;var _emscripten_glBlendColor=(x0,x1,x2,x3)=>GLctx.blendColor(x0,x1,x2,x3);var _glBlendColor=_emscripten_glBlendColor;var _emscripten_glBlendEquation=x0=>GLctx.blendEquation(x0);var _glBlendEquation=_emscripten_glBlendEquation;var _emscripten_glBlendFunc=(x0,x1)=>GLctx.blendFunc(x0,x1);var _glBlendFunc=_emscripten_glBlendFunc;var _emscripten_glBlendFuncSeparate=(x0,x1,x2,x3)=>GLctx.blendFuncSeparate(x0,x1,x2,x3);var _glBlendFuncSeparate=_emscripten_glBlendFuncSeparate;var _emscripten_glBlitFramebuffer=(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9)=>GLctx.blitFramebuffer(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9);var _glBlitFramebuffer=_emscripten_glBlitFramebuffer;var _emscripten_glBufferData=(target,size,data,usage)=>{if(GL.currentContext.version>=2){if(data&&size){GLctx.bufferData(target,HEAPU8,usage,data,size)}else{GLctx.bufferData(target,size,usage)}return}GLctx.bufferData(target,data?HEAPU8.subarray(data,data+size):size,usage)};var _glBufferData=_emscripten_glBufferData;var _emscripten_glBufferSubData=(target,offset,size,data)=>{if(GL.currentContext.version>=2){size&&GLctx.bufferSubData(target,offset,HEAPU8,data,size);return}GLctx.bufferSubData(target,offset,HEAPU8.subarray(data,data+size))};var _glBufferSubData=_emscripten_glBufferSubData;var _emscripten_glCheckFramebufferStatus=x0=>GLctx.checkFramebufferStatus(x0);var _glCheckFramebufferStatus=_emscripten_glCheckFramebufferStatus;var _emscripten_glClear=x0=>GLctx.clear(x0);var _glClear=_emscripten_glClear;var _emscripten_glClearBufferfv=(buffer,drawbuffer,value)=>{GLctx.clearBufferfv(buffer,drawbuffer,HEAPF32,value>>2)};var _glClearBufferfv=_emscripten_glClearBufferfv;var _emscripten_glClearColor=(x0,x1,x2,x3)=>GLctx.clearColor(x0,x1,x2,x3);var _glClearColor=_emscripten_glClearColor;var _emscripten_glClearDepthf=x0=>GLctx.clearDepth(x0);var _glClearDepthf=_emscripten_glClearDepthf;var _emscripten_glClearStencil=x0=>GLctx.clearStencil(x0);var _glClearStencil=_emscripten_glClearStencil;var _emscripten_glColorMask=(red,green,blue,alpha)=>{GLctx.colorMask(!!red,!!green,!!blue,!!alpha)};var _glColorMask=_emscripten_glColorMask;var _emscripten_glCompileShader=shader=>{GLctx.compileShader(GL.shaders[shader])};var _glCompileShader=_emscripten_glCompileShader;var _emscripten_glCompressedTexImage2D=(target,level,internalFormat,width,height,border,imageSize,data)=>{if(GL.currentContext.version>=2){if(GLctx.currentPixelUnpackBufferBinding||!imageSize){GLctx.compressedTexImage2D(target,level,internalFormat,width,height,border,imageSize,data);return}GLctx.compressedTexImage2D(target,level,internalFormat,width,height,border,HEAPU8,data,imageSize);return}GLctx.compressedTexImage2D(target,level,internalFormat,width,height,border,HEAPU8.subarray(data,data+imageSize))};var _glCompressedTexImage2D=_emscripten_glCompressedTexImage2D;var _emscripten_glCompressedTexImage3D=(target,level,internalFormat,width,height,depth,border,imageSize,data)=>{if(GLctx.currentPixelUnpackBufferBinding){GLctx.compressedTexImage3D(target,level,internalFormat,width,height,depth,border,imageSize,data)}else{GLctx.compressedTexImage3D(target,level,internalFormat,width,height,depth,border,HEAPU8,data,imageSize)}};var _glCompressedTexImage3D=_emscripten_glCompressedTexImage3D;var _emscripten_glCompressedTexSubImage3D=(target,level,xoffset,yoffset,zoffset,width,height,depth,format,imageSize,data)=>{if(GLctx.currentPixelUnpackBufferBinding){GLctx.compressedTexSubImage3D(target,level,xoffset,yoffset,zoffset,width,height,depth,format,imageSize,data)}else{GLctx.compressedTexSubImage3D(target,level,xoffset,yoffset,zoffset,width,height,depth,format,HEAPU8,data,imageSize)}};var _glCompressedTexSubImage3D=_emscripten_glCompressedTexSubImage3D;var _emscripten_glCopyBufferSubData=(x0,x1,x2,x3,x4)=>GLctx.copyBufferSubData(x0,x1,x2,x3,x4);var _glCopyBufferSubData=_emscripten_glCopyBufferSubData;var _emscripten_glCreateProgram=()=>{var id=GL.getNewId(GL.programs);var program=GLctx.createProgram();program.name=id;program.maxUniformLength=program.maxAttributeLength=program.maxUniformBlockNameLength=0;program.uniformIdCounter=1;GL.programs[id]=program;return id};var _glCreateProgram=_emscripten_glCreateProgram;var _emscripten_glCreateShader=shaderType=>{var id=GL.getNewId(GL.shaders);GL.shaders[id]=GLctx.createShader(shaderType);return id};var _glCreateShader=_emscripten_glCreateShader;var _emscripten_glCullFace=x0=>GLctx.cullFace(x0);var _glCullFace=_emscripten_glCullFace;var _emscripten_glDeleteBuffers=(n,buffers)=>{for(var i=0;i<n;i++){var id=HEAP32[buffers+i*4>>2];var buffer=GL.buffers[id];if(!buffer)continue;GLctx.deleteBuffer(buffer);buffer.name=0;GL.buffers[id]=null;if(id==GLctx.currentPixelPackBufferBinding)GLctx.currentPixelPackBufferBinding=0;if(id==GLctx.currentPixelUnpackBufferBinding)GLctx.currentPixelUnpackBufferBinding=0}};var _glDeleteBuffers=_emscripten_glDeleteBuffers;var _emscripten_glDeleteFramebuffers=(n,framebuffers)=>{for(var i=0;i<n;++i){var id=HEAP32[framebuffers+i*4>>2];var framebuffer=GL.framebuffers[id];if(!framebuffer)continue;GLctx.deleteFramebuffer(framebuffer);framebuffer.name=0;GL.framebuffers[id]=null}};var _glDeleteFramebuffers=_emscripten_glDeleteFramebuffers;var _emscripten_glDeleteProgram=id=>{if(!id)return;var program=GL.programs[id];if(!program){GL.recordError(1281);return}GLctx.deleteProgram(program);program.name=0;GL.programs[id]=null};var _glDeleteProgram=_emscripten_glDeleteProgram;var _emscripten_glDeleteQueries=(n,ids)=>{for(var i=0;i<n;i++){var id=HEAP32[ids+i*4>>2];var query=GL.queries[id];if(!query)continue;GLctx.deleteQuery(query);GL.queries[id]=null}};var _glDeleteQueries=_emscripten_glDeleteQueries;var _emscripten_glDeleteRenderbuffers=(n,renderbuffers)=>{for(var i=0;i<n;i++){var id=HEAP32[renderbuffers+i*4>>2];var renderbuffer=GL.renderbuffers[id];if(!renderbuffer)continue;GLctx.deleteRenderbuffer(renderbuffer);renderbuffer.name=0;GL.renderbuffers[id]=null}};var _glDeleteRenderbuffers=_emscripten_glDeleteRenderbuffers;var _emscripten_glDeleteShader=id=>{if(!id)return;var shader=GL.shaders[id];if(!shader){GL.recordError(1281);return}GLctx.deleteShader(shader);GL.shaders[id]=null};var _glDeleteShader=_emscripten_glDeleteShader;var _emscripten_glDeleteSync=id=>{if(!id)return;var sync=GL.syncs[id];if(!sync){GL.recordError(1281);return}GLctx.deleteSync(sync);sync.name=0;GL.syncs[id]=null};var _glDeleteSync=_emscripten_glDeleteSync;var _emscripten_glDeleteTextures=(n,textures)=>{for(var i=0;i<n;i++){var id=HEAP32[textures+i*4>>2];var texture=GL.textures[id];if(!texture)continue;GLctx.deleteTexture(texture);texture.name=0;GL.textures[id]=null}};var _glDeleteTextures=_emscripten_glDeleteTextures;var _emscripten_glDeleteVertexArrays=(n,vaos)=>{for(var i=0;i<n;i++){var id=HEAP32[vaos+i*4>>2];GLctx.deleteVertexArray(GL.vaos[id]);GL.vaos[id]=null}};var _glDeleteVertexArrays=_emscripten_glDeleteVertexArrays;var _emscripten_glDepthFunc=x0=>GLctx.depthFunc(x0);var _glDepthFunc=_emscripten_glDepthFunc;var _emscripten_glDepthMask=flag=>{GLctx.depthMask(!!flag)};var _glDepthMask=_emscripten_glDepthMask;var _emscripten_glDisable=x0=>GLctx.disable(x0);var _glDisable=_emscripten_glDisable;var _emscripten_glDisableVertexAttribArray=index=>{GLctx.disableVertexAttribArray(index)};var _glDisableVertexAttribArray=_emscripten_glDisableVertexAttribArray;var _emscripten_glDrawArrays=(mode,first,count)=>{GLctx.drawArrays(mode,first,count)};var _glDrawArrays=_emscripten_glDrawArrays;var _emscripten_glDrawArraysInstanced=(mode,first,count,primcount)=>{GLctx.drawArraysInstanced(mode,first,count,primcount)};var _glDrawArraysInstanced=_emscripten_glDrawArraysInstanced;var tempFixedLengthArray=[];var _emscripten_glDrawBuffers=(n,bufs)=>{var bufArray=tempFixedLengthArray[n];for(var i=0;i<n;i++){bufArray[i]=HEAP32[bufs+i*4>>2]}GLctx.drawBuffers(bufArray)};var _glDrawBuffers=_emscripten_glDrawBuffers;var _emscripten_glDrawElements=(mode,count,type,indices)=>{GLctx.drawElements(mode,count,type,indices)};var _glDrawElements=_emscripten_glDrawElements;var _emscripten_glDrawElementsInstanced=(mode,count,type,indices,primcount)=>{GLctx.drawElementsInstanced(mode,count,type,indices,primcount)};var _glDrawElementsInstanced=_emscripten_glDrawElementsInstanced;var _emscripten_glEnable=x0=>GLctx.enable(x0);var _glEnable=_emscripten_glEnable;var _emscripten_glEnableVertexAttribArray=index=>{GLctx.enableVertexAttribArray(index)};var _glEnableVertexAttribArray=_emscripten_glEnableVertexAttribArray;var _emscripten_glEndTransformFeedback=()=>GLctx.endTransformFeedback();var _glEndTransformFeedback=_emscripten_glEndTransformFeedback;var _emscripten_glFenceSync=(condition,flags)=>{var sync=GLctx.fenceSync(condition,flags);if(sync){var id=GL.getNewId(GL.syncs);sync.name=id;GL.syncs[id]=sync;return id}return 0};var _glFenceSync=_emscripten_glFenceSync;var _emscripten_glFinish=()=>GLctx.finish();var _glFinish=_emscripten_glFinish;var _emscripten_glFramebufferRenderbuffer=(target,attachment,renderbuffertarget,renderbuffer)=>{GLctx.framebufferRenderbuffer(target,attachment,renderbuffertarget,GL.renderbuffers[renderbuffer])};var _glFramebufferRenderbuffer=_emscripten_glFramebufferRenderbuffer;var _emscripten_glFramebufferTexture2D=(target,attachment,textarget,texture,level)=>{GLctx.framebufferTexture2D(target,attachment,textarget,GL.textures[texture],level)};var _glFramebufferTexture2D=_emscripten_glFramebufferTexture2D;var _emscripten_glFramebufferTextureLayer=(target,attachment,texture,level,layer)=>{GLctx.framebufferTextureLayer(target,attachment,GL.textures[texture],level,layer)};var _glFramebufferTextureLayer=_emscripten_glFramebufferTextureLayer;var _emscripten_glFrontFace=x0=>GLctx.frontFace(x0);var _glFrontFace=_emscripten_glFrontFace;var _emscripten_glGenBuffers=(n,buffers)=>{GL.genObject(n,buffers,"createBuffer",GL.buffers)};var _glGenBuffers=_emscripten_glGenBuffers;var _emscripten_glGenFramebuffers=(n,ids)=>{GL.genObject(n,ids,"createFramebuffer",GL.framebuffers)};var _glGenFramebuffers=_emscripten_glGenFramebuffers;var _emscripten_glGenQueries=(n,ids)=>{GL.genObject(n,ids,"createQuery",GL.queries)};var _glGenQueries=_emscripten_glGenQueries;var _emscripten_glGenRenderbuffers=(n,renderbuffers)=>{GL.genObject(n,renderbuffers,"createRenderbuffer",GL.renderbuffers)};var _glGenRenderbuffers=_emscripten_glGenRenderbuffers;var _emscripten_glGenTextures=(n,textures)=>{GL.genObject(n,textures,"createTexture",GL.textures)};var _glGenTextures=_emscripten_glGenTextures;var _emscripten_glGenVertexArrays=(n,arrays)=>{GL.genObject(n,arrays,"createVertexArray",GL.vaos)};var _glGenVertexArrays=_emscripten_glGenVertexArrays;var _emscripten_glGenerateMipmap=x0=>GLctx.generateMipmap(x0);var _glGenerateMipmap=_emscripten_glGenerateMipmap;var writeI53ToI64=(ptr,num)=>{HEAPU32[ptr>>2]=num;var lower=HEAPU32[ptr>>2];HEAPU32[ptr+4>>2]=(num-lower)/4294967296};var webglGetExtensions=()=>{var exts=getEmscriptenSupportedExtensions(GLctx);exts=exts.concat(exts.map(e=>"GL_"+e));return exts};var emscriptenWebGLGet=(name_,p,type)=>{if(!p){GL.recordError(1281);return}var ret=undefined;switch(name_){case 36346:ret=1;break;case 36344:if(type!=0&&type!=1){GL.recordError(1280)}return;case 34814:case 36345:ret=0;break;case 34466:var formats=GLctx.getParameter(34467);ret=formats?formats.length:0;break;case 33309:if(GL.currentContext.version<2){GL.recordError(1282);return}ret=webglGetExtensions().length;break;case 33307:case 33308:if(GL.currentContext.version<2){GL.recordError(1280);return}ret=name_==33307?3:0;break}if(ret===undefined){var result=GLctx.getParameter(name_);switch(typeof result){case"number":ret=result;break;case"boolean":ret=result?1:0;break;case"string":GL.recordError(1280);return;case"object":if(result===null){switch(name_){case 34964:case 35725:case 34965:case 36006:case 36007:case 32873:case 34229:case 36662:case 36663:case 35053:case 35055:case 36010:case 35097:case 35869:case 32874:case 36389:case 35983:case 35368:case 34068:{ret=0;break}default:{GL.recordError(1280);return}}}else if(result instanceof Float32Array||result instanceof Uint32Array||result instanceof Int32Array||result instanceof Array){for(var i=0;i<result.length;++i){switch(type){case 0:HEAP32[p+i*4>>2]=result[i];break;case 2:HEAPF32[p+i*4>>2]=result[i];break;case 4:HEAP8[p+i]=result[i]?1:0;break}}return}else{try{ret=result.name|0}catch(e){GL.recordError(1280);err(`GL_INVALID_ENUM in glGet${type}v: Unknown object returned from WebGL getParameter(${name_})! (error: ${e})`);return}}break;default:GL.recordError(1280);err(`GL_INVALID_ENUM in glGet${type}v: Native code calling glGet${type}v(${name_}) and it returns ${result} of type ${typeof result}!`);return}}switch(type){case 1:writeI53ToI64(p,ret);break;case 0:HEAP32[p>>2]=ret;break;case 2:HEAPF32[p>>2]=ret;break;case 4:HEAP8[p]=ret?1:0;break}};var _emscripten_glGetFloatv=(name_,p)=>emscriptenWebGLGet(name_,p,2);var _glGetFloatv=_emscripten_glGetFloatv;var _emscripten_glGetInteger64v=(name_,p)=>{emscriptenWebGLGet(name_,p,1)};var _glGetInteger64v=_emscripten_glGetInteger64v;var _emscripten_glGetIntegerv=(name_,p)=>emscriptenWebGLGet(name_,p,0);var _glGetIntegerv=_emscripten_glGetIntegerv;var _emscripten_glGetProgramInfoLog=(program,maxLength,length,infoLog)=>{var log=GLctx.getProgramInfoLog(GL.programs[program]);if(log===null)log="(unknown error)";var numBytesWrittenExclNull=maxLength>0&&infoLog?stringToUTF8(log,infoLog,maxLength):0;if(length)HEAP32[length>>2]=numBytesWrittenExclNull};var _glGetProgramInfoLog=_emscripten_glGetProgramInfoLog;var _emscripten_glGetProgramiv=(program,pname,p)=>{if(!p){GL.recordError(1281);return}if(program>=GL.counter){GL.recordError(1281);return}program=GL.programs[program];if(pname==35716){var log=GLctx.getProgramInfoLog(program);if(log===null)log="(unknown error)";HEAP32[p>>2]=log.length+1}else if(pname==35719){if(!program.maxUniformLength){var numActiveUniforms=GLctx.getProgramParameter(program,35718);for(var i=0;i<numActiveUniforms;++i){program.maxUniformLength=Math.max(program.maxUniformLength,GLctx.getActiveUniform(program,i).name.length+1)}}HEAP32[p>>2]=program.maxUniformLength}else if(pname==35722){if(!program.maxAttributeLength){var numActiveAttributes=GLctx.getProgramParameter(program,35721);for(var i=0;i<numActiveAttributes;++i){program.maxAttributeLength=Math.max(program.maxAttributeLength,GLctx.getActiveAttrib(program,i).name.length+1)}}HEAP32[p>>2]=program.maxAttributeLength}else if(pname==35381){if(!program.maxUniformBlockNameLength){var numActiveUniformBlocks=GLctx.getProgramParameter(program,35382);for(var i=0;i<numActiveUniformBlocks;++i){program.maxUniformBlockNameLength=Math.max(program.maxUniformBlockNameLength,GLctx.getActiveUniformBlockName(program,i).length+1)}}HEAP32[p>>2]=program.maxUniformBlockNameLength}else{HEAP32[p>>2]=GLctx.getProgramParameter(program,pname)}};var _glGetProgramiv=_emscripten_glGetProgramiv;var _emscripten_glGetShaderInfoLog=(shader,maxLength,length,infoLog)=>{var log=GLctx.getShaderInfoLog(GL.shaders[shader]);if(log===null)log="(unknown error)";var numBytesWrittenExclNull=maxLength>0&&infoLog?stringToUTF8(log,infoLog,maxLength):0;if(length)HEAP32[length>>2]=numBytesWrittenExclNull};var _glGetShaderInfoLog=_emscripten_glGetShaderInfoLog;var _emscripten_glGetShaderiv=(shader,pname,p)=>{if(!p){GL.recordError(1281);return}if(pname==35716){var log=GLctx.getShaderInfoLog(GL.shaders[shader]);if(log===null)log="(unknown error)";var logLength=log?log.length+1:0;HEAP32[p>>2]=logLength}else if(pname==35720){var source=GLctx.getShaderSource(GL.shaders[shader]);var sourceLength=source?source.length+1:0;HEAP32[p>>2]=sourceLength}else{HEAP32[p>>2]=GLctx.getShaderParameter(GL.shaders[shader],pname)}};var _glGetShaderiv=_emscripten_glGetShaderiv;var _emscripten_glGetString=name_=>{var ret=GL.stringCache[name_];if(!ret){switch(name_){case 7939:ret=stringToNewUTF8(webglGetExtensions().join(" "));break;case 7936:case 7937:case 37445:case 37446:var s=GLctx.getParameter(name_);if(!s){GL.recordError(1280)}ret=s?stringToNewUTF8(s):0;break;case 7938:var webGLVersion=GLctx.getParameter(7938);var glVersion=`OpenGL ES 2.0 (${webGLVersion})`;if(GL.currentContext.version>=2)glVersion=`OpenGL ES 3.0 (${webGLVersion})`;ret=stringToNewUTF8(glVersion);break;case 35724:var glslVersion=GLctx.getParameter(35724);var ver_re=/^WebGL GLSL ES ([0-9]\.[0-9][0-9]?)(?:$| .*)/;var ver_num=glslVersion.match(ver_re);if(ver_num!==null){if(ver_num[1].length==3)ver_num[1]=ver_num[1]+"0";glslVersion=`OpenGL ES GLSL ES ${ver_num[1]} (${glslVersion})`}ret=stringToNewUTF8(glslVersion);break;default:GL.recordError(1280)}GL.stringCache[name_]=ret}return ret};var _glGetString=_emscripten_glGetString;var _emscripten_glGetSynciv=(sync,pname,bufSize,length,values)=>{if(bufSize<0){GL.recordError(1281);return}if(!values){GL.recordError(1281);return}var ret=GLctx.getSyncParameter(GL.syncs[sync],pname);if(ret!==null){HEAP32[values>>2]=ret;if(length)HEAP32[length>>2]=1}};var _glGetSynciv=_emscripten_glGetSynciv;var _emscripten_glGetUniformBlockIndex=(program,uniformBlockName)=>GLctx.getUniformBlockIndex(GL.programs[program],UTF8ToString(uniformBlockName));var _glGetUniformBlockIndex=_emscripten_glGetUniformBlockIndex;var jstoi_q=str=>parseInt(str);var webglGetLeftBracePos=name=>name.slice(-1)=="]"&&name.lastIndexOf("[");var webglPrepareUniformLocationsBeforeFirstUse=program=>{var uniformLocsById=program.uniformLocsById,uniformSizeAndIdsByName=program.uniformSizeAndIdsByName,i,j;if(!uniformLocsById){program.uniformLocsById=uniformLocsById={};program.uniformArrayNamesById={};var numActiveUniforms=GLctx.getProgramParameter(program,35718);for(i=0;i<numActiveUniforms;++i){var u=GLctx.getActiveUniform(program,i);var nm=u.name;var sz=u.size;var lb=webglGetLeftBracePos(nm);var arrayName=lb>0?nm.slice(0,lb):nm;var id=program.uniformIdCounter;program.uniformIdCounter+=sz;uniformSizeAndIdsByName[arrayName]=[sz,id];for(j=0;j<sz;++j){uniformLocsById[id]=j;program.uniformArrayNamesById[id++]=arrayName}}}};var _emscripten_glGetUniformLocation=(program,name)=>{name=UTF8ToString(name);if(program=GL.programs[program]){webglPrepareUniformLocationsBeforeFirstUse(program);var uniformLocsById=program.uniformLocsById;var arrayIndex=0;var uniformBaseName=name;var leftBrace=webglGetLeftBracePos(name);if(leftBrace>0){arrayIndex=jstoi_q(name.slice(leftBrace+1))>>>0;uniformBaseName=name.slice(0,leftBrace)}var sizeAndId=program.uniformSizeAndIdsByName[uniformBaseName];if(sizeAndId&&arrayIndex<sizeAndId[0]){arrayIndex+=sizeAndId[1];if(uniformLocsById[arrayIndex]=uniformLocsById[arrayIndex]||GLctx.getUniformLocation(program,name)){return arrayIndex}}}else{GL.recordError(1281)}return-1};var _glGetUniformLocation=_emscripten_glGetUniformLocation;var _emscripten_glLinkProgram=program=>{program=GL.programs[program];GLctx.linkProgram(program);program.uniformLocsById=0;program.uniformSizeAndIdsByName={}};var _glLinkProgram=_emscripten_glLinkProgram;var _emscripten_glPixelStorei=(pname,param)=>{if(pname==3317){GL.unpackAlignment=param}else if(pname==3314){GL.unpackRowLength=param}GLctx.pixelStorei(pname,param)};var _glPixelStorei=_emscripten_glPixelStorei;var _emscripten_glReadBuffer=x0=>GLctx.readBuffer(x0);var _glReadBuffer=_emscripten_glReadBuffer;var computeUnpackAlignedImageSize=(width,height,sizePerPixel)=>{function roundedToNextMultipleOf(x,y){return x+y-1&-y}var plainRowSize=(GL.unpackRowLength||width)*sizePerPixel;var alignedRowSize=roundedToNextMultipleOf(plainRowSize,GL.unpackAlignment);return height*alignedRowSize};var colorChannelsInGlTextureFormat=format=>{var colorChannels={5:3,6:4,8:2,29502:3,29504:4,26917:2,26918:2,29846:3,29847:4};return colorChannels[format-6402]||1};var heapObjectForWebGLType=type=>{type-=5120;if(type==0)return HEAP8;if(type==1)return HEAPU8;if(type==2)return HEAP16;if(type==4)return HEAP32;if(type==6)return HEAPF32;if(type==5||type==28922||type==28520||type==30779||type==30782)return HEAPU32;return HEAPU16};var toTypedArrayIndex=(pointer,heap)=>pointer>>>31-Math.clz32(heap.BYTES_PER_ELEMENT);var emscriptenWebGLGetTexPixelData=(type,format,width,height,pixels,internalFormat)=>{var heap=heapObjectForWebGLType(type);var sizePerPixel=colorChannelsInGlTextureFormat(format)*heap.BYTES_PER_ELEMENT;var bytes=computeUnpackAlignedImageSize(width,height,sizePerPixel);return heap.subarray(toTypedArrayIndex(pixels,heap),toTypedArrayIndex(pixels+bytes,heap))};var _emscripten_glReadPixels=(x,y,width,height,format,type,pixels)=>{if(GL.currentContext.version>=2){if(GLctx.currentPixelPackBufferBinding){GLctx.readPixels(x,y,width,height,format,type,pixels);return}var heap=heapObjectForWebGLType(type);var target=toTypedArrayIndex(pixels,heap);GLctx.readPixels(x,y,width,height,format,type,heap,target);return}var pixelData=emscriptenWebGLGetTexPixelData(type,format,width,height,pixels,format);if(!pixelData){GL.recordError(1280);return}GLctx.readPixels(x,y,width,height,format,type,pixelData)};var _glReadPixels=_emscripten_glReadPixels;var _emscripten_glRenderbufferStorage=(x0,x1,x2,x3)=>GLctx.renderbufferStorage(x0,x1,x2,x3);var _glRenderbufferStorage=_emscripten_glRenderbufferStorage;var _emscripten_glRenderbufferStorageMultisample=(x0,x1,x2,x3,x4)=>GLctx.renderbufferStorageMultisample(x0,x1,x2,x3,x4);var _glRenderbufferStorageMultisample=_emscripten_glRenderbufferStorageMultisample;var _emscripten_glScissor=(x0,x1,x2,x3)=>GLctx.scissor(x0,x1,x2,x3);var _glScissor=_emscripten_glScissor;var _emscripten_glShaderSource=(shader,count,string,length)=>{var source=GL.getSource(shader,count,string,length);GLctx.shaderSource(GL.shaders[shader],source)};var _glShaderSource=_emscripten_glShaderSource;var _emscripten_glStencilFunc=(x0,x1,x2)=>GLctx.stencilFunc(x0,x1,x2);var _glStencilFunc=_emscripten_glStencilFunc;var _emscripten_glStencilMask=x0=>GLctx.stencilMask(x0);var _glStencilMask=_emscripten_glStencilMask;var _emscripten_glStencilOp=(x0,x1,x2)=>GLctx.stencilOp(x0,x1,x2);var _glStencilOp=_emscripten_glStencilOp;var _emscripten_glTexImage2D=(target,level,internalFormat,width,height,border,format,type,pixels)=>{if(GL.currentContext.version>=2){if(GLctx.currentPixelUnpackBufferBinding){GLctx.texImage2D(target,level,internalFormat,width,height,border,format,type,pixels);return}if(pixels){var heap=heapObjectForWebGLType(type);var index=toTypedArrayIndex(pixels,heap);GLctx.texImage2D(target,level,internalFormat,width,height,border,format,type,heap,index);return}}var pixelData=pixels?emscriptenWebGLGetTexPixelData(type,format,width,height,pixels,internalFormat):null;GLctx.texImage2D(target,level,internalFormat,width,height,border,format,type,pixelData)};var _glTexImage2D=_emscripten_glTexImage2D;var _emscripten_glTexImage3D=(target,level,internalFormat,width,height,depth,border,format,type,pixels)=>{if(GLctx.currentPixelUnpackBufferBinding){GLctx.texImage3D(target,level,internalFormat,width,height,depth,border,format,type,pixels)}else if(pixels){var heap=heapObjectForWebGLType(type);GLctx.texImage3D(target,level,internalFormat,width,height,depth,border,format,type,heap,toTypedArrayIndex(pixels,heap))}else{GLctx.texImage3D(target,level,internalFormat,width,height,depth,border,format,type,null)}};var _glTexImage3D=_emscripten_glTexImage3D;var _emscripten_glTexParameterf=(x0,x1,x2)=>GLctx.texParameterf(x0,x1,x2);var _glTexParameterf=_emscripten_glTexParameterf;var _emscripten_glTexParameteri=(x0,x1,x2)=>GLctx.texParameteri(x0,x1,x2);var _glTexParameteri=_emscripten_glTexParameteri;var _emscripten_glTexStorage2D=(x0,x1,x2,x3,x4)=>GLctx.texStorage2D(x0,x1,x2,x3,x4);var _glTexStorage2D=_emscripten_glTexStorage2D;var _emscripten_glTexSubImage3D=(target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,pixels)=>{if(GLctx.currentPixelUnpackBufferBinding){GLctx.texSubImage3D(target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,pixels)}else if(pixels){var heap=heapObjectForWebGLType(type);GLctx.texSubImage3D(target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,heap,toTypedArrayIndex(pixels,heap))}else{GLctx.texSubImage3D(target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,null)}};var _glTexSubImage3D=_emscripten_glTexSubImage3D;var _emscripten_glTransformFeedbackVaryings=(program,count,varyings,bufferMode)=>{program=GL.programs[program];var vars=[];for(var i=0;i<count;i++)vars.push(UTF8ToString(HEAP32[varyings+i*4>>2]));GLctx.transformFeedbackVaryings(program,vars,bufferMode)};var _glTransformFeedbackVaryings=_emscripten_glTransformFeedbackVaryings;var webglGetUniformLocation=location=>{var p=GLctx.currentProgram;if(p){var webglLoc=p.uniformLocsById[location];if(typeof webglLoc=="number"){p.uniformLocsById[location]=webglLoc=GLctx.getUniformLocation(p,p.uniformArrayNamesById[location]+(webglLoc>0?`[${webglLoc}]`:""))}return webglLoc}else{GL.recordError(1282)}};var _emscripten_glUniform1f=(location,v0)=>{GLctx.uniform1f(webglGetUniformLocation(location),v0)};var _glUniform1f=_emscripten_glUniform1f;var _emscripten_glUniform1i=(location,v0)=>{GLctx.uniform1i(webglGetUniformLocation(location),v0)};var _glUniform1i=_emscripten_glUniform1i;var miniTempWebGLIntBuffers=[];var _emscripten_glUniform1iv=(location,count,value)=>{if(GL.currentContext.version>=2){count&&GLctx.uniform1iv(webglGetUniformLocation(location),HEAP32,value>>2,count);return}if(count<=288){var view=miniTempWebGLIntBuffers[count];for(var i=0;i<count;++i){view[i]=HEAP32[value+4*i>>2]}}else{var view=HEAP32.subarray(value>>2,value+count*4>>2)}GLctx.uniform1iv(webglGetUniformLocation(location),view)};var _glUniform1iv=_emscripten_glUniform1iv;var _emscripten_glUniform1ui=(location,v0)=>{GLctx.uniform1ui(webglGetUniformLocation(location),v0)};var _glUniform1ui=_emscripten_glUniform1ui;var _emscripten_glUniform1uiv=(location,count,value)=>{count&&GLctx.uniform1uiv(webglGetUniformLocation(location),HEAPU32,value>>2,count)};var _glUniform1uiv=_emscripten_glUniform1uiv;var _emscripten_glUniform2f=(location,v0,v1)=>{GLctx.uniform2f(webglGetUniformLocation(location),v0,v1)};var _glUniform2f=_emscripten_glUniform2f;var miniTempWebGLFloatBuffers=[];var _emscripten_glUniform2fv=(location,count,value)=>{if(GL.currentContext.version>=2){count&&GLctx.uniform2fv(webglGetUniformLocation(location),HEAPF32,value>>2,count*2);return}if(count<=144){count*=2;var view=miniTempWebGLFloatBuffers[count];for(var i=0;i<count;i+=2){view[i]=HEAPF32[value+4*i>>2];view[i+1]=HEAPF32[value+(4*i+4)>>2]}}else{var view=HEAPF32.subarray(value>>2,value+count*8>>2)}GLctx.uniform2fv(webglGetUniformLocation(location),view)};var _glUniform2fv=_emscripten_glUniform2fv;var _emscripten_glUniform2iv=(location,count,value)=>{if(GL.currentContext.version>=2){count&&GLctx.uniform2iv(webglGetUniformLocation(location),HEAP32,value>>2,count*2);return}if(count<=144){count*=2;var view=miniTempWebGLIntBuffers[count];for(var i=0;i<count;i+=2){view[i]=HEAP32[value+4*i>>2];view[i+1]=HEAP32[value+(4*i+4)>>2]}}else{var view=HEAP32.subarray(value>>2,value+count*8>>2)}GLctx.uniform2iv(webglGetUniformLocation(location),view)};var _glUniform2iv=_emscripten_glUniform2iv;var _emscripten_glUniform3fv=(location,count,value)=>{if(GL.currentContext.version>=2){count&&GLctx.uniform3fv(webglGetUniformLocation(location),HEAPF32,value>>2,count*3);return}if(count<=96){count*=3;var view=miniTempWebGLFloatBuffers[count];for(var i=0;i<count;i+=3){view[i]=HEAPF32[value+4*i>>2];view[i+1]=HEAPF32[value+(4*i+4)>>2];view[i+2]=HEAPF32[value+(4*i+8)>>2]}}else{var view=HEAPF32.subarray(value>>2,value+count*12>>2)}GLctx.uniform3fv(webglGetUniformLocation(location),view)};var _glUniform3fv=_emscripten_glUniform3fv;var _emscripten_glUniform4f=(location,v0,v1,v2,v3)=>{GLctx.uniform4f(webglGetUniformLocation(location),v0,v1,v2,v3)};var _glUniform4f=_emscripten_glUniform4f;var _emscripten_glUniform4fv=(location,count,value)=>{if(GL.currentContext.version>=2){count&&GLctx.uniform4fv(webglGetUniformLocation(location),HEAPF32,value>>2,count*4);return}if(count<=72){var view=miniTempWebGLFloatBuffers[4*count];var heap=HEAPF32;value=value>>2;count*=4;for(var i=0;i<count;i+=4){var dst=value+i;view[i]=heap[dst];view[i+1]=heap[dst+1];view[i+2]=heap[dst+2];view[i+3]=heap[dst+3]}}else{var view=HEAPF32.subarray(value>>2,value+count*16>>2)}GLctx.uniform4fv(webglGetUniformLocation(location),view)};var _glUniform4fv=_emscripten_glUniform4fv;var _emscripten_glUniformBlockBinding=(program,uniformBlockIndex,uniformBlockBinding)=>{program=GL.programs[program];GLctx.uniformBlockBinding(program,uniformBlockIndex,uniformBlockBinding)};var _glUniformBlockBinding=_emscripten_glUniformBlockBinding;var _emscripten_glUniformMatrix3fv=(location,count,transpose,value)=>{if(GL.currentContext.version>=2){count&&GLctx.uniformMatrix3fv(webglGetUniformLocation(location),!!transpose,HEAPF32,value>>2,count*9);return}if(count<=32){count*=9;var view=miniTempWebGLFloatBuffers[count];for(var i=0;i<count;i+=9){view[i]=HEAPF32[value+4*i>>2];view[i+1]=HEAPF32[value+(4*i+4)>>2];view[i+2]=HEAPF32[value+(4*i+8)>>2];view[i+3]=HEAPF32[value+(4*i+12)>>2];view[i+4]=HEAPF32[value+(4*i+16)>>2];view[i+5]=HEAPF32[value+(4*i+20)>>2];view[i+6]=HEAPF32[value+(4*i+24)>>2];view[i+7]=HEAPF32[value+(4*i+28)>>2];view[i+8]=HEAPF32[value+(4*i+32)>>2]}}else{var view=HEAPF32.subarray(value>>2,value+count*36>>2)}GLctx.uniformMatrix3fv(webglGetUniformLocation(location),!!transpose,view)};var _glUniformMatrix3fv=_emscripten_glUniformMatrix3fv;var _emscripten_glUniformMatrix4fv=(location,count,transpose,value)=>{if(GL.currentContext.version>=2){count&&GLctx.uniformMatrix4fv(webglGetUniformLocation(location),!!transpose,HEAPF32,value>>2,count*16);return}if(count<=18){var view=miniTempWebGLFloatBuffers[16*count];var heap=HEAPF32;value=value>>2;count*=16;for(var i=0;i<count;i+=16){var dst=value+i;view[i]=heap[dst];view[i+1]=heap[dst+1];view[i+2]=heap[dst+2];view[i+3]=heap[dst+3];view[i+4]=heap[dst+4];view[i+5]=heap[dst+5];view[i+6]=heap[dst+6];view[i+7]=heap[dst+7];view[i+8]=heap[dst+8];view[i+9]=heap[dst+9];view[i+10]=heap[dst+10];view[i+11]=heap[dst+11];view[i+12]=heap[dst+12];view[i+13]=heap[dst+13];view[i+14]=heap[dst+14];view[i+15]=heap[dst+15]}}else{var view=HEAPF32.subarray(value>>2,value+count*64>>2)}GLctx.uniformMatrix4fv(webglGetUniformLocation(location),!!transpose,view)};var _glUniformMatrix4fv=_emscripten_glUniformMatrix4fv;var _emscripten_glUseProgram=program=>{program=GL.programs[program];GLctx.useProgram(program);GLctx.currentProgram=program};var _glUseProgram=_emscripten_glUseProgram;var _emscripten_glVertexAttrib4f=(x0,x1,x2,x3,x4)=>GLctx.vertexAttrib4f(x0,x1,x2,x3,x4);var _glVertexAttrib4f=_emscripten_glVertexAttrib4f;var _emscripten_glVertexAttribDivisor=(index,divisor)=>{GLctx.vertexAttribDivisor(index,divisor)};var _glVertexAttribDivisor=_emscripten_glVertexAttribDivisor;var _emscripten_glVertexAttribI4ui=(x0,x1,x2,x3,x4)=>GLctx.vertexAttribI4ui(x0,x1,x2,x3,x4);var _glVertexAttribI4ui=_emscripten_glVertexAttribI4ui;var _emscripten_glVertexAttribIPointer=(index,size,type,stride,ptr)=>{GLctx.vertexAttribIPointer(index,size,type,stride,ptr)};var _glVertexAttribIPointer=_emscripten_glVertexAttribIPointer;var _emscripten_glVertexAttribPointer=(index,size,type,normalized,stride,ptr)=>{GLctx.vertexAttribPointer(index,size,type,!!normalized,stride,ptr)};var _glVertexAttribPointer=_emscripten_glVertexAttribPointer;var _emscripten_glViewport=(x0,x1,x2,x3)=>GLctx.viewport(x0,x1,x2,x3);var _glViewport=_emscripten_glViewport;var GodotRuntime={get_func:function(ptr){return wasmTable.get(ptr)},error:function(){err.apply(null,Array.from(arguments))},print:function(){out.apply(null,Array.from(arguments))},malloc:function(p_size){return _malloc(p_size)},free:function(p_ptr){_free(p_ptr)},getHeapValue:function(p_ptr,p_type){return getValue(p_ptr,p_type)},setHeapValue:function(p_ptr,p_value,p_type){setValue(p_ptr,p_value,p_type)},heapSub:function(p_heap,p_ptr,p_len){const bytes=p_heap.BYTES_PER_ELEMENT;return p_heap.subarray(p_ptr/bytes,p_ptr/bytes+p_len)},heapSlice:function(p_heap,p_ptr,p_len){const bytes=p_heap.BYTES_PER_ELEMENT;return p_heap.slice(p_ptr/bytes,p_ptr/bytes+p_len)},heapCopy:function(p_dst,p_src,p_ptr){const bytes=p_src.BYTES_PER_ELEMENT;return p_dst.set(p_src,p_ptr/bytes)},parseString:function(p_ptr){return UTF8ToString(p_ptr)},parseStringArray:function(p_ptr,p_size){const strings=[];const ptrs=GodotRuntime.heapSub(HEAP32,p_ptr,p_size);ptrs.forEach(function(ptr){strings.push(GodotRuntime.parseString(ptr))});return strings},strlen:function(p_str){return lengthBytesUTF8(p_str)},allocString:function(p_str){const length=GodotRuntime.strlen(p_str)+1;const c_str=GodotRuntime.malloc(length);stringToUTF8(p_str,c_str,length);return c_str},allocStringArray:function(p_strings){const size=p_strings.length;const c_ptr=GodotRuntime.malloc(size*4);for(let i=0;i<size;i++){HEAP32[(c_ptr>>2)+i]=GodotRuntime.allocString(p_strings[i])}return c_ptr},freeStringArray:function(p_ptr,p_len){for(let i=0;i<p_len;i++){GodotRuntime.free(HEAP32[(p_ptr>>2)+i])}GodotRuntime.free(p_ptr)},stringToHeap:function(p_str,p_ptr,p_len){return stringToUTF8Array(p_str,HEAP8,p_ptr,p_len)}};var GodotConfig={canvas:null,locale:"en",canvas_resize_policy:2,virtual_keyboard:false,persistent_drops:false,godot_pool_size:4,on_execute:null,on_exit:null,init_config:function(p_opts){GodotConfig.canvas_resize_policy=p_opts["canvasResizePolicy"];GodotConfig.canvas=p_opts["canvas"];GodotConfig.locale=p_opts["locale"]||GodotConfig.locale;GodotConfig.virtual_keyboard=p_opts["virtualKeyboard"];GodotConfig.persistent_drops=!!p_opts["persistentDrops"];GodotConfig.godot_pool_size=p_opts["godotPoolSize"];GodotConfig.on_execute=p_opts["onExecute"];GodotConfig.on_exit=p_opts["onExit"];if(p_opts["focusCanvas"]){GodotConfig.canvas.focus()}},locate_file:function(file){return Module["locateFile"](file)},clear:function(){GodotConfig.canvas=null;GodotConfig.locale="en";GodotConfig.canvas_resize_policy=2;GodotConfig.virtual_keyboard=false;GodotConfig.persistent_drops=false;GodotConfig.on_execute=null;GodotConfig.on_exit=null}};var GodotFS={ENOENT:44,_idbfs:false,_syncing:false,_mount_points:[],is_persistent:function(){return GodotFS._idbfs?1:0},init:function(persistentPaths){GodotFS._idbfs=false;if(!Array.isArray(persistentPaths)){return Promise.reject(new Error("Persistent paths must be an array"))}if(!persistentPaths.length){return Promise.resolve()}GodotFS._mount_points=persistentPaths.slice();function createRecursive(dir){try{FS.stat(dir)}catch(e){if(e.errno!==GodotFS.ENOENT){GodotRuntime.error(e)}FS.mkdirTree(dir)}}GodotFS._mount_points.forEach(function(path){createRecursive(path);FS.mount(IDBFS,{},path)});return new Promise(function(resolve,reject){FS.syncfs(true,function(err){if(err){GodotFS._mount_points=[];GodotFS._idbfs=false;GodotRuntime.print(`IndexedDB not available: ${err.message}`)}else{GodotFS._idbfs=true}resolve(err)})})},deinit:function(){GodotFS._mount_points.forEach(function(path){try{FS.unmount(path)}catch(e){GodotRuntime.print("Already unmounted",e)}if(GodotFS._idbfs&&IDBFS.dbs[path]){IDBFS.dbs[path].close();delete IDBFS.dbs[path]}});GodotFS._mount_points=[];GodotFS._idbfs=false;GodotFS._syncing=false},sync:function(){if(GodotFS._syncing){GodotRuntime.error("Already syncing!");return Promise.resolve()}GodotFS._syncing=true;return new Promise(function(resolve,reject){FS.syncfs(false,function(error){if(error){GodotRuntime.error(`Failed to save IDB file system: ${error.message}`)}GodotFS._syncing=false;resolve(error)})})},copy_to_fs:function(path,buffer){const idx=path.lastIndexOf("/");let dir="/";if(idx>0){dir=path.slice(0,idx)}try{FS.stat(dir)}catch(e){if(e.errno!==GodotFS.ENOENT){GodotRuntime.error(e)}FS.mkdirTree(dir)}FS.writeFile(path,new Uint8Array(buffer))}};var GodotOS={request_quit:function(){},_async_cbs:[],_fs_sync_promise:null,atexit:function(p_promise_cb){GodotOS._async_cbs.push(p_promise_cb)},cleanup:function(exit_code){const cb=GodotConfig.on_exit;GodotFS.deinit();GodotConfig.clear();if(cb){cb(exit_code)}},finish_async:function(callback){GodotOS._fs_sync_promise.then(function(err){const promises=[];GodotOS._async_cbs.forEach(function(cb){promises.push(new Promise(cb))});return Promise.all(promises)}).then(function(){return GodotFS.sync()}).then(function(err){setTimeout(function(){callback()},0)})}};var GodotAudio={MAX_VOLUME_CHANNELS:8,GodotChannel:{CHANNEL_L:0,CHANNEL_R:1,CHANNEL_C:3,CHANNEL_LFE:4,CHANNEL_RL:5,CHANNEL_RR:6,CHANNEL_SL:7,CHANNEL_SR:8},WebChannel:{CHANNEL_L:0,CHANNEL_R:1,CHANNEL_SL:2,CHANNEL_SR:3,CHANNEL_C:4,CHANNEL_LFE:5},samples:null,Sample:class Sample{static getSample(id){if(!GodotAudio.samples.has(id)){throw new ReferenceError(`Could not find sample "${id}"`)}return GodotAudio.samples.get(id)}static getSampleOrNull(id){return GodotAudio.samples.get(id)??null}static create(params,options={}){const sample=new GodotAudio.Sample(params,options);GodotAudio.samples.set(params.id,sample);return sample}static delete(id){GodotAudio.samples.delete(id)}constructor(params,options={}){this.id=params.id;this._audioBuffer=null;this.numberOfChannels=options.numberOfChannels??2;this.sampleRate=options.sampleRate??44100;this.loopMode=options.loopMode??"disabled";this.loopBegin=options.loopBegin??0;this.loopEnd=options.loopEnd??0;this.setAudioBuffer(params.audioBuffer)}getAudioBuffer(){return this._duplicateAudioBuffer()}setAudioBuffer(val){this._audioBuffer=val}clear(){this.setAudioBuffer(null);GodotAudio.Sample.delete(this.id)}_duplicateAudioBuffer(){if(this._audioBuffer==null){throw new Error("couldn't duplicate a null audioBuffer")}const channels=new Array(this._audioBuffer.numberOfChannels);for(let i=0;i<this._audioBuffer.numberOfChannels;i++){const channel=new Float32Array(this._audioBuffer.getChannelData(i));channels[i]=channel}const buffer=GodotAudio.ctx.createBuffer(this.numberOfChannels,this._audioBuffer.length,this._audioBuffer.sampleRate);for(let i=0;i<channels.length;i++){buffer.copyToChannel(channels[i],i,0)}return buffer}},SampleNodeBus:class SampleNodeBus{static create(bus){return new GodotAudio.SampleNodeBus(bus)}constructor(bus){const NUMBER_OF_WEB_CHANNELS=6;this._bus=bus;this._channelSplitter=GodotAudio.ctx.createChannelSplitter(NUMBER_OF_WEB_CHANNELS);this._l=GodotAudio.ctx.createGain();this._r=GodotAudio.ctx.createGain();this._sl=GodotAudio.ctx.createGain();this._sr=GodotAudio.ctx.createGain();this._c=GodotAudio.ctx.createGain();this._lfe=GodotAudio.ctx.createGain();this._channelMerger=GodotAudio.ctx.createChannelMerger(NUMBER_OF_WEB_CHANNELS);this._channelSplitter.connect(this._l,GodotAudio.WebChannel.CHANNEL_L).connect(this._channelMerger,GodotAudio.WebChannel.CHANNEL_L,GodotAudio.WebChannel.CHANNEL_L);this._channelSplitter.connect(this._r,GodotAudio.WebChannel.CHANNEL_R).connect(this._channelMerger,GodotAudio.WebChannel.CHANNEL_L,GodotAudio.WebChannel.CHANNEL_R);this._channelSplitter.connect(this._sl,GodotAudio.WebChannel.CHANNEL_SL).connect(this._channelMerger,GodotAudio.WebChannel.CHANNEL_L,GodotAudio.WebChannel.CHANNEL_SL);this._channelSplitter.connect(this._sr,GodotAudio.WebChannel.CHANNEL_SR).connect(this._channelMerger,GodotAudio.WebChannel.CHANNEL_L,GodotAudio.WebChannel.CHANNEL_SR);this._channelSplitter.connect(this._c,GodotAudio.WebChannel.CHANNEL_C).connect(this._channelMerger,GodotAudio.WebChannel.CHANNEL_L,GodotAudio.WebChannel.CHANNEL_C);this._channelSplitter.connect(this._lfe,GodotAudio.WebChannel.CHANNEL_L).connect(this._channelMerger,GodotAudio.WebChannel.CHANNEL_L,GodotAudio.WebChannel.CHANNEL_LFE);this._channelMerger.connect(this._bus.getInputNode())}getInputNode(){return this._channelSplitter}getOutputNode(){return this._channelMerger}setVolume(volume){if(volume.length!==GodotAudio.MAX_VOLUME_CHANNELS){throw new Error(`Volume length isn't "${GodotAudio.MAX_VOLUME_CHANNELS}", is ${volume.length} instead`)}this._l.gain.value=volume[GodotAudio.GodotChannel.CHANNEL_L]??0;this._r.gain.value=volume[GodotAudio.GodotChannel.CHANNEL_R]??0;this._sl.gain.value=volume[GodotAudio.GodotChannel.CHANNEL_SL]??0;this._sr.gain.value=volume[GodotAudio.GodotChannel.CHANNEL_SR]??0;this._c.gain.value=volume[GodotAudio.GodotChannel.CHANNEL_C]??0;this._lfe.gain.value=volume[GodotAudio.GodotChannel.CHANNEL_LFE]??0}clear(){this._bus=null;this._channelSplitter.disconnect();this._channelSplitter=null;this._l.disconnect();this._l=null;this._r.disconnect();this._r=null;this._sl.disconnect();this._sl=null;this._sr.disconnect();this._sr=null;this._c.disconnect();this._c=null;this._lfe.disconnect();this._lfe=null;this._channelMerger.disconnect();this._channelMerger=null}},sampleNodes:null,SampleNode:class SampleNode{static getSampleNode(id){if(!GodotAudio.sampleNodes.has(id)){throw new ReferenceError(`Could not find sample node "${id}"`)}return GodotAudio.sampleNodes.get(id)}static getSampleNodeOrNull(id){return GodotAudio.sampleNodes.get(id)??null}static stopSampleNode(id){const sampleNode=GodotAudio.SampleNode.getSampleNodeOrNull(id);if(sampleNode==null){return}sampleNode.stop()}static pauseSampleNode(id,enable){const sampleNode=GodotAudio.SampleNode.getSampleNodeOrNull(id);if(sampleNode==null){return}sampleNode.pause(enable)}static create(params,options={}){const sampleNode=new GodotAudio.SampleNode(params,options);GodotAudio.sampleNodes.set(params.id,sampleNode);return sampleNode}static delete(id){GodotAudio.deleteSampleNode(id)}constructor(params,options={}){this.id=params.id;this.streamObjectId=params.streamObjectId;this.offset=options.offset??0;this._playbackPosition=options.offset;this.startTime=options.startTime??0;this.isPaused=false;this.isStarted=false;this.isCanceled=false;this.pauseTime=0;this._playbackRate=44100;this.loopMode=options.loopMode??this.getSample().loopMode??"disabled";this._pitchScale=options.pitchScale??1;this._sourceStartTime=0;this._sampleNodeBuses=new Map;this._source=GodotAudio.ctx.createBufferSource();this._onended=null;this._positionWorklet=null;this.setPlaybackRate(options.playbackRate??44100);this._source.buffer=this.getSample().getAudioBuffer();this._addEndedListener();const bus=GodotAudio.Bus.getBus(params.busIndex);const sampleNodeBus=this.getSampleNodeBus(bus);sampleNodeBus.setVolume(options.volume);this.connectPositionWorklet(options.start).catch(err=>{const newErr=new Error("Failed to create PositionWorklet.");newErr.cause=err;GodotRuntime.error(newErr)})}getPlaybackRate(){return this._playbackRate}getPlaybackPosition(){return this._playbackPosition}setPlaybackRate(val){this._playbackRate=val;this._syncPlaybackRate()}getPitchScale(){return this._pitchScale}setPitchScale(val){this._pitchScale=val;this._syncPlaybackRate()}getSample(){return GodotAudio.Sample.getSample(this.streamObjectId)}getOutputNode(){return this._source}start(){if(this.isStarted){return}this._resetSourceStartTime();this._source.start(this.startTime,this.offset);this.isStarted=true}stop(){this.clear()}restart(){this.isPaused=false;this.pauseTime=0;this._resetSourceStartTime();this._restart()}pause(enable=true){if(enable){this._pause();return}this._unpause()}connect(node){return this.getOutputNode().connect(node)}setVolumes(buses,volumes){for(let busIdx=0;busIdx<buses.length;busIdx++){const sampleNodeBus=this.getSampleNodeBus(buses[busIdx]);sampleNodeBus.setVolume(volumes.slice(busIdx*GodotAudio.MAX_VOLUME_CHANNELS,busIdx*GodotAudio.MAX_VOLUME_CHANNELS+GodotAudio.MAX_VOLUME_CHANNELS))}}getSampleNodeBus(bus){if(!this._sampleNodeBuses.has(bus)){const sampleNodeBus=GodotAudio.SampleNodeBus.create(bus);this._sampleNodeBuses.set(bus,sampleNodeBus);this._source.connect(sampleNodeBus.getInputNode())}return this._sampleNodeBuses.get(bus)}async connectPositionWorklet(start){await GodotAudio.audioPositionWorkletPromise;if(this.isCanceled){return}this._source.connect(this.getPositionWorklet());if(start){this.start()}}getPositionWorklet(){if(this._positionWorklet!=null){return this._positionWorklet}if(GodotAudio.audioPositionWorkletNodes.length>0){this._positionWorklet=GodotAudio.audioPositionWorkletNodes.pop()}else{this._positionWorklet=new AudioWorkletNode(GodotAudio.ctx,"godot-position-reporting-processor")}this._playbackPosition=this.offset;this._positionWorklet.port.onmessage=event=>{switch(event.data["type"]){case"position":this._playbackPosition=parseInt(event.data.data,10)/this.getSample().sampleRate+this.offset;break;default:}};const resetParameter=this._positionWorklet.parameters.get("reset");resetParameter.setValueAtTime(1,GodotAudio.ctx.currentTime);resetParameter.setValueAtTime(0,GodotAudio.ctx.currentTime+1);return this._positionWorklet}clear(){this.isCanceled=true;this.isPaused=false;this.pauseTime=0;if(this._source!=null){this._source.removeEventListener("ended",this._onended);this._onended=null;if(this.isStarted){this._source.stop()}this._source.disconnect();this._source=null}for(const sampleNodeBus of this._sampleNodeBuses.values()){sampleNodeBus.clear()}this._sampleNodeBuses.clear();if(this._positionWorklet){this._positionWorklet.disconnect();this._positionWorklet.port.onmessage=null;GodotAudio.audioPositionWorkletNodes.push(this._positionWorklet);this._positionWorklet=null}GodotAudio.SampleNode.delete(this.id)}_resetSourceStartTime(){this._sourceStartTime=GodotAudio.ctx.currentTime}_syncPlaybackRate(){this._source.playbackRate.value=this.getPlaybackRate()*this.getPitchScale()}_restart(){if(this._source!=null){this._source.disconnect()}this._source=GodotAudio.ctx.createBufferSource();this._source.buffer=this.getSample().getAudioBuffer();for(const sampleNodeBus of this._sampleNodeBuses.values()){this.connect(sampleNodeBus.getInputNode())}this._addEndedListener();const pauseTime=this.isPaused?this.pauseTime:0;if(this._positionWorklet!=null){this._positionWorklet.port.postMessage({type:"clear"});this._source.connect(this._positionWorklet)}this._source.start(this.startTime,this.offset+pauseTime);this.isStarted=true}_pause(){if(!this.isStarted){return}this.isPaused=true;this.pauseTime=(GodotAudio.ctx.currentTime-this._sourceStartTime)/this.getPlaybackRate();this._source.stop()}_unpause(){this._restart();this.isPaused=false;this.pauseTime=0}_addEndedListener(){if(this._onended!=null){this._source.removeEventListener("ended",this._onended)}const self=this;this._onended=_=>{if(self.isPaused){return}switch(self.getSample().loopMode){case"disabled":self.stop();break;case"forward":case"backward":self.restart();break;default:}};this._source.addEventListener("ended",this._onended)}},deleteSampleNode:pSampleNodeId=>{GodotAudio.sampleNodes.delete(pSampleNodeId);if(GodotAudio.sampleFinishedCallback==null){return}const sampleNodeIdPtr=GodotRuntime.allocString(pSampleNodeId);GodotAudio.sampleFinishedCallback(sampleNodeIdPtr);GodotRuntime.free(sampleNodeIdPtr)},buses:null,busSolo:null,Bus:class Bus{static getCount(){return GodotAudio.buses.length}static setCount(val){const buses=GodotAudio.buses;if(val===buses.length){return}if(val<buses.length){const deletedBuses=buses.slice(val);for(let i=0;i<deletedBuses.length;i++){const deletedBus=deletedBuses[i];deletedBus.clear()}GodotAudio.buses=buses.slice(0,val);return}for(let i=GodotAudio.buses.length;i<val;i++){GodotAudio.Bus.create()}}static getBus(index){if(index<0||index>=GodotAudio.buses.length){throw new ReferenceError(`invalid bus index "${index}"`)}return GodotAudio.buses[index]}static getBusOrNull(index){if(index<0||index>=GodotAudio.buses.length){return null}return GodotAudio.buses[index]}static move(fromIndex,toIndex){const movedBus=GodotAudio.Bus.getBusOrNull(fromIndex);if(movedBus==null){return}const buses=GodotAudio.buses.filter((_,i)=>i!==fromIndex);buses.splice(toIndex-1,0,movedBus);GodotAudio.buses=buses}static addAt(index){const newBus=GodotAudio.Bus.create();if(index!==newBus.getId()){GodotAudio.Bus.move(newBus.getId(),index)}}static create(){const newBus=new GodotAudio.Bus;const isFirstBus=GodotAudio.buses.length===0;GodotAudio.buses.push(newBus);if(isFirstBus){newBus.setSend(null)}else{newBus.setSend(GodotAudio.Bus.getBus(0))}return newBus}constructor(){this._sampleNodes=new Set;this.isSolo=false;this._send=null;this._gainNode=GodotAudio.ctx.createGain();this._soloNode=GodotAudio.ctx.createGain();this._muteNode=GodotAudio.ctx.createGain();this._gainNode.connect(this._soloNode).connect(this._muteNode)}getId(){return GodotAudio.buses.indexOf(this)}getVolumeDb(){return GodotAudio.linear_to_db(this._gainNode.gain.value)}setVolumeDb(val){const linear=GodotAudio.db_to_linear(val);if(isFinite(linear)){this._gainNode.gain.value=linear}}getSend(){return this._send}setSend(val){this._send=val;if(val==null){if(this.getId()==0){this.getOutputNode().connect(GodotAudio.ctx.destination);return}throw new Error(`Cannot send to "${val}" without the bus being at index 0 (current index: ${this.getId()})`)}this.connect(val)}getInputNode(){return this._gainNode}getOutputNode(){return this._muteNode}mute(enable){this._muteNode.gain.value=enable?0:1}solo(enable){if(this.isSolo===enable){return}if(enable){if(GodotAudio.busSolo!=null&&GodotAudio.busSolo!==this){GodotAudio.busSolo._disableSolo()}this._enableSolo();return}this._disableSolo()}addSampleNode(sampleNode){this._sampleNodes.add(sampleNode);sampleNode.getOutputNode().connect(this.getInputNode())}removeSampleNode(sampleNode){this._sampleNodes.delete(sampleNode);sampleNode.getOutputNode().disconnect()}connect(bus){if(bus==null){throw new Error("cannot connect to null bus")}this.getOutputNode().disconnect();this.getOutputNode().connect(bus.getInputNode());return bus}clear(){GodotAudio.buses=GodotAudio.buses.filter(v=>v!==this)}_syncSampleNodes(){const sampleNodes=Array.from(this._sampleNodes);for(let i=0;i<sampleNodes.length;i++){const sampleNode=sampleNodes[i];sampleNode.getOutputNode().disconnect();sampleNode.getOutputNode().connect(this.getInputNode())}}_enableSolo(){this.isSolo=true;GodotAudio.busSolo=this;this._soloNode.gain.value=1;const otherBuses=GodotAudio.buses.filter(otherBus=>otherBus!==this);for(let i=0;i<otherBuses.length;i++){const otherBus=otherBuses[i];otherBus._soloNode.gain.value=0}}_disableSolo(){this.isSolo=false;GodotAudio.busSolo=null;this._soloNode.gain.value=1;const otherBuses=GodotAudio.buses.filter(otherBus=>otherBus!==this);for(let i=0;i<otherBuses.length;i++){const otherBus=otherBuses[i];otherBus._soloNode.gain.value=1}}},sampleFinishedCallback:null,ctx:null,input:null,driver:null,interval:0,audioPositionWorkletPromise:null,audioPositionWorkletNodes:null,linear_to_db:function(linear){return Math.log(linear)*8.685889638065037},db_to_linear:function(db){return Math.exp(db*.11512925464970228)},init:function(mix_rate,latency,onstatechange,onlatencyupdate){GodotAudio.samples=new Map;GodotAudio.sampleNodes=new Map;GodotAudio.buses=[];GodotAudio.busSolo=null;GodotAudio.audioPositionWorkletNodes=[];const opts={};if(mix_rate){GodotAudio.sampleRate=mix_rate;opts["sampleRate"]=mix_rate}const ctx=new(window.AudioContext||window.webkitAudioContext)(opts);GodotAudio.ctx=ctx;ctx.onstatechange=function(){let state=0;switch(ctx.state){case"suspended":state=0;break;case"running":state=1;break;case"closed":state=2;break;default:}onstatechange(state)};ctx.onstatechange();GodotAudio.interval=setInterval(function(){let computed_latency=0;if(ctx.baseLatency){computed_latency+=GodotAudio.ctx.baseLatency}if(ctx.outputLatency){computed_latency+=GodotAudio.ctx.outputLatency}onlatencyupdate(computed_latency)},1e3);GodotOS.atexit(GodotAudio.close_async);const path=GodotConfig.locate_file("godot.audio.position.worklet.js");GodotAudio.audioPositionWorkletPromise=ctx.audioWorklet.addModule(path);return ctx.destination.channelCount},create_input:function(callback){if(GodotAudio.input){return 0}function gotMediaInput(stream){try{GodotAudio.input=GodotAudio.ctx.createMediaStreamSource(stream);callback(GodotAudio.input)}catch(e){GodotRuntime.error("Failed creating input.",e)}}if(navigator.mediaDevices&&navigator.mediaDevices.getUserMedia){navigator.mediaDevices.getUserMedia({audio:true}).then(gotMediaInput,function(e){GodotRuntime.error("Error getting user media.",e)})}else{if(!navigator.getUserMedia){navigator.getUserMedia=navigator.webkitGetUserMedia||navigator.mozGetUserMedia}if(!navigator.getUserMedia){GodotRuntime.error("getUserMedia not available.");return 1}navigator.getUserMedia({audio:true},gotMediaInput,function(e){GodotRuntime.print(e)})}return 0},close_async:function(resolve,reject){const ctx=GodotAudio.ctx;GodotAudio.ctx=null;if(!ctx){resolve();return}if(GodotAudio.interval){clearInterval(GodotAudio.interval);GodotAudio.interval=0}if(GodotAudio.input){GodotAudio.input.disconnect();GodotAudio.input=null}let closed=Promise.resolve();if(GodotAudio.driver){closed=GodotAudio.driver.close()}closed.then(function(){return ctx.close()}).then(function(){ctx.onstatechange=null;resolve()}).catch(function(e){ctx.onstatechange=null;GodotRuntime.error("Error closing AudioContext",e);resolve()})},start_sample:function(playbackObjectId,streamObjectId,busIndex,startOptions){GodotAudio.SampleNode.stopSampleNode(playbackObjectId);GodotAudio.SampleNode.create({busIndex,id:playbackObjectId,streamObjectId},startOptions)},stop_sample:function(playbackObjectId){GodotAudio.SampleNode.stopSampleNode(playbackObjectId)},sample_set_pause:function(playbackObjectId,pause){GodotAudio.SampleNode.pauseSampleNode(playbackObjectId,pause)},update_sample_pitch_scale:function(playbackObjectId,pitchScale){const sampleNode=GodotAudio.SampleNode.getSampleNodeOrNull(playbackObjectId);if(sampleNode==null){return}sampleNode.setPitchScale(pitchScale)},sample_set_volumes_linear:function(playbackObjectId,busIndexes,volumes){const sampleNode=GodotAudio.SampleNode.getSampleNodeOrNull(playbackObjectId);if(sampleNode==null){return}const buses=busIndexes.map(busIndex=>GodotAudio.Bus.getBus(busIndex));sampleNode.setVolumes(buses,volumes)},set_sample_bus_count:function(count){GodotAudio.Bus.setCount(count)},remove_sample_bus:function(index){const bus=GodotAudio.Bus.getBusOrNull(index);if(bus==null){return}bus.clear()},add_sample_bus:function(atPos){GodotAudio.Bus.addAt(atPos)},move_sample_bus:function(busIndex,toPos){GodotAudio.Bus.move(busIndex,toPos)},set_sample_bus_send:function(busIndex,sendIndex){const bus=GodotAudio.Bus.getBusOrNull(busIndex);if(bus==null){return}let targetBus=GodotAudio.Bus.getBusOrNull(sendIndex);if(targetBus==null){targetBus=GodotAudio.Bus.getBus(0)}bus.setSend(targetBus)},set_sample_bus_volume_db:function(busIndex,volumeDb){const bus=GodotAudio.Bus.getBusOrNull(busIndex);if(bus==null){return}bus.setVolumeDb(volumeDb)},set_sample_bus_solo:function(busIndex,enable){const bus=GodotAudio.Bus.getBusOrNull(busIndex);if(bus==null){return}bus.solo(enable)},set_sample_bus_mute:function(busIndex,enable){const bus=GodotAudio.Bus.getBusOrNull(busIndex);if(bus==null){return}bus.mute(enable)}};function _godot_audio_get_sample_playback_position(playbackObjectIdStrPtr){const playbackObjectId=GodotRuntime.parseString(playbackObjectIdStrPtr);const sampleNode=GodotAudio.SampleNode.getSampleNodeOrNull(playbackObjectId);if(sampleNode==null){return 0}return sampleNode.getPlaybackPosition()}function _godot_audio_has_script_processor(){return GodotAudio.ctx&&GodotAudio.ctx.createScriptProcessor?1:0}function _godot_audio_has_worklet(){return GodotAudio.ctx&&GodotAudio.ctx.audioWorklet?1:0}function _godot_audio_init(p_mix_rate,p_latency,p_state_change,p_latency_update){const statechange=GodotRuntime.get_func(p_state_change);const latencyupdate=GodotRuntime.get_func(p_latency_update);const mix_rate=GodotRuntime.getHeapValue(p_mix_rate,"i32");const channels=GodotAudio.init(mix_rate,p_latency,statechange,latencyupdate);GodotRuntime.setHeapValue(p_mix_rate,GodotAudio.ctx.sampleRate,"i32");return channels}function _godot_audio_input_start(){return GodotAudio.create_input(function(input){input.connect(GodotAudio.driver.get_node())})}function _godot_audio_input_stop(){if(GodotAudio.input){const tracks=GodotAudio.input["mediaStream"]["getTracks"]();for(let i=0;i<tracks.length;i++){tracks[i]["stop"]()}GodotAudio.input.disconnect();GodotAudio.input=null}}function _godot_audio_is_available(){if(!(window.AudioContext||window.webkitAudioContext)){return 0}return 1}function _godot_audio_resume(){if(GodotAudio.ctx&&GodotAudio.ctx.state!=="running"){GodotAudio.ctx.resume()}}function _godot_audio_sample_bus_add(atPos){GodotAudio.add_sample_bus(atPos)}function _godot_audio_sample_bus_move(fromPos,toPos){GodotAudio.move_sample_bus(fromPos,toPos)}function _godot_audio_sample_bus_remove(index){GodotAudio.remove_sample_bus(index)}function _godot_audio_sample_bus_set_count(count){GodotAudio.set_sample_bus_count(count)}function _godot_audio_sample_bus_set_mute(bus,enable){GodotAudio.set_sample_bus_mute(bus,Boolean(enable))}function _godot_audio_sample_bus_set_send(bus,sendIndex){GodotAudio.set_sample_bus_send(bus,sendIndex)}function _godot_audio_sample_bus_set_solo(bus,enable){GodotAudio.set_sample_bus_solo(bus,Boolean(enable))}function _godot_audio_sample_bus_set_volume_db(bus,volumeDb){GodotAudio.set_sample_bus_volume_db(bus,volumeDb)}function _godot_audio_sample_is_active(playbackObjectIdStrPtr){const playbackObjectId=GodotRuntime.parseString(playbackObjectIdStrPtr);return Number(GodotAudio.sampleNodes.has(playbackObjectId))}function _godot_audio_sample_register_stream(streamObjectIdStrPtr,framesPtr,framesTotal,loopModeStrPtr,loopBegin,loopEnd){const BYTES_PER_FLOAT32=4;const streamObjectId=GodotRuntime.parseString(streamObjectIdStrPtr);const loopMode=GodotRuntime.parseString(loopModeStrPtr);const numberOfChannels=2;const sampleRate=GodotAudio.ctx.sampleRate;const subLeft=GodotRuntime.heapSub(HEAPF32,framesPtr,framesTotal);const subRight=GodotRuntime.heapSub(HEAPF32,framesPtr+framesTotal*BYTES_PER_FLOAT32,framesTotal);const audioBuffer=GodotAudio.ctx.createBuffer(numberOfChannels,framesTotal,sampleRate);audioBuffer.copyToChannel(new Float32Array(subLeft),0,0);audioBuffer.copyToChannel(new Float32Array(subRight),1,0);GodotAudio.Sample.create({id:streamObjectId,audioBuffer},{loopBegin,loopEnd,loopMode,numberOfChannels,sampleRate})}function _godot_audio_sample_set_finished_callback(callbackPtr){GodotAudio.sampleFinishedCallback=GodotRuntime.get_func(callbackPtr)}function _godot_audio_sample_set_pause(playbackObjectIdStrPtr,pause){const playbackObjectId=GodotRuntime.parseString(playbackObjectIdStrPtr);GodotAudio.sample_set_pause(playbackObjectId,Boolean(pause))}function _godot_audio_sample_set_volumes_linear(playbackObjectIdStrPtr,busesPtr,busesSize,volumesPtr,volumesSize){const playbackObjectId=GodotRuntime.parseString(playbackObjectIdStrPtr);const buses=GodotRuntime.heapSub(HEAP32,busesPtr,busesSize);const volumes=GodotRuntime.heapSub(HEAPF32,volumesPtr,volumesSize);GodotAudio.sample_set_volumes_linear(playbackObjectId,Array.from(buses),volumes)}function _godot_audio_sample_start(playbackObjectIdStrPtr,streamObjectIdStrPtr,busIndex,offset,pitchScale,volumePtr){const playbackObjectId=GodotRuntime.parseString(playbackObjectIdStrPtr);const streamObjectId=GodotRuntime.parseString(streamObjectIdStrPtr);const volume=GodotRuntime.heapSub(HEAPF32,volumePtr,8);const startOptions={offset,volume,playbackRate:1,pitchScale,start:true};GodotAudio.start_sample(playbackObjectId,streamObjectId,busIndex,startOptions)}function _godot_audio_sample_stop(playbackObjectIdStrPtr){const playbackObjectId=GodotRuntime.parseString(playbackObjectIdStrPtr);GodotAudio.stop_sample(playbackObjectId)}function _godot_audio_sample_stream_is_registered(streamObjectIdStrPtr){const streamObjectId=GodotRuntime.parseString(streamObjectIdStrPtr);return Number(GodotAudio.Sample.getSampleOrNull(streamObjectId)!=null)}function _godot_audio_sample_unregister_stream(streamObjectIdStrPtr){const streamObjectId=GodotRuntime.parseString(streamObjectIdStrPtr);const sample=GodotAudio.Sample.getSampleOrNull(streamObjectId);if(sample!=null){sample.clear()}}function _godot_audio_sample_update_pitch_scale(playbackObjectIdStrPtr,pitchScale){const playbackObjectId=GodotRuntime.parseString(playbackObjectIdStrPtr);GodotAudio.update_sample_pitch_scale(playbackObjectId,pitchScale)}var GodotAudioScript={script:null,create:function(buffer_length,channel_count){GodotAudioScript.script=GodotAudio.ctx.createScriptProcessor(buffer_length,2,channel_count);GodotAudio.driver=GodotAudioScript;return GodotAudioScript.script.bufferSize},start:function(p_in_buf,p_in_size,p_out_buf,p_out_size,onprocess){GodotAudioScript.script.onaudioprocess=function(event){const inb=GodotRuntime.heapSub(HEAPF32,p_in_buf,p_in_size);const input=event.inputBuffer;if(GodotAudio.input){const inlen=input.getChannelData(0).length;for(let ch=0;ch<2;ch++){const data=input.getChannelData(ch);for(let s=0;s<inlen;s++){inb[s*2+ch]=data[s]}}}onprocess();const outb=GodotRuntime.heapSub(HEAPF32,p_out_buf,p_out_size);const output=event.outputBuffer;const channels=output.numberOfChannels;for(let ch=0;ch<channels;ch++){const data=output.getChannelData(ch);for(let sample=0;sample<data.length;sample++){data[sample]=outb[sample*channels+ch]}}};GodotAudioScript.script.connect(GodotAudio.ctx.destination)},get_node:function(){return GodotAudioScript.script},close:function(){return new Promise(function(resolve,reject){GodotAudioScript.script.disconnect();GodotAudioScript.script.onaudioprocess=null;GodotAudioScript.script=null;resolve()})}};function _godot_audio_script_create(buffer_length,channel_count){const buf_len=GodotRuntime.getHeapValue(buffer_length,"i32");try{const out_len=GodotAudioScript.create(buf_len,channel_count);GodotRuntime.setHeapValue(buffer_length,out_len,"i32")}catch(e){GodotRuntime.error("Error starting AudioDriverScriptProcessor",e);return 1}return 0}function _godot_audio_script_start(p_in_buf,p_in_size,p_out_buf,p_out_size,p_cb){const onprocess=GodotRuntime.get_func(p_cb);GodotAudioScript.start(p_in_buf,p_in_size,p_out_buf,p_out_size,onprocess)}var GodotAudioWorklet={promise:null,worklet:null,ring_buffer:null,create:function(channels){const path=GodotConfig.locate_file("godot.audio.worklet.js");GodotAudioWorklet.promise=GodotAudio.ctx.audioWorklet.addModule(path).then(function(){GodotAudioWorklet.worklet=new AudioWorkletNode(GodotAudio.ctx,"godot-processor",{outputChannelCount:[channels]});return Promise.resolve()});GodotAudio.driver=GodotAudioWorklet},start:function(in_buf,out_buf,state){GodotAudioWorklet.promise.then(function(){const node=GodotAudioWorklet.worklet;node.connect(GodotAudio.ctx.destination);node.port.postMessage({cmd:"start",data:[state,in_buf,out_buf]});node.port.onmessage=function(event){GodotRuntime.error(event.data)}})},start_no_threads:function(p_out_buf,p_out_size,out_callback,p_in_buf,p_in_size,in_callback){function RingBuffer(){let wpos=0;let rpos=0;let pending_samples=0;const wbuf=new Float32Array(p_out_size);function send(port){if(pending_samples===0){return}const buffer=GodotRuntime.heapSub(HEAPF32,p_out_buf,p_out_size);const size=buffer.length;const tot_sent=pending_samples;out_callback(wpos,pending_samples);if(wpos+pending_samples>=size){const high=size-wpos;wbuf.set(buffer.subarray(wpos,size));pending_samples-=high;wpos=0}if(pending_samples>0){wbuf.set(buffer.subarray(wpos,wpos+pending_samples),tot_sent-pending_samples)}port.postMessage({cmd:"chunk",data:wbuf.subarray(0,tot_sent)});wpos+=pending_samples;pending_samples=0}this.receive=function(recv_buf){const buffer=GodotRuntime.heapSub(HEAPF32,p_in_buf,p_in_size);const from=rpos;let to_write=recv_buf.length;let high=0;if(rpos+to_write>=p_in_size){high=p_in_size-rpos;buffer.set(recv_buf.subarray(0,high),rpos);to_write-=high;rpos=0}if(to_write){buffer.set(recv_buf.subarray(high,to_write),rpos)}in_callback(from,recv_buf.length);rpos+=to_write};this.consumed=function(size,port){pending_samples+=size;send(port)}}GodotAudioWorklet.ring_buffer=new RingBuffer;GodotAudioWorklet.promise.then(function(){const node=GodotAudioWorklet.worklet;const buffer=GodotRuntime.heapSlice(HEAPF32,p_out_buf,p_out_size);node.connect(GodotAudio.ctx.destination);node.port.postMessage({cmd:"start_nothreads",data:[buffer,p_in_size]});node.port.onmessage=function(event){if(!GodotAudioWorklet.worklet){return}if(event.data["cmd"]==="read"){const read=event.data["data"];GodotAudioWorklet.ring_buffer.consumed(read,GodotAudioWorklet.worklet.port)}else if(event.data["cmd"]==="input"){const buf=event.data["data"];if(buf.length>p_in_size){GodotRuntime.error("Input chunk is too big");return}GodotAudioWorklet.ring_buffer.receive(buf)}else{GodotRuntime.error(event.data)}}})},get_node:function(){return GodotAudioWorklet.worklet},close:function(){return new Promise(function(resolve,reject){if(GodotAudioWorklet.promise===null){return}const p=GodotAudioWorklet.promise;p.then(function(){GodotAudioWorklet.worklet.port.postMessage({cmd:"stop",data:null});GodotAudioWorklet.worklet.disconnect();GodotAudioWorklet.worklet.port.onmessage=null;GodotAudioWorklet.worklet=null;GodotAudioWorklet.promise=null;resolve()}).catch(function(err){GodotRuntime.error(err)})})}};function _godot_audio_worklet_create(channels){try{GodotAudioWorklet.create(channels)}catch(e){GodotRuntime.error("Error starting AudioDriverWorklet",e);return 1}return 0}function _godot_audio_worklet_start_no_threads(p_out_buf,p_out_size,p_out_callback,p_in_buf,p_in_size,p_in_callback){const out_callback=GodotRuntime.get_func(p_out_callback);const in_callback=GodotRuntime.get_func(p_in_callback);GodotAudioWorklet.start_no_threads(p_out_buf,p_out_size,out_callback,p_in_buf,p_in_size,in_callback)}function _godot_js_config_canvas_id_get(p_ptr,p_ptr_max){GodotRuntime.stringToHeap(`#${GodotConfig.canvas.id}`,p_ptr,p_ptr_max)}function _godot_js_config_locale_get(p_ptr,p_ptr_max){GodotRuntime.stringToHeap(GodotConfig.locale,p_ptr,p_ptr_max)}var GodotDisplayCursor={shape:"default",visible:true,cursors:{},set_style:function(style){GodotConfig.canvas.style.cursor=style},set_shape:function(shape){GodotDisplayCursor.shape=shape;let css=shape;if(shape in GodotDisplayCursor.cursors){const c=GodotDisplayCursor.cursors[shape];css=`url("${c.url}") ${c.x} ${c.y}, default`}if(GodotDisplayCursor.visible){GodotDisplayCursor.set_style(css)}},clear:function(){GodotDisplayCursor.set_style("");GodotDisplayCursor.shape="default";GodotDisplayCursor.visible=true;Object.keys(GodotDisplayCursor.cursors).forEach(function(key){URL.revokeObjectURL(GodotDisplayCursor.cursors[key]);delete GodotDisplayCursor.cursors[key]})},lockPointer:function(){const canvas=GodotConfig.canvas;if(canvas.requestPointerLock){canvas.requestPointerLock()}},releasePointer:function(){if(document.exitPointerLock){document.exitPointerLock()}},isPointerLocked:function(){return document.pointerLockElement===GodotConfig.canvas}};var GodotEventListeners={handlers:[],has:function(target,event,method,capture){return GodotEventListeners.handlers.findIndex(function(e){return e.target===target&&e.event===event&&e.method===method&&e.capture===capture})!==-1},add:function(target,event,method,capture){if(GodotEventListeners.has(target,event,method,capture)){return}function Handler(p_target,p_event,p_method,p_capture){this.target=p_target;this.event=p_event;this.method=p_method;this.capture=p_capture}GodotEventListeners.handlers.push(new Handler(target,event,method,capture));target.addEventListener(event,method,capture)},clear:function(){GodotEventListeners.handlers.forEach(function(h){h.target.removeEventListener(h.event,h.method,h.capture)});GodotEventListeners.handlers.length=0}};var _emscripten_webgl_do_get_current_context=()=>GL.currentContext?GL.currentContext.handle:0;var _emscripten_webgl_get_current_context=_emscripten_webgl_do_get_current_context;var GodotDisplayScreen={desired_size:[0,0],hidpi:true,getPixelRatio:function(){return GodotDisplayScreen.hidpi?window.devicePixelRatio||1:1},isFullscreen:function(){const elem=document.fullscreenElement||document.mozFullscreenElement||document.webkitFullscreenElement||document.msFullscreenElement;if(elem){return elem===GodotConfig.canvas}return document.fullscreen||document.mozFullScreen||document.webkitIsFullscreen},hasFullscreen:function(){return document.fullscreenEnabled||document.mozFullScreenEnabled||document.webkitFullscreenEnabled},requestFullscreen:function(){if(!GodotDisplayScreen.hasFullscreen()){return 1}const canvas=GodotConfig.canvas;try{const promise=(canvas.requestFullscreen||canvas.msRequestFullscreen||canvas.mozRequestFullScreen||canvas.mozRequestFullscreen||canvas.webkitRequestFullscreen).call(canvas);if(promise){promise.catch(function(){})}}catch(e){return 1}return 0},exitFullscreen:function(){if(!GodotDisplayScreen.isFullscreen()){return 0}try{const promise=document.exitFullscreen();if(promise){promise.catch(function(){})}}catch(e){return 1}return 0},_updateGL:function(){const gl_context_handle=_emscripten_webgl_get_current_context();const gl=GL.getContext(gl_context_handle);if(gl){GL.resizeOffscreenFramebuffer(gl)}},updateSize:function(){const isFullscreen=GodotDisplayScreen.isFullscreen();const wantsFullWindow=GodotConfig.canvas_resize_policy===2;const noResize=GodotConfig.canvas_resize_policy===0;const dWidth=GodotDisplayScreen.desired_size[0];const dHeight=GodotDisplayScreen.desired_size[1];const canvas=GodotConfig.canvas;let width=dWidth;let height=dHeight;if(noResize){if(canvas.width!==width||canvas.height!==height){GodotDisplayScreen.desired_size=[canvas.width,canvas.height];GodotDisplayScreen._updateGL();return 1}return 0}const scale=GodotDisplayScreen.getPixelRatio();if(isFullscreen||wantsFullWindow){width=Math.floor(window.innerWidth*scale);height=Math.floor(window.innerHeight*scale)}const csw=`${Math.floor(width/scale)}px`;const csh=`${Math.floor(height/scale)}px`;if(canvas.style.width!==csw||canvas.style.height!==csh||canvas.width!==width||canvas.height!==height){canvas.width=width;canvas.height=height;canvas.style.width=csw;canvas.style.height=csh;GodotDisplayScreen._updateGL();return 1}return 0}};var GodotInputGamepads={samples:[],get_pads:function(){try{const pads=navigator.getGamepads();if(pads){return pads}return[]}catch(e){return[]}},get_samples:function(){return GodotInputGamepads.samples},get_sample:function(index){const samples=GodotInputGamepads.samples;return index<samples.length?samples[index]:null},sample:function(){const pads=GodotInputGamepads.get_pads();const samples=[];for(let i=0;i<pads.length;i++){const pad=pads[i];if(!pad){samples.push(null);continue}const s={standard:pad.mapping==="standard",buttons:[],axes:[],connected:pad.connected};for(let b=0;b<pad.buttons.length;b++){s.buttons.push(pad.buttons[b].value)}for(let a=0;a<pad.axes.length;a++){s.axes.push(pad.axes[a])}samples.push(s)}GodotInputGamepads.samples=samples},init:function(onchange){GodotInputGamepads.samples=[];function add(pad){const guid=GodotInputGamepads.get_guid(pad);const c_id=GodotRuntime.allocString(pad.id);const c_guid=GodotRuntime.allocString(guid);onchange(pad.index,1,c_id,c_guid);GodotRuntime.free(c_id);GodotRuntime.free(c_guid)}const pads=GodotInputGamepads.get_pads();for(let i=0;i<pads.length;i++){if(pads[i]){add(pads[i])}}GodotEventListeners.add(window,"gamepadconnected",function(evt){if(evt.gamepad){add(evt.gamepad)}},false);GodotEventListeners.add(window,"gamepaddisconnected",function(evt){if(evt.gamepad){onchange(evt.gamepad.index,0)}},false)},get_guid:function(pad){if(pad.mapping){return pad.mapping}const ua=navigator.userAgent;let os="Unknown";if(ua.indexOf("Android")>=0){os="Android"}else if(ua.indexOf("Linux")>=0){os="Linux"}else if(ua.indexOf("iPhone")>=0){os="iOS"}else if(ua.indexOf("Macintosh")>=0){os="MacOSX"}else if(ua.indexOf("Windows")>=0){os="Windows"}const id=pad.id;const exp1=/vendor: ([0-9a-f]{4}) product: ([0-9a-f]{4})/i;const exp2=/^([0-9a-f]+)-([0-9a-f]+)-/i;let vendor="";let product="";if(exp1.test(id)){const match=exp1.exec(id);vendor=match[1].padStart(4,"0");product=match[2].padStart(4,"0")}else if(exp2.test(id)){const match=exp2.exec(id);vendor=match[1].padStart(4,"0");product=match[2].padStart(4,"0")}if(!vendor||!product){return`${os}Unknown`}return os+vendor+product}};var GodotInputDragDrop={promises:[],pending_files:[],add_entry:function(entry){if(entry.isDirectory){GodotInputDragDrop.add_dir(entry)}else if(entry.isFile){GodotInputDragDrop.add_file(entry)}else{GodotRuntime.error("Unrecognized entry...",entry)}},add_dir:function(entry){GodotInputDragDrop.promises.push(new Promise(function(resolve,reject){const reader=entry.createReader();reader.readEntries(function(entries){for(let i=0;i<entries.length;i++){GodotInputDragDrop.add_entry(entries[i])}resolve()})}))},add_file:function(entry){GodotInputDragDrop.promises.push(new Promise(function(resolve,reject){entry.file(function(file){const reader=new FileReader;reader.onload=function(){const f={path:file.relativePath||file.webkitRelativePath,name:file.name,type:file.type,size:file.size,data:reader.result};if(!f["path"]){f["path"]=f["name"]}GodotInputDragDrop.pending_files.push(f);resolve()};reader.onerror=function(){GodotRuntime.print("Error reading file");reject()};reader.readAsArrayBuffer(file)},function(err){GodotRuntime.print("Error!");reject()})}))},process:function(resolve,reject){if(GodotInputDragDrop.promises.length===0){resolve();return}GodotInputDragDrop.promises.pop().then(function(){setTimeout(function(){GodotInputDragDrop.process(resolve,reject)},0)})},_process_event:function(ev,callback){ev.preventDefault();if(ev.dataTransfer.items){for(let i=0;i<ev.dataTransfer.items.length;i++){const item=ev.dataTransfer.items[i];let entry=null;if("getAsEntry"in item){entry=item.getAsEntry()}else if("webkitGetAsEntry"in item){entry=item.webkitGetAsEntry()}if(entry){GodotInputDragDrop.add_entry(entry)}}}else{GodotRuntime.error("File upload not supported")}new Promise(GodotInputDragDrop.process).then(function(){const DROP=`/tmp/drop-${parseInt(Math.random()*(1<<30),10)}/`;const drops=[];const files=[];FS.mkdir(DROP.slice(0,-1));GodotInputDragDrop.pending_files.forEach(elem=>{const path=elem["path"];GodotFS.copy_to_fs(DROP+path,elem["data"]);let idx=path.indexOf("/");if(idx===-1){drops.push(DROP+path)}else{const sub=path.substr(0,idx);idx=sub.indexOf("/");if(idx<0&&drops.indexOf(DROP+sub)===-1){drops.push(DROP+sub)}}files.push(DROP+path)});GodotInputDragDrop.promises=[];GodotInputDragDrop.pending_files=[];callback(drops);if(GodotConfig.persistent_drops){GodotOS.atexit(function(resolve,reject){GodotInputDragDrop.remove_drop(files,DROP);resolve()})}else{GodotInputDragDrop.remove_drop(files,DROP)}})},remove_drop:function(files,drop_path){const dirs=[drop_path.substr(0,drop_path.length-1)];files.forEach(function(file){FS.unlink(file);let dir=file.replace(drop_path,"");let idx=dir.lastIndexOf("/");while(idx>0){dir=dir.substr(0,idx);if(dirs.indexOf(drop_path+dir)===-1){dirs.push(drop_path+dir)}idx=dir.lastIndexOf("/")}});dirs.sort(function(a,b){const al=(a.match(/\//g)||[]).length;const bl=(b.match(/\//g)||[]).length;if(al>bl){return-1}else if(al<bl){return 1}return 0}).forEach(function(dir){FS.rmdir(dir)})},handler:function(callback){return function(ev){GodotInputDragDrop._process_event(ev,callback)}}};var GodotIME={ime:null,active:false,focusTimerIntervalId:-1,getModifiers:function(evt){return evt.shiftKey+0+(evt.altKey+0<<1)+(evt.ctrlKey+0<<2)+(evt.metaKey+0<<3)},ime_active:function(active){function clearFocusTimerInterval(){clearInterval(GodotIME.focusTimerIntervalId);GodotIME.focusTimerIntervalId=-1}function focusTimer(){if(GodotIME.ime==null){clearFocusTimerInterval();return}GodotIME.ime.focus()}if(GodotIME.focusTimerIntervalId>-1){clearFocusTimerInterval()}if(GodotIME.ime==null){return}GodotIME.active=active;if(active){GodotIME.ime.style.display="block";GodotIME.focusTimerIntervalId=setInterval(focusTimer,100)}else{GodotIME.ime.style.display="none";GodotConfig.canvas.focus()}},ime_position:function(x,y){if(GodotIME.ime==null){return}const canvas=GodotConfig.canvas;const rect=canvas.getBoundingClientRect();const rw=canvas.width/rect.width;const rh=canvas.height/rect.height;const clx=x/rw+rect.x;const cly=y/rh+rect.y;GodotIME.ime.style.left=`${clx}px`;GodotIME.ime.style.top=`${cly}px`},init:function(ime_cb,key_cb,code,key){function key_event_cb(pressed,evt){const modifiers=GodotIME.getModifiers(evt);GodotRuntime.stringToHeap(evt.code,code,32);GodotRuntime.stringToHeap(evt.key,key,32);key_cb(pressed,evt.repeat,modifiers);evt.preventDefault()}function ime_event_cb(event){if(GodotIME.ime==null){return}switch(event.type){case"compositionstart":ime_cb(0,null);GodotIME.ime.innerHTML="";break;case"compositionupdate":{const ptr=GodotRuntime.allocString(event.data);ime_cb(1,ptr);GodotRuntime.free(ptr)}break;case"compositionend":{const ptr=GodotRuntime.allocString(event.data);ime_cb(2,ptr);GodotRuntime.free(ptr);GodotIME.ime.innerHTML=""}break;default:}}const ime=document.createElement("div");ime.className="ime";ime.style.background="none";ime.style.opacity=0;ime.style.position="fixed";ime.style.textAlign="left";ime.style.fontSize="1px";ime.style.left="0px";ime.style.top="0px";ime.style.width="100%";ime.style.height="40px";ime.style.pointerEvents="none";ime.style.display="none";ime.contentEditable="true";GodotEventListeners.add(ime,"compositionstart",ime_event_cb,false);GodotEventListeners.add(ime,"compositionupdate",ime_event_cb,false);GodotEventListeners.add(ime,"compositionend",ime_event_cb,false);GodotEventListeners.add(ime,"keydown",key_event_cb.bind(null,1),false);GodotEventListeners.add(ime,"keyup",key_event_cb.bind(null,0),false);ime.onblur=function(){this.style.display="none";GodotConfig.canvas.focus();GodotIME.active=false};GodotConfig.canvas.parentElement.appendChild(ime);GodotIME.ime=ime},clear:function(){if(GodotIME.ime==null){return}if(GodotIME.focusTimerIntervalId>-1){clearInterval(GodotIME.focusTimerIntervalId);GodotIME.focusTimerIntervalId=-1}GodotIME.ime.remove();GodotIME.ime=null}};var GodotInput={inputKeyCallback:null,setInputKeyData:null,getModifiers:function(evt){return evt.shiftKey+0+(evt.altKey+0<<1)+(evt.ctrlKey+0<<2)+(evt.metaKey+0<<3)},computePosition:function(evt,rect){const canvas=GodotConfig.canvas;const rw=canvas.width/rect.width;const rh=canvas.height/rect.height;const x=(evt.clientX-rect.x)*rw;const y=(evt.clientY-rect.y)*rh;return[x,y]},onKeyEvent:function(pIsPressed,pEvent){if(GodotInput.inputKeyCallback==null){throw new TypeError("GodotInput.onKeyEvent(): GodotInput.inputKeyCallback is null, cannot process key event.")}if(GodotInput.setInputKeyData==null){throw new TypeError("GodotInput.onKeyEvent(): GodotInput.setInputKeyData is null, cannot process key event.")}const modifiers=GodotInput.getModifiers(pEvent);GodotInput.setInputKeyData(pEvent.code,pEvent.key);GodotInput.inputKeyCallback(pIsPressed?1:0,pEvent.repeat,modifiers);pEvent.preventDefault()}};var GodotDisplayVK={textinput:null,textarea:null,available:function(){return GodotConfig.virtual_keyboard&&"ontouchstart"in window},init:function(input_cb){function create(what){const elem=document.createElement(what);elem.style.display="none";elem.style.position="absolute";elem.style.zIndex="-1";elem.style.background="transparent";elem.style.padding="0px";elem.style.margin="0px";elem.style.overflow="hidden";elem.style.width="0px";elem.style.height="0px";elem.style.border="0px";elem.style.outline="none";elem.readonly=true;elem.disabled=true;GodotEventListeners.add(elem,"input",function(evt){const c_str=GodotRuntime.allocString(elem.value);input_cb(c_str,elem.selectionEnd);GodotRuntime.free(c_str)},false);if(what==="input"){const onKey=(pEvent,pEventName)=>{if(pEvent.key!=="Enter"){return}GodotInput.onKeyEvent(pEventName==="keydown",pEvent)};GodotEventListeners.add(elem,"keydown",pEvent=>onKey(pEvent,"keydown"),false);GodotEventListeners.add(elem,"keyup",pEvent=>onKey(pEvent,"keyup"),false)}GodotEventListeners.add(elem,"blur",function(evt){elem.style.display="none";elem.readonly=true;elem.disabled=true},false);GodotConfig.canvas.insertAdjacentElement("beforebegin",elem);return elem}GodotDisplayVK.textinput=create("input");GodotDisplayVK.textarea=create("textarea");GodotDisplayVK.updateSize()},show:function(text,type,start,end){if(!GodotDisplayVK.textinput||!GodotDisplayVK.textarea){return}if(GodotDisplayVK.textinput.style.display!==""||GodotDisplayVK.textarea.style.display!==""){GodotDisplayVK.hide()}GodotDisplayVK.updateSize();let elem=GodotDisplayVK.textinput;switch(type){case 0:elem.type="text";elem.inputmode="";break;case 1:elem=GodotDisplayVK.textarea;break;case 2:elem.type="text";elem.inputmode="numeric";break;case 3:elem.type="text";elem.inputmode="decimal";break;case 4:elem.type="tel";elem.inputmode="";break;case 5:elem.type="email";elem.inputmode="";break;case 6:elem.type="password";elem.inputmode="";break;case 7:elem.type="url";elem.inputmode="";break;default:elem.type="text";elem.inputmode="";break}elem.readonly=false;elem.disabled=false;elem.value=text;elem.style.display="block";elem.focus();elem.setSelectionRange(start,end)},hide:function(){if(!GodotDisplayVK.textinput||!GodotDisplayVK.textarea){return}[GodotDisplayVK.textinput,GodotDisplayVK.textarea].forEach(function(elem){elem.blur();elem.style.display="none";elem.value=""})},updateSize:function(){if(!GodotDisplayVK.textinput||!GodotDisplayVK.textarea){return}const rect=GodotConfig.canvas.getBoundingClientRect();function update(elem){elem.style.left=`${rect.left}px`;elem.style.top=`${rect.top}px`;elem.style.width=`${rect.width}px`;elem.style.height=`${rect.height}px`}update(GodotDisplayVK.textinput);update(GodotDisplayVK.textarea)},clear:function(){if(GodotDisplayVK.textinput){GodotDisplayVK.textinput.remove();GodotDisplayVK.textinput=null}if(GodotDisplayVK.textarea){GodotDisplayVK.textarea.remove();GodotDisplayVK.textarea=null}}};var GodotDisplay={window_icon:"",getDPI:function(){const dpi=Math.round(window.devicePixelRatio*96);return dpi>=96?dpi:96}};function _godot_js_display_alert(p_text){window.alert(GodotRuntime.parseString(p_text))}function _godot_js_display_canvas_focus(){GodotConfig.canvas.focus()}function _godot_js_display_canvas_is_focused(){return document.activeElement===GodotConfig.canvas}function _godot_js_display_clipboard_get(callback){const func=GodotRuntime.get_func(callback);try{navigator.clipboard.readText().then(function(result){const ptr=GodotRuntime.allocString(result);func(ptr);GodotRuntime.free(ptr)}).catch(function(e){})}catch(e){}}function _godot_js_display_clipboard_set(p_text){const text=GodotRuntime.parseString(p_text);if(!navigator.clipboard||!navigator.clipboard.writeText){return 1}navigator.clipboard.writeText(text).catch(function(e){GodotRuntime.error("Setting OS clipboard is only possible from an input callback for the Web platform. Exception:",e)});return 0}function _godot_js_display_cursor_is_hidden(){return!GodotDisplayCursor.visible}function _godot_js_display_cursor_is_locked(){return GodotDisplayCursor.isPointerLocked()?1:0}function _godot_js_display_cursor_lock_set(p_lock){if(p_lock){GodotDisplayCursor.lockPointer()}else{GodotDisplayCursor.releasePointer()}}function _godot_js_display_cursor_set_custom_shape(p_shape,p_ptr,p_len,p_hotspot_x,p_hotspot_y){const shape=GodotRuntime.parseString(p_shape);const old_shape=GodotDisplayCursor.cursors[shape];if(p_len>0){const png=new Blob([GodotRuntime.heapSlice(HEAPU8,p_ptr,p_len)],{type:"image/png"});const url=URL.createObjectURL(png);GodotDisplayCursor.cursors[shape]={url,x:p_hotspot_x,y:p_hotspot_y}}else{delete GodotDisplayCursor.cursors[shape]}if(shape===GodotDisplayCursor.shape){GodotDisplayCursor.set_shape(GodotDisplayCursor.shape)}if(old_shape){URL.revokeObjectURL(old_shape.url)}}function _godot_js_display_cursor_set_shape(p_string){GodotDisplayCursor.set_shape(GodotRuntime.parseString(p_string))}function _godot_js_display_cursor_set_visible(p_visible){const visible=p_visible!==0;if(visible===GodotDisplayCursor.visible){return}GodotDisplayCursor.visible=visible;if(visible){GodotDisplayCursor.set_shape(GodotDisplayCursor.shape)}else{GodotDisplayCursor.set_style("none")}}function _godot_js_display_desired_size_set(width,height){GodotDisplayScreen.desired_size=[width,height];GodotDisplayScreen.updateSize()}function _godot_js_display_fullscreen_cb(callback){const canvas=GodotConfig.canvas;const func=GodotRuntime.get_func(callback);function change_cb(evt){if(evt.target===canvas){func(GodotDisplayScreen.isFullscreen())}}GodotEventListeners.add(document,"fullscreenchange",change_cb,false);GodotEventListeners.add(document,"mozfullscreenchange",change_cb,false);GodotEventListeners.add(document,"webkitfullscreenchange",change_cb,false)}function _godot_js_display_fullscreen_exit(){return GodotDisplayScreen.exitFullscreen()}function _godot_js_display_fullscreen_request(){return GodotDisplayScreen.requestFullscreen()}function _godot_js_display_has_webgl(p_version){if(p_version!==1&&p_version!==2){return false}try{return!!document.createElement("canvas").getContext(p_version===2?"webgl2":"webgl")}catch(e){}return false}function _godot_js_display_is_swap_ok_cancel(){const win=["Windows","Win64","Win32","WinCE"];const plat=navigator.platform||"";if(win.indexOf(plat)!==-1){return 1}return 0}function _godot_js_display_notification_cb(callback,p_enter,p_exit,p_in,p_out){const canvas=GodotConfig.canvas;const func=GodotRuntime.get_func(callback);const notif=[p_enter,p_exit,p_in,p_out];["mouseover","mouseleave","focus","blur"].forEach(function(evt_name,idx){GodotEventListeners.add(canvas,evt_name,function(){func(notif[idx])},true)})}function _godot_js_display_pixel_ratio_get(){return GodotDisplayScreen.getPixelRatio()}function _godot_js_display_screen_dpi_get(){return GodotDisplay.getDPI()}function _godot_js_display_screen_size_get(width,height){const scale=GodotDisplayScreen.getPixelRatio();GodotRuntime.setHeapValue(width,window.screen.width*scale,"i32");GodotRuntime.setHeapValue(height,window.screen.height*scale,"i32")}function _godot_js_display_setup_canvas(p_width,p_height,p_fullscreen,p_hidpi){const canvas=GodotConfig.canvas;GodotEventListeners.add(canvas,"contextmenu",function(ev){ev.preventDefault()},false);GodotEventListeners.add(canvas,"webglcontextlost",function(ev){alert("WebGL context lost, please reload the page");ev.preventDefault()},false);GodotDisplayScreen.hidpi=!!p_hidpi;switch(GodotConfig.canvas_resize_policy){case 0:GodotDisplayScreen.desired_size=[canvas.width,canvas.height];break;case 1:GodotDisplayScreen.desired_size=[p_width,p_height];break;default:canvas.style.position="absolute";canvas.style.top=0;canvas.style.left=0;break}GodotDisplayScreen.updateSize();if(p_fullscreen){GodotDisplayScreen.requestFullscreen()}}function _godot_js_display_size_update(){const updated=GodotDisplayScreen.updateSize();if(updated){GodotDisplayVK.updateSize()}return updated}function _godot_js_display_touchscreen_is_available(){return"ontouchstart"in window}function _godot_js_display_tts_available(){return"speechSynthesis"in window}function _godot_js_display_vk_available(){return GodotDisplayVK.available()}function _godot_js_display_vk_cb(p_input_cb){const input_cb=GodotRuntime.get_func(p_input_cb);if(GodotDisplayVK.available()){GodotDisplayVK.init(input_cb)}}function _godot_js_display_vk_hide(){GodotDisplayVK.hide()}function _godot_js_display_vk_show(p_text,p_type,p_start,p_end){const text=GodotRuntime.parseString(p_text);const start=p_start>0?p_start:0;const end=p_end>0?p_end:start;GodotDisplayVK.show(text,p_type,start,end)}function _godot_js_display_window_blur_cb(callback){const func=GodotRuntime.get_func(callback);GodotEventListeners.add(window,"blur",function(){func()},false)}function _godot_js_display_window_icon_set(p_ptr,p_len){let link=document.getElementById("-gd-engine-icon");const old_icon=GodotDisplay.window_icon;if(p_ptr){if(link===null){link=document.createElement("link");link.rel="icon";link.id="-gd-engine-icon";document.head.appendChild(link)}const png=new Blob([GodotRuntime.heapSlice(HEAPU8,p_ptr,p_len)],{type:"image/png"});GodotDisplay.window_icon=URL.createObjectURL(png);link.href=GodotDisplay.window_icon}else{if(link){link.remove()}GodotDisplay.window_icon=null}if(old_icon){URL.revokeObjectURL(old_icon)}}function _godot_js_display_window_size_get(p_width,p_height){GodotRuntime.setHeapValue(p_width,GodotConfig.canvas.width,"i32");GodotRuntime.setHeapValue(p_height,GodotConfig.canvas.height,"i32")}function _godot_js_display_window_title_set(p_data){document.title=GodotRuntime.parseString(p_data)}function _godot_js_emscripten_get_version(){const emscriptenVersionPtr=GodotRuntime.allocString("4.0.20");return emscriptenVersionPtr}function _godot_js_eval(p_js,p_use_global_ctx,p_union_ptr,p_byte_arr,p_byte_arr_write,p_callback){const js_code=GodotRuntime.parseString(p_js);let eval_ret=null;try{if(p_use_global_ctx){const global_eval=eval;eval_ret=global_eval(js_code)}else{eval_ret=eval(js_code)}}catch(e){GodotRuntime.error(e)}switch(typeof eval_ret){case"boolean":GodotRuntime.setHeapValue(p_union_ptr,eval_ret,"i32");return 1;case"number":GodotRuntime.setHeapValue(p_union_ptr,eval_ret,"double");return 3;case"string":GodotRuntime.setHeapValue(p_union_ptr,GodotRuntime.allocString(eval_ret),"*");return 4;case"object":if(eval_ret===null){break}if(ArrayBuffer.isView(eval_ret)&&!(eval_ret instanceof Uint8Array)){eval_ret=new Uint8Array(eval_ret.buffer)}else if(eval_ret instanceof ArrayBuffer){eval_ret=new Uint8Array(eval_ret)}if(eval_ret instanceof Uint8Array){const func=GodotRuntime.get_func(p_callback);const bytes_ptr=func(p_byte_arr,p_byte_arr_write,eval_ret.length);HEAPU8.set(eval_ret,bytes_ptr);return 29}break}return 0}var IDHandler={_last_id:0,_references:{},get:function(p_id){return IDHandler._references[p_id]},add:function(p_data){const id=++IDHandler._last_id;IDHandler._references[id]=p_data;return id},remove:function(p_id){delete IDHandler._references[p_id]}};var GodotFetch={onread:function(id,result){const obj=IDHandler.get(id);if(!obj){return}if(result.value){obj.chunks.push(result.value)}obj.reading=false;obj.done=result.done},onresponse:function(id,response){const obj=IDHandler.get(id);if(!obj){return}let chunked=false;response.headers.forEach(function(value,header){const v=value.toLowerCase().trim();const h=header.toLowerCase().trim();if(h==="transfer-encoding"&&v==="chunked"){chunked=true}});obj.status=response.status;obj.response=response;obj.reader=response.body?.getReader();obj.chunked=chunked},onerror:function(id,err){GodotRuntime.error(err);const obj=IDHandler.get(id);if(!obj){return}obj.error=err},create:function(method,url,headers,body){const obj={request:null,response:null,reader:null,error:null,done:false,reading:false,status:0,chunks:[]};const id=IDHandler.add(obj);const init={method,headers,body};obj.request=fetch(url,init);obj.request.then(GodotFetch.onresponse.bind(null,id)).catch(GodotFetch.onerror.bind(null,id));return id},free:function(id){const obj=IDHandler.get(id);if(!obj){return}IDHandler.remove(id);if(!obj.request){return}obj.request.then(function(response){response.abort()}).catch(function(e){})},read:function(id){const obj=IDHandler.get(id);if(!obj){return}if(obj.reader&&!obj.reading){if(obj.done){obj.reader=null;return}obj.reading=true;obj.reader.read().then(GodotFetch.onread.bind(null,id)).catch(GodotFetch.onerror.bind(null,id))}else if(obj.reader==null&&obj.response.body==null){obj.reading=true;GodotFetch.onread(id,{value:undefined,done:true})}}};function _godot_js_fetch_create(p_method,p_url,p_headers,p_headers_size,p_body,p_body_size){const method=GodotRuntime.parseString(p_method);const url=GodotRuntime.parseString(p_url);const headers=GodotRuntime.parseStringArray(p_headers,p_headers_size);const body=p_body_size?GodotRuntime.heapSlice(HEAP8,p_body,p_body_size):null;return GodotFetch.create(method,url,headers.map(function(hv){const idx=hv.indexOf(":");if(idx<=0){return[]}return[hv.slice(0,idx).trim(),hv.slice(idx+1).trim()]}).filter(function(v){return v.length===2}),body)}function _godot_js_fetch_free(id){GodotFetch.free(id)}function _godot_js_fetch_http_status_get(p_id){const obj=IDHandler.get(p_id);if(!obj||!obj.response){return 0}return obj.status}function _godot_js_fetch_is_chunked(p_id){const obj=IDHandler.get(p_id);if(!obj||!obj.response){return-1}return obj.chunked?1:0}function _godot_js_fetch_read_chunk(p_id,p_buf,p_buf_size){const obj=IDHandler.get(p_id);if(!obj||!obj.response){return 0}let to_read=p_buf_size;const chunks=obj.chunks;while(to_read&&chunks.length){const chunk=obj.chunks[0];if(chunk.length>to_read){GodotRuntime.heapCopy(HEAP8,chunk.slice(0,to_read),p_buf);chunks[0]=chunk.slice(to_read);to_read=0}else{GodotRuntime.heapCopy(HEAP8,chunk,p_buf);to_read-=chunk.length;chunks.pop()}}if(!chunks.length){GodotFetch.read(p_id)}return p_buf_size-to_read}function _godot_js_fetch_read_headers(p_id,p_parse_cb,p_ref){const obj=IDHandler.get(p_id);if(!obj||!obj.response){return 1}const cb=GodotRuntime.get_func(p_parse_cb);const arr=[];obj.response.headers.forEach(function(v,h){arr.push(`${h}:${v}`)});const c_ptr=GodotRuntime.allocStringArray(arr);cb(arr.length,c_ptr,p_ref);GodotRuntime.freeStringArray(c_ptr,arr.length);return 0}function _godot_js_fetch_state_get(p_id){const obj=IDHandler.get(p_id);if(!obj){return-1}if(obj.error){return-1}if(!obj.response){return 0}if(obj.reader||obj.response.body==null&&!obj.done){return 1}if(obj.done){return 2}return-1}function _godot_js_input_drop_files_cb(callback){const func=GodotRuntime.get_func(callback);const dropFiles=function(files){const args=files||[];if(!args.length){return}const argc=args.length;const argv=GodotRuntime.allocStringArray(args);func(argv,argc);GodotRuntime.freeStringArray(argv,argc)};const canvas=GodotConfig.canvas;GodotEventListeners.add(canvas,"dragover",function(ev){ev.preventDefault()},false);GodotEventListeners.add(canvas,"drop",GodotInputDragDrop.handler(dropFiles))}function _godot_js_input_gamepad_cb(change_cb){const onchange=GodotRuntime.get_func(change_cb);GodotInputGamepads.init(onchange)}function _godot_js_input_gamepad_sample(){GodotInputGamepads.sample();return 0}function _godot_js_input_gamepad_sample_count(){return GodotInputGamepads.get_samples().length}function _godot_js_input_gamepad_sample_get(p_index,r_btns,r_btns_num,r_axes,r_axes_num,r_standard){const sample=GodotInputGamepads.get_sample(p_index);if(!sample||!sample.connected){return 1}const btns=sample.buttons;const btns_len=btns.length<16?btns.length:16;for(let i=0;i<btns_len;i++){GodotRuntime.setHeapValue(r_btns+(i<<2),btns[i],"float")}GodotRuntime.setHeapValue(r_btns_num,btns_len,"i32");const axes=sample.axes;const axes_len=axes.length<10?axes.length:10;for(let i=0;i<axes_len;i++){GodotRuntime.setHeapValue(r_axes+(i<<2),axes[i],"float")}GodotRuntime.setHeapValue(r_axes_num,axes_len,"i32");const is_standard=sample.standard?1:0;GodotRuntime.setHeapValue(r_standard,is_standard,"i32");return 0}var _godot_js_input_key_cb=function(pCallback,pCodePtr,pKeyPtr){GodotInput.inputKeyCallback=GodotRuntime.get_func(pCallback);GodotInput.setInputKeyData=(pCode,pKey)=>{GodotRuntime.stringToHeap(pCode,pCodePtr,32);GodotRuntime.stringToHeap(pKey,pKeyPtr,32)};GodotEventListeners.add(GodotConfig.canvas,"keydown",GodotInput.onKeyEvent.bind(null,true),false);GodotEventListeners.add(GodotConfig.canvas,"keyup",GodotInput.onKeyEvent.bind(null,false),false)};function _godot_js_input_mouse_button_cb(callback){const func=GodotRuntime.get_func(callback);const canvas=GodotConfig.canvas;function button_cb(p_pressed,evt){const rect=canvas.getBoundingClientRect();const pos=GodotInput.computePosition(evt,rect);const modifiers=GodotInput.getModifiers(evt);if(p_pressed){GodotConfig.canvas.focus()}if(func(p_pressed,evt.button,pos[0],pos[1],modifiers)){evt.preventDefault()}}GodotEventListeners.add(canvas,"mousedown",button_cb.bind(null,1),false);GodotEventListeners.add(window,"mouseup",button_cb.bind(null,0),false)}function _godot_js_input_mouse_move_cb(callback){const func=GodotRuntime.get_func(callback);const canvas=GodotConfig.canvas;function move_cb(evt){const rect=canvas.getBoundingClientRect();const pos=GodotInput.computePosition(evt,rect);const rw=canvas.width/rect.width;const rh=canvas.height/rect.height;const rel_pos_x=evt.movementX*rw;const rel_pos_y=evt.movementY*rh;const modifiers=GodotInput.getModifiers(evt);func(pos[0],pos[1],rel_pos_x,rel_pos_y,modifiers,evt.pressure)}GodotEventListeners.add(window,"pointermove",move_cb,false)}function _godot_js_input_mouse_wheel_cb(callback){const func=GodotRuntime.get_func(callback);function wheel_cb(evt){if(func(evt.deltaMode,evt.deltaX??0,evt.deltaY??0)){evt.preventDefault()}}GodotEventListeners.add(GodotConfig.canvas,"wheel",wheel_cb,false)}function _godot_js_input_paste_cb(callback){const func=GodotRuntime.get_func(callback);GodotEventListeners.add(window,"paste",function(evt){const text=evt.clipboardData.getData("text");const ptr=GodotRuntime.allocString(text);func(ptr);GodotRuntime.free(ptr)},false)}function _godot_js_input_touch_cb(callback,ids,coords){const func=GodotRuntime.get_func(callback);const canvas=GodotConfig.canvas;function touch_cb(type,evt){if(type===0){GodotConfig.canvas.focus()}const rect=canvas.getBoundingClientRect();const touches=evt.changedTouches;for(let i=0;i<touches.length;i++){const touch=touches[i];const pos=GodotInput.computePosition(touch,rect);GodotRuntime.setHeapValue(coords+i*2*8,pos[0],"double");GodotRuntime.setHeapValue(coords+(i*2+1)*8,pos[1],"double");GodotRuntime.setHeapValue(ids+i*4,touch.identifier,"i32")}func(type,touches.length);if(evt.cancelable){evt.preventDefault()}}GodotEventListeners.add(canvas,"touchstart",touch_cb.bind(null,0),false);GodotEventListeners.add(canvas,"touchend",touch_cb.bind(null,1),false);GodotEventListeners.add(canvas,"touchcancel",touch_cb.bind(null,1),false);GodotEventListeners.add(canvas,"touchmove",touch_cb.bind(null,2),false)}function _godot_js_input_vibrate_handheld(p_duration_ms){if(typeof navigator.vibrate!=="function"){GodotRuntime.print("This browser does not support vibration.")}else{navigator.vibrate(p_duration_ms)}}function _godot_js_is_ime_focused(){return GodotIME.active}function _godot_js_os_download_buffer(p_ptr,p_size,p_name,p_mime){const buf=GodotRuntime.heapSlice(HEAP8,p_ptr,p_size);const name=GodotRuntime.parseString(p_name);const mime=GodotRuntime.parseString(p_mime);const blob=new Blob([buf],{type:mime});const url=window.URL.createObjectURL(blob);const a=document.createElement("a");a.href=url;a.download=name;a.style.display="none";document.body.appendChild(a);a.click();a.remove();window.URL.revokeObjectURL(url)}function _godot_js_os_execute(p_json){const json_args=GodotRuntime.parseString(p_json);const args=JSON.parse(json_args);if(GodotConfig.on_execute){GodotConfig.on_execute(args);return 0}return 1}function _godot_js_os_finish_async(p_callback){const func=GodotRuntime.get_func(p_callback);GodotOS.finish_async(func)}function _godot_js_os_fs_is_persistent(){return GodotFS.is_persistent()}function _godot_js_os_fs_sync(callback){const func=GodotRuntime.get_func(callback);GodotOS._fs_sync_promise=GodotFS.sync();GodotOS._fs_sync_promise.then(function(err){func()})}function _godot_js_os_has_feature(p_ftr){const ftr=GodotRuntime.parseString(p_ftr);const ua=navigator.userAgent;if(ftr==="web_macos"){return ua.indexOf("Mac")!==-1?1:0}if(ftr==="web_windows"){return ua.indexOf("Windows")!==-1?1:0}if(ftr==="web_android"){return ua.indexOf("Android")!==-1?1:0}if(ftr==="web_ios"){return ua.indexOf("iPhone")!==-1||ua.indexOf("iPad")!==-1||ua.indexOf("iPod")!==-1?1:0}if(ftr==="web_linuxbsd"){return ua.indexOf("CrOS")!==-1||ua.indexOf("BSD")!==-1||ua.indexOf("Linux")!==-1||ua.indexOf("X11")!==-1?1:0}return 0}function _godot_js_os_hw_concurrency_get(){const concurrency=navigator.hardwareConcurrency||1;return concurrency<2?concurrency:2}function _godot_js_os_request_quit_cb(p_callback){GodotOS.request_quit=GodotRuntime.get_func(p_callback)}function _godot_js_os_shell_open(p_uri){window.open(GodotRuntime.parseString(p_uri),"_blank")}var GodotPWA={hasUpdate:false,updateState:function(cb,reg){if(!reg){return}if(!reg.active){return}if(reg.waiting){GodotPWA.hasUpdate=true;cb()}GodotEventListeners.add(reg,"updatefound",function(){const installing=reg.installing;GodotEventListeners.add(installing,"statechange",function(){if(installing.state==="installed"){GodotPWA.hasUpdate=true;cb()}})})}};function _godot_js_pwa_cb(p_update_cb){if("serviceWorker"in navigator){try{const cb=GodotRuntime.get_func(p_update_cb);navigator.serviceWorker.getRegistration().then(GodotPWA.updateState.bind(null,cb))}catch(e){GodotRuntime.error("Failed to assign PWA callback",e)}}}function _godot_js_pwa_update(){if("serviceWorker"in navigator&&GodotPWA.hasUpdate){try{navigator.serviceWorker.getRegistration().then(function(reg){if(!reg||!reg.waiting){return}reg.waiting.postMessage("update")})}catch(e){GodotRuntime.error(e);return 1}return 0}return 1}var GodotRTCDataChannel={connect:function(p_id,p_on_open,p_on_message,p_on_error,p_on_close){const ref=IDHandler.get(p_id);if(!ref){return}ref.binaryType="arraybuffer";ref.onopen=function(event){p_on_open()};ref.onclose=function(event){p_on_close()};ref.onerror=function(event){p_on_error()};ref.onmessage=function(event){let buffer;let is_string=0;if(event.data instanceof ArrayBuffer){buffer=new Uint8Array(event.data)}else if(event.data instanceof Blob){GodotRuntime.error("Blob type not supported");return}else if(typeof event.data==="string"){is_string=1;const enc=new TextEncoder("utf-8");buffer=new Uint8Array(enc.encode(event.data))}else{GodotRuntime.error("Unknown message type");return}const len=buffer.length*buffer.BYTES_PER_ELEMENT;const out=GodotRuntime.malloc(len);HEAPU8.set(buffer,out);p_on_message(out,len,is_string);GodotRuntime.free(out)}},close:function(p_id){const ref=IDHandler.get(p_id);if(!ref){return}ref.onopen=null;ref.onmessage=null;ref.onerror=null;ref.onclose=null;ref.close()},get_prop:function(p_id,p_prop,p_def){const ref=IDHandler.get(p_id);return ref&&ref[p_prop]!==undefined?ref[p_prop]:p_def}};function _godot_js_rtc_datachannel_close(p_id){const ref=IDHandler.get(p_id);if(!ref){return}GodotRTCDataChannel.close(p_id)}function _godot_js_rtc_datachannel_connect(p_id,p_ref,p_on_open,p_on_message,p_on_error,p_on_close){const onopen=GodotRuntime.get_func(p_on_open).bind(null,p_ref);const onmessage=GodotRuntime.get_func(p_on_message).bind(null,p_ref);const onerror=GodotRuntime.get_func(p_on_error).bind(null,p_ref);const onclose=GodotRuntime.get_func(p_on_close).bind(null,p_ref);GodotRTCDataChannel.connect(p_id,onopen,onmessage,onerror,onclose)}function _godot_js_rtc_datachannel_destroy(p_id){GodotRTCDataChannel.close(p_id);IDHandler.remove(p_id)}function _godot_js_rtc_datachannel_get_buffered_amount(p_id){return GodotRTCDataChannel.get_prop(p_id,"bufferedAmount",0)}function _godot_js_rtc_datachannel_id_get(p_id){return GodotRTCDataChannel.get_prop(p_id,"id",65535)}function _godot_js_rtc_datachannel_is_negotiated(p_id){return GodotRTCDataChannel.get_prop(p_id,"negotiated",65535)}function _godot_js_rtc_datachannel_is_ordered(p_id){return GodotRTCDataChannel.get_prop(p_id,"ordered",true)}function _godot_js_rtc_datachannel_label_get(p_id){const ref=IDHandler.get(p_id);if(!ref||!ref.label){return 0}return GodotRuntime.allocString(ref.label)}function _godot_js_rtc_datachannel_max_packet_lifetime_get(p_id){const ref=IDHandler.get(p_id);if(!ref){return 65535}if(ref["maxPacketLifeTime"]!==undefined){return ref["maxPacketLifeTime"]}else if(ref["maxRetransmitTime"]!==undefined){return ref["maxRetransmitTime"]}return 65535}function _godot_js_rtc_datachannel_max_retransmits_get(p_id){return GodotRTCDataChannel.get_prop(p_id,"maxRetransmits",65535)}function _godot_js_rtc_datachannel_protocol_get(p_id){const ref=IDHandler.get(p_id);if(!ref||!ref.protocol){return 0}return GodotRuntime.allocString(ref.protocol)}function _godot_js_rtc_datachannel_ready_state_get(p_id){const ref=IDHandler.get(p_id);if(!ref){return 3}switch(ref.readyState){case"connecting":return 0;case"open":return 1;case"closing":return 2;case"closed":default:return 3}}function _godot_js_rtc_datachannel_send(p_id,p_buffer,p_length,p_raw){const ref=IDHandler.get(p_id);if(!ref){return 1}const bytes_array=new Uint8Array(p_length);for(let i=0;i<p_length;i++){bytes_array[i]=GodotRuntime.getHeapValue(p_buffer+i,"i8")}if(p_raw){ref.send(bytes_array.buffer)}else{const string=new TextDecoder("utf-8").decode(bytes_array);ref.send(string)}return 0}var GodotRTCPeerConnection={ConnectionState:{new:0,connecting:1,connected:2,disconnected:3,failed:4,closed:5},ConnectionStateCompat:{new:0,checking:1,connected:2,completed:2,disconnected:3,failed:4,closed:5},IceGatheringState:{new:0,gathering:1,complete:2},SignalingState:{stable:0,"have-local-offer":1,"have-remote-offer":2,"have-local-pranswer":3,"have-remote-pranswer":4,closed:5},create:function(config,onConnectionChange,onSignalingChange,onIceGatheringChange,onIceCandidate,onDataChannel){let conn=null;try{conn=new RTCPeerConnection(config)}catch(e){GodotRuntime.error(e);return 0}const id=IDHandler.add(conn);if("connectionState"in conn&&conn["connectionState"]!==undefined){conn.onconnectionstatechange=function(event){if(!IDHandler.get(id)){return}onConnectionChange(GodotRTCPeerConnection.ConnectionState[conn.connectionState]||0)}}else{conn.oniceconnectionstatechange=function(event){if(!IDHandler.get(id)){return}onConnectionChange(GodotRTCPeerConnection.ConnectionStateCompat[conn.iceConnectionState]||0)}}conn.onicegatheringstatechange=function(event){if(!IDHandler.get(id)){return}onIceGatheringChange(GodotRTCPeerConnection.IceGatheringState[conn.iceGatheringState]||0)};conn.onsignalingstatechange=function(event){if(!IDHandler.get(id)){return}onSignalingChange(GodotRTCPeerConnection.SignalingState[conn.signalingState]||0)};conn.onicecandidate=function(event){if(!IDHandler.get(id)){return}const c=event.candidate;if(!c||!c.candidate){return}const candidate_str=GodotRuntime.allocString(c.candidate);const mid_str=GodotRuntime.allocString(c.sdpMid);onIceCandidate(mid_str,c.sdpMLineIndex,candidate_str);GodotRuntime.free(candidate_str);GodotRuntime.free(mid_str)};conn.ondatachannel=function(event){if(!IDHandler.get(id)){return}const cid=IDHandler.add(event.channel);onDataChannel(cid)};return id},destroy:function(p_id){const conn=IDHandler.get(p_id);if(!conn){return}conn.onconnectionstatechange=null;conn.oniceconnectionstatechange=null;conn.onicegatheringstatechange=null;conn.onsignalingstatechange=null;conn.onicecandidate=null;conn.ondatachannel=null;IDHandler.remove(p_id)},onsession:function(p_id,callback,session){if(!IDHandler.get(p_id)){return}const type_str=GodotRuntime.allocString(session.type);const sdp_str=GodotRuntime.allocString(session.sdp);callback(type_str,sdp_str);GodotRuntime.free(type_str);GodotRuntime.free(sdp_str)},onerror:function(p_id,callback,error){const ref=IDHandler.get(p_id);if(!ref){return}GodotRuntime.error(error);callback()}};function _godot_js_rtc_pc_close(p_id){const ref=IDHandler.get(p_id);if(!ref){return}ref.close()}function _godot_js_rtc_pc_create(p_config,p_ref,p_on_connection_state_change,p_on_ice_gathering_state_change,p_on_signaling_state_change,p_on_ice_candidate,p_on_datachannel){const wrap=function(p_func){return GodotRuntime.get_func(p_func).bind(null,p_ref)};return GodotRTCPeerConnection.create(JSON.parse(GodotRuntime.parseString(p_config)),wrap(p_on_connection_state_change),wrap(p_on_signaling_state_change),wrap(p_on_ice_gathering_state_change),wrap(p_on_ice_candidate),wrap(p_on_datachannel))}function _godot_js_rtc_pc_datachannel_create(p_id,p_label,p_config){try{const ref=IDHandler.get(p_id);if(!ref){return 0}const label=GodotRuntime.parseString(p_label);const config=JSON.parse(GodotRuntime.parseString(p_config));const channel=ref.createDataChannel(label,config);return IDHandler.add(channel)}catch(e){GodotRuntime.error(e);return 0}}function _godot_js_rtc_pc_destroy(p_id){GodotRTCPeerConnection.destroy(p_id)}function _godot_js_rtc_pc_ice_candidate_add(p_id,p_mid_name,p_mline_idx,p_sdp){const ref=IDHandler.get(p_id);if(!ref){return}const sdpMidName=GodotRuntime.parseString(p_mid_name);const sdpName=GodotRuntime.parseString(p_sdp);ref.addIceCandidate(new RTCIceCandidate({candidate:sdpName,sdpMid:sdpMidName,sdpMlineIndex:p_mline_idx}))}function _godot_js_rtc_pc_local_description_set(p_id,p_type,p_sdp,p_obj,p_on_error){const ref=IDHandler.get(p_id);if(!ref){return}const type=GodotRuntime.parseString(p_type);const sdp=GodotRuntime.parseString(p_sdp);const onerror=GodotRuntime.get_func(p_on_error).bind(null,p_obj);ref.setLocalDescription({sdp,type}).catch(function(error){GodotRTCPeerConnection.onerror(p_id,onerror,error)})}function _godot_js_rtc_pc_offer_create(p_id,p_obj,p_on_session,p_on_error){const ref=IDHandler.get(p_id);if(!ref){return}const onsession=GodotRuntime.get_func(p_on_session).bind(null,p_obj);const onerror=GodotRuntime.get_func(p_on_error).bind(null,p_obj);ref.createOffer().then(function(session){GodotRTCPeerConnection.onsession(p_id,onsession,session)}).catch(function(error){GodotRTCPeerConnection.onerror(p_id,onerror,error)})}function _godot_js_rtc_pc_remote_description_set(p_id,p_type,p_sdp,p_obj,p_session_created,p_on_error){const ref=IDHandler.get(p_id);if(!ref){return}const type=GodotRuntime.parseString(p_type);const sdp=GodotRuntime.parseString(p_sdp);const onerror=GodotRuntime.get_func(p_on_error).bind(null,p_obj);const onsession=GodotRuntime.get_func(p_session_created).bind(null,p_obj);ref.setRemoteDescription({sdp,type}).then(function(){if(type!=="offer"){return Promise.resolve()}return ref.createAnswer().then(function(session){GodotRTCPeerConnection.onsession(p_id,onsession,session)})}).catch(function(error){GodotRTCPeerConnection.onerror(p_id,onerror,error)})}function _godot_js_set_ime_active(p_active){GodotIME.ime_active(p_active)}function _godot_js_set_ime_cb(p_ime_cb,p_key_cb,code,key){const ime_cb=GodotRuntime.get_func(p_ime_cb);const key_cb=GodotRuntime.get_func(p_key_cb);GodotIME.init(ime_cb,key_cb,code,key)}function _godot_js_set_ime_position(p_x,p_y){GodotIME.ime_position(p_x,p_y)}function _godot_js_tts_get_voices(p_callback){const func=GodotRuntime.get_func(p_callback);try{const arr=[];const voices=window.speechSynthesis.getVoices();for(let i=0;i<voices.length;i++){arr.push(`${voices[i].lang};${voices[i].name}`)}const c_ptr=GodotRuntime.allocStringArray(arr);func(arr.length,c_ptr);GodotRuntime.freeStringArray(c_ptr,arr.length)}catch(e){}}function _godot_js_tts_is_paused(){return window.speechSynthesis.paused}function _godot_js_tts_is_speaking(){return window.speechSynthesis.speaking}function _godot_js_tts_pause(){window.speechSynthesis.pause()}function _godot_js_tts_resume(){window.speechSynthesis.resume()}function _godot_js_tts_speak(p_text,p_voice,p_volume,p_pitch,p_rate,p_utterance_id,p_callback){const func=GodotRuntime.get_func(p_callback);function listener_end(evt){evt.currentTarget.cb(1,evt.currentTarget.id,0)}function listener_start(evt){evt.currentTarget.cb(0,evt.currentTarget.id,0)}function listener_error(evt){evt.currentTarget.cb(2,evt.currentTarget.id,0)}function listener_bound(evt){evt.currentTarget.cb(3,evt.currentTarget.id,evt.charIndex)}const utterance=new SpeechSynthesisUtterance(GodotRuntime.parseString(p_text));utterance.rate=p_rate;utterance.pitch=p_pitch;utterance.volume=p_volume/100;utterance.addEventListener("end",listener_end);utterance.addEventListener("start",listener_start);utterance.addEventListener("error",listener_error);utterance.addEventListener("boundary",listener_bound);utterance.id=p_utterance_id;utterance.cb=func;const voice=GodotRuntime.parseString(p_voice);const voices=window.speechSynthesis.getVoices();for(let i=0;i<voices.length;i++){if(voices[i].name===voice){utterance.voice=voices[i];break}}window.speechSynthesis.resume();window.speechSynthesis.speak(utterance)}function _godot_js_tts_stop(){window.speechSynthesis.cancel();window.speechSynthesis.resume()}var GodotWebMidi={abortControllers:[],isListening:false};function _godot_js_webmidi_close_midi_inputs(){for(const abortController of GodotWebMidi.abortControllers){abortController.abort()}GodotWebMidi.abortControllers=[];GodotWebMidi.isListening=false}function _godot_js_webmidi_open_midi_inputs(pSetInputNamesCb,pOnMidiMessageCb,pDataBuffer,dataBufferLen){if(GodotWebMidi.is_listening){return 0}if(!navigator.requestMIDIAccess){return 2}const setInputNamesCb=GodotRuntime.get_func(pSetInputNamesCb);const onMidiMessageCb=GodotRuntime.get_func(pOnMidiMessageCb);GodotWebMidi.isListening=true;navigator.requestMIDIAccess().then(midi=>{const inputs=[...midi.inputs.values()];const inputNames=inputs.map(input=>input.name);const c_ptr=GodotRuntime.allocStringArray(inputNames);setInputNamesCb(inputNames.length,c_ptr);GodotRuntime.freeStringArray(c_ptr,inputNames.length);inputs.forEach((input,i)=>{const abortController=new AbortController;GodotWebMidi.abortControllers.push(abortController);input.addEventListener("midimessage",event=>{const status=event.data[0];const data=event.data.slice(1);const size=data.length;if(size>dataBufferLen){throw new Error(`data too big ${size} > ${dataBufferLen}`)}HEAPU8.set(data,pDataBuffer);onMidiMessageCb(i,status,pDataBuffer,data.length)},{signal:abortController.signal})})});return 0}var GodotWebSocket={_onopen:function(p_id,callback,event){const ref=IDHandler.get(p_id);if(!ref){return}const c_str=GodotRuntime.allocString(ref.protocol);callback(c_str);GodotRuntime.free(c_str)},_onmessage:function(p_id,callback,event){const ref=IDHandler.get(p_id);if(!ref){return}let buffer;let is_string=0;if(event.data instanceof ArrayBuffer){buffer=new Uint8Array(event.data)}else if(event.data instanceof Blob){GodotRuntime.error("Blob type not supported");return}else if(typeof event.data==="string"){is_string=1;buffer=new TextEncoder("utf-8").encode(event.data)}else{GodotRuntime.error("Unknown message type");return}const len=buffer.length*buffer.BYTES_PER_ELEMENT;const out=GodotRuntime.malloc(len);HEAPU8.set(buffer,out);callback(out,len,is_string);GodotRuntime.free(out)},_onerror:function(p_id,callback,event){const ref=IDHandler.get(p_id);if(!ref){return}callback()},_onclose:function(p_id,callback,event){const ref=IDHandler.get(p_id);if(!ref){return}const c_str=GodotRuntime.allocString(event.reason);callback(event.code,c_str,event.wasClean?1:0);GodotRuntime.free(c_str)},send:function(p_id,p_data){const ref=IDHandler.get(p_id);if(!ref||ref.readyState!==ref.OPEN){return 1}ref.send(p_data);return 0},bufferedAmount:function(p_id){const ref=IDHandler.get(p_id);if(!ref){return 0}return ref.bufferedAmount},create:function(socket,p_on_open,p_on_message,p_on_error,p_on_close){const id=IDHandler.add(socket);socket.onopen=GodotWebSocket._onopen.bind(null,id,p_on_open);socket.onmessage=GodotWebSocket._onmessage.bind(null,id,p_on_message);socket.onerror=GodotWebSocket._onerror.bind(null,id,p_on_error);socket.onclose=GodotWebSocket._onclose.bind(null,id,p_on_close);return id},close:function(p_id,p_code,p_reason){const ref=IDHandler.get(p_id);if(ref&&ref.readyState<ref.CLOSING){const code=p_code;const reason=p_reason;ref.close(code,reason)}},destroy:function(p_id){const ref=IDHandler.get(p_id);if(!ref){return}GodotWebSocket.close(p_id,3001,"destroyed");IDHandler.remove(p_id);ref.onopen=null;ref.onmessage=null;ref.onerror=null;ref.onclose=null}};function _godot_js_websocket_buffered_amount(p_id){return GodotWebSocket.bufferedAmount(p_id)}function _godot_js_websocket_close(p_id,p_code,p_reason){const code=p_code;const reason=GodotRuntime.parseString(p_reason);GodotWebSocket.close(p_id,code,reason)}function _godot_js_websocket_create(p_ref,p_url,p_proto,p_on_open,p_on_message,p_on_error,p_on_close){const on_open=GodotRuntime.get_func(p_on_open).bind(null,p_ref);const on_message=GodotRuntime.get_func(p_on_message).bind(null,p_ref);const on_error=GodotRuntime.get_func(p_on_error).bind(null,p_ref);const on_close=GodotRuntime.get_func(p_on_close).bind(null,p_ref);const url=GodotRuntime.parseString(p_url);const protos=GodotRuntime.parseString(p_proto);let socket=null;try{if(protos){socket=new WebSocket(url,protos.split(","))}else{socket=new WebSocket(url)}}catch(e){return 0}socket.binaryType="arraybuffer";return GodotWebSocket.create(socket,on_open,on_message,on_error,on_close)}function _godot_js_websocket_destroy(p_id){GodotWebSocket.destroy(p_id)}function _godot_js_websocket_send(p_id,p_buf,p_buf_len,p_raw){let out=GodotRuntime.heapSlice(HEAPU8,p_buf,p_buf_len);if(!p_raw){out=new TextDecoder("utf-8").decode(out)}return GodotWebSocket.send(p_id,out)}var GodotJSWrapper={proxies:null,cb_ret:null,MyProxy:function(val){const id=IDHandler.add(this);GodotJSWrapper.proxies.set(val,id);let refs=1;this.ref=function(){refs++};this.unref=function(){refs--;if(refs===0){IDHandler.remove(id);GodotJSWrapper.proxies.delete(val)}};this.get_val=function(){return val};this.get_id=function(){return id}},get_proxied:function(val){const id=GodotJSWrapper.proxies.get(val);if(id===undefined){const proxy=new GodotJSWrapper.MyProxy(val);return proxy.get_id()}IDHandler.get(id).ref();return id},get_proxied_value:function(id){const proxy=IDHandler.get(id);if(proxy===undefined){return undefined}return proxy.get_val()},variant2js:function(type,val){switch(type){case 0:return null;case 1:return Boolean(GodotRuntime.getHeapValue(val,"i64"));case 2:{const heap_value=GodotRuntime.getHeapValue(val,"i64");return heap_value>=Number.MIN_SAFE_INTEGER&&heap_value<=Number.MAX_SAFE_INTEGER?Number(heap_value):heap_value}case 3:return Number(GodotRuntime.getHeapValue(val,"double"));case 4:return GodotRuntime.parseString(GodotRuntime.getHeapValue(val,"*"));case 24:return GodotJSWrapper.get_proxied_value(GodotRuntime.getHeapValue(val,"i64"));default:return undefined}},js2variant:function(p_val,p_exchange){if(p_val===undefined||p_val===null){return 0}const type=typeof p_val;if(type==="boolean"){GodotRuntime.setHeapValue(p_exchange,p_val,"i64");return 1}else if(type==="number"){if(Number.isInteger(p_val)){GodotRuntime.setHeapValue(p_exchange,p_val,"i64");return 2}GodotRuntime.setHeapValue(p_exchange,p_val,"double");return 3}else if(type==="bigint"){GodotRuntime.setHeapValue(p_exchange,p_val,"i64");return 2}else if(type==="string"){const c_str=GodotRuntime.allocString(p_val);GodotRuntime.setHeapValue(p_exchange,c_str,"*");return 4}const id=GodotJSWrapper.get_proxied(p_val);GodotRuntime.setHeapValue(p_exchange,id,"i64");return 24},isBuffer:function(obj){return obj instanceof ArrayBuffer||ArrayBuffer.isView(obj)}};function _godot_js_wrapper_create_cb(p_ref,p_func){const func=GodotRuntime.get_func(p_func);let id=0;const cb=function(){if(!GodotJSWrapper.get_proxied_value(id)){return undefined}GodotJSWrapper.cb_ret=null;const args=Array.from(arguments);const argsProxy=new GodotJSWrapper.MyProxy(args);func(p_ref,argsProxy.get_id(),args.length);argsProxy.unref();const ret=GodotJSWrapper.cb_ret;GodotJSWrapper.cb_ret=null;return ret};id=GodotJSWrapper.get_proxied(cb);return id}function _godot_js_wrapper_create_object(p_object,p_args,p_argc,p_convert_callback,p_exchange,p_lock,p_free_lock_callback){const name=GodotRuntime.parseString(p_object);if(typeof window[name]==="undefined"){return-1}const convert=GodotRuntime.get_func(p_convert_callback);const freeLock=GodotRuntime.get_func(p_free_lock_callback);const args=new Array(p_argc);for(let i=0;i<p_argc;i++){const type=convert(p_args,i,p_exchange,p_lock);const lock=GodotRuntime.getHeapValue(p_lock,"*");args[i]=GodotJSWrapper.variant2js(type,p_exchange);if(lock){freeLock(p_lock,type)}}try{const res=new window[name](...args);return GodotJSWrapper.js2variant(res,p_exchange)}catch(e){GodotRuntime.error(`Error calling constructor ${name} with args:`,args,"error:",e);return-1}}function _godot_js_wrapper_interface_get(p_name){const name=GodotRuntime.parseString(p_name);if(typeof window[name]!=="undefined"){return GodotJSWrapper.get_proxied(window[name])}return 0}function _godot_js_wrapper_object_call(p_id,p_method,p_args,p_argc,p_convert_callback,p_exchange,p_lock,p_free_lock_callback){const obj=GodotJSWrapper.get_proxied_value(p_id);if(obj===undefined){return-1}const method=GodotRuntime.parseString(p_method);const convert=GodotRuntime.get_func(p_convert_callback);const freeLock=GodotRuntime.get_func(p_free_lock_callback);const args=new Array(p_argc);for(let i=0;i<p_argc;i++){const type=convert(p_args,i,p_exchange,p_lock);const lock=GodotRuntime.getHeapValue(p_lock,"*");args[i]=GodotJSWrapper.variant2js(type,p_exchange);if(lock){freeLock(p_lock,type)}}try{const res=obj[method](...args);return GodotJSWrapper.js2variant(res,p_exchange)}catch(e){GodotRuntime.error(`Error calling method ${method} on:`,obj,"error:",e);return-1}}function _godot_js_wrapper_object_get(p_id,p_exchange,p_prop){const obj=GodotJSWrapper.get_proxied_value(p_id);if(obj===undefined){return 0}if(p_prop){const prop=GodotRuntime.parseString(p_prop);try{return GodotJSWrapper.js2variant(obj[prop],p_exchange)}catch(e){GodotRuntime.error(`Error getting variable ${prop} on object`,obj);return 0}}return GodotJSWrapper.js2variant(obj,p_exchange)}function _godot_js_wrapper_object_getvar(p_id,p_type,p_exchange){const obj=GodotJSWrapper.get_proxied_value(p_id);if(obj===undefined){return-1}const prop=GodotJSWrapper.variant2js(p_type,p_exchange);if(prop===undefined||prop===null){return-1}try{return GodotJSWrapper.js2variant(obj[prop],p_exchange)}catch(e){GodotRuntime.error(`Error getting variable ${prop} on object`,obj,e);return-1}}function _godot_js_wrapper_object_is_buffer(p_id){const obj=GodotJSWrapper.get_proxied_value(p_id);return GodotJSWrapper.isBuffer(obj)?1:0}function _godot_js_wrapper_object_set(p_id,p_name,p_type,p_exchange){const obj=GodotJSWrapper.get_proxied_value(p_id);if(obj===undefined){return}const name=GodotRuntime.parseString(p_name);try{obj[name]=GodotJSWrapper.variant2js(p_type,p_exchange)}catch(e){GodotRuntime.error(`Error setting variable ${name} on object`,obj)}}function _godot_js_wrapper_object_set_cb_ret(p_val_type,p_val_ex){GodotJSWrapper.cb_ret=GodotJSWrapper.variant2js(p_val_type,p_val_ex)}function _godot_js_wrapper_object_setvar(p_id,p_key_type,p_key_ex,p_val_type,p_val_ex){const obj=GodotJSWrapper.get_proxied_value(p_id);if(obj===undefined){return-1}const key=GodotJSWrapper.variant2js(p_key_type,p_key_ex);try{obj[key]=GodotJSWrapper.variant2js(p_val_type,p_val_ex);return 0}catch(e){GodotRuntime.error(`Error setting variable ${key} on object`,obj);return-1}}function _godot_js_wrapper_object_transfer_buffer(p_id,p_byte_arr,p_byte_arr_write,p_callback){let obj=GodotJSWrapper.get_proxied_value(p_id);if(!GodotJSWrapper.isBuffer(obj)){return}if(ArrayBuffer.isView(obj)&&!(obj instanceof Uint8Array)){obj=new Uint8Array(obj.buffer)}else if(obj instanceof ArrayBuffer){obj=new Uint8Array(obj)}const resizePackedByteArrayAndOpenWrite=GodotRuntime.get_func(p_callback);const bytesPtr=resizePackedByteArrayAndOpenWrite(p_byte_arr,p_byte_arr_write,obj.length);HEAPU8.set(obj,bytesPtr)}function _godot_js_wrapper_object_unref(p_id){const proxy=IDHandler.get(p_id);if(proxy!==undefined){proxy.unref()}}function _godot_webgl2_glFramebufferTextureMultisampleMultiviewOVR(target,attachment,texture,level,samples,base_view_index,num_views){const context=GL.currentContext;if(typeof context.oculusMultiviewExt==="undefined"){const ext=context.GLctx.getExtension("OCULUS_multiview");if(!ext){GodotRuntime.error("Trying to call glFramebufferTextureMultisampleMultiviewOVR() without the OCULUS_multiview extension");return}context.oculusMultiviewExt=ext}const ext=context.oculusMultiviewExt;ext.framebufferTextureMultisampleMultiviewOVR(target,attachment,GL.textures[texture],level,samples,base_view_index,num_views)}function _godot_webgl2_glFramebufferTextureMultiviewOVR(target,attachment,texture,level,base_view_index,num_views){const context=GL.currentContext;if(typeof context.multiviewExt==="undefined"){const ext=context.GLctx.getExtension("OVR_multiview2");if(!ext){GodotRuntime.error("Trying to call glFramebufferTextureMultiviewOVR() without the OVR_multiview2 extension");return}context.multiviewExt=ext}const ext=context.multiviewExt;ext.framebufferTextureMultiviewOVR(target,attachment,GL.textures[texture],level,base_view_index,num_views)}function _godot_webgl2_glGetBufferSubData(target,offset,size,data){const gl_context_handle=_emscripten_webgl_get_current_context();const gl=GL.getContext(gl_context_handle);if(gl){gl.GLctx["getBufferSubData"](target,offset,HEAPU8,data,size)}}var GodotWebXR={gl:null,session:null,gl_binding:null,layer:null,space:null,frame:null,pose:null,view_count:1,input_sources:[,,,,,,,,,,,,,,,],touches:[,,,,],onsimpleevent:null,orig_requestAnimationFrame:null,requestAnimationFrame:callback=>{if(GodotWebXR.session&&GodotWebXR.space){const onFrame=function(time,frame){GodotWebXR.frame=frame;GodotWebXR.pose=frame.getViewerPose(GodotWebXR.space);callback(time);GodotWebXR.frame=null;GodotWebXR.pose=null};GodotWebXR.session.requestAnimationFrame(onFrame)}else{GodotWebXR.orig_requestAnimationFrame(callback)}},monkeyPatchRequestAnimationFrame:enable=>{if(GodotWebXR.orig_requestAnimationFrame===null){GodotWebXR.orig_requestAnimationFrame=MainLoop.requestAnimationFrame}MainLoop.requestAnimationFrame=enable?GodotWebXR.requestAnimationFrame:GodotWebXR.orig_requestAnimationFrame},pauseResumeMainLoop:()=>{MainLoop.pause();runtimeKeepalivePush();window.setTimeout(function(){runtimeKeepalivePop();MainLoop.resume()},0)},getLayer:()=>{const new_view_count=GodotWebXR.pose?GodotWebXR.pose.views.length:1;let layer=GodotWebXR.layer;if(layer&&GodotWebXR.view_count===new_view_count){return layer}if(!GodotWebXR.session||!GodotWebXR.gl_binding||!GodotWebXR.gl_binding.createProjectionLayer){return null}const gl=GodotWebXR.gl;layer=GodotWebXR.gl_binding.createProjectionLayer({textureType:new_view_count>1?"texture-array":"texture",colorFormat:gl.RGBA8,depthFormat:gl.DEPTH_COMPONENT24});GodotWebXR.session.updateRenderState({layers:[layer]});GodotWebXR.layer=layer;GodotWebXR.view_count=new_view_count;return layer},getSubImage:()=>{if(!GodotWebXR.pose){return null}const layer=GodotWebXR.getLayer();if(layer===null){return null}return GodotWebXR.gl_binding.getViewSubImage(layer,GodotWebXR.pose.views[0])},getTextureId:texture=>{if(texture.name!==undefined){return texture.name}const id=GL.getNewId(GL.textures);texture.name=id;GL.textures[id]=texture;return id},addInputSource:input_source=>{let name=-1;if(input_source.targetRayMode==="tracked-pointer"&&input_source.handedness==="left"){name=0}else if(input_source.targetRayMode==="tracked-pointer"&&input_source.handedness==="right"){name=1}else{for(let i=2;i<16;i++){if(!GodotWebXR.input_sources[i]){name=i;break}}}if(name>=0){GodotWebXR.input_sources[name]=input_source;input_source.name=name;if(input_source.targetRayMode==="screen"){let touch_index=-1;for(let i=0;i<5;i++){if(!GodotWebXR.touches[i]){touch_index=i;break}}if(touch_index>=0){GodotWebXR.touches[touch_index]=input_source;input_source.touch_index=touch_index}}}return name},removeInputSource:input_source=>{if(input_source.name!==undefined){const name=input_source.name;if(name>=0&&name<16){GodotWebXR.input_sources[name]=null}if(input_source.touch_index!==undefined){const touch_index=input_source.touch_index;if(touch_index>=0&&touch_index<5){GodotWebXR.touches[touch_index]=null}}return name}return-1},getInputSourceId:input_source=>{if(input_source!==undefined){return input_source.name}return-1},getTouchIndex:input_source=>{if(input_source.touch_index!==undefined){return input_source.touch_index}return-1}};function _godot_webxr_get_bounds_geometry(r_points){if(!GodotWebXR.space||!GodotWebXR.space.boundsGeometry){return 0}const point_count=GodotWebXR.space.boundsGeometry.length;if(point_count===0){return 0}const buf=GodotRuntime.malloc(point_count*3*4);for(let i=0;i<point_count;i++){const point=GodotWebXR.space.boundsGeometry[i];GodotRuntime.setHeapValue(buf+(i*3+0)*4,point.x,"float");GodotRuntime.setHeapValue(buf+(i*3+1)*4,point.y,"float");GodotRuntime.setHeapValue(buf+(i*3+2)*4,point.z,"float")}GodotRuntime.setHeapValue(r_points,buf,"i32");return point_count}function _godot_webxr_get_color_texture(){const subimage=GodotWebXR.getSubImage();if(subimage===null){return 0}return GodotWebXR.getTextureId(subimage.colorTexture)}function _godot_webxr_get_depth_texture(){const subimage=GodotWebXR.getSubImage();if(subimage===null){return 0}if(!subimage.depthStencilTexture){return 0}return GodotWebXR.getTextureId(subimage.depthStencilTexture)}function _godot_webxr_get_frame_rate(){if(!GodotWebXR.session||GodotWebXR.session.frameRate===undefined){return 0}return GodotWebXR.session.frameRate}function _godot_webxr_get_projection_for_view(p_view,r_transform){if(!GodotWebXR.session||!GodotWebXR.pose){return false}const matrix=GodotWebXR.pose.views[p_view].projectionMatrix;for(let i=0;i<16;i++){GodotRuntime.setHeapValue(r_transform+i*4,matrix[i],"float")}return true}function _godot_webxr_get_render_target_size(r_size){const subimage=GodotWebXR.getSubImage();if(subimage===null){return false}GodotRuntime.setHeapValue(r_size+0,subimage.viewport.width,"i32");GodotRuntime.setHeapValue(r_size+4,subimage.viewport.height,"i32");return true}function _godot_webxr_get_supported_frame_rates(r_frame_rates){if(!GodotWebXR.session||GodotWebXR.session.supportedFrameRates===undefined){return 0}const frame_rate_count=GodotWebXR.session.supportedFrameRates.length;if(frame_rate_count===0){return 0}const buf=GodotRuntime.malloc(frame_rate_count*4);for(let i=0;i<frame_rate_count;i++){GodotRuntime.setHeapValue(buf+i*4,GodotWebXR.session.supportedFrameRates[i],"float")}GodotRuntime.setHeapValue(r_frame_rates,buf,"i32");return frame_rate_count}function _godot_webxr_get_transform_for_view(p_view,r_transform){if(!GodotWebXR.session||!GodotWebXR.pose){return false}const views=GodotWebXR.pose.views;let matrix;if(p_view>=0){matrix=views[p_view].transform.matrix}else{matrix=GodotWebXR.pose.transform.matrix}for(let i=0;i<16;i++){GodotRuntime.setHeapValue(r_transform+i*4,matrix[i],"float")}return true}function _godot_webxr_get_velocity_texture(){const subimage=GodotWebXR.getSubImage();if(subimage===null){return 0}if(!subimage.motionVectorTexture){return 0}return GodotWebXR.getTextureId(subimage.motionVectorTexture)}function _godot_webxr_get_view_count(){if(!GodotWebXR.session||!GodotWebXR.pose){return 1}const view_count=GodotWebXR.pose.views.length;return view_count>0?view_count:1}function _godot_webxr_get_visibility_state(){if(!GodotWebXR.session||!GodotWebXR.session.visibilityState){return 0}return GodotRuntime.allocString(GodotWebXR.session.visibilityState)}var _godot_webxr_initialize=function(p_session_mode,p_required_features,p_optional_features,p_requested_reference_spaces,p_on_session_started,p_on_session_ended,p_on_session_failed,p_on_input_event,p_on_simple_event){GodotWebXR.monkeyPatchRequestAnimationFrame(true);const session_mode=GodotRuntime.parseString(p_session_mode);const required_features=GodotRuntime.parseString(p_required_features).split(",").map(s=>s.trim()).filter(s=>s!=="");const optional_features=GodotRuntime.parseString(p_optional_features).split(",").map(s=>s.trim()).filter(s=>s!=="");const requested_reference_space_types=GodotRuntime.parseString(p_requested_reference_spaces).split(",").map(s=>s.trim());const onstarted=GodotRuntime.get_func(p_on_session_started);const onended=GodotRuntime.get_func(p_on_session_ended);const onfailed=GodotRuntime.get_func(p_on_session_failed);const oninputevent=GodotRuntime.get_func(p_on_input_event);const onsimpleevent=GodotRuntime.get_func(p_on_simple_event);const session_init={};if(required_features.length>0){session_init["requiredFeatures"]=required_features}if(optional_features.length>0){session_init["optionalFeatures"]=optional_features}navigator.xr.requestSession(session_mode,session_init).then(function(session){GodotWebXR.session=session;session.addEventListener("end",function(evt){onended()});session.addEventListener("inputsourceschange",function(evt){evt.added.forEach(GodotWebXR.addInputSource);evt.removed.forEach(GodotWebXR.removeInputSource)});["selectstart","selectend","squeezestart","squeezeend"].forEach((input_event,index)=>{session.addEventListener(input_event,function(evt){GodotWebXR.frame=evt.frame;oninputevent(index,GodotWebXR.getInputSourceId(evt.inputSource));GodotWebXR.frame=null})});session.addEventListener("visibilitychange",function(evt){const c_str=GodotRuntime.allocString("visibility_state_changed");onsimpleevent(c_str);GodotRuntime.free(c_str)});GodotWebXR.onsimpleevent=onsimpleevent;const gl_context_handle=_emscripten_webgl_get_current_context();const gl=GL.getContext(gl_context_handle).GLctx;GodotWebXR.gl=gl;gl.makeXRCompatible().then(function(){const throwNoWebXRLayersError=()=>{throw new Error("This browser doesn't support WebXR Layers (which Godot requires) nor is the polyfill in use. If you are the developer of this application, please consider including the polyfill.")};try{GodotWebXR.gl_binding=new XRWebGLBinding(session,gl)}catch(error){throwNoWebXRLayersError()}if(!GodotWebXR.gl_binding.createProjectionLayer){throwNoWebXRLayersError()}const layer=GodotWebXR.getLayer();if(!layer){throw new Error("Unable to create WebXR Layer.")}function onReferenceSpaceSuccess(reference_space,reference_space_type){GodotWebXR.space=reference_space;reference_space.onreset=function(evt){const c_str=GodotRuntime.allocString("reference_space_reset");onsimpleevent(c_str);GodotRuntime.free(c_str)};GodotWebXR.pauseResumeMainLoop();window.setTimeout(function(){const reference_space_c_str=GodotRuntime.allocString(reference_space_type);const enabled_features="enabledFeatures"in session?Array.from(session.enabledFeatures):[];const enabled_features_c_str=GodotRuntime.allocString(enabled_features.join(","));const environment_blend_mode="environmentBlendMode"in session?session.environmentBlendMode:"";const environment_blend_mode_c_str=GodotRuntime.allocString(environment_blend_mode);onstarted(reference_space_c_str,enabled_features_c_str,environment_blend_mode_c_str);GodotRuntime.free(reference_space_c_str);GodotRuntime.free(enabled_features_c_str);GodotRuntime.free(environment_blend_mode_c_str)},0)}function requestReferenceSpace(){const reference_space_type=requested_reference_space_types.shift();session.requestReferenceSpace(reference_space_type).then(refSpace=>{onReferenceSpaceSuccess(refSpace,reference_space_type)}).catch(()=>{if(requested_reference_space_types.length===0){const c_str=GodotRuntime.allocString("Unable to get any of the requested reference space types");onfailed(c_str);GodotRuntime.free(c_str)}else{requestReferenceSpace()}})}requestReferenceSpace()}).catch(function(error){const c_str=GodotRuntime.allocString(`Unable to make WebGL context compatible with WebXR: ${error}`);onfailed(c_str);GodotRuntime.free(c_str)})}).catch(function(error){const c_str=GodotRuntime.allocString(`Unable to start session: ${error}`);onfailed(c_str);GodotRuntime.free(c_str)})};function _godot_webxr_is_session_supported(p_session_mode,p_callback){const session_mode=GodotRuntime.parseString(p_session_mode);const cb=GodotRuntime.get_func(p_callback);if(navigator.xr){navigator.xr.isSessionSupported(session_mode).then(function(supported){const c_str=GodotRuntime.allocString(session_mode);cb(c_str,supported?1:0);GodotRuntime.free(c_str)})}else{const c_str=GodotRuntime.allocString(session_mode);cb(c_str,0);GodotRuntime.free(c_str)}}function _godot_webxr_is_supported(){return!!navigator.xr}var _godot_webxr_uninitialize=function(){if(GodotWebXR.session){GodotWebXR.session.end().catch(e=>{})}GodotWebXR.session=null;GodotWebXR.gl_binding=null;GodotWebXR.layer=null;GodotWebXR.space=null;GodotWebXR.frame=null;GodotWebXR.pose=null;GodotWebXR.view_count=1;GodotWebXR.input_sources=new Array(16);GodotWebXR.touches=new Array(5);GodotWebXR.onsimpleevent=null;GodotWebXR.monkeyPatchRequestAnimationFrame(false);GodotWebXR.pauseResumeMainLoop()};function _godot_webxr_update_input_source(p_input_source_id,r_target_pose,r_target_ray_mode,r_touch_index,r_has_grip_pose,r_grip_pose,r_has_standard_mapping,r_button_count,r_buttons,r_axes_count,r_axes,r_has_hand_data,r_hand_joints,r_hand_radii){if(!GodotWebXR.session||!GodotWebXR.frame){return 0}if(p_input_source_id<0||p_input_source_id>=GodotWebXR.input_sources.length||!GodotWebXR.input_sources[p_input_source_id]){return false}const input_source=GodotWebXR.input_sources[p_input_source_id];const frame=GodotWebXR.frame;const space=GodotWebXR.space;const target_pose=frame.getPose(input_source.targetRaySpace,space);if(!target_pose){return false}const target_pose_matrix=target_pose.transform.matrix;for(let i=0;i<16;i++){GodotRuntime.setHeapValue(r_target_pose+i*4,target_pose_matrix[i],"float")}let target_ray_mode=0;switch(input_source.targetRayMode){case"gaze":target_ray_mode=1;break;case"tracked-pointer":target_ray_mode=2;break;case"screen":target_ray_mode=3;break;default:}GodotRuntime.setHeapValue(r_target_ray_mode,target_ray_mode,"i32");GodotRuntime.setHeapValue(r_touch_index,GodotWebXR.getTouchIndex(input_source),"i32");let has_grip_pose=false;if(input_source.gripSpace){const grip_pose=frame.getPose(input_source.gripSpace,space);if(grip_pose){const grip_pose_matrix=grip_pose.transform.matrix;for(let i=0;i<16;i++){GodotRuntime.setHeapValue(r_grip_pose+i*4,grip_pose_matrix[i],"float")}has_grip_pose=true}}GodotRuntime.setHeapValue(r_has_grip_pose,has_grip_pose?1:0,"i32");let has_standard_mapping=false;let button_count=0;let axes_count=0;if(input_source.gamepad){if(input_source.gamepad.mapping==="xr-standard"){has_standard_mapping=true}button_count=Math.min(input_source.gamepad.buttons.length,10);for(let i=0;i<button_count;i++){GodotRuntime.setHeapValue(r_buttons+i*4,input_source.gamepad.buttons[i].value,"float")}axes_count=Math.min(input_source.gamepad.axes.length,10);for(let i=0;i<axes_count;i++){GodotRuntime.setHeapValue(r_axes+i*4,input_source.gamepad.axes[i],"float")}}GodotRuntime.setHeapValue(r_has_standard_mapping,has_standard_mapping?1:0,"i32");GodotRuntime.setHeapValue(r_button_count,button_count,"i32");GodotRuntime.setHeapValue(r_axes_count,axes_count,"i32");let has_hand_data=false;if(input_source.hand&&r_hand_joints!==0&&r_hand_radii!==0){const hand_joint_array=new Float32Array(25*16);const hand_radii_array=new Float32Array(25);if(frame.fillPoses(input_source.hand.values(),space,hand_joint_array)&&frame.fillJointRadii(input_source.hand.values(),hand_radii_array)){GodotRuntime.heapCopy(HEAPF32,hand_joint_array,r_hand_joints);GodotRuntime.heapCopy(HEAPF32,hand_radii_array,r_hand_radii);has_hand_data=true}}GodotRuntime.setHeapValue(r_has_hand_data,has_hand_data?1:0,"i32");return true}function _godot_webxr_update_target_frame_rate(p_frame_rate){if(!GodotWebXR.session||GodotWebXR.session.updateTargetFrameRate===undefined){return}GodotWebXR.session.updateTargetFrameRate(p_frame_rate).then(()=>{const c_str=GodotRuntime.allocString("display_refresh_rate_changed");GodotWebXR.onsimpleevent(c_str);GodotRuntime.free(c_str)})}var stackAlloc=sz=>__emscripten_stack_alloc(sz);var stringToUTF8OnStack=str=>{var size=lengthBytesUTF8(str)+1;var ret=stackAlloc(size);stringToUTF8(str,ret,size);return ret};var getCFunc=ident=>{var func=Module["_"+ident];return func};var writeArrayToMemory=(array,buffer)=>{HEAP8.set(array,buffer)};var stackSave=()=>_emscripten_stack_get_current();var stackRestore=val=>__emscripten_stack_restore(val);var ccall=(ident,returnType,argTypes,args,opts)=>{var toC={string:str=>{var ret=0;if(str!==null&&str!==undefined&&str!==0){ret=stringToUTF8OnStack(str)}return ret},array:arr=>{var ret=stackAlloc(arr.length);writeArrayToMemory(arr,ret);return ret}};function convertReturnValue(ret){if(returnType==="string"){return UTF8ToString(ret)}if(returnType==="boolean")return Boolean(ret);return ret}var func=getCFunc(ident);var cArgs=[];var stack=0;if(args){for(var i=0;i<args.length;i++){var converter=toC[argTypes[i]];if(converter){if(stack===0)stack=stackSave();cArgs[i]=converter(args[i])}else{cArgs[i]=args[i]}}}var ret=func(...cArgs);function onDone(ret){if(stack!==0)stackRestore(stack);return convertReturnValue(ret)}ret=onDone(ret);return ret};var cwrap=(ident,returnType,argTypes,opts)=>{var numericArgs=!argTypes||argTypes.every(type=>type==="number"||type==="boolean");var numericRet=returnType!=="string";if(numericRet&&numericArgs&&!opts){return getCFunc(ident)}return(...args)=>ccall(ident,returnType,argTypes,args,opts)};FS.createPreloadedFile=FS_createPreloadedFile;FS.preloadFile=FS_preloadFile;FS.staticInit();Module["requestAnimationFrame"]=MainLoop.requestAnimationFrame;Module["pauseMainLoop"]=MainLoop.pause;Module["resumeMainLoop"]=MainLoop.resume;MainLoop.init();for(let i=0;i<32;++i)tempFixedLengthArray.push(new Array(i));var miniTempWebGLIntBuffersStorage=new Int32Array(288);for(var i=0;i<=288;++i){miniTempWebGLIntBuffers[i]=miniTempWebGLIntBuffersStorage.subarray(0,i)}var miniTempWebGLFloatBuffersStorage=new Float32Array(288);for(var i=0;i<=288;++i){miniTempWebGLFloatBuffers[i]=miniTempWebGLFloatBuffersStorage.subarray(0,i)}Module["request_quit"]=function(){GodotOS.request_quit()};Module["onExit"]=GodotOS.cleanup;GodotOS._fs_sync_promise=Promise.resolve();Module["initConfig"]=GodotConfig.init_config;Module["initFS"]=GodotFS.init;Module["copyToFS"]=GodotFS.copy_to_fs;GodotOS.atexit(function(resolve,reject){GodotDisplayCursor.clear();resolve()});GodotOS.atexit(function(resolve,reject){GodotEventListeners.clear();resolve()});GodotOS.atexit(function(resolve,reject){GodotDisplayVK.clear();resolve()});GodotOS.atexit(function(resolve,reject){GodotIME.clear();resolve()});GodotJSWrapper.proxies=new Map;{if(Module["noExitRuntime"])noExitRuntime=Module["noExitRuntime"];if(Module["preloadPlugins"])preloadPlugins=Module["preloadPlugins"];if(Module["print"])out=Module["print"];if(Module["printErr"])err=Module["printErr"];if(Module["wasmBinary"])wasmBinary=Module["wasmBinary"];if(Module["arguments"])arguments_=Module["arguments"];if(Module["thisProgram"])thisProgram=Module["thisProgram"];if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].shift()()}}}Module["callMain"]=callMain;Module["cwrap"]=cwrap;var _free,__Z14godot_web_mainiPPc,_main,_malloc,_fflush,__emwebxr_on_input_event,__emwebxr_on_simple_event,___funcs_on_exit,_emscripten_builtin_memalign,__emscripten_timeout,__emscripten_stack_restore,__emscripten_stack_alloc,_emscripten_stack_get_current,memory,__indirect_function_table,wasmMemory,wasmTable;function assignWasmExports(wasmExports){_free=Module["_free"]=wasmExports["qf"];__Z14godot_web_mainiPPc=Module["__Z14godot_web_mainiPPc"]=wasmExports["rf"];_main=Module["_main"]=wasmExports["sf"];_malloc=Module["_malloc"]=wasmExports["tf"];_fflush=wasmExports["uf"];__emwebxr_on_input_event=Module["__emwebxr_on_input_event"]=wasmExports["vf"];__emwebxr_on_simple_event=Module["__emwebxr_on_simple_event"]=wasmExports["wf"];___funcs_on_exit=wasmExports["yf"];_emscripten_builtin_memalign=wasmExports["zf"];__emscripten_timeout=wasmExports["Af"];__emscripten_stack_restore=wasmExports["Bf"];__emscripten_stack_alloc=wasmExports["Cf"];_emscripten_stack_get_current=wasmExports["Df"];memory=wasmMemory=wasmExports["of"];__indirect_function_table=wasmTable=wasmExports["xf"]}var wasmImports={Pc:___call_sighandler,gd:___syscall_chdir,Ya:___syscall_chmod,hd:___syscall_faccessat,ed:___syscall_fchmod,U:___syscall_fcntl64,dd:___syscall_fstat64,$c:___syscall_ftruncate64,_c:___syscall_getcwd,Oc:___syscall_getdents64,Aa:___syscall_ioctl,bd:___syscall_lstat64,Vc:___syscall_mkdirat,Uc:___syscall_mknodat,ad:___syscall_newfstatat,Wa:___syscall_openat,Nc:___syscall_readlinkat,Lc:___syscall_renameat,Sa:___syscall_rmdir,cd:___syscall_stat64,Kc:___syscall_statfs64,Jc:___syscall_symlinkat,Ta:___syscall_unlinkat,id:__abort_js,Rc:__emscripten_runtime_keepalive_clear,Sc:__gmtime_js,Tc:__localtime_js,Gc:__setitimer_js,jd:__tzset_js,fd:_clock_time_get,wb:_emscripten_cancel_main_loop,Xa:_emscripten_date_now,We:_emscripten_force_exit,Ic:_emscripten_get_heap_max,ka:_emscripten_get_now,Hc:_emscripten_resize_heap,Mc:_emscripten_set_canvas_element_size,Ka:_emscripten_set_main_loop,Oa:_emscripten_webgl_commit_frame,cc:_emscripten_webgl_create_context,Mb:_emscripten_webgl_destroy_context,ac:_emscripten_webgl_enable_extension,wd:_emscripten_webgl_get_supported_extensions,bc:_emscripten_webgl_make_context_current,Yc:_environ_get,Zc:_environ_sizes_get,Ja:_exit,oa:_fd_close,Ua:_fd_fdstat_get,Za:_fd_read,Xc:_fd_seek,za:_fd_write,g:_glActiveTexture,cb:_glAttachShader,ga:_glBeginTransformFeedback,b:_glBindBuffer,y:_glBindBufferBase,Da:_glBindBufferRange,d:_glBindFramebuffer,ta:_glBindRenderbuffer,c:_glBindTexture,f:_glBindVertexArray,Rd:_glBlendColor,G:_glBlendEquation,ja:_glBlendFunc,B:_glBlendFuncSeparate,ia:_glBlitFramebuffer,h:_glBufferData,P:_glBufferSubData,R:_glCheckFramebufferStatus,H:_glClear,kb:_glClearBufferfv,Q:_glClearColor,_:_glClearDepthf,hb:_glClearStencil,S:_glColorMask,eb:_glCompileShader,pd:_glCompressedTexImage2D,rd:_glCompressedTexImage3D,qd:_glCompressedTexSubImage3D,sd:_glCopyBufferSubData,Cd:_glCreateProgram,gb:_glCreateShader,na:_glCullFace,m:_glDeleteBuffers,u:_glDeleteFramebuffers,ha:_glDeleteProgram,md:_glDeleteQueries,pa:_glDeleteRenderbuffers,W:_glDeleteShader,ob:_glDeleteSync,j:_glDeleteTextures,N:_glDeleteVertexArrays,F:_glDepthFunc,x:_glDepthMask,e:_glDisable,n:_glDisableVertexAttribArray,E:_glDrawArrays,T:_glDrawArraysInstanced,da:_glDrawBuffers,K:_glDrawElements,L:_glDrawElementsInstanced,r:_glEnable,o:_glEnableVertexAttribArray,fa:_glEndTransformFeedback,nb:_glFenceSync,Kd:_glFinish,Ha:_glFramebufferRenderbuffer,t:_glFramebufferTexture2D,ca:_glFramebufferTextureLayer,lb:_glFrontFace,k:_glGenBuffers,C:_glGenFramebuffers,nd:_glGenQueries,Ia:_glGenRenderbuffers,v:_glGenTextures,M:_glGenVertexArrays,ld:_glGenerateMipmap,ud:_glGetFloatv,vd:_glGetInteger64v,aa:_glGetIntegerv,xd:_glGetProgramInfoLog,bb:_glGetProgramiv,db:_glGetShaderInfoLog,sa:_glGetShaderiv,Z:_glGetString,Ud:_glGetSynciv,Fd:_glGetUniformBlockIndex,Ea:_glGetUniformLocation,zd:_glLinkProgram,Ba:_glPixelStorei,Id:_glReadBuffer,Ca:_glReadPixels,Nd:_glRenderbufferStorage,$a:_glRenderbufferStorageMultisample,va:_glScissor,fb:_glShaderSource,jb:_glStencilFunc,ba:_glStencilMask,Hd:_glStencilOp,w:_glTexImage2D,Y:_glTexImage3D,Ga:_glTexParameterf,a:_glTexParameteri,Fa:_glTexStorage2D,_a:_glTexSubImage3D,Ad:_glTransformFeedbackVaryings,i:_glUniform1f,D:_glUniform1i,Dd:_glUniform1iv,p:_glUniform1ui,ma:_glUniform1uiv,X:_glUniform2f,I:_glUniform2fv,la:_glUniform2iv,q:_glUniform3fv,O:_glUniform4f,A:_glUniform4fv,Ed:_glUniformBlockBinding,ib:_glUniformMatrix3fv,J:_glUniformMatrix4fv,l:_glUseProgram,ua:_glVertexAttrib4f,$:_glVertexAttribDivisor,mb:_glVertexAttribI4ui,ea:_glVertexAttribIPointer,s:_glVertexAttribPointer,z:_glViewport,Je:_godot_audio_get_sample_playback_position,yd:_godot_audio_has_script_processor,Jd:_godot_audio_has_worklet,mf:_godot_audio_init,zc:_godot_audio_input_start,sc:_godot_audio_input_stop,nf:_godot_audio_is_available,qa:_godot_audio_resume,Td:_godot_audio_sample_bus_add,Sd:_godot_audio_sample_bus_move,_d:_godot_audio_sample_bus_remove,he:_godot_audio_sample_bus_set_count,Ld:_godot_audio_sample_bus_set_mute,Pd:_godot_audio_sample_bus_set_send,Md:_godot_audio_sample_bus_set_solo,Od:_godot_audio_sample_bus_set_volume_db,Ue:_godot_audio_sample_is_active,Zb:_godot_audio_sample_register_stream,Qd:_godot_audio_sample_set_finished_callback,af:_godot_audio_sample_set_pause,qe:_godot_audio_sample_set_volumes_linear,Gb:_godot_audio_sample_start,lf:_godot_audio_sample_stop,ic:_godot_audio_sample_stream_is_registered,Ob:_godot_audio_sample_unregister_stream,Ae:_godot_audio_sample_update_pitch_scale,td:_godot_audio_script_create,od:_godot_audio_script_start,Gd:_godot_audio_worklet_create,Bd:_godot_audio_worklet_start_no_threads,hc:_godot_js_config_canvas_id_get,Le:_godot_js_config_locale_get,Te:_godot_js_display_alert,tc:_godot_js_display_canvas_focus,uc:_godot_js_display_canvas_is_focused,jc:_godot_js_display_clipboard_get,kc:_godot_js_display_clipboard_set,wc:_godot_js_display_cursor_is_hidden,vc:_godot_js_display_cursor_is_locked,xa:_godot_js_display_cursor_lock_set,Ra:_godot_js_display_cursor_set_custom_shape,xc:_godot_js_display_cursor_set_shape,ya:_godot_js_display_cursor_set_visible,Fb:_godot_js_display_desired_size_set,Rb:_godot_js_display_fullscreen_cb,Eb:_godot_js_display_fullscreen_exit,Db:_godot_js_display_fullscreen_request,dc:_godot_js_display_has_webgl,fc:_godot_js_display_is_swap_ok_cancel,Pb:_godot_js_display_notification_cb,Ib:_godot_js_display_pixel_ratio_get,Jb:_godot_js_display_screen_dpi_get,Kb:_godot_js_display_screen_size_get,gc:_godot_js_display_setup_canvas,Wc:_godot_js_display_size_update,rc:_godot_js_display_touchscreen_is_available,Lb:_godot_js_display_tts_available,Na:_godot_js_display_vk_available,Nb:_godot_js_display_vk_cb,pc:_godot_js_display_vk_hide,qc:_godot_js_display_vk_show,Qb:_godot_js_display_window_blur_cb,Pa:_godot_js_display_window_icon_set,Ma:_godot_js_display_window_size_get,Hb:_godot_js_display_window_title_set,Ve:_godot_js_emscripten_get_version,$e:_godot_js_eval,Bb:_godot_js_fetch_create,La:_godot_js_fetch_free,yb:_godot_js_fetch_http_status_get,Ab:_godot_js_fetch_is_chunked,zb:_godot_js_fetch_read_chunk,kf:_godot_js_fetch_read_headers,wa:_godot_js_fetch_state_get,Ub:_godot_js_input_drop_files_cb,Tb:_godot_js_input_gamepad_cb,Cb:_godot_js_input_gamepad_sample,mc:_godot_js_input_gamepad_sample_count,lc:_godot_js_input_gamepad_sample_get,Wb:_godot_js_input_key_cb,$b:_godot_js_input_mouse_button_cb,_b:_godot_js_input_mouse_move_cb,Yb:_godot_js_input_mouse_wheel_cb,Vb:_godot_js_input_paste_cb,Xb:_godot_js_input_touch_cb,Ne:_godot_js_input_vibrate_handheld,Qa:_godot_js_is_ime_focused,Ye:_godot_js_os_download_buffer,Re:_godot_js_os_execute,vb:_godot_js_os_finish_async,Ie:_godot_js_os_fs_is_persistent,Se:_godot_js_os_fs_sync,Pe:_godot_js_os_has_feature,Qe:_godot_js_os_hw_concurrency_get,ec:_godot_js_os_request_quit_cb,Oe:_godot_js_os_shell_open,Ke:_godot_js_pwa_cb,Me:_godot_js_pwa_update,ub:_godot_js_rtc_datachannel_close,ye:_godot_js_rtc_datachannel_connect,ve:_godot_js_rtc_datachannel_destroy,ze:_godot_js_rtc_datachannel_get_buffered_amount,Ee:_godot_js_rtc_datachannel_id_get,Be:_godot_js_rtc_datachannel_is_negotiated,Fe:_godot_js_rtc_datachannel_is_ordered,xe:_godot_js_rtc_datachannel_label_get,De:_godot_js_rtc_datachannel_max_packet_lifetime_get,Ce:_godot_js_rtc_datachannel_max_retransmits_get,we:_godot_js_rtc_datachannel_protocol_get,He:_godot_js_rtc_datachannel_ready_state_get,Ge:_godot_js_rtc_datachannel_send,tb:_godot_js_rtc_pc_close,pe:_godot_js_rtc_pc_create,oe:_godot_js_rtc_pc_datachannel_create,sb:_godot_js_rtc_pc_destroy,re:_godot_js_rtc_pc_ice_candidate_add,te:_godot_js_rtc_pc_local_description_set,ue:_godot_js_rtc_pc_offer_create,se:_godot_js_rtc_pc_remote_description_set,oc:_godot_js_set_ime_active,Sb:_godot_js_set_ime_cb,nc:_godot_js_set_ime_position,Dc:_godot_js_tts_get_voices,Ec:_godot_js_tts_is_paused,Fc:_godot_js_tts_is_speaking,Bc:_godot_js_tts_pause,Ac:_godot_js_tts_resume,Cc:_godot_js_tts_speak,yc:_godot_js_tts_stop,Va:_godot_js_webmidi_close_midi_inputs,kd:_godot_js_webmidi_open_midi_inputs,le:_godot_js_websocket_buffered_amount,ke:_godot_js_websocket_close,ne:_godot_js_websocket_create,rb:_godot_js_websocket_destroy,me:_godot_js_websocket_send,df:_godot_js_wrapper_create_cb,bf:_godot_js_wrapper_create_object,cf:_godot_js_wrapper_interface_get,ff:_godot_js_wrapper_object_call,hf:_godot_js_wrapper_object_get,xb:_godot_js_wrapper_object_getvar,_e:_godot_js_wrapper_object_is_buffer,jf:_godot_js_wrapper_object_set,ef:_godot_js_wrapper_object_set_cb_ret,gf:_godot_js_wrapper_object_setvar,Ze:_godot_js_wrapper_object_transfer_buffer,Xe:_godot_js_wrapper_object_unref,ab:_godot_webgl2_glFramebufferTextureMultisampleMultiviewOVR,V:_godot_webgl2_glFramebufferTextureMultiviewOVR,ra:_godot_webgl2_glGetBufferSubData,ge:_godot_webxr_get_bounds_geometry,Yd:_godot_webxr_get_color_texture,Xd:_godot_webxr_get_depth_texture,fe:_godot_webxr_get_frame_rate,Zd:_godot_webxr_get_projection_for_view,$d:_godot_webxr_get_render_target_size,de:_godot_webxr_get_supported_frame_rates,pb:_godot_webxr_get_transform_for_view,Wd:_godot_webxr_get_velocity_texture,qb:_godot_webxr_get_view_count,ie:_godot_webxr_get_visibility_state,be:_godot_webxr_initialize,je:_godot_webxr_is_session_supported,ce:_godot_webxr_is_supported,ae:_godot_webxr_uninitialize,Vd:_godot_webxr_update_input_source,ee:_godot_webxr_update_target_frame_rate,Qc:_proc_exit};function callMain(args=[]){var entryFunction=_main;args.unshift(thisProgram);var argc=args.length;var argv=stackAlloc((argc+1)*4);var argv_ptr=argv;for(var arg of args){HEAPU32[argv_ptr>>2]=stringToUTF8OnStack(arg);argv_ptr+=4}HEAPU32[argv_ptr>>2]=0;try{var ret=entryFunction(argc,argv);exitJS(ret,true);return ret}catch(e){return handleException(e)}}function run(args=arguments_){if(runDependencies>0){dependenciesFulfilled=run;return}preRun();if(runDependencies>0){dependenciesFulfilled=run;return}function doRun(){Module["calledRun"]=true;if(ABORT)return;initRuntime();preMain();readyPromiseResolve?.(Module);Module["onRuntimeInitialized"]?.();var noInitialRun=Module["noInitialRun"]||true;if(!noInitialRun)callMain(args);postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(()=>{setTimeout(()=>Module["setStatus"](""),1);doRun()},1)}else{doRun()}}var wasmExports;wasmExports=await (createWasm());run();addOnPostRun(function(){GL.getSource=(shader,count,string,length)=>{let source="";for(let i=0;i<count;++i){const ptr=HEAPU32[string+i*4>>2];const len=length?HEAPU32[length+i*4>>2]:undefined;if(len){const endPtr=ptr+len;const slice=HEAPU8.buffer instanceof ArrayBuffer?HEAPU8.subarray(ptr,endPtr):HEAPU8.slice(ptr,endPtr);source+=UTF8Decoder.decode(slice)}else{source+=UTF8ToString(ptr,len)}}return source}});if(runtimeInitialized){moduleRtn=Module}else{moduleRtn=new Promise((resolve,reject)=>{readyPromiseResolve=resolve;readyPromiseReject=reject})} +;return moduleRtn}})();if(typeof exports==="object"&&typeof module==="object"){module.exports=Godot;module.exports.default=Godot}else if(typeof define==="function"&&define["amd"])define([],()=>Godot); + +const Features = { + /** + * Check whether WebGL is available. Optionally, specify a particular version of WebGL to check for. + * + * @param {number=} [majorVersion=1] The major WebGL version to check for. + * @returns {boolean} If the given major version of WebGL is available. + * @function Engine.isWebGLAvailable + */ + isWebGLAvailable: function (majorVersion = 1) { + try { + return !!document.createElement('canvas').getContext(['webgl', 'webgl2'][majorVersion - 1]); + } catch (e) { /* Not available */ } + return false; + }, + + /** + * Check whether the Fetch API available and supports streaming responses. + * + * @returns {boolean} If the Fetch API is available and supports streaming responses. + * @function Engine.isFetchAvailable + */ + isFetchAvailable: function () { + return 'fetch' in window && 'Response' in window && 'body' in window.Response.prototype; + }, + + /** + * Check whether the engine is running in a Secure Context. + * + * @returns {boolean} If the engine is running in a Secure Context. + * @function Engine.isSecureContext + */ + isSecureContext: function () { + return window['isSecureContext'] === true; + }, + + /** + * Check whether the engine is cross origin isolated. + * This value is dependent on Cross-Origin-Opener-Policy and Cross-Origin-Embedder-Policy headers sent by the server. + * + * @returns {boolean} If the engine is running in a Secure Context. + * @function Engine.isSecureContext + */ + isCrossOriginIsolated: function () { + return window['crossOriginIsolated'] === true; + }, + + /** + * Check whether SharedBufferArray is available. + * + * Most browsers require the page to be running in a secure context, and the + * the server to provide specific CORS headers for SharedArrayBuffer to be available. + * + * @returns {boolean} If SharedArrayBuffer is available. + * @function Engine.isSharedArrayBufferAvailable + */ + isSharedArrayBufferAvailable: function () { + return 'SharedArrayBuffer' in window; + }, + + /** + * Check whether the AudioContext supports AudioWorkletNodes. + * + * @returns {boolean} If AudioWorkletNode is available. + * @function Engine.isAudioWorkletAvailable + */ + isAudioWorkletAvailable: function () { + return 'AudioContext' in window && 'audioWorklet' in AudioContext.prototype; + }, + + /** + * Return an array of missing required features (as string). + * + * @returns {Array<string>} A list of human-readable missing features. + * @function Engine.getMissingFeatures + * @param {{threads: (boolean|undefined)}} supportedFeatures + */ + getMissingFeatures: function (supportedFeatures = {}) { + const { + // Quotes are needed for the Closure compiler. + 'threads': supportsThreads = true, + } = supportedFeatures; + + const missing = []; + if (!Features.isWebGLAvailable(2)) { + missing.push('WebGL2 - Check web browser configuration and hardware support'); + } + if (!Features.isFetchAvailable()) { + missing.push('Fetch - Check web browser version'); + } + if (!Features.isSecureContext()) { + missing.push('Secure Context - Check web server configuration (use HTTPS)'); + } + + if (supportsThreads) { + if (!Features.isCrossOriginIsolated()) { + missing.push('Cross-Origin Isolation - Check that the web server configuration sends the correct headers.'); + } + if (!Features.isSharedArrayBufferAvailable()) { + missing.push('SharedArrayBuffer - Check that the web server configuration sends the correct headers.'); + } + } + + // Audio is normally optional since we have a dummy fallback. + return missing; + }, +}; + +const Preloader = /** @constructor */ function () { // eslint-disable-line no-unused-vars + function getTrackedResponse(response, load_status) { + function onloadprogress(reader, controller) { + return reader.read().then(function (result) { + if (load_status.done) { + return Promise.resolve(); + } + if (result.value) { + controller.enqueue(result.value); + load_status.loaded += result.value.length; + } + if (!result.done) { + return onloadprogress(reader, controller); + } + load_status.done = true; + return Promise.resolve(); + }); + } + const reader = response.body.getReader(); + return new Response(new ReadableStream({ + start: function (controller) { + onloadprogress(reader, controller).then(function () { + controller.close(); + }); + }, + }), { headers: response.headers }); + } + + function loadFetch(file, tracker, fileSize, raw) { + tracker[file] = { + total: fileSize || 0, + loaded: 0, + done: false, + }; + return fetch(file).then(function (response) { + if (!response.ok) { + return Promise.reject(new Error(`Failed loading file '${file}'`)); + } + const tr = getTrackedResponse(response, tracker[file]); + if (raw) { + return Promise.resolve(tr); + } + return tr.arrayBuffer(); + }); + } + + function retry(func, attempts = 1) { + function onerror(err) { + if (attempts <= 1) { + return Promise.reject(err); + } + return new Promise(function (resolve, reject) { + setTimeout(function () { + retry(func, attempts - 1).then(resolve).catch(reject); + }, 1000); + }); + } + return func().catch(onerror); + } + + const DOWNLOAD_ATTEMPTS_MAX = 4; + const loadingFiles = {}; + const lastProgress = { loaded: 0, total: 0 }; + let progressFunc = null; + + const animateProgress = function () { + let loaded = 0; + let total = 0; + let totalIsValid = true; + let progressIsFinal = true; + + Object.keys(loadingFiles).forEach(function (file) { + const stat = loadingFiles[file]; + if (!stat.done) { + progressIsFinal = false; + } + if (!totalIsValid || stat.total === 0) { + totalIsValid = false; + total = 0; + } else { + total += stat.total; + } + loaded += stat.loaded; + }); + if (loaded !== lastProgress.loaded || total !== lastProgress.total) { + lastProgress.loaded = loaded; + lastProgress.total = total; + if (typeof progressFunc === 'function') { + progressFunc(loaded, total); + } + } + if (!progressIsFinal) { + requestAnimationFrame(animateProgress); + } + }; + + this.animateProgress = animateProgress; + + this.setProgressFunc = function (callback) { + progressFunc = callback; + }; + + this.loadPromise = function (file, fileSize, raw = false) { + return retry(loadFetch.bind(null, file, loadingFiles, fileSize, raw), DOWNLOAD_ATTEMPTS_MAX); + }; + + this.preloadedFiles = []; + this.preload = function (pathOrBuffer, destPath, fileSize) { + let buffer = null; + if (typeof pathOrBuffer === 'string') { + const me = this; + return this.loadPromise(pathOrBuffer, fileSize).then(function (buf) { + me.preloadedFiles.push({ + path: destPath || pathOrBuffer, + buffer: buf, + }); + return Promise.resolve(); + }); + } else if (pathOrBuffer instanceof ArrayBuffer) { + buffer = new Uint8Array(pathOrBuffer); + } else if (ArrayBuffer.isView(pathOrBuffer)) { + buffer = new Uint8Array(pathOrBuffer.buffer); + } + if (buffer) { + this.preloadedFiles.push({ + path: destPath, + buffer: pathOrBuffer, + }); + return Promise.resolve(); + } + return Promise.reject(new Error('Invalid object for preloading')); + }; +}; + +/** + * An object used to configure the Engine instance based on godot export options, and to override those in custom HTML + * templates if needed. + * + * @header Engine configuration + * @summary The Engine configuration object. This is just a typedef, create it like a regular object, e.g.: + * + * ``const MyConfig = { executable: 'godot', unloadAfterInit: false }`` + * + * @typedef {Object} EngineConfig + */ +const EngineConfig = {}; // eslint-disable-line no-unused-vars + +/** + * @struct + * @constructor + * @ignore + */ +const InternalConfig = function (initConfig) { // eslint-disable-line no-unused-vars + const cfg = /** @lends {InternalConfig.prototype} */ { + /** + * Whether to unload the engine automatically after the instance is initialized. + * + * @memberof EngineConfig + * @default + * @type {boolean} + */ + unloadAfterInit: true, + /** + * The HTML DOM Canvas object to use. + * + * By default, the first canvas element in the document will be used is none is specified. + * + * @memberof EngineConfig + * @default + * @type {?HTMLCanvasElement} + */ + canvas: null, + /** + * The name of the WASM file without the extension. (Set by Godot Editor export process). + * + * @memberof EngineConfig + * @default + * @type {string} + */ + executable: '', + /** + * An alternative name for the game pck to load. The executable name is used otherwise. + * + * @memberof EngineConfig + * @default + * @type {?string} + */ + mainPack: null, + /** + * Specify a language code to select the proper localization for the game. + * + * The browser locale will be used if none is specified. See complete list of + * :ref:`supported locales <doc_locales>`. + * + * @memberof EngineConfig + * @type {?string} + * @default + */ + locale: null, + /** + * The canvas resize policy determines how the canvas should be resized by Godot. + * + * ``0`` means Godot won't do any resizing. This is useful if you want to control the canvas size from + * javascript code in your template. + * + * ``1`` means Godot will resize the canvas on start, and when changing window size via engine functions. + * + * ``2`` means Godot will adapt the canvas size to match the whole browser window. + * + * @memberof EngineConfig + * @type {number} + * @default + */ + canvasResizePolicy: 2, + /** + * The arguments to be passed as command line arguments on startup. + * + * See :ref:`command line tutorial <doc_command_line_tutorial>`. + * + * **Note**: :js:meth:`startGame <Engine.prototype.startGame>` will always add the ``--main-pack`` argument. + * + * @memberof EngineConfig + * @type {Array<string>} + * @default + */ + args: [], + /** + * When enabled, the game canvas will automatically grab the focus when the engine starts. + * + * @memberof EngineConfig + * @type {boolean} + * @default + */ + focusCanvas: true, + /** + * When enabled, this will turn on experimental virtual keyboard support on mobile. + * + * @memberof EngineConfig + * @type {boolean} + * @default + */ + experimentalVK: false, + /** + * The progressive web app service worker to install. + * @memberof EngineConfig + * @default + * @type {string} + */ + serviceWorker: '', + /** + * @ignore + * @type {Array.<string>} + */ + persistentPaths: ['/userfs'], + /** + * @ignore + * @type {boolean} + */ + persistentDrops: false, + /** + * @ignore + * @type {Array.<string>} + */ + gdextensionLibs: [], + /** + * @ignore + * @type {Array.<string>} + */ + fileSizes: [], + /** + * @ignore + * @type {number} + */ + emscriptenPoolSize: 8, + /** + * @ignore + * @type {number} + */ + godotPoolSize: 4, + /** + * A callback function for handling Godot's ``OS.execute`` calls. + * + * This is for example used in the Web Editor template to switch between project manager and editor, and for running the game. + * + * @callback EngineConfig.onExecute + * @param {string} path The path that Godot's wants executed. + * @param {Array.<string>} args The arguments of the "command" to execute. + */ + /** + * @ignore + * @type {?function(string, Array.<string>)} + */ + onExecute: null, + /** + * A callback function for being notified when the Godot instance quits. + * + * **Note**: This function will not be called if the engine crashes or become unresponsive. + * + * @callback EngineConfig.onExit + * @param {number} status_code The status code returned by Godot on exit. + */ + /** + * @ignore + * @type {?function(number)} + */ + onExit: null, + /** + * A callback function for displaying download progress. + * + * The function is called once per frame while downloading files, so the usage of ``requestAnimationFrame()`` + * is not necessary. + * + * If the callback function receives a total amount of bytes as 0, this means that it is impossible to calculate. + * Possible reasons include: + * + * - Files are delivered with server-side chunked compression + * - Files are delivered with server-side compression on Chromium + * - Not all file downloads have started yet (usually on servers without multi-threading) + * + * @callback EngineConfig.onProgress + * @param {number} current The current amount of downloaded bytes so far. + * @param {number} total The total amount of bytes to be downloaded. + */ + /** + * @ignore + * @type {?function(number, number)} + */ + onProgress: null, + /** + * A callback function for handling the standard output stream. This method should usually only be used in debug pages. + * + * By default, ``console.log()`` is used. + * + * @callback EngineConfig.onPrint + * @param {...*} [var_args] A variadic number of arguments to be printed. + */ + /** + * @ignore + * @type {?function(...*)} + */ + onPrint: function () { + console.log.apply(console, Array.from(arguments)); // eslint-disable-line no-console + }, + /** + * A callback function for handling the standard error stream. This method should usually only be used in debug pages. + * + * By default, ``console.error()`` is used. + * + * @callback EngineConfig.onPrintError + * @param {...*} [var_args] A variadic number of arguments to be printed as errors. + */ + /** + * @ignore + * @type {?function(...*)} + */ + onPrintError: function (var_args) { + console.error.apply(console, Array.from(arguments)); // eslint-disable-line no-console + }, + }; + + /** + * @ignore + * @struct + * @constructor + * @param {EngineConfig} opts + */ + function Config(opts) { + this.update(opts); + } + + Config.prototype = cfg; + + /** + * @ignore + * @param {EngineConfig} opts + */ + Config.prototype.update = function (opts) { + const config = opts || {}; + // NOTE: We must explicitly pass the default, accessing it via + // the key will fail due to closure compiler renames. + function parse(key, def) { + if (typeof (config[key]) === 'undefined') { + return def; + } + return config[key]; + } + // Module config + this.unloadAfterInit = parse('unloadAfterInit', this.unloadAfterInit); + this.onPrintError = parse('onPrintError', this.onPrintError); + this.onPrint = parse('onPrint', this.onPrint); + this.onProgress = parse('onProgress', this.onProgress); + + // Godot config + this.canvas = parse('canvas', this.canvas); + this.executable = parse('executable', this.executable); + this.mainPack = parse('mainPack', this.mainPack); + this.locale = parse('locale', this.locale); + this.canvasResizePolicy = parse('canvasResizePolicy', this.canvasResizePolicy); + this.persistentPaths = parse('persistentPaths', this.persistentPaths); + this.persistentDrops = parse('persistentDrops', this.persistentDrops); + this.experimentalVK = parse('experimentalVK', this.experimentalVK); + this.focusCanvas = parse('focusCanvas', this.focusCanvas); + this.serviceWorker = parse('serviceWorker', this.serviceWorker); + this.gdextensionLibs = parse('gdextensionLibs', this.gdextensionLibs); + this.fileSizes = parse('fileSizes', this.fileSizes); + this.emscriptenPoolSize = parse('emscriptenPoolSize', this.emscriptenPoolSize); + this.godotPoolSize = parse('godotPoolSize', this.godotPoolSize); + this.args = parse('args', this.args); + this.onExecute = parse('onExecute', this.onExecute); + this.onExit = parse('onExit', this.onExit); + }; + + /** + * @ignore + * @param {string} loadPath + * @param {Response} response + */ + Config.prototype.getModuleConfig = function (loadPath, response) { + let r = response; + const gdext = this.gdextensionLibs; + return { + 'print': this.onPrint, + 'printErr': this.onPrintError, + 'thisProgram': this.executable, + 'noExitRuntime': false, + 'dynamicLibraries': [`${loadPath}.side.wasm`].concat(this.gdextensionLibs), + 'emscriptenPoolSize': this.emscriptenPoolSize, + 'instantiateWasm': function (imports, onSuccess) { + function done(result) { + onSuccess(result['instance'], result['module']); + } + if (typeof (WebAssembly.instantiateStreaming) !== 'undefined') { + WebAssembly.instantiateStreaming(Promise.resolve(r), imports).then(done); + } else { + r.arrayBuffer().then(function (buffer) { + WebAssembly.instantiate(buffer, imports).then(done); + }); + } + r = null; + return {}; + }, + 'locateFile': function (path) { + if (!path.startsWith('godot.')) { + return path; + } else if (path.endsWith('.audio.worklet.js')) { + return `${loadPath}.audio.worklet.js`; + } else if (path.endsWith('.audio.position.worklet.js')) { + return `${loadPath}.audio.position.worklet.js`; + } else if (path.endsWith('.js')) { + return `${loadPath}.js`; + } else if (path in gdext) { + return path; + } else if (path.endsWith('.side.wasm')) { + return `${loadPath}.side.wasm`; + } else if (path.endsWith('.wasm')) { + return `${loadPath}.wasm`; + } + return path; + }, + }; + }; + + /** + * @ignore + * @param {function()} cleanup + */ + Config.prototype.getGodotConfig = function (cleanup) { + // Try to find a canvas + if (!(this.canvas instanceof HTMLCanvasElement)) { + const nodes = document.getElementsByTagName('canvas'); + if (nodes.length && nodes[0] instanceof HTMLCanvasElement) { + const first = nodes[0]; + this.canvas = /** @type {!HTMLCanvasElement} */ (first); + } + if (!this.canvas) { + throw new Error('No canvas found in page'); + } + } + // Canvas can grab focus on click, or key events won't work. + if (this.canvas.tabIndex < 0) { + this.canvas.tabIndex = 0; + } + + // Browser locale, or custom one if defined. + let locale = this.locale; + if (!locale) { + locale = navigator.languages ? navigator.languages[0] : navigator.language; + locale = locale.split('.')[0]; + } + locale = locale.replace('-', '_'); + const onExit = this.onExit; + + // Godot configuration. + return { + 'canvas': this.canvas, + 'canvasResizePolicy': this.canvasResizePolicy, + 'locale': locale, + 'persistentDrops': this.persistentDrops, + 'virtualKeyboard': this.experimentalVK, + 'godotPoolSize': this.godotPoolSize, + 'focusCanvas': this.focusCanvas, + 'onExecute': this.onExecute, + 'onExit': function (p_code) { + cleanup(); // We always need to call the cleanup callback to free memory. + if (typeof (onExit) === 'function') { + onExit(p_code); + } + }, + }; + }; + return new Config(initConfig); +}; + +/** + * Projects exported for the Web expose the :js:class:`Engine` class to the JavaScript environment, that allows + * fine control over the engine's start-up process. + * + * This API is built in an asynchronous manner and requires basic understanding + * of `Promises <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Using_promises>`__. + * + * @module Engine + * @header Web export JavaScript reference + */ +const Engine = (function () { + const preloader = new Preloader(); + + let loadPromise = null; + let loadPath = ''; + let initPromise = null; + + /** + * @classdesc The ``Engine`` class provides methods for loading and starting exported projects on the Web. For default export + * settings, this is already part of the exported HTML page. To understand practical use of the ``Engine`` class, + * see :ref:`Custom HTML page for Web export <doc_customizing_html5_shell>`. + * + * @description Create a new Engine instance with the given configuration. + * + * @global + * @constructor + * @param {EngineConfig} initConfig The initial config for this instance. + */ + function Engine(initConfig) { // eslint-disable-line no-shadow + this.config = new InternalConfig(initConfig); + this.rtenv = null; + } + + /** + * Load the engine from the specified base path. + * + * @param {string} basePath Base path of the engine to load. + * @param {number=} [size=0] The file size if known. + * @returns {Promise} A Promise that resolves once the engine is loaded. + * + * @function Engine.load + */ + Engine.load = function (basePath, size) { + if (loadPromise == null) { + loadPath = basePath; + loadPromise = preloader.loadPromise(`${loadPath}.wasm`, size, true); + requestAnimationFrame(preloader.animateProgress); + } + return loadPromise; + }; + + /** + * Unload the engine to free memory. + * + * This method will be called automatically depending on the configuration. See :js:attr:`unloadAfterInit`. + * + * @function Engine.unload + */ + Engine.unload = function () { + loadPromise = null; + }; + + /** + * Safe Engine constructor, creates a new prototype for every new instance to avoid prototype pollution. + * @ignore + * @constructor + */ + function SafeEngine(initConfig) { + const proto = /** @lends Engine.prototype */ { + /** + * Initialize the engine instance. Optionally, pass the base path to the engine to load it, + * if it hasn't been loaded yet. See :js:meth:`Engine.load`. + * + * @param {string=} basePath Base path of the engine to load. + * @return {Promise} A ``Promise`` that resolves once the engine is loaded and initialized. + */ + init: function (basePath) { + if (initPromise) { + return initPromise; + } + if (loadPromise == null) { + if (!basePath) { + initPromise = Promise.reject(new Error('A base path must be provided when calling `init` and the engine is not loaded.')); + return initPromise; + } + Engine.load(basePath, this.config.fileSizes[`${basePath}.wasm`]); + } + const me = this; + function doInit(promise) { + // Care! Promise chaining is bogus with old emscripten versions. + // This caused a regression with the Mono build (which uses an older emscripten version). + // Make sure to test that when refactoring. + return new Promise(function (resolve, reject) { + promise.then(function (response) { + const cloned = new Response(response.clone().body, { 'headers': [['content-type', 'application/wasm']] }); + Godot(me.config.getModuleConfig(loadPath, cloned)).then(function (module) { + const paths = me.config.persistentPaths; + module['initFS'](paths).then(function (err) { + me.rtenv = module; + if (me.config.unloadAfterInit) { + Engine.unload(); + } + resolve(); + }); + }); + }); + }); + } + preloader.setProgressFunc(this.config.onProgress); + initPromise = doInit(loadPromise); + return initPromise; + }, + + /** + * Load a file so it is available in the instance's file system once it runs. Must be called **before** starting the + * instance. + * + * If not provided, the ``path`` is derived from the URL of the loaded file. + * + * @param {string|ArrayBuffer} file The file to preload. + * + * If a ``string`` the file will be loaded from that path. + * + * If an ``ArrayBuffer`` or a view on one, the buffer will used as the content of the file. + * + * @param {string=} path Path by which the file will be accessible. Required, if ``file`` is not a string. + * + * @returns {Promise} A Promise that resolves once the file is loaded. + */ + preloadFile: function (file, path) { + return preloader.preload(file, path, this.config.fileSizes[file]); + }, + + /** + * Start the engine instance using the given override configuration (if any). + * :js:meth:`startGame <Engine.prototype.startGame>` can be used in typical cases instead. + * + * This will initialize the instance if it is not initialized. For manual initialization, see :js:meth:`init <Engine.prototype.init>`. + * The engine must be loaded beforehand. + * + * Fails if a canvas cannot be found on the page, or not specified in the configuration. + * + * @param {EngineConfig} override An optional configuration override. + * @return {Promise} Promise that resolves once the engine started. + */ + start: function (override) { + this.config.update(override); + const me = this; + return me.init().then(function () { + if (!me.rtenv) { + return Promise.reject(new Error('The engine must be initialized before it can be started')); + } + + let config = {}; + try { + config = me.config.getGodotConfig(function () { + me.rtenv = null; + }); + } catch (e) { + return Promise.reject(e); + } + // Godot configuration. + me.rtenv['initConfig'](config); + + // Preload GDExtension libraries. + if (me.config.gdextensionLibs.length > 0 && !me.rtenv['loadDynamicLibrary']) { + return Promise.reject(new Error('GDExtension libraries are not supported by this engine version. ' + + 'Enable "Extensions Support" for your export preset and/or build your custom template with "dlink_enabled=yes".')); + } + return new Promise(function (resolve, reject) { + for (const file of preloader.preloadedFiles) { + me.rtenv['copyToFS'](file.path, file.buffer); + } + preloader.preloadedFiles.length = 0; // Clear memory + me.rtenv['callMain'](me.config.args); + initPromise = null; + me.installServiceWorker(); + resolve(); + }); + }); + }, + + /** + * Start the game instance using the given configuration override (if any). + * + * This will initialize the instance if it is not initialized. For manual initialization, see :js:meth:`init <Engine.prototype.init>`. + * + * This will load the engine if it is not loaded, and preload the main pck. + * + * This method expects the initial config (or the override) to have both the :js:attr:`executable` and :js:attr:`mainPack` + * properties set (normally done by the editor during export). + * + * @param {EngineConfig} override An optional configuration override. + * @return {Promise} Promise that resolves once the game started. + */ + startGame: function (override) { + this.config.update(override); + // Add main-pack argument. + const exe = this.config.executable; + const pack = this.config.mainPack || `${exe}.pck`; + this.config.args = ['--main-pack', pack].concat(this.config.args); + // Start and init with execName as loadPath if not inited. + const me = this; + return Promise.all([ + this.init(exe), + this.preloadFile(pack, pack), + ]).then(function () { + return me.start.apply(me); + }); + }, + + /** + * Create a file at the specified ``path`` with the passed as ``buffer`` in the instance's file system. + * + * @param {string} path The location where the file will be created. + * @param {ArrayBuffer} buffer The content of the file. + */ + copyToFS: function (path, buffer) { + if (this.rtenv == null) { + throw new Error('Engine must be inited before copying files'); + } + this.rtenv['copyToFS'](path, buffer); + }, + + /** + * Request that the current instance quit. + * + * This is akin the user pressing the close button in the window manager, and will + * have no effect if the engine has crashed, or is stuck in a loop. + * + */ + requestQuit: function () { + if (this.rtenv) { + this.rtenv['request_quit'](); + } + }, + + /** + * Install the progressive-web app service worker. + * @returns {Promise} The service worker registration promise. + */ + installServiceWorker: function () { + if (this.config.serviceWorker && 'serviceWorker' in navigator) { + try { + return navigator.serviceWorker.register(this.config.serviceWorker); + } catch (e) { + return Promise.reject(e); + } + } + return Promise.resolve(); + }, + }; + + Engine.prototype = proto; + // Closure compiler exported instance methods. + Engine.prototype['init'] = Engine.prototype.init; + Engine.prototype['preloadFile'] = Engine.prototype.preloadFile; + Engine.prototype['start'] = Engine.prototype.start; + Engine.prototype['startGame'] = Engine.prototype.startGame; + Engine.prototype['copyToFS'] = Engine.prototype.copyToFS; + Engine.prototype['requestQuit'] = Engine.prototype.requestQuit; + Engine.prototype['installServiceWorker'] = Engine.prototype.installServiceWorker; + // Also expose static methods as instance methods + Engine.prototype['load'] = Engine.load; + Engine.prototype['unload'] = Engine.unload; + return new Engine(initConfig); + } + + // Closure compiler exported static methods. + SafeEngine['load'] = Engine.load; + SafeEngine['unload'] = Engine.unload; + + // Feature-detection utilities. + SafeEngine['isWebGLAvailable'] = Features.isWebGLAvailable; + SafeEngine['isFetchAvailable'] = Features.isFetchAvailable; + SafeEngine['isSecureContext'] = Features.isSecureContext; + SafeEngine['isCrossOriginIsolated'] = Features.isCrossOriginIsolated; + SafeEngine['isSharedArrayBufferAvailable'] = Features.isSharedArrayBufferAvailable; + SafeEngine['isAudioWorkletAvailable'] = Features.isAudioWorkletAvailable; + SafeEngine['getMissingFeatures'] = Features.getMissingFeatures; + + return SafeEngine; +}()); +if (typeof window !== 'undefined') { + window['Engine'] = Engine; +} diff --git a/2026/games_submissions/mankeymaster18/index.manifest.json b/2026/games_submissions/mankeymaster18/index.manifest.json new file mode 100644 index 0000000..4e314c1 --- /dev/null +++ b/2026/games_submissions/mankeymaster18/index.manifest.json @@ -0,0 +1 @@ +{"background_color":"#000000","display":"browser","icons":[{"sizes":"144x144","src":"index.144x144.png","type":"image/png"},{"sizes":"180x180","src":"index.180x180.png","type":"image/png"},{"sizes":"512x512","src":"index.512x512.png","type":"image/png"}],"name":"Crimes against Ratmanity","orientation":"any","start_url":"./index.html"}
\ No newline at end of file diff --git a/2026/games_submissions/mankeymaster18/index.offline.html b/2026/games_submissions/mankeymaster18/index.offline.html new file mode 100644 index 0000000..ae5298a --- /dev/null +++ b/2026/games_submissions/mankeymaster18/index.offline.html @@ -0,0 +1,41 @@ +<!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"> + <title>You are offline</title> + <style> +html { + background-color: #000000; + color: #ffffff; +} + +body { + font-family: system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji"; + margin: 2rem; +} + +p { + margin-block: 1rem; +} + +button { + display: block; + padding: 1rem 2rem; + margin: 3rem auto 0; +} + </style> + </head> + <body> + <h1>You are offline</h1> + <p>This application requires an Internet connection to run for the first time.</p> + <p>Press the button below to try reloading:</p> + <button type="button">Reload</button> + <script> +document.querySelector('button').addEventListener('click', () => { + window.location.reload(); +}); + </script> + </body> +</html> diff --git a/2026/games_submissions/mankeymaster18/index.pck b/2026/games_submissions/mankeymaster18/index.pck Binary files differnew file mode 100644 index 0000000..8f04fcf --- /dev/null +++ b/2026/games_submissions/mankeymaster18/index.pck diff --git a/2026/games_submissions/mankeymaster18/index.png b/2026/games_submissions/mankeymaster18/index.png Binary files differnew file mode 100644 index 0000000..1a40e71 --- /dev/null +++ b/2026/games_submissions/mankeymaster18/index.png diff --git a/2026/games_submissions/mankeymaster18/index.service.worker.js b/2026/games_submissions/mankeymaster18/index.service.worker.js new file mode 100644 index 0000000..7227101 --- /dev/null +++ b/2026/games_submissions/mankeymaster18/index.service.worker.js @@ -0,0 +1,166 @@ +// This service worker is required to expose an exported Godot project as a +// Progressive Web App. It provides an offline fallback page telling the user +// that they need an Internet connection to run the project if desired. +// Incrementing CACHE_VERSION will kick off the install event and force +// previously cached resources to be updated from the network. +/** @type {string} */ +const CACHE_VERSION = '1785459040|299428606'; +/** @type {string} */ +const CACHE_PREFIX = 'Crimes against R-sw-cache-'; +const CACHE_NAME = CACHE_PREFIX + CACHE_VERSION; +/** @type {string} */ +const OFFLINE_URL = 'index.offline.html'; +/** @type {boolean} */ +const ENSURE_CROSSORIGIN_ISOLATION_HEADERS = true; +// Files that will be cached on load. +/** @type {string[]} */ +const CACHED_FILES = ["index.html","index.js","index.offline.html","index.icon.png","index.apple-touch-icon.png","index.audio.worklet.js","index.audio.position.worklet.js"]; +// Files that we might not want the user to preload, and will only be cached on first load. +/** @type {string[]} */ +const CACHEABLE_FILES = ["index.wasm","index.pck"]; +const FULL_CACHE = CACHED_FILES.concat(CACHEABLE_FILES); + +self.addEventListener('install', (event) => { + event.waitUntil(caches.open(CACHE_NAME).then((cache) => cache.addAll(CACHED_FILES))); +}); + +self.addEventListener('activate', (event) => { + event.waitUntil(caches.keys().then( + function (keys) { + // Remove old caches. + return Promise.all(keys.filter((key) => key.startsWith(CACHE_PREFIX) && key !== CACHE_NAME).map((key) => caches.delete(key))); + } + ).then(function () { + // Enable navigation preload if available. + return ('navigationPreload' in self.registration) ? self.registration.navigationPreload.enable() : Promise.resolve(); + })); +}); + +/** + * Ensures that the response has the correct COEP/COOP headers + * @param {Response} response + * @returns {Response} + */ +function ensureCrossOriginIsolationHeaders(response) { + if (response.headers.get('Cross-Origin-Embedder-Policy') === 'require-corp' + && response.headers.get('Cross-Origin-Opener-Policy') === 'same-origin') { + return response; + } + + const crossOriginIsolatedHeaders = new Headers(response.headers); + crossOriginIsolatedHeaders.set('Cross-Origin-Embedder-Policy', 'require-corp'); + crossOriginIsolatedHeaders.set('Cross-Origin-Opener-Policy', 'same-origin'); + const newResponse = new Response(response.body, { + status: response.status, + statusText: response.statusText, + headers: crossOriginIsolatedHeaders, + }); + + return newResponse; +} + +/** + * Calls fetch and cache the result if it is cacheable + * @param {FetchEvent} event + * @param {Cache} cache + * @param {boolean} isCacheable + * @returns {Response} + */ +async function fetchAndCache(event, cache, isCacheable) { + // Use the preloaded response, if it's there + /** @type { Response } */ + let response = await event.preloadResponse; + if (response == null) { + // Or, go over network. + response = await self.fetch(event.request); + } + + if (ENSURE_CROSSORIGIN_ISOLATION_HEADERS) { + response = ensureCrossOriginIsolationHeaders(response); + } + + if (isCacheable) { + // And update the cache + cache.put(event.request, response.clone()); + } + + return response; +} + +self.addEventListener( + 'fetch', + /** + * Triggered on fetch + * @param {FetchEvent} event + */ + (event) => { + const isNavigate = event.request.mode === 'navigate'; + const url = event.request.url || ''; + const referrer = event.request.referrer || ''; + const base = referrer.slice(0, referrer.lastIndexOf('/') + 1); + const local = url.startsWith(base) ? url.replace(base, '') : ''; + const isCacheable = FULL_CACHE.some((v) => v === local) || (base === referrer && base.endsWith(CACHED_FILES[0])); + if (isNavigate || isCacheable) { + event.respondWith((async () => { + // Try to use cache first + const cache = await caches.open(CACHE_NAME); + if (isNavigate) { + // Check if we have full cache during HTML page request. + /** @type {Response[]} */ + const fullCache = await Promise.all(FULL_CACHE.map((name) => cache.match(name))); + const missing = fullCache.some((v) => v === undefined); + if (missing) { + try { + // Try network if some cached file is missing (so we can display offline page in case). + const response = await fetchAndCache(event, cache, isCacheable); + return response; + } catch (e) { + // And return the hopefully always cached offline page in case of network failure. + console.error('Network error: ', e); // eslint-disable-line no-console + return caches.match(OFFLINE_URL); + } + } + } + let cached = await cache.match(event.request); + if (cached != null) { + if (ENSURE_CROSSORIGIN_ISOLATION_HEADERS) { + cached = ensureCrossOriginIsolationHeaders(cached); + } + return cached; + } + // Try network if don't have it in cache. + const response = await fetchAndCache(event, cache, isCacheable); + return response; + })()); + } else if (ENSURE_CROSSORIGIN_ISOLATION_HEADERS) { + event.respondWith((async () => { + let response = await fetch(event.request); + response = ensureCrossOriginIsolationHeaders(response); + return response; + })()); + } + } +); + +self.addEventListener('message', (event) => { + // No cross origin + if (event.origin !== self.origin) { + return; + } + const id = event.source.id || ''; + const msg = event.data || ''; + // Ensure it's one of our clients. + self.clients.get(id).then(function (client) { + if (!client) { + return; // Not a valid client. + } + if (msg === 'claim') { + self.skipWaiting().then(() => self.clients.claim()); + } else if (msg === 'clear') { + caches.delete(CACHE_NAME); + } else if (msg === 'update') { + self.skipWaiting().then(() => self.clients.claim()).then(() => self.clients.matchAll()).then((all) => all.forEach((c) => c.navigate(c.url))); + } + }); +}); + diff --git a/2026/games_submissions/mankeymaster18/index.wasm b/2026/games_submissions/mankeymaster18/index.wasm Binary files differnew file mode 100644 index 0000000..9b5c8b8 --- /dev/null +++ b/2026/games_submissions/mankeymaster18/index.wasm diff --git a/2026/games_submissions/rpc2dot0/.cargo/config.toml b/2026/games_submissions/rpc2dot0/.cargo/config.toml new file mode 100644 index 0000000..2abe49c --- /dev/null +++ b/2026/games_submissions/rpc2dot0/.cargo/config.toml @@ -0,0 +1,2 @@ +[build]
+target = "wasm32-unknown-unknown"
diff --git a/2026/games_submissions/rpc2dot0/Cargo.lock b/2026/games_submissions/rpc2dot0/Cargo.lock new file mode 100644 index 0000000..11a75df --- /dev/null +++ b/2026/games_submissions/rpc2dot0/Cargo.lock @@ -0,0 +1,3717 @@ +# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "ab_glyph"
+version = "0.2.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01c0457472c38ea5bd1c3b5ada5e368271cb550be7a4ca4a0b4634e9913f6cc2"
+dependencies = [
+ "ab_glyph_rasterizer",
+ "owned_ttf_parser",
+]
+
+[[package]]
+name = "ab_glyph_rasterizer"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "366ffbaa4442f4684d91e2cd7c5ea7c4ed8add41959a31447066e279e432b618"
+
+[[package]]
+name = "adler2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
+
+[[package]]
+name = "ahash"
+version = "0.8.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b79b82693f705137f8fb9b37871d99e4f9a7df12b917eed79c3d3954830a60b"
+dependencies = [
+ "cfg-if",
+ "getrandom 0.2.17",
+ "once_cell",
+ "version_check",
+ "zerocopy 0.7.35",
+]
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "allocator-api2"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
+
+[[package]]
+name = "alsa"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed7572b7ba83a31e20d1b48970ee402d2e3e0537dcfe0a3ff4d6eb7508617d43"
+dependencies = [
+ "alsa-sys",
+ "bitflags 2.12.1",
+ "cfg-if",
+ "libc",
+]
+
+[[package]]
+name = "alsa-sys"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db8fee663d06c4e303404ef5f40488a53e062f89ba8bfed81f42325aafad1527"
+dependencies = [
+ "libc",
+ "pkg-config",
+]
+
+[[package]]
+name = "android-activity"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee91c0c2905bae44f84bfa4e044536541df26b7703fd0888deeb9060fcc44289"
+dependencies = [
+ "android-properties",
+ "bitflags 2.12.1",
+ "cc",
+ "cesu8",
+ "jni",
+ "jni-sys 0.3.1",
+ "libc",
+ "log",
+ "ndk",
+ "ndk-context",
+ "ndk-sys",
+ "num_enum",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "android-properties"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc7eb209b1518d6bb87b283c20095f5228ecda460da70b44f0802523dea6da04"
+
+[[package]]
+name = "anstream"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d"
+dependencies = [
+ "anstyle",
+ "anstyle-parse",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is_terminal_polyfill",
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle"
+version = "1.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000"
+
+[[package]]
+name = "anstyle-parse"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e"
+dependencies = [
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle-query"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "anstyle-wincon"
+version = "3.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
+dependencies = [
+ "anstyle",
+ "once_cell_polyfill",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.102"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
+
+[[package]]
+name = "approx"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cab112f0a86d568ea0e627cc1d6be74a1e9cd55214684db5561995f6dad897c6"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "arrayref"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"
+
+[[package]]
+name = "arrayvec"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
+
+[[package]]
+name = "as-raw-xcb-connection"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "175571dd1d178ced59193a6fc02dde1b972eb0bc56c892cde9beeceac5bf0f6b"
+
+[[package]]
+name = "atomic-waker"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
+
+[[package]]
+name = "autocfg"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
+
+[[package]]
+name = "base64"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
+
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
+[[package]]
+name = "bimap"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "230c5f1ca6a325a32553f8640d31ac9b49f2411e901e427570154868b46da4f7"
+
+[[package]]
+name = "bincode"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36eaf5d7b090263e8150820482d5d93cd964a81e4019913c972f4edcc6edb740"
+dependencies = [
+ "bincode_derive",
+ "serde",
+ "unty",
+]
+
+[[package]]
+name = "bincode_derive"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf95709a440f45e986983918d0e8a1f30a9b1df04918fc828670606804ac3c09"
+dependencies = [
+ "virtue",
+]
+
+[[package]]
+name = "bindgen"
+version = "0.72.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "993776b509cfb49c750f11b8f07a46fa23e0a1386ffc01fb1e7d343efc387895"
+dependencies = [
+ "bitflags 2.12.1",
+ "cexpr",
+ "clang-sys",
+ "itertools",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "rustc-hash",
+ "shlex 1.3.0",
+ "syn",
+]
+
+[[package]]
+name = "bit-vec"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2c54ff287cfc0a34f38a6b832ea1bd8e448a330b3e40a50859e6488bee07f22"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bitflags"
+version = "2.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84d7ced0ae9557296835c32bf1b1e02b44c746701f898460fb000d7eaa84f00a"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "block-sys"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae85a0696e7ea3b835a453750bf002770776609115e6d25c6d2ff28a8200f7e7"
+dependencies = [
+ "objc-sys",
+]
+
+[[package]]
+name = "block2"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15b55663a85f33501257357e6421bb33e769d5c9ffb5ba0921c975a123e35e68"
+dependencies = [
+ "block-sys",
+ "objc2 0.4.1",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.20.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"
+
+[[package]]
+name = "bytemuck"
+version = "1.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8efb64bd706a16a1bdde310ae86b351e4d21550d98d056f22f8a7f7a2183fec"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "byteorder-lite"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495"
+
+[[package]]
+name = "bytes"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
+
+[[package]]
+name = "calloop"
+version = "0.12.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fba7adb4dd5aa98e5553510223000e7148f621165ec5f9acd7113f6ca4995298"
+dependencies = [
+ "bitflags 2.12.1",
+ "log",
+ "polling",
+ "rustix 0.38.44",
+ "slab",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "calloop-wayland-source"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f0ea9b9476c7fad82841a8dbb380e2eae480c21910feba80725b46931ed8f02"
+dependencies = [
+ "calloop",
+ "rustix 0.38.44",
+ "wayland-backend",
+ "wayland-client",
+]
+
+[[package]]
+name = "cc"
+version = "1.2.63"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "556e016178bb5662a08681bbe0f00f8e17631781a4dfc8c45e466e4b185ec27f"
+dependencies = [
+ "find-msvc-tools",
+ "jobserver",
+ "libc",
+ "shlex 2.0.1",
+]
+
+[[package]]
+name = "cesu8"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c"
+
+[[package]]
+name = "cexpr"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
+dependencies = [
+ "nom",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "cfg_aliases"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e"
+
+[[package]]
+name = "clang-sys"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4"
+dependencies = [
+ "glob",
+ "libc",
+ "libloading",
+]
+
+[[package]]
+name = "colorchoice"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"
+
+[[package]]
+name = "combine"
+version = "4.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba5a308b75df32fe02788e748662718f03fde005016435c444eea572398219fd"
+dependencies = [
+ "bytes",
+ "memchr",
+]
+
+[[package]]
+name = "concurrent-queue"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "console_error_panic_hook"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "console_log"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be8aed40e4edbf4d3b4431ab260b63fdc40f5780a4766824329ea0f1eefe3c0f"
+dependencies = [
+ "log",
+ "web-sys",
+]
+
+[[package]]
+name = "core-foundation"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
+
+[[package]]
+name = "core-graphics"
+version = "0.23.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c07782be35f9e1140080c6b96f0d44b739e2278479f64e02fdab4e32dfd8b081"
+dependencies = [
+ "bitflags 1.3.2",
+ "core-foundation 0.9.4",
+ "core-graphics-types",
+ "foreign-types 0.5.0",
+ "libc",
+]
+
+[[package]]
+name = "core-graphics-types"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "45390e6114f68f718cc7a830514a96f903cccd70d02a8f6d9f643ac4ba45afaf"
+dependencies = [
+ "bitflags 1.3.2",
+ "core-foundation 0.9.4",
+ "libc",
+]
+
+[[package]]
+name = "coreaudio-rs"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "321077172d79c662f64f5071a03120748d5bb652f5231570141be24cfcd2bace"
+dependencies = [
+ "bitflags 1.3.2",
+ "core-foundation-sys",
+ "coreaudio-sys",
+]
+
+[[package]]
+name = "coreaudio-sys"
+version = "0.2.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9b4739a805a62757a83e5654fa3faabec0442666b263bb2287d5a8185bfd953"
+dependencies = [
+ "bindgen",
+]
+
+[[package]]
+name = "cpal"
+version = "0.15.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "873dab07c8f743075e57f524c583985fbaf745602acbe916a01539364369a779"
+dependencies = [
+ "alsa",
+ "core-foundation-sys",
+ "coreaudio-rs",
+ "dasp_sample",
+ "jni",
+ "js-sys",
+ "libc",
+ "mach2",
+ "ndk",
+ "ndk-context",
+ "oboe",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+ "windows",
+]
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crc32fast"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "crossbeam"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1137cd7e7fc0fb5d3c5a8678be38ec56e819125d8d7907411fe24ccb943faca8"
+dependencies = [
+ "crossbeam-channel",
+ "crossbeam-deque",
+ "crossbeam-epoch",
+ "crossbeam-queue",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-queue"
+version = "0.3.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f58bbc28f91df819d0aa2a2c00cd19754769c2fad90579b3592b1c9ba7a3115"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "cursor-icon"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f27ae1dd37df86211c42e150270f82743308803d90a6f6e6651cd730d5e1732f"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "dasp_sample"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c87e182de0887fd5361989c677c4e8f5000cd9491d6d563161a8f3a5519fc7f"
+
+[[package]]
+name = "data-encoding"
+version = "2.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4ae5f15dda3c708c0ade84bfee31ccab44a3da4f88015ed22f63732abe300c8"
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
+[[package]]
+name = "directories"
+version = "6.0.0"
+source = "git+https://github.com/lcolonq/directories-rs#164536daab2c07265167715934081cb1942387b0"
+dependencies = [
+ "dirs-sys",
+]
+
+[[package]]
+name = "dirs-sys"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e01a3366d27ee9890022452ee61b2b63a67e6f13f58900b651ff5665f0bb1fab"
+dependencies = [
+ "libc",
+ "option-ext",
+ "redox_users",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "dispatch"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd0c93bb4b0c6d9b77f4435b0ae98c24d17f1c45b2ff844c6151a07256ca923b"
+
+[[package]]
+name = "dlib"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab8ecd87370524b461f8557c119c405552c396ed91fc0a8eec68679eab26f94a"
+dependencies = [
+ "libloading",
+]
+
+[[package]]
+name = "downcast-rs"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75b325c5dbd37f80359721ad39aca5a29fb04c89279657cffdda8736d0c0b9d2"
+
+[[package]]
+name = "eatyourgreens"
+version = "0.1.0"
+dependencies = [
+ "enum-map",
+ "glam",
+ "js-sys",
+ "log",
+ "rand",
+ "rand_chacha",
+ "serde",
+ "serde-wasm-bindgen",
+ "teleia",
+ "teleia_macros",
+ "wasm-bindgen",
+ "web-sys",
+ "winit",
+]
+
+[[package]]
+name = "either"
+version = "1.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91622ff5e7162018101f2fea40d6ebf4a78bbe5a49736a2020649edf9693679e"
+
+[[package]]
+name = "ena"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eabffdaee24bd1bf95c5ef7cec31260444317e72ea56c4c91750e8b7ee58d5f1"
+dependencies = [
+ "log",
+]
+
+[[package]]
+name = "encoding_rs"
+version = "0.8.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "enum-map"
+version = "2.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6866f3bfdf8207509a033af1a75a7b08abda06bbaaeae6669323fd5a097df2e9"
+dependencies = [
+ "enum-map-derive",
+ "serde",
+]
+
+[[package]]
+name = "enum-map-derive"
+version = "0.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f282cfdfe92516eb26c2af8589c274c7c17681f5ecc03c18255fe741c6aa64eb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "env"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc95de49ad098572c02d3fbf368c9a020bfff5ae78483685b77f51d8a7e9486d"
+dependencies = [
+ "num_threads",
+]
+
+[[package]]
+name = "env_filter"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32e90c2accc4b07a8456ea0debdc2e7587bdd890680d71173a15d4ae604f6eef"
+dependencies = [
+ "log",
+ "regex",
+]
+
+[[package]]
+name = "env_logger"
+version = "0.11.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0621c04f2196ac3f488dd583365b9c09be011a4ab8b9f37248ffcc8f6198b56a"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "env_filter",
+ "jiff",
+ "log",
+]
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "errno"
+version = "0.3.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "extended"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af9673d8203fcb076b19dfd17e38b3d4ae9f44959416ea532ce72415a6020365"
+
+[[package]]
+name = "eyre"
+version = "0.6.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7cd915d99f24784cdc19fd37ef22b97e3ff0ae756c7e492e9fbfe897d61e2aec"
+dependencies = [
+ "indenter",
+ "once_cell",
+]
+
+[[package]]
+name = "fastrand"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6"
+
+[[package]]
+name = "fdeflate"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c"
+dependencies = [
+ "simd-adler32",
+]
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+
+[[package]]
+name = "flate2"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "foldhash"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+
+[[package]]
+name = "foldhash"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
+
+[[package]]
+name = "foreign-types"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
+dependencies = [
+ "foreign-types-shared 0.1.1",
+]
+
+[[package]]
+name = "foreign-types"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d737d9aa519fb7b749cbc3b962edcf310a8dd1f4b67c91c4f83975dbdd17d965"
+dependencies = [
+ "foreign-types-macros",
+ "foreign-types-shared 0.3.1",
+]
+
+[[package]]
+name = "foreign-types-macros"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a5c6c585bc94aaf2c7b51dd4c2ba22680844aba4c687be581871a6f518c5742"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "foreign-types-shared"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
+
+[[package]]
+name = "foreign-types-shared"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b"
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "gethostname"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bd49230192a3797a9a4d6abe9b3eed6f7fa4c8a8a4947977c6f80025f92cbd8"
+dependencies = [
+ "rustix 1.1.4",
+ "windows-link",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "libc",
+ "wasi",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi 5.3.0",
+ "wasip2",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi 6.0.0",
+ "wasip2",
+ "wasip3",
+]
+
+[[package]]
+name = "glam"
+version = "0.29.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8babf46d4c1c9d92deac9f7be466f76dfc4482b6452fc5024b5e8daf6ffeb3ee"
+dependencies = [
+ "mint",
+]
+
+[[package]]
+name = "glfw"
+version = "0.59.0"
+source = "git+https://github.com/lcolonq/glfw-rs#1ce13a2bcf3ef3bf6184bcb4c2a90d9034956841"
+dependencies = [
+ "bitflags 1.3.2",
+ "objc2 0.5.2",
+ "raw-window-handle",
+ "serde",
+ "winapi",
+]
+
+[[package]]
+name = "glob"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
+
+[[package]]
+name = "glow"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd348e04c43b32574f2de31c8bb397d96c9fcfa1371bd4ca6d8bdc464ab121b1"
+dependencies = [
+ "js-sys",
+ "slotmap",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "gltf"
+version = "1.4.1"
+source = "git+https://github.com/lcolonq/gltf#9763a5abe8c168eb1282a037ff16668542fe2a6d"
+dependencies = [
+ "base64 0.13.1",
+ "byteorder",
+ "gltf-json",
+ "image",
+ "lazy_static",
+ "serde_json",
+ "urlencoding",
+]
+
+[[package]]
+name = "gltf-derive"
+version = "1.4.1"
+source = "git+https://github.com/lcolonq/gltf#9763a5abe8c168eb1282a037ff16668542fe2a6d"
+dependencies = [
+ "inflections",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "gltf-json"
+version = "1.4.1"
+source = "git+https://github.com/lcolonq/gltf#9763a5abe8c168eb1282a037ff16668542fe2a6d"
+dependencies = [
+ "gltf-derive",
+ "serde",
+ "serde_derive",
+ "serde_json",
+]
+
+[[package]]
+name = "hash32"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47d60b12902ba28e2730cd37e95b8c9223af2808df9e902d4df49588d1470606"
+dependencies = [
+ "byteorder",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.15.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+dependencies = [
+ "foldhash 0.1.5",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+dependencies = [
+ "allocator-api2",
+ "equivalent",
+ "foldhash 0.2.0",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.17.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
+
+[[package]]
+name = "heapless"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bfb9eb618601c89945a70e254898da93b13be0388091d42117462b265bb3fad"
+dependencies = [
+ "hash32",
+ "stable_deref_trait",
+]
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "hermit-abi"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
+
+[[package]]
+name = "http"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8be7462df143984c4598a256ef469b251d7d7f9e271135073e78fc535414f3d0"
+dependencies = [
+ "bytes",
+ "itoa",
+]
+
+[[package]]
+name = "httparse"
+version = "1.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
+
+[[package]]
+name = "icrate"
+version = "0.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99d3aaff8a54577104bafdf686ff18565c3b6903ca5782a2026ef06e2c7aa319"
+dependencies = [
+ "block2",
+ "dispatch",
+ "objc2 0.4.1",
+]
+
+[[package]]
+name = "id-arena"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
+
+[[package]]
+name = "image"
+version = "0.25.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85ab80394333c02fe689eaf900ab500fbd0c2213da414687ebf995a65d5a6104"
+dependencies = [
+ "bytemuck",
+ "byteorder-lite",
+ "moxcms",
+ "num-traits",
+ "png",
+ "zune-core",
+ "zune-jpeg",
+]
+
+[[package]]
+name = "indenter"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "964de6e86d545b246d84badc0fef527924ace5134f30641c203ef52ba83f58d5"
+
+[[package]]
+name = "indexmap"
+version = "2.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.17.1",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "inflections"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a257582fdcde896fd96463bf2d40eefea0580021c0712a0e2b028b60b47a837a"
+
+[[package]]
+name = "is_terminal_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
+
+[[package]]
+name = "itertools"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+
+[[package]]
+name = "jiff"
+version = "0.2.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4603d3033e49e2b0e31229fcab20a5d40089c607d975cd9c80551dc69eed9102"
+dependencies = [
+ "jiff-static",
+ "log",
+ "portable-atomic",
+ "portable-atomic-util",
+ "serde_core",
+]
+
+[[package]]
+name = "jiff-static"
+version = "0.2.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "782d32378dddf207193ac91cefb848ad41abb58195c95168e1291227a0832b47"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "jni"
+version = "0.21.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a87aa2bb7d2af34197c04845522473242e1aa17c12f4935d5856491a7fb8c97"
+dependencies = [
+ "cesu8",
+ "cfg-if",
+ "combine",
+ "jni-sys 0.3.1",
+ "log",
+ "thiserror 1.0.69",
+ "walkdir",
+ "windows-sys 0.45.0",
+]
+
+[[package]]
+name = "jni-sys"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41a652e1f9b6e0275df1f15b32661cf0d4b78d4d87ddec5e0c3c20f097433258"
+dependencies = [
+ "jni-sys 0.4.1",
+]
+
+[[package]]
+name = "jni-sys"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6377a88cb3910bee9b0fa88d4f42e1d2da8e79915598f65fb0c7ee14c878af2"
+dependencies = [
+ "jni-sys-macros",
+]
+
+[[package]]
+name = "jni-sys-macros"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38c0b942f458fe50cdac086d2f946512305e5631e720728f2a61aabcd47a6264"
+dependencies = [
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "jobserver"
+version = "0.1.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33"
+dependencies = [
+ "getrandom 0.3.4",
+ "libc",
+]
+
+[[package]]
+name = "js-sys"
+version = "0.3.77"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1cfaf33c695fc6e08064efbc1f72ec937429614f25eef83af942d0e227c3a28f"
+dependencies = [
+ "once_cell",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "kira"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb5a9f9dff5e262540b628b00d5e1a772270a962d6869f8695bb24832ff3b394"
+dependencies = [
+ "cpal",
+ "glam",
+ "mint",
+ "paste",
+ "ringbuf",
+ "send_wrapper",
+ "symphonia",
+ "triple_buffer",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
+[[package]]
+name = "leb128fmt"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
+
+[[package]]
+name = "libc"
+version = "0.2.186"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
+
+[[package]]
+name = "libloading"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55"
+dependencies = [
+ "cfg-if",
+ "windows-link",
+]
+
+[[package]]
+name = "libm"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
+
+[[package]]
+name = "libredox"
+version = "0.1.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f02ab6bace2054fb888a3c16f990117b579d14a3088e472d63c6011fa185c9d3"
+dependencies = [
+ "bitflags 2.12.1",
+ "libc",
+ "plain",
+ "redox_syscall 0.8.1",
+]
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.4.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
+
+[[package]]
+name = "litrs"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11d3d7f243d5c5a8b9bb5d6dd2b1602c0cb0b9db1621bafc7ed66e35ff9fe092"
+
+[[package]]
+name = "log"
+version = "0.4.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "953f07c43838f8e6f9758cab68bf5bed85465e7587ebe0b823f1bcd81978ad3a"
+
+[[package]]
+name = "mach2"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d640282b302c0bb0a2a8e0233ead9035e3bed871f0b7e81fe4a1ec829765db44"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "matrixmultiply"
+version = "0.3.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a06de3016e9fae57a36fd14dba131fccf49f74b40b7fbdb472f96e361ec71a08"
+dependencies = [
+ "autocfg",
+ "rawpointer",
+]
+
+[[package]]
+name = "memchr"
+version = "2.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b947ae49db0d222b1dbc6b113ce7248a3fc3a6ca21b696717bfc000ba4484d8"
+
+[[package]]
+name = "memmap2"
+version = "0.9.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "714098028fe011992e1c3962653c96b2d578c4b4bce9036e15ff220319b1e0e3"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
+[[package]]
+name = "miniz_oxide"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
+dependencies = [
+ "adler2",
+ "simd-adler32",
+]
+
+[[package]]
+name = "mint"
+version = "0.5.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e53debba6bda7a793e5f99b8dacf19e626084f525f7829104ba9898f367d85ff"
+
+[[package]]
+name = "moxcms"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb85c154ba489f01b25c0d36ae69a87e4a1c73a72631fc6c0eb6dde34a73e44b"
+dependencies = [
+ "num-traits",
+ "pxfm",
+]
+
+[[package]]
+name = "nalgebra"
+version = "0.33.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d43ddcacf343185dfd6de2ee786d9e8b1c2301622afab66b6c73baf9882abfd"
+dependencies = [
+ "approx",
+ "glam",
+ "matrixmultiply",
+ "nalgebra-macros",
+ "num-complex",
+ "num-rational",
+ "num-traits",
+ "simba",
+ "typenum",
+]
+
+[[package]]
+name = "nalgebra-macros"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "254a5372af8fc138e36684761d3c0cdb758a4410e938babcff1c860ce14ddbfc"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "native-tls"
+version = "0.2.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "465500e14ea162429d264d44189adc38b199b62b1c21eea9f69e4b73cb03bbf2"
+dependencies = [
+ "libc",
+ "log",
+ "openssl",
+ "openssl-probe",
+ "openssl-sys",
+ "schannel",
+ "security-framework",
+ "security-framework-sys",
+ "tempfile",
+]
+
+[[package]]
+name = "ndk"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2076a31b7010b17a38c01907c45b945e8f11495ee4dd588309718901b1f7a5b7"
+dependencies = [
+ "bitflags 2.12.1",
+ "jni-sys 0.3.1",
+ "log",
+ "ndk-sys",
+ "num_enum",
+ "raw-window-handle",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "ndk-context"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27b02d87554356db9e9a873add8782d4ea6e3e58ea071a9adb9a2e8ddb884a8b"
+
+[[package]]
+name = "ndk-sys"
+version = "0.5.0+25.2.9519653"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c196769dd60fd4f363e11d948139556a344e79d451aeb2fa2fd040738ef7691"
+dependencies = [
+ "jni-sys 0.3.1",
+]
+
+[[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
+[[package]]
+name = "num-bigint"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-complex"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-derive"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-rational"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824"
+dependencies = [
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+ "libm",
+]
+
+[[package]]
+name = "num_enum"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d0bca838442ec211fa11de3a8b0e0e8f3a4522575b5c4c06ed722e005036f26"
+dependencies = [
+ "num_enum_derive",
+ "rustversion",
+]
+
+[[package]]
+name = "num_enum_derive"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "680998035259dcfcafe653688bf2aa6d3e2dc05e98be6ab46afb089dc84f1df8"
+dependencies = [
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "num_threads"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c7398b9c8b70908f6371f47ed36737907c87c52af34c268fed0bf0ceb92ead9"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "objc-sys"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdb91bdd390c7ce1a8607f35f3ca7151b65afc0ff5ff3b34fa350f7d7c7e4310"
+
+[[package]]
+name = "objc2"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "559c5a40fdd30eb5e344fbceacf7595a81e242529fb4e21cf5f43fb4f11ff98d"
+dependencies = [
+ "objc-sys",
+ "objc2-encode 3.0.0",
+]
+
+[[package]]
+name = "objc2"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46a785d4eeff09c14c487497c162e92766fbb3e4059a71840cecc03d9a50b804"
+dependencies = [
+ "objc-sys",
+ "objc2-encode 4.1.0",
+]
+
+[[package]]
+name = "objc2-encode"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d079845b37af429bfe5dfa76e6d087d788031045b25cfc6fd898486fd9847666"
+
+[[package]]
+name = "objc2-encode"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33"
+
+[[package]]
+name = "oboe"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8b61bebd49e5d43f5f8cc7ee2891c16e0f41ec7954d36bcb6c14c5e0de867fb"
+dependencies = [
+ "jni",
+ "ndk",
+ "ndk-context",
+ "num-derive",
+ "num-traits",
+ "oboe-sys",
+]
+
+[[package]]
+name = "oboe-sys"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c8bb09a4a2b1d668170cfe0a7d5bc103f8999fb316c98099b6a9939c9f2e79d"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "once_cell_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
+
+[[package]]
+name = "openssl"
+version = "0.10.80"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a45fa2aa886c42762255da344f0a0d313e254066c46aad76f300c3d3da62d967"
+dependencies = [
+ "bitflags 2.12.1",
+ "cfg-if",
+ "foreign-types 0.3.2",
+ "libc",
+ "openssl-macros",
+ "openssl-sys",
+]
+
+[[package]]
+name = "openssl-macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "openssl-probe"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"
+
+[[package]]
+name = "openssl-sys"
+version = "0.9.116"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f28a22dc7140cda5f096e5e7724a6962ca81a7f8bfd2979f9b18c11af56318c4"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "option-ext"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
+
+[[package]]
+name = "orbclient"
+version = "0.3.55"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5df339f526ea9a60e371768d50efc2f2508c7203290731565d1f7a6f71d21747"
+dependencies = [
+ "libc",
+ "libredox",
+]
+
+[[package]]
+name = "ordered-float"
+version = "4.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7bb71e1b3fa6ca1c61f383464aaf2bb0e2f8e772a1f01d486832464de363b951"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "owned_ttf_parser"
+version = "0.25.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36820e9051aca1014ddc75770aab4d68bc1e9e632f0f5627c4086bc216fb583b"
+dependencies = [
+ "ttf-parser",
+]
+
+[[package]]
+name = "parry3d"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecb572cea5c76b06bc744aaefdbb9e6ea9e5695f50f79c0227bddecd6ec925a4"
+dependencies = [
+ "approx",
+ "arrayvec",
+ "bitflags 2.12.1",
+ "downcast-rs",
+ "either",
+ "ena",
+ "log",
+ "nalgebra",
+ "num-derive",
+ "num-traits",
+ "ordered-float",
+ "rstar",
+ "rustc-hash",
+ "simba",
+ "slab",
+ "smallvec",
+ "spade",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "paste"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
+
+[[package]]
+name = "pkg-config"
+version = "0.3.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19f132c84eca552bf34cab8ec81f1c1dcc229b811638f9d283dceabe58c5569e"
+
+[[package]]
+name = "plain"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
+
+[[package]]
+name = "png"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60769b8b31b2a9f263dae2776c37b1b28ae246943cf719eb6946a1db05128a61"
+dependencies = [
+ "bitflags 2.12.1",
+ "crc32fast",
+ "fdeflate",
+ "flate2",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "polling"
+version = "3.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218"
+dependencies = [
+ "cfg-if",
+ "concurrent-queue",
+ "hermit-abi",
+ "pin-project-lite",
+ "rustix 1.1.4",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "portable-atomic"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
+
+[[package]]
+name = "portable-atomic-util"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2a106d1259c23fac8e543272398ae0e3c0b8d33c88ed73d0cc71b0f1d902618"
+dependencies = [
+ "portable-atomic",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy 0.8.50",
+]
+
+[[package]]
+name = "prettyplease"
+version = "0.2.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
+dependencies = [
+ "proc-macro2",
+ "syn",
+]
+
+[[package]]
+name = "proc-macro-crate"
+version = "3.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f"
+dependencies = [
+ "toml_edit",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "profiling"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d595e54a326bc53c1c197b32d295e14b169e3cfeaa8dc82b529f947fba6bcf5"
+dependencies = [
+ "profiling-procmacros",
+]
+
+[[package]]
+name = "profiling-procmacros"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4488a4a36b9a4ba6b9334a32a39971f77c1436ec82c38707bce707699cc3bbcb"
+dependencies = [
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pxfm"
+version = "0.1.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e0c5ccf5294c6ccd63a74f1565028353830a9c2f5eb0c682c355c471726a6e3f"
+
+[[package]]
+name = "quick-xml"
+version = "0.39.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdcc8dd4e2f670d309a5f0e83fe36dfdc05af317008fea29144da1a2ac858e5e"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "r-efi"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom 0.2.17",
+]
+
+[[package]]
+name = "rapier3d"
+version = "0.23.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37d84644f385b81f065576058bc8f7e3d64e56a66f2f5fc40bfd917774659e12"
+dependencies = [
+ "approx",
+ "arrayvec",
+ "bit-vec",
+ "bitflags 2.12.1",
+ "crossbeam",
+ "downcast-rs",
+ "log",
+ "nalgebra",
+ "num-derive",
+ "num-traits",
+ "ordered-float",
+ "parry3d",
+ "profiling",
+ "rustc-hash",
+ "simba",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "raw-window-handle"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20675572f6f24e9e76ef639bc5552774ed45f1c30e2951e1e99c59888861c539"
+
+[[package]]
+name = "rawpointer"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3"
+
+[[package]]
+name = "redox_syscall"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "567664f262709473930a4bf9e51bf2ebf3348f2e748ccc50dea20646858f8f29"
+dependencies = [
+ "bitflags 1.3.2",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b44b894f2a6e36457d665d1e08c3866add6ed5e70050c1b4ba8a8ddedb02ce7"
+dependencies = [
+ "bitflags 2.12.1",
+]
+
+[[package]]
+name = "redox_users"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4e608c6638b9c18977b00b475ac1f28d14e84b27d8d42f70e0bf1e3dec127ac"
+dependencies = [
+ "getrandom 0.2.17",
+ "libredox",
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "regex"
+version = "1.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
+
+[[package]]
+name = "ringbuf"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79abed428d1fd2a128201cec72c5f6938e2da607c6f3745f769fabea399d950a"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "robust"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e27ee8bb91ca0adcf0ecb116293afa12d393f9c2b9b9cd54d33e8078fe19839"
+
+[[package]]
+name = "rstar"
+version = "0.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "421400d13ccfd26dfa5858199c30a5d76f9c54e0dba7575273025b43c5175dbb"
+dependencies = [
+ "heapless",
+ "num-traits",
+ "smallvec",
+]
+
+[[package]]
+name = "rustc-hash"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94300abf3f1ae2e2b8ffb7b58043de3d399c73fa6f4b73826402a5c457614dbe"
+
+[[package]]
+name = "rustix"
+version = "0.38.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154"
+dependencies = [
+ "bitflags 2.12.1",
+ "errno",
+ "libc",
+ "linux-raw-sys 0.4.15",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "rustix"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
+dependencies = [
+ "bitflags 2.12.1",
+ "errno",
+ "libc",
+ "linux-raw-sys 0.12.1",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "safe_arch"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96b02de82ddbe1b636e6170c21be622223aea188ef2e139be0a5b219ec215323"
+dependencies = [
+ "bytemuck",
+]
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "schannel"
+version = "0.1.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91c1b7e4904c873ef0710c1f407dde2e6287de2bebc1bbbf7d430bb7cbffd939"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "scoped-tls"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
+
+[[package]]
+name = "sctk-adwaita"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70b31447ca297092c5a9916fc3b955203157b37c19ca8edde4f52e9843e602c7"
+dependencies = [
+ "ab_glyph",
+ "log",
+ "memmap2",
+ "smithay-client-toolkit",
+ "tiny-skia",
+]
+
+[[package]]
+name = "security-framework"
+version = "3.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d"
+dependencies = [
+ "bitflags 2.12.1",
+ "core-foundation 0.10.1",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
+
+[[package]]
+name = "security-framework-sys"
+version = "2.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2691df843ecc5d231c0b14ece2acc3efb62c0a398c7e1d875f3983ce020e3"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "semver"
+version = "1.0.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
+
+[[package]]
+name = "send_wrapper"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd0b0ec5f1c1ca621c432a25813d8d60c88abe6d3e08a3eb9cf37d97a0fe3d73"
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde-wasm-bindgen"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8302e169f0eddcc139c70f139d19d6467353af16f9fce27e8c30158036a1e16b"
+dependencies = [
+ "js-sys",
+ "serde",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.150"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8014e44b4736ed0538adeecded0fce2a272f22dc9578a7eb6b2d9993c74cfb9"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "sha1"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "sharded-slab"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6"
+dependencies = [
+ "lazy_static",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "shlex"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
+
+[[package]]
+name = "simba"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c99284beb21666094ba2b75bbceda012e610f5479dfcc2d6e2426f53197ffd95"
+dependencies = [
+ "approx",
+ "num-complex",
+ "num-traits",
+ "paste",
+ "wide",
+]
+
+[[package]]
+name = "simd-adler32"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "703d5c7ef118737c72f1af64ad2f6f8c5e1921f818cdcb97b8fe6fc69bf66214"
+
+[[package]]
+name = "simple-eyre"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b561532e8ffe7ecf09108c4f662896a9ec3eac4999eba84015ec3dcb8cc630a"
+dependencies = [
+ "eyre",
+ "indenter",
+]
+
+[[package]]
+name = "slab"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
+
+[[package]]
+name = "slotmap"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bdd58c3c93c3d278ca835519292445cb4b0d4dc59ccfdf7ceadaab3f8aeb4038"
+dependencies = [
+ "version_check",
+]
+
+[[package]]
+name = "smallvec"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
+
+[[package]]
+name = "smithay-client-toolkit"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "922fd3eeab3bd820d76537ce8f582b1cf951eceb5475c28500c7457d9d17f53a"
+dependencies = [
+ "bitflags 2.12.1",
+ "calloop",
+ "calloop-wayland-source",
+ "cursor-icon",
+ "libc",
+ "log",
+ "memmap2",
+ "rustix 0.38.44",
+ "thiserror 1.0.69",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-csd-frame",
+ "wayland-cursor",
+ "wayland-protocols",
+ "wayland-protocols-wlr",
+ "wayland-scanner",
+ "xkeysym",
+]
+
+[[package]]
+name = "smol_str"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd538fb6910ac1099850255cf94a94df6551fbdd602454387d0adb2d1ca6dead"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "spade"
+version = "2.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9699399fd9349b00b184f5635b074f9ec93afffef30c853f8c875b32c0f8c7fa"
+dependencies = [
+ "hashbrown 0.16.1",
+ "num-traits",
+ "robust",
+ "smallvec",
+]
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
+
+[[package]]
+name = "strict-num"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6637bab7722d379c8b41ba849228d680cc12d0a45ba1fa2b48f2a30577a06731"
+
+[[package]]
+name = "strum"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af23d6f6c1a224baef9d3f61e287d2761385a5b88fdab4eb4c6f11aeb54c4bcf"
+dependencies = [
+ "strum_macros",
+]
+
+[[package]]
+name = "strum_macros"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7695ce3845ea4b33927c055a39dc438a45b059f7c1b3d91d38d10355fb8cbca7"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "symphonia"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5773a4c030a19d9bfaa090f49746ff35c75dfddfa700df7a5939d5e076a57039"
+dependencies = [
+ "lazy_static",
+ "symphonia-bundle-mp3",
+ "symphonia-codec-pcm",
+ "symphonia-codec-vorbis",
+ "symphonia-core",
+ "symphonia-format-ogg",
+ "symphonia-format-riff",
+ "symphonia-metadata",
+]
+
+[[package]]
+name = "symphonia-bundle-mp3"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4872dd6bb56bf5eac799e3e957aa1981086c3e613b27e0ac23b176054f7c57ed"
+dependencies = [
+ "lazy_static",
+ "log",
+ "symphonia-core",
+ "symphonia-metadata",
+]
+
+[[package]]
+name = "symphonia-codec-pcm"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e89d716c01541ad3ebe7c91ce4c8d38a7cf266a3f7b2f090b108fb0cb031d95"
+dependencies = [
+ "log",
+ "symphonia-core",
+]
+
+[[package]]
+name = "symphonia-codec-vorbis"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f025837c309cd69ffef572750b4a2257b59552c5399a5e49707cc5b1b85d1c73"
+dependencies = [
+ "log",
+ "symphonia-core",
+ "symphonia-utils-xiph",
+]
+
+[[package]]
+name = "symphonia-core"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea00cc4f79b7f6bb7ff87eddc065a1066f3a43fe1875979056672c9ef948c2af"
+dependencies = [
+ "arrayvec",
+ "bitflags 1.3.2",
+ "bytemuck",
+ "lazy_static",
+ "log",
+]
+
+[[package]]
+name = "symphonia-format-ogg"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b4955c67c1ed3aa8ae8428d04ca8397fbef6a19b2b051e73b5da8b1435639cb"
+dependencies = [
+ "log",
+ "symphonia-core",
+ "symphonia-metadata",
+ "symphonia-utils-xiph",
+]
+
+[[package]]
+name = "symphonia-format-riff"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2d7c3df0e7d94efb68401d81906eae73c02b40d5ec1a141962c592d0f11a96f"
+dependencies = [
+ "extended",
+ "log",
+ "symphonia-core",
+ "symphonia-metadata",
+]
+
+[[package]]
+name = "symphonia-metadata"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36306ff42b9ffe6e5afc99d49e121e0bd62fe79b9db7b9681d48e29fa19e6b16"
+dependencies = [
+ "encoding_rs",
+ "lazy_static",
+ "log",
+ "symphonia-core",
+]
+
+[[package]]
+name = "symphonia-utils-xiph"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee27c85ab799a338446b68eec77abf42e1a6f1bb490656e121c6e27bfbab9f16"
+dependencies = [
+ "symphonia-core",
+ "symphonia-metadata",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "teleia"
+version = "0.1.0"
+dependencies = [
+ "ahash",
+ "base64 0.22.1",
+ "bimap",
+ "bincode",
+ "bitflags 2.12.1",
+ "byteorder",
+ "bytes",
+ "console_error_panic_hook",
+ "console_log",
+ "directories",
+ "enum-map",
+ "env_logger",
+ "getrandom 0.2.17",
+ "glam",
+ "glfw",
+ "glow",
+ "gltf",
+ "image",
+ "js-sys",
+ "kira",
+ "log",
+ "nalgebra",
+ "parry3d",
+ "polling",
+ "rand",
+ "rapier3d",
+ "serde",
+ "serde_json",
+ "simple-eyre",
+ "strum",
+ "tobj",
+ "tracing-wasm",
+ "tungstenite",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+ "winit",
+]
+
+[[package]]
+name = "teleia_macros"
+version = "0.1.0"
+dependencies = [
+ "env",
+ "heck",
+ "litrs",
+ "walkdir",
+]
+
+[[package]]
+name = "tempfile"
+version = "3.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
+dependencies = [
+ "fastrand",
+ "getrandom 0.4.2",
+ "once_cell",
+ "rustix 1.1.4",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl 1.0.69",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"
+dependencies = [
+ "thiserror-impl 2.0.18",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "thread_local"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "tiny-skia"
+version = "0.11.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83d13394d44dae3207b52a326c0c85a8bf87f1541f23b0d143811088497b09ab"
+dependencies = [
+ "arrayref",
+ "arrayvec",
+ "bytemuck",
+ "cfg-if",
+ "log",
+ "tiny-skia-path",
+]
+
+[[package]]
+name = "tiny-skia-path"
+version = "0.11.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c9e7fc0c2e86a30b117d0462aa261b72b7a99b7ebd7deb3a14ceda95c5bdc93"
+dependencies = [
+ "arrayref",
+ "bytemuck",
+ "strict-num",
+]
+
+[[package]]
+name = "tobj"
+version = "4.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f7ca3ec0405b0f2f95e0dbcced28882190dc79b0dac63ff82533d256d770223"
+dependencies = [
+ "ahash",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "1.1.1+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3165f65f62e28e0115a00b2ebdd37eb6f3b641855f9d636d3cd4103767159ad7"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.25.12+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2153edc6955a6c354fad8f5efd38b6a8769bdccf9fe50f8e1329f81b0baa5d7"
+dependencies = [
+ "indexmap",
+ "toml_datetime",
+ "toml_parser",
+ "winnow",
+]
+
+[[package]]
+name = "toml_parser"
+version = "1.1.2+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2abe9b86193656635d2411dc43050282ca48aa31c2451210f4202550afb7526"
+dependencies = [
+ "winnow",
+]
+
+[[package]]
+name = "tracing"
+version = "0.1.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
+dependencies = [
+ "pin-project-lite",
+ "tracing-attributes",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-attributes"
+version = "0.1.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
+dependencies = [
+ "once_cell",
+]
+
+[[package]]
+name = "tracing-subscriber"
+version = "0.3.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb7f578e5945fb242538965c2d0b04418d38ec25c79d160cd279bf0731c8d319"
+dependencies = [
+ "sharded-slab",
+ "thread_local",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-wasm"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4575c663a174420fa2d78f4108ff68f65bf2fbb7dd89f33749b6e826b3626e07"
+dependencies = [
+ "tracing",
+ "tracing-subscriber",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "triple_buffer"
+version = "8.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "420466259f9fa5decc654c490b9ab538400e5420df8237f84ecbe20368bcf72b"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "ttf-parser"
+version = "0.25.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2df906b07856748fa3f6e0ad0cbaa047052d4a7dd609e231c4f72cee8c36f31"
+
+[[package]]
+name = "tungstenite"
+version = "0.24.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18e5b8366ee7a95b16d32197d0b2604b43a0be89dc5fac9f8e96ccafbaedda8a"
+dependencies = [
+ "byteorder",
+ "bytes",
+ "data-encoding",
+ "http",
+ "httparse",
+ "log",
+ "native-tls",
+ "rand",
+ "sha1",
+ "thiserror 1.0.69",
+ "utf-8",
+]
+
+[[package]]
+name = "typenum"
+version = "1.20.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unicode-segmentation"
+version = "1.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
+
+[[package]]
+name = "unty"
+version = "0.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d49784317cd0d1ee7ec5c716dd598ec5b4483ea832a2dced265471cc0f690ae"
+
+[[package]]
+name = "urlencoding"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da"
+
+[[package]]
+name = "utf-8"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
+
+[[package]]
+name = "utf8parse"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "virtue"
+version = "0.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "051eb1abcf10076295e815102942cc58f9d5e3b4560e46e53c21e8ff6f3af7b1"
+
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
+[[package]]
+name = "wasip2"
+version = "1.0.3+wasi-0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20064672db26d7cdc89c7798c48a0fdfac8213434a1186e5ef29fd560ae223d6"
+dependencies = [
+ "wit-bindgen 0.57.1",
+]
+
+[[package]]
+name = "wasip3"
+version = "0.4.0+wasi-0.3.0-rc-2026-01-06"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5"
+dependencies = [
+ "wit-bindgen 0.51.0",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6"
+dependencies = [
+ "bumpalo",
+ "log",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-futures"
+version = "0.4.50"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "555d470ec0bc3bb57890405e5d4322cc9ea83cebb085523ced7be4144dac1e61"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "once_cell",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "wasm-encoder"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319"
+dependencies = [
+ "leb128fmt",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasm-metadata"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909"
+dependencies = [
+ "anyhow",
+ "indexmap",
+ "wasm-encoder",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"
+dependencies = [
+ "bitflags 2.12.1",
+ "hashbrown 0.15.5",
+ "indexmap",
+ "semver",
+]
+
+[[package]]
+name = "wayland-backend"
+version = "0.3.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2857dd20b54e916ec7253b3d6b4d5c4d7d4ca2c33c2e11c6c76a99bd8744755d"
+dependencies = [
+ "cc",
+ "downcast-rs",
+ "rustix 1.1.4",
+ "scoped-tls",
+ "smallvec",
+ "wayland-sys",
+]
+
+[[package]]
+name = "wayland-client"
+version = "0.31.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "645c7c96bb74690c3189b5c9cb4ca1627062bb23693a4fad9d8c3de958260144"
+dependencies = [
+ "bitflags 2.12.1",
+ "rustix 1.1.4",
+ "wayland-backend",
+ "wayland-scanner",
+]
+
+[[package]]
+name = "wayland-csd-frame"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "625c5029dbd43d25e6aa9615e88b829a5cad13b2819c4ae129fdbb7c31ab4c7e"
+dependencies = [
+ "bitflags 2.12.1",
+ "cursor-icon",
+ "wayland-backend",
+]
+
+[[package]]
+name = "wayland-cursor"
+version = "0.31.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a52d18780be9b1314328a3de5f930b73d2200112e3849ca6cb11822793fb34d"
+dependencies = [
+ "rustix 1.1.4",
+ "wayland-client",
+ "xcursor",
+]
+
+[[package]]
+name = "wayland-protocols"
+version = "0.31.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f81f365b8b4a97f422ac0e8737c438024b5951734506b0e1d775c73030561f4"
+dependencies = [
+ "bitflags 2.12.1",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-scanner",
+]
+
+[[package]]
+name = "wayland-protocols-plasma"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23803551115ff9ea9bce586860c5c5a971e360825a0309264102a9495a5ff479"
+dependencies = [
+ "bitflags 2.12.1",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-protocols",
+ "wayland-scanner",
+]
+
+[[package]]
+name = "wayland-protocols-wlr"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad1f61b76b6c2d8742e10f9ba5c3737f6530b4c243132c2a2ccc8aa96fe25cd6"
+dependencies = [
+ "bitflags 2.12.1",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-protocols",
+ "wayland-scanner",
+]
+
+[[package]]
+name = "wayland-scanner"
+version = "0.31.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c324a910fd86ebdc364a3e61ec1f11737d3b1d6c273c0239ee8ff4bc0d24b4a"
+dependencies = [
+ "proc-macro2",
+ "quick-xml",
+ "quote",
+]
+
+[[package]]
+name = "wayland-sys"
+version = "0.31.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8eab23fefc9e41f8e841df4a9c707e8a8c4ed26e944ef69297184de2785e3be"
+dependencies = [
+ "dlib",
+ "log",
+ "once_cell",
+ "pkg-config",
+]
+
+[[package]]
+name = "web-sys"
+version = "0.3.77"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33b6dd2ef9186f1f2072e409e99cd22a975331a6b3591b12c764e0e55c60d5d2"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "web-time"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa30049b1c872b72c89866d458eae9f20380ab280ffd1b1e18df2d3e2d98cfe0"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "wide"
+version = "0.7.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ce5da8ecb62bcd8ec8b7ea19f69a51275e91299be594ea5cc6ef7819e16cd03"
+dependencies = [
+ "bytemuck",
+ "safe_arch",
+]
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows"
+version = "0.54.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9252e5725dbed82865af151df558e754e4a3c2c30818359eb17465f1346a1b49"
+dependencies = [
+ "windows-core",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.54.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12661b9c89351d684a50a8a643ce5f608e20243b9fb84687800163429f161d65"
+dependencies = [
+ "windows-result",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-result"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e383302e8ec8515204254685643de10811af0ed97ea37210dc26fb0032647f8"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.45.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
+dependencies = [
+ "windows-targets 0.42.2",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+dependencies = [
+ "windows-targets 0.48.5",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
+dependencies = [
+ "windows_aarch64_gnullvm 0.42.2",
+ "windows_aarch64_msvc 0.42.2",
+ "windows_i686_gnu 0.42.2",
+ "windows_i686_msvc 0.42.2",
+ "windows_x86_64_gnu 0.42.2",
+ "windows_x86_64_gnullvm 0.42.2",
+ "windows_x86_64_msvc 0.42.2",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
+dependencies = [
+ "windows_aarch64_gnullvm 0.48.5",
+ "windows_aarch64_msvc 0.48.5",
+ "windows_i686_gnu 0.48.5",
+ "windows_i686_msvc 0.48.5",
+ "windows_x86_64_gnu 0.48.5",
+ "windows_x86_64_gnullvm 0.48.5",
+ "windows_x86_64_msvc 0.48.5",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "winit"
+version = "0.29.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d59ad965a635657faf09c8f062badd885748428933dad8e8bdd64064d92e5ca"
+dependencies = [
+ "ahash",
+ "android-activity",
+ "atomic-waker",
+ "bitflags 2.12.1",
+ "bytemuck",
+ "calloop",
+ "cfg_aliases",
+ "core-foundation 0.9.4",
+ "core-graphics",
+ "cursor-icon",
+ "icrate",
+ "js-sys",
+ "libc",
+ "log",
+ "memmap2",
+ "ndk",
+ "ndk-sys",
+ "objc2 0.4.1",
+ "once_cell",
+ "orbclient",
+ "percent-encoding",
+ "raw-window-handle",
+ "redox_syscall 0.3.5",
+ "rustix 0.38.44",
+ "sctk-adwaita",
+ "serde",
+ "smithay-client-toolkit",
+ "smol_str",
+ "unicode-segmentation",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-protocols",
+ "wayland-protocols-plasma",
+ "web-sys",
+ "web-time",
+ "windows-sys 0.48.0",
+ "x11-dl",
+ "x11rb",
+ "xkbcommon-dl",
+]
+
+[[package]]
+name = "winnow"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0592e1c9d151f854e6fd382574c3a0855250e1d9b2f99d9281c6e6391af352f1"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "wit-bindgen"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
+dependencies = [
+ "wit-bindgen-rust-macro",
+]
+
+[[package]]
+name = "wit-bindgen"
+version = "0.57.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"
+
+[[package]]
+name = "wit-bindgen-core"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc"
+dependencies = [
+ "anyhow",
+ "heck",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-bindgen-rust"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21"
+dependencies = [
+ "anyhow",
+ "heck",
+ "indexmap",
+ "prettyplease",
+ "syn",
+ "wasm-metadata",
+ "wit-bindgen-core",
+ "wit-component",
+]
+
+[[package]]
+name = "wit-bindgen-rust-macro"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a"
+dependencies = [
+ "anyhow",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wit-bindgen-core",
+ "wit-bindgen-rust",
+]
+
+[[package]]
+name = "wit-component"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"
+dependencies = [
+ "anyhow",
+ "bitflags 2.12.1",
+ "indexmap",
+ "log",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "wasm-encoder",
+ "wasm-metadata",
+ "wasmparser",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-parser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736"
+dependencies = [
+ "anyhow",
+ "id-arena",
+ "indexmap",
+ "log",
+ "semver",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "unicode-xid",
+ "wasmparser",
+]
+
+[[package]]
+name = "x11-dl"
+version = "2.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38735924fedd5314a6e548792904ed8c6de6636285cb9fec04d5b1db85c1516f"
+dependencies = [
+ "libc",
+ "once_cell",
+ "pkg-config",
+]
+
+[[package]]
+name = "x11rb"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9993aa5be5a26815fe2c3eacfc1fde061fc1a1f094bf1ad2a18bf9c495dd7414"
+dependencies = [
+ "as-raw-xcb-connection",
+ "gethostname",
+ "libc",
+ "libloading",
+ "once_cell",
+ "rustix 1.1.4",
+ "x11rb-protocol",
+]
+
+[[package]]
+name = "x11rb-protocol"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea6fc2961e4ef194dcbfe56bb845534d0dc8098940c7e5c012a258bfec6701bd"
+
+[[package]]
+name = "xcursor"
+version = "0.3.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bec9e4a500ca8864c5b47b8b482a73d62e4237670e5b5f1d6b9e3cae50f28f2b"
+
+[[package]]
+name = "xkbcommon-dl"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d039de8032a9a8856a6be89cea3e5d12fdd82306ab7c94d74e6deab2460651c5"
+dependencies = [
+ "bitflags 2.12.1",
+ "dlib",
+ "log",
+ "once_cell",
+ "xkeysym",
+]
+
+[[package]]
+name = "xkeysym"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9cc00251562a284751c9973bace760d86c0276c471b4be569fe6b068ee97a56"
+
+[[package]]
+name = "zerocopy"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
+dependencies = [
+ "zerocopy-derive 0.7.35",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.8.50"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b065d4f0e55f82fae73202e189638116a87c55ab6b8e6c2721e13dd9d854ad1"
+dependencies = [
+ "zerocopy-derive 0.8.50",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.50"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b631b19d36a892ab55420c92dbc83ccd79274f25be714855d3074aa71cab639"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "zmij"
+version = "1.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
+
+[[package]]
+name = "zune-core"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb8a0807f7c01457d0379ba880ba6322660448ddebc890ce29bb64da71fb40f9"
+
+[[package]]
+name = "zune-jpeg"
+version = "0.5.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27bc9d5b815bc103f142aa054f561d9187d191692ec7c2d1e2b4737f8dbd7296"
+dependencies = [
+ "zune-core",
+]
diff --git a/2026/games_submissions/rpc2dot0/Cargo.toml b/2026/games_submissions/rpc2dot0/Cargo.toml new file mode 100644 index 0000000..031cf9e --- /dev/null +++ b/2026/games_submissions/rpc2dot0/Cargo.toml @@ -0,0 +1,36 @@ +[package]
+name = "eatyourgreens"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+crate-type = ["cdylib"]
+
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+enum-map = { version = "2.7.3", features = ["serde"] } # teleia needs this ???
+glam = "*"
+js-sys = "*"
+log = "*"
+rand = "*"
+rand_chacha = "*"
+serde = { version = "1.0.228", features = ["derive"] }
+serde-wasm-bindgen = "0.6.5"
+teleia = { path = "vendor/teleia/crates/teleia" }
+teleia_macros = { path = "vendor/teleia/crates/teleia_macros" }
+wasm-bindgen = "=0.2.100"
+web-sys = { version = "0.3", features = [
+ "Window",
+ "Document",
+ "HtmlVideoElement",
+ "Element",
+ "CssStyleDeclaration",
+ "HtmlElement",
+ "Blob",
+ "BlobPropertyBag",
+ "HtmlIFrameElement",
+ "HtmlCollection",
+ "Node",
+ "Url",
+] }
+winit = { version = "=0.29.15" }
diff --git a/2026/games_submissions/rpc2dot0/LICENSE b/2026/games_submissions/rpc2dot0/LICENSE new file mode 100644 index 0000000..92cb74f --- /dev/null +++ b/2026/games_submissions/rpc2dot0/LICENSE @@ -0,0 +1,21 @@ +MIT License
+
+Copyright (c) 2026 rpc2dot0
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/2026/games_submissions/rpc2dot0/README.md b/2026/games_submissions/rpc2dot0/README.md new file mode 100644 index 0000000..a3f3bb4 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/README.md @@ -0,0 +1,37 @@ +# Eat Your Greens!
+
+## What is it?
+"Eat Your Greens!" is a microgame for Lcolonq JAM 2026 event
+
+## How to play it :
+ - mouse (to click Heads)
+ - Optional : Up/left/down/right keys (to move disquette)
+
+## How to build it :
+ - `wasm-pack build --target web --release`
+ - `cp -r index.* pkg/ ../jam/2026/games/eatyourgreens/`
+ - you can debug by having fixed seed for reproduciable behaviour by
+ forcing the seed value in `src/random.rs`, `new(seed: usize)` function.
+ - also there a shit tone of logs in web console.
+
+## Game rules :
+
+### Main objective
+Survive the round and reach the required score target to win!
+
+### Basic scoring (Eating Greens)
+* **Eat Greens**: Click on **Green** entities to consume them. Each green gives you **+1 point**.
+* **Avoid the Rest**: Clicking on **it** will penalize you with **-1 point**.
+
+### Disquette & computer (optional)
+* There is a **Disquette** (floppy disk) bouncing around the screen.
+* You can take manual control of the disquette using your **Keyboard arrow keys**.
+* Steer the disquette into the **Computer** to plug it in.
+* Once inserted, use your mouse to click the **Power Button** on the computer to boot it up. This boots the computer (surprise) !
+
+### Hazards & Entity Rules
+* **Pac-Man Chasers (we call him mr Blue balls)**: Some **Blue** entities are actively hunting! If they catch and touch the disquette before you plug it into the computer, the disquette gets consumed and is gone for the rest of the round.
+* **Red Time Bombs**: **Red** entities have a 3-second countdown timer. If you don't click them to destroy them before the timer runs out, they will explode and **consume ALL Green entities** currently on the screen! *(clicking on them to disarm them still costs you -1 point).*
+* **Green Mutations**: If two **Green** entities bump into each other, they might undergo a bad reaction : one will turn **Yellow** and the other will turn **Red**.
+* **Red Collisions**: If two **Red** entities collide, they will blow each other up, but the explosion will also instantly kill the all green entities.
+* **Rogue Greens**: Be careful! Some Greens are fakes. If you hover your mouse near a "Rogue" Green, it will temporarily flash its true colors.
diff --git a/2026/games_submissions/rpc2dot0/index.css b/2026/games_submissions/rpc2dot0/index.css new file mode 100644 index 0000000..f31f38a --- /dev/null +++ b/2026/games_submissions/rpc2dot0/index.css @@ -0,0 +1,59 @@ +html {
+ touch-action: manipulation;
+}
+
+body {
+ background: none transparent;
+}
+
+html,
+body {
+ overflow: hidden;
+ margin: 0 !important;
+ padding: 0 !important;
+}
+
+canvas {
+ display: block;
+ max-width: 100vw !important;
+ max-height: 100vh !important;
+ width: auto !important;
+ height: auto !important;
+ position: absolute;
+ top: 50%;
+ left: 50%;
+ transform: translate(-50%, -50%);
+ image-rendering: pixelated;
+}
+
+.centered {
+ margin-right: auto;
+ margin-left: auto;
+ display: block;
+ position: absolute;
+ font-size: 24px;
+ font-family: Ubuntu-Light, Helvetica, sans-serif;
+ text-align: center;
+ image-rendering: pixelated;
+}
+
+#os-box {
+ position: absolute;
+ top: 50%;
+ left: 50%;
+ transform: translate(-50%, -50%);
+ width: min(240px, 100vw, 150vh);
+ aspect-ratio: 240 / 160;
+ background: #111;
+ overflow: hidden;
+ z-index: 9999;
+}
+
+#ad-video {
+ position: absolute;
+ inset: 0;
+ width: 100%;
+ height: 100%;
+ object-fit: cover;
+ background: #111;
+}
\ No newline at end of file diff --git a/2026/games_submissions/rpc2dot0/index.html b/2026/games_submissions/rpc2dot0/index.html new file mode 100644 index 0000000..e70680b --- /dev/null +++ b/2026/games_submissions/rpc2dot0/index.html @@ -0,0 +1,23 @@ +<!DOCTYPE html>
+<html>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
+
+<head>
+ <meta charset="UTF-8">
+ <link rel="icon" href="data:;base64,iVBORw0KGgo=">
+ <link rel="stylesheet" href="./index.css" />
+ <title>Eat your greens !</title>
+</head>
+
+<body>
+ <div id="teleia-parent"></div>
+
+ <div id="os-box" style="display: none;">
+ <video id="ad-video" preload="auto" playsinline muted></video>
+ </div>
+
+ <script type="module" src="./index.js"></script>
+</body>
+
+</html>
\ No newline at end of file diff --git a/2026/games_submissions/rpc2dot0/index.js b/2026/games_submissions/rpc2dot0/index.js new file mode 100644 index 0000000..2a8d674 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/index.js @@ -0,0 +1,48 @@ +import init, { main_js, set_difficulty_js, receive_op_js } from './pkg/eatyourgreens.js'; + +let is_embedded = false; +let currentDifficulty = 1.0; + +window.addEventListener("DOMContentLoaded", async (event) => { + await init(); + is_embedded = window.parent !== window; + main_js(is_embedded); + window.addEventListener("message", (ev) => { + if (ev.data && ev.data.op === 'play_video') { + play_video(ev.data.video_url); + return; + } + + if (is_embedded && ev.data && ev.data.op) { + currentDifficulty = ev.data.difficulty || currentDifficulty; + set_difficulty_js(currentDifficulty); + receive_op_js(ev.data.op); + } + }); +}); + + +// os (inside computer) +const osBox = document.getElementById('os-box'); +const video = document.getElementById('ad-video'); + +video.addEventListener('ended', () => { + osBox.style.display = 'none'; + receive_op_js('video_finished'); +}); + +function play_video(videoUrl) { + if (!videoUrl) { + return; + } + osBox.style.display = 'block'; + video.src = videoUrl; + video.muted = false; + video.volume = 0.85; + video.play().catch((e) => { + console.error("Failed to play video with sound:", e); + // fallback if autoplay policy blocked it + video.muted = true; + video.play(); + }); +} diff --git a/2026/games_submissions/rpc2dot0/rust-toolchain.toml b/2026/games_submissions/rpc2dot0/rust-toolchain.toml new file mode 100644 index 0000000..5360e5c --- /dev/null +++ b/2026/games_submissions/rpc2dot0/rust-toolchain.toml @@ -0,0 +1,4 @@ +[toolchain]
+channel = "nightly"
+targets = ["wasm32-unknown-unknown"]
+features = ["simd"]
diff --git a/2026/games_submissions/rpc2dot0/spec.txt b/2026/games_submissions/rpc2dot0/spec.txt new file mode 100644 index 0000000..e14d3ff --- /dev/null +++ b/2026/games_submissions/rpc2dot0/spec.txt @@ -0,0 +1,106 @@ +
+LCOLONQ MICROJAM 2K26-A-PALOOZA
+
+ what is it: a game jam for the LCOLONQ zone or "greencircle" or cyberspace or whatever else we call it!
+ why is it: let's have some fun on the computer together!
+ when is it: submissions are due on Friday, July 17th 2026.
+ where is it: submit links to entries on Discord or IRC or Twitch Chatroom or anywhere we are likely to see them. if you need a place to upload your submission, contact clonk! this is a small group, we can ask each other questions and figure things out together.
+ who is it: you, maybe! if you don't feel confident making a game alone, maybe team up with somebody else! ask around in the Discord or IRC or Twitch Chatroom or anywhere else!
+ how is it: pretty good; see below!
+
+THE DETAILS
+or, what are we making, actually
+
+For this event, your challenge is to make a "microgame". Microgame is a term used by the WarioWare game series to describe short, (mostly) self-contained minigames played in rapid succession. The individual microgames tend to present a single gameplay mechanic or task for the player to perform, with a well-defined success and failure state. Typical microgames are only a few seconds long, while some end-of-stage "boss games" can last a minute or more. In WarioWare, the player is presented with a series of microgames to play in a random order. Failing at an individual microgame costs the player a life, and losing all lives means game over!
+
+For an example of this type of gameplay, here is a nice demonstration video.
+
+Your mission in this game jam is to make a microgame! At the end, we'll collect all the submissions together, so you can play through the whole collection like you would a stage in WarioWare. In order for this to work nicely, it's best if everyone follows some simple guidelines. These mostly aren't hard-and-fast rules, but moreso a framework to ensure that the overall collection is playable.
+
+ Make a game that's playable in the browser.
+
+ The browser is how we're going to ensure all of the games can play nicely together. This doesn't mean you have to write a game with JavaScript!
+
+ Many languages and libraries can be built to WebAssembly. For example, if you like C and raylib, check out this guide! It's also quite easy to write Rust programs targeting WebAssembly. In general, if you have a preferred language and graphics library, it's likely you'll be able to make something work!
+
+ Full-fledged game engines like Godot also have the ability to export a web build. For Godot, see the documentation.
+
+ It's also perfectly fine to work with JavaScript and Canvas, either using some library or plain browser APIs! If you'd like to go this route and aren't sure where to start, check out the MDN documentation for the Canvas API or maybe WebGL. If you'd like something a bit more batteries-included, maybe check out Pixi or Phaser.
+ Games should be primarily controlled using the mouse.
+
+ We want to make sure that someone playing the collection doesn't get confused by the controls. With keyboard controls, each game might pick totally different keys, and adjusting the player will be a challenge. As such, please center your game's control scheme around a standard two-button mouse. You're still welcome to use the keyboard and any other input method that's generally available, but try to avoid assuming that the player will know the control scheme you require. For example, a keyboard-involved microgame might involving mashing keys indiscriminately, or playing a "hot-and-cold" game based on the physical locations of keys pressed in the player's keyboard layout. Get creative!
+ Keep it short and focused! Less than a minute is ideal.
+
+ Ideally your game is tightly focused on a single gameplay idea. Feel free to interpret this however you wish! If you want to make a two minute mini-RPG, be my guest! Rough and interesting is a good way to go.
+ Make sure there is an obvious win condition and lose condition.
+
+ We need a way to know if the player should lose a life after your game runs. The player running out of time is a perfectly good lose condition (but make sure to display a timer somewhere onscreen if this is the case!). But again, feel free to be inventive!
+
+TECHNICAL INFO
+what do I need to do to make my game work?
+
+When you submit your game, ideally you should submit an archive (ZIP or tarball) containing a folder. That folder should contain all of your game's assets, alongside an index.html that runs the game. Most game engine web exports will give you exactly this!
+
+Your game should be scaled to fill the entire browser window. We recommend that games render at 240x160, but this is not a hard requirement. Feel free to break/bend this rule if you like!
+
+In order for things to work smoothly, you'll need your game to report when certain things have happened, and also to respond to certain requests. Don't worry! This is simple and easy, and we have some examples available using common tools.
+
+Your game can communicate with the "harness" by calling the JavaScript function window.parent.postMessage. The harness will send some messages back to your game in the same way (and you can listen for them with window.addEventListener("message", your_message_handler_here)). If that's inconvenient, we also set certain special JavaScript variables whenever events fire, so you can poll those variables inside your game loop if it's easier.
+
+Here's what you need to send and receive from the harness:
+
+ When your game's page loads, you should load all assets and send a ready message to the harness:
+
+ window.parent.postMessage({op: "ready"});
+
+
+ After sending this message, wait patiently! The game has not started yet, so you shouldn't start any timers or expect the player to input anything just yet.
+
+ The harness will tell you that the game should start, and at which difficulty level. You can detect this by either listening for an event, or reading a variable:
+
+ window.addEventListener("message", ev => console.log(ev.data));
+ // ev.data will be {op: "start", difficulty: 42.0}
+
+
+ or:
+
+ window.lcolonqJamStart
+ // this variable will either be an integer or falsy!
+ // you can check it repeatedly in your game loop until
+ // it's an integer - that integer is the difficulty level
+
+
+ This means that your game should start right away - you can start any timers and expect player input! You are free to interpret the difficulty number any way you like - this number will be roughly the number of previously-completed games so far in the current round.
+
+ When your game starts (in response to the previous message), you should let the harness know it started successfully:
+
+ window.parent.postMessage({op: "started", verb: "catch!"});
+
+
+ The verb field tells the harness to display a particular word as a prompt to the player as your game appears.
+
+ You are free to run your game! When the game is done, report whether the user won or lost:
+
+ window.parent.postMessage({op: "done", win: true});
+
+
+ or
+
+ window.parent.postMessage({op: "done", win: false});
+
+
+ At this point, the user will no longer be able to interact with your game. You should reset things, and be ready to run the game again fresh when you receive the start message. In general, you should assume that your game page could be reloaded entirely, or it could never be reloaded and receive repeated start events!
+
+ That's it!
+
+THE RULES
+ok these are actual rules don't bend these ones please
+
+ Alongside your game, please submit source code (either a link to a repository or actual source in an archive file). Please include the open-source license you are releasing your code under, as well as any licenses and attribution for any assets used.
+
+ Please do not use any "trained" machine learning tool with external training data for programming or asset creation. That is: no off-the-shelf LLMs, image generation, etc. anywhere in the development process or final game. Feel free to use machine learning techniques at your leisure if you're using a model you trained entirely yourself on data you have collected yourself (and to which you have a license).
+
+ In brief: Claude code/ChatGPT/AI images are banned. If you'd like to write some weird genetic algorithm thing or do reinforcement learning for game AI or procedural textures or whatever else, that's cool and please do it!
+ Be kind.
+
+LCOLONQ 2"K"26. Most rights reversed. All words endorsed by my employer. I love the computer and the people on it.
diff --git a/2026/games_submissions/rpc2dot0/src/assets.rs b/2026/games_submissions/rpc2dot0/src/assets.rs new file mode 100644 index 0000000..fa160a1 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/assets.rs @@ -0,0 +1,38 @@ +teleia_macros::generate_assets!("src/assets/");
+
+pub const AUDIO_ASSETS: &[(&str, &[u8])] = &[
+ ("crunch", include_bytes!("assets/audio/crunch.wav")),
+ ("fart", include_bytes!("assets/audio/fart.wav")),
+ ("explosion", include_bytes!("assets/audio/explosion.wav")),
+];
+
+pub const VIDEO_ASSETS: &[(&str, &[u8])] = &[
+ (
+ "seks_is_bad.mp4",
+ include_bytes!("assets/video/adzzz/seks_is_bad.mp4"),
+ ),
+ (
+ "seks_is_gud.mp4",
+ include_bytes!("assets/video/adzzz/seks_is_gud.mp4"),
+ ),
+ (
+ "pinnesse_c.mp4",
+ include_bytes!("assets/video/adzzz/pinnesse_c.mp4"),
+ ),
+ (
+ "hyped_c.mp4",
+ include_bytes!("assets/video/adzzz/hyped_c.mp4"),
+ ),
+ (
+ "GG_win_c.mp4",
+ include_bytes!("assets/video/adzzz/GG_win_c.mp4"),
+ ),
+ (
+ "game_over_c.mp4",
+ include_bytes!("assets/video/adzzz/game_over_c.mp4"),
+ ),
+ (
+ "confused_c.mp4",
+ include_bytes!("assets/video/adzzz/confused_c.mp4"),
+ ),
+];
diff --git a/2026/games_submissions/rpc2dot0/src/assets/audio/crunch.wav b/2026/games_submissions/rpc2dot0/src/assets/audio/crunch.wav Binary files differnew file mode 100644 index 0000000..f11334f --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/assets/audio/crunch.wav diff --git a/2026/games_submissions/rpc2dot0/src/assets/audio/explosion.wav b/2026/games_submissions/rpc2dot0/src/assets/audio/explosion.wav Binary files differnew file mode 100644 index 0000000..c3e867f --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/assets/audio/explosion.wav diff --git a/2026/games_submissions/rpc2dot0/src/assets/audio/fart.wav b/2026/games_submissions/rpc2dot0/src/assets/audio/fart.wav Binary files differnew file mode 100644 index 0000000..ebb001d --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/assets/audio/fart.wav diff --git a/2026/games_submissions/rpc2dot0/src/assets/audio/footsteps.wav b/2026/games_submissions/rpc2dot0/src/assets/audio/footsteps.wav Binary files differnew file mode 100644 index 0000000..57bfddf --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/assets/audio/footsteps.wav diff --git a/2026/games_submissions/rpc2dot0/src/assets/audio/test.wav b/2026/games_submissions/rpc2dot0/src/assets/audio/test.wav Binary files differnew file mode 100644 index 0000000..0eabe85 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/assets/audio/test.wav diff --git a/2026/games_submissions/rpc2dot0/src/assets/meshes/square.obj b/2026/games_submissions/rpc2dot0/src/assets/meshes/square.obj new file mode 100644 index 0000000..7acdef6 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/assets/meshes/square.obj @@ -0,0 +1,15 @@ +# Blender 3.6.2
+# www.blender.org
+o Cube
+v -1.000000 -1.000000 0.000000
+v 1.000000 -1.000000 0.000000
+v -1.000000 1.000000 0.000000
+v 1.000000 1.000000 0.000000
+vn -0.0000 -0.0000 -1.0000
+vt 0.0 1.0
+vt 1.0 0.0
+vt 0.0 0.0
+vt 1.0 1.0
+s 0
+f 3/1/1 2/2/1 1/3/1
+f 3/1/1 4/4/1 2/2/1
diff --git a/2026/games_submissions/rpc2dot0/src/assets/shaders/flat/frag.glsl b/2026/games_submissions/rpc2dot0/src/assets/shaders/flat/frag.glsl new file mode 100644 index 0000000..6ebdfa9 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/assets/shaders/flat/frag.glsl @@ -0,0 +1,11 @@ +uniform sampler2D texture_data;
+
+void main()
+{
+ vec2 tcfull = vec2(vertex_texcoord.x, 1.0 - vertex_texcoord.y);
+ vec4 texel = texture(texture_data, tcfull);
+ if (texel.a != 1.0) {
+ discard;
+ }
+ frag_color = texel;
+}
diff --git a/2026/games_submissions/rpc2dot0/src/assets/shaders/flat/vert.glsl b/2026/games_submissions/rpc2dot0/src/assets/shaders/flat/vert.glsl new file mode 100644 index 0000000..6e796cc --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/assets/shaders/flat/vert.glsl @@ -0,0 +1,4 @@ +void main()
+{
+ default_main();
+}
\ No newline at end of file diff --git a/2026/games_submissions/rpc2dot0/src/assets/textures/background_main.png b/2026/games_submissions/rpc2dot0/src/assets/textures/background_main.png Binary files differnew file mode 100644 index 0000000..82b3ebe --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/assets/textures/background_main.png diff --git a/2026/games_submissions/rpc2dot0/src/assets/textures/computer.png b/2026/games_submissions/rpc2dot0/src/assets/textures/computer.png Binary files differnew file mode 100644 index 0000000..be5c723 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/assets/textures/computer.png diff --git a/2026/games_submissions/rpc2dot0/src/assets/textures/disquette.png b/2026/games_submissions/rpc2dot0/src/assets/textures/disquette.png Binary files differnew file mode 100644 index 0000000..12399f4 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/assets/textures/disquette.png diff --git a/2026/games_submissions/rpc2dot0/src/assets/textures/landing.png b/2026/games_submissions/rpc2dot0/src/assets/textures/landing.png Binary files differnew file mode 100644 index 0000000..229e6ad --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/assets/textures/landing.png diff --git a/2026/games_submissions/rpc2dot0/src/assets/textures/mrbleu.png b/2026/games_submissions/rpc2dot0/src/assets/textures/mrbleu.png Binary files differnew file mode 100644 index 0000000..d16a717 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/assets/textures/mrbleu.png diff --git a/2026/games_submissions/rpc2dot0/src/assets/textures/mrbleu_lurking.png b/2026/games_submissions/rpc2dot0/src/assets/textures/mrbleu_lurking.png Binary files differnew file mode 100644 index 0000000..3217129 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/assets/textures/mrbleu_lurking.png diff --git a/2026/games_submissions/rpc2dot0/src/assets/textures/mrgreen.png b/2026/games_submissions/rpc2dot0/src/assets/textures/mrgreen.png Binary files differnew file mode 100644 index 0000000..2eb7210 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/assets/textures/mrgreen.png diff --git a/2026/games_submissions/rpc2dot0/src/assets/textures/mrred.png b/2026/games_submissions/rpc2dot0/src/assets/textures/mrred.png Binary files differnew file mode 100644 index 0000000..2c4bc18 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/assets/textures/mrred.png diff --git a/2026/games_submissions/rpc2dot0/src/assets/textures/mryellow.png b/2026/games_submissions/rpc2dot0/src/assets/textures/mryellow.png Binary files differnew file mode 100644 index 0000000..9784a8f --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/assets/textures/mryellow.png diff --git a/2026/games_submissions/rpc2dot0/src/assets/textures/mute.png b/2026/games_submissions/rpc2dot0/src/assets/textures/mute.png Binary files differnew file mode 100644 index 0000000..b4b81dd --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/assets/textures/mute.png diff --git a/2026/games_submissions/rpc2dot0/src/assets/textures/unmute.png b/2026/games_submissions/rpc2dot0/src/assets/textures/unmute.png Binary files differnew file mode 100644 index 0000000..278d227 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/assets/textures/unmute.png diff --git a/2026/games_submissions/rpc2dot0/src/assets/video/adzzz/GG_win_c.mp4 b/2026/games_submissions/rpc2dot0/src/assets/video/adzzz/GG_win_c.mp4 Binary files differnew file mode 100644 index 0000000..c24a0d9 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/assets/video/adzzz/GG_win_c.mp4 diff --git a/2026/games_submissions/rpc2dot0/src/assets/video/adzzz/confused_c.mp4 b/2026/games_submissions/rpc2dot0/src/assets/video/adzzz/confused_c.mp4 Binary files differnew file mode 100644 index 0000000..0c7756d --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/assets/video/adzzz/confused_c.mp4 diff --git a/2026/games_submissions/rpc2dot0/src/assets/video/adzzz/game_over_c.mp4 b/2026/games_submissions/rpc2dot0/src/assets/video/adzzz/game_over_c.mp4 Binary files differnew file mode 100644 index 0000000..bccb605 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/assets/video/adzzz/game_over_c.mp4 diff --git a/2026/games_submissions/rpc2dot0/src/assets/video/adzzz/hyped_c.mp4 b/2026/games_submissions/rpc2dot0/src/assets/video/adzzz/hyped_c.mp4 Binary files differnew file mode 100644 index 0000000..909c56a --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/assets/video/adzzz/hyped_c.mp4 diff --git a/2026/games_submissions/rpc2dot0/src/assets/video/adzzz/pinnesse_c.mp4 b/2026/games_submissions/rpc2dot0/src/assets/video/adzzz/pinnesse_c.mp4 Binary files differnew file mode 100644 index 0000000..38cdc53 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/assets/video/adzzz/pinnesse_c.mp4 diff --git a/2026/games_submissions/rpc2dot0/src/assets/video/adzzz/seks_is_bad.mp4 b/2026/games_submissions/rpc2dot0/src/assets/video/adzzz/seks_is_bad.mp4 Binary files differnew file mode 100644 index 0000000..fb9d490 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/assets/video/adzzz/seks_is_bad.mp4 diff --git a/2026/games_submissions/rpc2dot0/src/assets/video/adzzz/seks_is_gud.mp4 b/2026/games_submissions/rpc2dot0/src/assets/video/adzzz/seks_is_gud.mp4 Binary files differnew file mode 100644 index 0000000..7aac4d5 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/assets/video/adzzz/seks_is_gud.mp4 diff --git a/2026/games_submissions/rpc2dot0/src/collision.rs b/2026/games_submissions/rpc2dot0/src/collision.rs new file mode 100644 index 0000000..aaae9a7 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/collision.rs @@ -0,0 +1,99 @@ +use crate::color::EntityColor;
+use crate::constants::{MAX_SPEED, MIN_SPEED, SPEED_COLLIDE_MULT};
+use crate::entity::Entity;
+use crate::math::BoundingCircle;
+use crate::random::RandomState;
+
+pub fn detect_collisions(entities: &[Entity], buffer: &mut Vec<(usize, usize)>) {
+ buffer.clear();
+ let len = entities.len();
+
+ for i in 0..len {
+ if !entities[i].alive {
+ continue;
+ }
+ for j in (i + 1)..len {
+ if !entities[j].alive {
+ continue;
+ }
+ if entities[i].overlaps_with(&entities[j]) {
+ buffer.push((i, j));
+ }
+ }
+ }
+}
+
+pub fn process_collisions(
+ entities: &mut Vec<Entity>,
+ rng: &mut RandomState,
+ _next_entity_id: &mut u32,
+ collision_buffer: &mut Vec<(usize, usize)>,
+ elapsed_ms: f32,
+ _events: &mut Vec<String>,
+) {
+ detect_collisions(entities, collision_buffer);
+
+ let new_entities = Vec::new();
+
+ for &(i, j) in collision_buffer.iter() {
+ if i >= entities.len() || j >= entities.len() {
+ continue;
+ }
+ if !entities[i].alive || !entities[j].alive {
+ continue;
+ }
+
+ let color_a = entities[i].color;
+ let color_b = entities[j].color;
+
+ match (color_a, color_b) {
+ (EntityColor::Green, EntityColor::Green) => {
+ if (rng.next_u32() & 1) == 0 {
+ entities[i].color = EntityColor::Yellow;
+ entities[j].color = EntityColor::Red;
+ entities[j].spawn_time_ms = Some(elapsed_ms);
+ } else {
+ entities[i].color = EntityColor::Red;
+ entities[i].spawn_time_ms = Some(elapsed_ms);
+ entities[j].color = EntityColor::Yellow;
+ }
+ }
+ (EntityColor::Red, EntityColor::Red) => {
+ let a = &entities[i];
+ let b = &entities[j];
+ let collision_point = (a.pos + b.pos) * 0.5;
+
+ entities[i].alive = false;
+ entities[j].alive = false;
+
+ let best_green_idx = entities
+ .iter()
+ .enumerate()
+ .filter(|(_, e)| e.alive && e.color == EntityColor::Green)
+ .min_by(|(_, e1), (_, e2)| {
+ e1.pos
+ .distance_squared(collision_point)
+ .partial_cmp(&e2.pos.distance_squared(collision_point))
+ .unwrap_or(std::cmp::Ordering::Equal)
+ })
+ .map(|(idx, _)| idx);
+
+ if let Some(idx) = best_green_idx {
+ entities[idx].alive = false;
+ }
+ }
+ _ => {
+ let a_speed = (entities[i].speed * SPEED_COLLIDE_MULT).clamp(MIN_SPEED, MAX_SPEED);
+ let b_speed = (entities[j].speed * SPEED_COLLIDE_MULT).clamp(MIN_SPEED, MAX_SPEED);
+ entities[i].speed = a_speed;
+ entities[j].speed = b_speed;
+ entities[i].normalize_velocity();
+ entities[j].normalize_velocity();
+ }
+ }
+ }
+
+ if !new_entities.is_empty() {
+ entities.extend(new_entities);
+ }
+}
diff --git a/2026/games_submissions/rpc2dot0/src/color.rs b/2026/games_submissions/rpc2dot0/src/color.rs new file mode 100644 index 0000000..ed81ec4 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/color.rs @@ -0,0 +1,25 @@ +use crate::assets;
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+
+pub enum EntityColor {
+ Red = 0,
+ Green = 1,
+ Bleu = 2,
+ Yellow = 3,
+}
+
+pub trait ColorExt {
+ fn texture(&self) -> assets::Texture;
+}
+
+impl ColorExt for EntityColor {
+ fn texture(&self) -> assets::Texture {
+ match self {
+ EntityColor::Red => assets::Texture::Mrred,
+ EntityColor::Green => assets::Texture::Mrgreen,
+ EntityColor::Bleu => assets::Texture::Mrbleu,
+ EntityColor::Yellow => assets::Texture::Mryellow,
+ }
+ }
+}
diff --git a/2026/games_submissions/rpc2dot0/src/computer.rs b/2026/games_submissions/rpc2dot0/src/computer.rs new file mode 100644 index 0000000..e25fb65 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/computer.rs @@ -0,0 +1,183 @@ +use crate::constants::*;
+use crate::disquette::Disquette;
+use crate::game::Game;
+use crate::math::ContainsPoint;
+use crate::math::Rectangle;
+use crate::random::RandomState;
+
+pub mod os;
+
+use os::Os;
+use teleia::context;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ComputerPhase {
+ Off,
+ Booting,
+ On,
+ ShutDown,
+}
+
+impl From<ComputerPhase> for &'static str {
+ fn from(value: ComputerPhase) -> Self {
+ match value {
+ ComputerPhase::Off => "Off",
+ ComputerPhase::Booting => "Booting",
+ ComputerPhase::On => "On",
+ ComputerPhase::ShutDown => "ShutDown",
+ }
+ }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum PowerButtonAction {
+ On,
+ Off,
+}
+
+impl From<PowerButtonAction> for &'static str {
+ fn from(value: PowerButtonAction) -> Self {
+ match value {
+ PowerButtonAction::On => "On",
+ PowerButtonAction::Off => "Off",
+ }
+ }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct Computer {
+ pub coord: glam::Vec2,
+ pub phase: ComputerPhase,
+ pub disquette: Disquette,
+ pub os: Os,
+}
+
+impl Computer {
+ pub fn new(
+ logical_width: f32,
+ logical_height: f32,
+ rng: &mut RandomState,
+ difficulty: f32,
+ ) -> Self {
+ const HALF_W: f32 = COMPUTER_WIDTH / 2.0;
+ const HALF_H: f32 = COMPUTER_HEIGHT / 2.0;
+ let x = rng.next_range(HALF_W, logical_width - HALF_W);
+ let y = rng.next_range(HALF_H, logical_height - HALF_H);
+ log::info!("eatyourgreens:: Computer new at ({}, {}) ", x, y);
+ let mut temp = Self {
+ coord: glam::Vec2::new(x, y),
+ phase: ComputerPhase::Off,
+ disquette: Disquette {
+ coord: glam::Vec2::ZERO,
+ vel: glam::Vec2::ZERO,
+ size: 0.0,
+ phase: crate::disquette::DisquettePhase::Free,
+ },
+ os: Os::from(ComputerPhase::Off),
+ };
+
+ let hitzone = temp.hit_zone(difficulty);
+ temp.disquette = Disquette::new(logical_width, logical_height, rng, Some(hitzone));
+ temp
+ }
+
+ pub fn disquette_inserted(&self) -> bool {
+ self.disquette.is_inserted()
+ }
+
+ pub fn boot(&mut self) {
+ log::info!("eatyourgreens:: computer boot");
+ self.phase = ComputerPhase::Booting;
+ self.os = Os::from(self.phase);
+ }
+
+ pub fn on(&mut self, ctx: &context::Context) {
+ log::info!("eatyourgreens:: computer on");
+ self.phase = ComputerPhase::On;
+ self.os.set(self.phase);
+ self.os.os_play(&ctx);
+ }
+
+ pub fn shutdown(&mut self) {
+ log::info!("eatyourgreens:: computer shutdown");
+ self.phase = ComputerPhase::Off;
+ self.os.set(self.phase);
+ }
+
+ pub fn already_used(&self) -> bool {
+ self.phase != ComputerPhase::Off
+ }
+
+ //
+ // hitzone calculation
+ //
+ // computer pos is (x, y)so its center.
+ // first find the top-left corner of the computer bbox.
+ // second define "hitzone" as the inner rectangle offset from that top-left corner.
+
+ // us diffculity to shrink the area, so user msut aim better at higher difficulties
+
+ // topleft(x -width/2 , y-height/2)
+ // +------------------------------------------+ ---
+ // | | |
+ // | TRIGGER_OFFSET_Y | |
+ // | v | | COMPUTER_HEIGHT
+ // | -> +----------------------------+ --- | |
+ // | ^ | diff_y | | | |
+ // | | | -> +---------------+ --- | | | |
+ // | | | ^ | | | | | TRIGGER_HEIGHT
+ // | | | | | Actual Hit |actual_| | | |
+ // | | | | | Zone (shrunk) |height | | | |
+ // | | | | +---------------+ --- | | | |
+ // | | | diff_x | | | |
+ // | | +----------------------------+ --- | |
+ // | | | |
+ // | TRIGGER_OFFSET_X | |
+ // +------------------------------------------+ ---
+ // |--------------COMPUTER_WIDTH--------------|
+
+ pub fn hit_zone(&self, difficulty: f32) -> Rectangle {
+ let topleft = self.coord - glam::Vec2::new(COMPUTER_WIDTH / 2.0, COMPUTER_HEIGHT / 2.0);
+
+ let size_multiplier = 1.0 / difficulty.max(1.0);
+ let actual_size = glam::Vec2::new(TRIGGER_WIDTH, TRIGGER_HEIGHT) * size_multiplier;
+
+ let diff = (glam::Vec2::new(TRIGGER_WIDTH, TRIGGER_HEIGHT) - actual_size) / 2.0;
+
+ let trigger_pos = topleft + glam::Vec2::new(TRIGGER_OFFSET_X, TRIGGER_OFFSET_Y) + diff;
+
+ Rectangle::from_min_max(trigger_pos, trigger_pos + actual_size)
+ }
+
+ pub fn check_power_button(
+ &self,
+ point: glam::Vec2,
+ difficulty: f32,
+ ) -> Option<PowerButtonAction> {
+ let topleft = self.coord - glam::Vec2::new(COMPUTER_WIDTH / 2.0, COMPUTER_HEIGHT / 2.0);
+ let pb_pos = topleft + glam::Vec2::new(POWER_BUTTON_OFFSET_X, POWER_BUTTON_OFFSET_Y);
+ let pb_size = glam::Vec2::new(POWER_BUTTON_WIDTH, POWER_BUTTON_HEIGHT);
+
+ let pb_rect = Rectangle::from_min_max(pb_pos, pb_pos + pb_size);
+
+ if pb_rect.contains(point) {
+ if difficulty > 1.0 {
+ let half_width = POWER_BUTTON_WIDTH / 2.0;
+ if point.x < pb_pos.x + half_width {
+ Some(PowerButtonAction::Off)
+ } else {
+ Some(PowerButtonAction::On)
+ }
+ } else {
+ Some(PowerButtonAction::On)
+ }
+ } else {
+ None
+ }
+ }
+
+ pub fn contains_disquette(&self, disquette: &Disquette, difficulty: f32) -> bool {
+ let hitzone = self.hit_zone(difficulty);
+ hitzone.contains(disquette.coord)
+ }
+}
diff --git a/2026/games_submissions/rpc2dot0/src/computer/os.rs b/2026/games_submissions/rpc2dot0/src/computer/os.rs new file mode 100644 index 0000000..797e07e --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/computer/os.rs @@ -0,0 +1,117 @@ +use std::fmt::Debug;
+
+use crate::computer::ComputerPhase;
+use crate::message::Message;
+use crate::{assets::VIDEO_ASSETS, random::RandomState};
+use crate::{constants::*, game};
+use teleia::context;
+use web_sys::{Blob, BlobPropertyBag, Url};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Os {
+ state: OsState,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum OsState {
+ Booting,
+ On,
+ ShutDown,
+ Off,
+}
+
+// TODO ???
+impl From<OsState> for ComputerPhase {
+ fn from(value: OsState) -> Self {
+ match value {
+ OsState::Booting => ComputerPhase::Booting,
+ OsState::On => ComputerPhase::On,
+ OsState::ShutDown => ComputerPhase::ShutDown,
+ OsState::Off => ComputerPhase::Off,
+ }
+ }
+}
+
+impl From<ComputerPhase> for OsState {
+ fn from(value: ComputerPhase) -> Self {
+ match value {
+ ComputerPhase::Off => OsState::Off,
+ ComputerPhase::Booting => OsState::Booting,
+ ComputerPhase::On => OsState::On,
+ ComputerPhase::ShutDown => OsState::ShutDown,
+ }
+ }
+}
+
+impl Os {
+ pub fn new() -> Self {
+ Self {
+ state: OsState::Off,
+ }
+ }
+ pub fn from(phase: ComputerPhase) -> Self {
+ Self {
+ state: OsState::from(phase),
+ }
+ }
+
+ pub fn set(&mut self, phase: ComputerPhase) {
+ self.state = OsState::from(phase);
+ }
+}
+
+impl Default for Os {
+ fn default() -> Self {
+ Self {
+ state: OsState::Off,
+ }
+ }
+}
+
+impl Os {
+ pub fn boot(rng: &mut RandomState) {
+ let idx = rng.next_range(0.0, VIDEO_ASSETS.len() as f32) as usize;
+ let bytes = VIDEO_ASSETS[idx].1;
+
+ // huh ? `of1` nice api name
+ let parts = js_sys::Array::of1(&js_sys::Uint8Array::from(bytes));
+ let blob_props = BlobPropertyBag::new();
+ blob_props.set_type("video/mp4");
+
+ let blob = match Blob::new_with_u8_array_sequence_and_options(&parts, &blob_props) {
+ Ok(b) => b,
+ Err(_) => {
+ log::error!("eatyourgreens:: failed to create blob");
+ return;
+ }
+ };
+
+ let url = match Url::create_object_url_with_blob(&blob) {
+ Ok(s) => s,
+ Err(_) => {
+ log::error!("eatyourgreens:: failed to create object URL");
+ return;
+ }
+ };
+ if let Some(window) = web_sys::window() {
+ let msg = Message {
+ op: "play_video",
+ verb: None,
+ win: None,
+ score: None,
+ video_url: Some(url),
+ };
+ Message::post(&window, &msg);
+ } else {
+ log::error!("eatyourgreens:: failed to get window and send os msg");
+ }
+ }
+
+ pub fn os_play(&self, ctx: &context::Context) {
+ log::debug!("eatyourgreens:: os play game:");
+ }
+
+ pub fn os_quit() {
+ log::debug!("eatyourgreens:: os quit");
+ }
+}
diff --git a/2026/games_submissions/rpc2dot0/src/constants.rs b/2026/games_submissions/rpc2dot0/src/constants.rs new file mode 100644 index 0000000..0e16b2b --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/constants.rs @@ -0,0 +1,109 @@ +use crate::color::EntityColor;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+pub const HEIGHT: u32 = 160;
+pub const WIDTH: u32 = 240;
+pub const LANDING_TEXTURE_HEIGHT: i32 = 160;
+pub const LANDING_TEXTURE_WIDTH: i32 = 240;
+pub const MUTE_ICON_SIZE: f32 = 16.0;
+pub const MUTE_ICON_MARGIN: f32 = 0.0;
+
+pub const GAME_DURATION_MS: u32 = 15_000;
+pub const NB_GREENS: i32 = 15;
+pub const INITIAL_SPAWN: u32 = 8;
+pub const MAX_ENTITIES: u32 = 40;
+pub const BASE_SPEED: f32 = 24.0;
+pub const SPEED_COLLIDE_MULT: f32 = 2.0;
+pub const ENTITY_RADIUS: f32 = 4.8;
+pub const INITIAL_SPAWN_SPREAD_MS: f32 = 1_000.0;
+pub const SPAWN_RATE_MIN_MS: u32 = 500;
+pub const SPAWN_RATE_MAX_MS: u32 = 1_200;
+pub const DAMPING_FACTOR: f32 = 0.98;
+pub const JITTER_STRENGTH: f32 = 0.12;
+pub const MIN_SPEED: f32 = 2.6;
+pub const MAX_SPEED: f32 = 64.0;
+pub const SPAWN_PADDING: f32 = 1.0;
+pub const ENTITY_SCALE_FACTOR: f32 = 1.5;
+pub const RED_COUNTDOWN_MS: f32 = 3_000.0;
+pub const ROGUE_DURATION_MS: f32 = 3_000.0;
+pub const PACMAN_CHASE_PROB: f64 = 0.30;
+pub const PACMAN_CHASE_SPEED_MULT: f32 = 1.5;
+
+pub const BASELINE_RATIOS: [f32; 4] = {
+ let mut b = [0.0f32; 4];
+ b[EntityColor::Red as usize] = 0.10;
+ b[EntityColor::Green as usize] = 0.60;
+ b[EntityColor::Bleu as usize] = 0.10;
+ b[EntityColor::Yellow as usize] = 0.20;
+ b
+};
+
+pub const fn get_baseline_ratio(color: EntityColor, difficulty: f32) -> f32 {
+ const SHIFT_PER_LEVEL: f32 = 0.15;
+ const GREEN_FLOOR: f32 = 0.05;
+
+ let green_base = BASELINE_RATIOS[EntityColor::Green as usize];
+ let red_base = BASELINE_RATIOS[EntityColor::Red as usize];
+
+ // how much we can actually shift without breaching the green floor.
+ let max_shift = green_base - GREEN_FLOOR;
+ let shift = (SHIFT_PER_LEVEL * (difficulty - 1.0).max(0.0)).min(max_shift);
+
+ match color {
+ EntityColor::Green => green_base - shift,
+ EntityColor::Red => red_base + shift,
+ // Bleu and Yellow stay fixed; only the Green/Red tension is modulated.
+ c => BASELINE_RATIOS[c as usize],
+ }
+}
+
+// UI constants
+pub const TITLE_HEADING_TEXT_COLOR: glam::Vec3 = glam::Vec3::new(0.105, 0.262, 0.196);
+pub const TITLE_DESCRIPTION_TEXT_COLOR: glam::Vec3 = glam::Vec3::new(0.184, 0.321, 0.2);
+pub const START_BUTTON_TEXT_COLOR: glam::Vec3 = glam::Vec3::new(1.0, 1.0, 1.0);
+pub const TITLE_START_BUTTON_LABEL: &str = "START";
+pub fn title_score_goal() -> String {
+ format!("Score {} or more to win", NB_GREENS)
+}
+pub const TITLE_CLICK_START_HINT: &str = "Click START to begin the 15s* round.";
+//pub const TITLE_ROUND_WARNING: &str = "(*in this computer seconds might be longer, TBI)";
+pub const TITLE_SCORING_HINT: &str = "Green gives +1, all other colors give -1.";
+pub const TITLE_HINT: &str = "hint: booting the computer is optional.";
+
+pub const HUD_TEXT_COLOR: glam::Vec3 = glam::Vec3::new(0.2, 0.2, 0.2);
+pub const HUD_SCORE_LABEL_PREFIX: &str = "Score: ";
+pub const HUD_TIME_LABEL_PREFIX: &str = "Time: ";
+pub const HUD_TIME_LABEL_SUFFIX: &str = "s";
+pub const HUD_FPS_LABEL_PREFIX: &str = "FPS: ";
+pub const HUD_SCORE_POSITION: glam::Vec2 = glam::Vec2::new(2.6, 6.6);
+pub const HUD_FPS_POSITION: glam::Vec2 = glam::Vec2::new(2.6, 20.0);
+pub const RESULT_DISPLAY_DELAY_MS: f64 = 2000.0;
+#[wasm_bindgen]
+pub fn get_result_display_delay_ms() -> f64 {
+ RESULT_DISPLAY_DELAY_MS
+}
+
+// UI rendering colors and uniforms
+pub const RED_COUNTDOWN_BAR_COLOR: glam::Vec4 = glam::Vec4::new(1.0, 0.266, 0.266, 1.0);
+pub const BUTTON_FILL_COLOR: glam::Vec4 = glam::Vec4::new(0.0, 0.0, 1.0, 0.9);
+pub const GAME_OVER_OVERLAY_COLOR: glam::Vec4 = glam::Vec4::new(1.0, 1.0, 1.0, 0.82);
+pub const UI_UNIFORM_COLOR_NAME: &str = "color";
+pub const UI_UNIFORM_OPACITY_NAME: &str = "opacity";
+pub const FLASH_SCREEN_BASE_COLOR: glam::Vec3 = glam::Vec3::new(1.0, 0.0, 0.0);
+pub const GAME_OVER_TEXT_COLOR: glam::Vec3 = glam::Vec3::new(0.105, 0.262, 0.196);
+pub const GAME_OVER_TITLE_TEXT: &str = "Game Over";
+pub const GAME_OVER_RESULT_PREFIX: &str = "Result: ";
+
+// computer
+pub const COMPUTER_WIDTH: f32 = 42.6;
+pub const COMPUTER_HEIGHT: f32 = 42.6;
+pub const TRIGGER_OFFSET_X: f32 = 9.8;
+pub const TRIGGER_OFFSET_Y: f32 = 4.0;
+pub const TRIGGER_WIDTH: f32 = 8.0;
+pub const TRIGGER_HEIGHT: f32 = 6.1;
+pub const POWER_BUTTON_OFFSET_X: f32 = 28.8;
+pub const POWER_BUTTON_OFFSET_Y: f32 = 2.6;
+pub const POWER_BUTTON_WIDTH: f32 = 9.6;
+pub const POWER_BUTTON_HEIGHT: f32 = 5.8;
+
+// Subgame
diff --git a/2026/games_submissions/rpc2dot0/src/disquette.rs b/2026/games_submissions/rpc2dot0/src/disquette.rs new file mode 100644 index 0000000..7940d17 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/disquette.rs @@ -0,0 +1,184 @@ +use crate::math::{ContainsPoint, Rectangle};
+use crate::random::RandomState;
+use teleia::state;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum DisquettePhase {
+ Free,
+ Inserted,
+}
+
+impl From<DisquettePhase> for &'static str {
+ fn from(value: DisquettePhase) -> Self {
+ match value {
+ DisquettePhase::Free => "Free",
+ DisquettePhase::Inserted => "Inserted",
+ }
+ }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct Disquette {
+ pub coord: glam::Vec2,
+ pub vel: glam::Vec2,
+ pub size: f32,
+ pub phase: DisquettePhase,
+}
+
+impl Disquette {
+ pub fn new(
+ logical_width: f32,
+ logical_height: f32,
+ rng: &mut RandomState,
+ computer_hitzone: Option<Rectangle>,
+ ) -> Self {
+ const SIZE: f32 = 6.4;
+ const HALF: f32 = SIZE / 2.0;
+ log::info!(
+ "eatyourgreens:: Disquette new at ({}, {})",
+ logical_width,
+ logical_height
+ );
+
+ let x = rng.next_range(HALF, logical_width - HALF);
+ let y = rng.next_range(HALF, logical_height - HALF);
+ let mut coord = glam::Vec2::new(x, y);
+
+ // prevent spawning inside the computer hitzone
+ // this is a bit stupidos, but it works for now.
+ // @TODO: find a better way to do this. like using rng api (random.rs) where you can
+ // specify the excluded area, or something less retarded.
+ if let Some(hitzone) = computer_hitzone {
+ // wasting few cpu cycles doesn't hurt anybody
+ while hitzone.contains(coord) {
+ coord.x = rng.next_range(HALF, logical_width - HALF);
+ coord.y = rng.next_range(HALF, logical_height - HALF);
+ }
+ }
+
+ Self {
+ coord,
+ vel: glam::Vec2::new(
+ // -/+ 21.3 as value cause it works, yeah idc
+ if rng.next_bool(0.5) { 21.3 } else { -21.3 },
+ if rng.next_bool(0.5) { 21.3 } else { -21.3 },
+ ),
+ size: SIZE,
+ phase: DisquettePhase::Free,
+ }
+ }
+
+ pub fn is_inserted(&self) -> bool {
+ self.phase == DisquettePhase::Inserted
+ }
+
+ pub fn update(
+ &mut self,
+ width: f32,
+ height: f32,
+ keys: &state::Keys,
+ delta_ms: f32,
+ difficulty: f32,
+ computer_hitzone: Option<Rectangle>,
+ ) {
+ let dt = delta_ms / 1000.0;
+ let impulse = 106.7 * difficulty;
+
+ let driven_by_user = keys.left() || keys.right() || keys.up() || keys.down();
+
+ if keys.left() {
+ self.vel.x -= impulse * dt;
+ }
+ if keys.right() {
+ self.vel.x += impulse * dt;
+ }
+ if keys.up() {
+ self.vel.y -= impulse * dt;
+ }
+ if keys.down() {
+ self.vel.y += impulse * dt;
+ }
+
+ // speed limiting
+ // @TODO : hum value below was adjusted manualy it might
+ // be wrong with game rendering speed? ??
+ let max_speed = 53.3 * difficulty;
+ let speed = self.vel.length();
+ if speed > max_speed {
+ self.vel = self.vel.normalize() * max_speed;
+ }
+
+ self.coord += self.vel * dt;
+
+ let half = self.size / 2.0;
+ let min_bounds = glam::Vec2::splat(half);
+ let max_bounds = glam::Vec2::new(width - half, height - half);
+
+ // boundary collision and bouncing
+ // left edge : clamp position and ensure it moves right
+ if self.coord.x < min_bounds.x {
+ self.coord.x = min_bounds.x;
+ // .abs() guarantees velocity is positive (moving right)
+ self.vel.x = self.vel.x.abs();
+ }
+ // right edge : clamp position and ensure it moves left
+ else if self.coord.x > max_bounds.x {
+ self.coord.x = max_bounds.x;
+ // -.abs() guarantees velocity is negative (moving left)
+ self.vel.x = -self.vel.x.abs();
+ }
+
+ // top and bottom edges
+ if self.coord.y < min_bounds.y {
+ self.coord.y = min_bounds.y;
+ // .abs() guarantees velocity is positive (moving down)
+ self.vel.y = self.vel.y.abs();
+ } else if self.coord.y > max_bounds.y {
+ self.coord.y = max_bounds.y;
+ // -.abs() guarantees velocity is negative (moving up)
+ self.vel.y = -self.vel.y.abs();
+ }
+
+ // bounce off computer hitzone unless user is actively driving it in
+ if !driven_by_user && let Some(hitzone) = computer_hitzone {
+ let prev_pos = self.coord - self.vel * dt;
+
+ if hitzone.contains(self.coord) {
+ let was_outside = !hitzone.contains(prev_pos);
+ if was_outside {
+ let was_left = prev_pos.x < hitzone.min.x;
+ let was_right = prev_pos.x > hitzone.max.x;
+ let was_top = prev_pos.y < hitzone.min.y;
+ let was_bottom = prev_pos.y > hitzone.max.y;
+
+ if was_left || was_right {
+ // reverse horizontal velocity to bounce off
+ self.vel.x = -self.vel.x;
+ // +/- 0.1 is a tiny extra push away from the hitzone.
+ // this prevent the disquette from getting stuck exactly on the boundary
+ // and repeatedly triggers collisions
+ // this bug took 2h from my life, fuck you disquette, you floppy disk :/.
+ self.coord.x = if was_left {
+ hitzone.min.x - 0.1
+ } else {
+ hitzone.max.x + 0.1
+ };
+ }
+ if was_top || was_bottom {
+ // reverse vertical velocity to bounce off
+ self.vel.y = -self.vel.y;
+ // +/- 0.1 adds a tiny gap to safely escape the hitzone
+ self.coord.y = if was_top {
+ hitzone.min.y - 0.1
+ } else {
+ hitzone.max.y + 0.1
+ };
+ }
+ }
+ }
+ }
+ }
+}
+
+// the hours spent on this zone/bouncing detection bs, I should've done something more productive, but
+// whatever.
diff --git a/2026/games_submissions/rpc2dot0/src/effects.rs b/2026/games_submissions/rpc2dot0/src/effects.rs new file mode 100644 index 0000000..02b33ef --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/effects.rs @@ -0,0 +1,58 @@ +use crate::color::EntityColor;
+use crate::constants::*;
+
+#[derive(Debug, Clone)]
+pub struct PacmanChase {
+ pub speed: f32,
+}
+
+impl PacmanChase {
+ pub fn new(speed: f32) -> Self {
+ Self { speed }
+ }
+}
+
+impl Default for PacmanChase {
+ fn default() -> Self {
+ Self::new(BASE_SPEED)
+ }
+}
+#[derive(Debug, Clone)]
+pub struct Rogue {
+ pub until_ms: f32,
+ pub hover_color: EntityColor,
+}
+
+impl Rogue {
+ pub fn new(until_ms: f32, hover_color: EntityColor) -> Self {
+ Self {
+ until_ms,
+ hover_color,
+ }
+ }
+}
+
+impl Default for Rogue {
+ fn default() -> Self {
+ Self::new(ROGUE_DURATION_MS, EntityColor::Yellow)
+ }
+}
+
+pub struct Explosion {
+ pub x: f32,
+ pub y: f32,
+ pub age_ms: f32,
+ pub duration_ms: f32,
+ pub radius: f32,
+}
+impl Explosion {
+ pub fn new(x: f32, y: f32) -> Self {
+ Self {
+ x,
+ y,
+ age_ms: 0.0,
+ duration_ms: 400.0,
+ radius: 8.0,
+ }
+ }
+}
diff --git a/2026/games_submissions/rpc2dot0/src/entity.rs b/2026/games_submissions/rpc2dot0/src/entity.rs new file mode 100644 index 0000000..3b4200f --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/entity.rs @@ -0,0 +1,90 @@ +use crate::color::EntityColor;
+use crate::constants::{DAMPING_FACTOR, MIN_SPEED};
+use crate::effects::{PacmanChase, Rogue};
+use crate::math::{BoundingCircle, Vec2};
+
+pub trait Update {
+ fn update(&mut self, delta_ms: f32);
+}
+
+#[derive(Debug, Clone)]
+pub struct Entity {
+ pub _id: u32,
+ pub pos: Vec2,
+ pub vel: Vec2,
+ pub speed: f32,
+ pub color: EntityColor,
+ pub radius: f32,
+ pub alive: bool,
+ pub spawn_time_ms: Option<f32>,
+ pub rogue: Option<Rogue>,
+ pub pacman_chase: Option<PacmanChase>,
+}
+
+impl Entity {
+ pub fn new(id: u32, pos: Vec2, vel: Vec2, color: EntityColor, speed: f32, radius: f32) -> Self {
+ let mut entity = Self {
+ _id: id,
+ pos,
+ vel,
+ speed,
+ color,
+ radius,
+ alive: true,
+ spawn_time_ms: None,
+ rogue: None,
+ pacman_chase: None,
+ };
+ entity.normalize_velocity();
+ entity
+ }
+
+ pub fn normalize_velocity(&mut self) {
+ let length = self.vel.length();
+ if length <= f32::EPSILON {
+ self.vel = Vec2::new(1.0, 0.0);
+ } else {
+ self.vel = self.vel / length * self.speed;
+ }
+ }
+
+ pub fn apply_jitter(&mut self, jitter: Vec2) {
+ self.vel += jitter;
+ self.normalize_velocity();
+ }
+
+ pub fn dampen_speed(&mut self, max_speed: f32) {
+ self.speed = (self.speed * DAMPING_FACTOR).clamp(MIN_SPEED, max_speed);
+ self.normalize_velocity();
+ }
+
+ pub fn bounds_bounce(&mut self, width: f32, height: f32) {
+ let min_bounds = Vec2::splat(self.radius);
+ let max_bounds = Vec2::new(width, height) - min_bounds;
+
+ let hit_min = self.pos.cmple(min_bounds);
+ let hit_max = self.pos.cmpge(max_bounds);
+
+ self.pos = self.pos.clamp(min_bounds, max_bounds);
+
+ self.vel = Vec2::select(hit_min, self.vel.abs(), self.vel);
+ self.vel = Vec2::select(hit_max, -self.vel.abs(), self.vel);
+ }
+}
+
+impl Update for Entity {
+ fn update(&mut self, delta_ms: f32) {
+ let dt = delta_ms / 1000.0;
+ self.pos += self.vel * dt;
+ }
+}
+
+impl BoundingCircle for Entity {
+ fn center(&self) -> Vec2 {
+ self.pos
+ }
+
+ fn radius(&self) -> f32 {
+ self.radius
+ }
+}
diff --git a/2026/games_submissions/rpc2dot0/src/errors.rs b/2026/games_submissions/rpc2dot0/src/errors.rs new file mode 100644 index 0000000..71a67cf --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/errors.rs @@ -0,0 +1,7 @@ +use crate::color::EntityColor;
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum ClickOutcome {
+ Hit(EntityColor),
+ Miss,
+}
diff --git a/2026/games_submissions/rpc2dot0/src/game.rs b/2026/games_submissions/rpc2dot0/src/game.rs new file mode 100644 index 0000000..7650e72 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/game.rs @@ -0,0 +1,869 @@ +use std::collections::HashMap;
+
+use teleia::renderer::UberFlags;
+use teleia::*;
+
+use crate::assets;
+use crate::assets::AUDIO_ASSETS;
+use crate::color::{ColorExt, EntityColor};
+use crate::computer::os::Os;
+use crate::computer::*;
+use crate::constants::*;
+use crate::disquette::*;
+use crate::effects::*;
+use crate::errors::*;
+use crate::math::*;
+use crate::message::Message;
+use crate::state::{GamePhase, GameState};
+
+pub struct Game {
+ renderer: renderer::Renderer<assets::Assets>,
+ state: GameState,
+ mouse: glam::Vec2,
+ explosions: Vec<Explosion>,
+ greens_wiped_flash: f32,
+ computer: Computer,
+ start_button_rect: Option<Rectangle>,
+ is_muted: bool,
+ mute_button_rect: Option<Rectangle>,
+ is_embedded: bool,
+ last_time_ms: Option<f64>,
+ finish_time_ms: Option<f64>,
+ done_sent: bool,
+}
+
+impl Game {
+ pub fn new(ctx: &context::Context, is_embedded: bool) -> Self {
+ log::info!("eatyourgreens:: entering new Game");
+ let mut state = GameState::new();
+ let computer = Computer::new(
+ ctx.render_width,
+ ctx.render_height,
+ &mut state.rng,
+ state.difficulty,
+ );
+ Self {
+ renderer: renderer::Renderer::new(ctx, assets::Assets::new),
+ state,
+ mouse: glam::Vec2::ZERO,
+ explosions: Vec::new(),
+ greens_wiped_flash: 0.0,
+ computer,
+ start_button_rect: None,
+ is_muted: false,
+ mute_button_rect: None,
+ is_embedded,
+ last_time_ms: None,
+ finish_time_ms: None,
+ done_sent: false,
+ }
+ }
+
+ pub fn set_difficulty(&mut self, difficulty: f32) {
+ log::info!("eatyourgreens:: set_difficulty: {}", difficulty);
+ self.state.set_difficulty(difficulty);
+ }
+
+ pub fn receive_op(&mut self, ctx: &context::Context, st: &mut state::State, op: String) {
+ log::info!(
+ "eatyourgreens:: receive op: {} (phase: {:?})",
+ op,
+ self.state.phase()
+ );
+ match self.state.phase() {
+ GamePhase::Waiting | GamePhase::Finished => {
+ if self.is_embedded && op == "start" {
+ self.reset_round(ctx, st);
+ const VERB: &str = "eat your greens";
+ self.send_op("started", Some(VERB), None, None, None);
+ } else {
+ log::warn!("eatyourgreens:: received unexpected op: {} (waiting) ", op);
+ }
+ }
+ GamePhase::Computer(computer_phase) => {
+ let currentop = op.as_str();
+ match computer_phase {
+ ComputerPhase::Booting => {
+ if currentop == "video_finished" {
+ self.state.set_phase(GamePhase::Computer(ComputerPhase::On));
+ self.computer.on(ctx);
+ } else {
+ log::warn!(
+ "eatyourgreens:: received unexpected op: {}, Phase {:?} (Computer)",
+ op,
+ computer_phase
+ );
+ }
+ }
+ ComputerPhase::On => {
+ if currentop == "computing" {
+ // nothing to do in here
+ // we wait for os-micro-game to send shutdown
+ log::info!("eatyourgreens:: computer computing. do nothing.");
+ } else if currentop == "shutdown" {
+ log::info!(
+ "eatyourgreens:: computer shutdown. Transition to main game."
+ );
+ self.computer.shutdown();
+ self.state.set_phase(GamePhase::Playing);
+ } else {
+ log::warn!(
+ "eatyourgreens:: received unexpected op: {}, Phase {:?} (Computer)",
+ op,
+ computer_phase
+ );
+ }
+ }
+
+ _ => {
+ // we shouldn't be receiving events while computer is off or shutdown
+ log::warn!(
+ "eatyourgreens:: received unexpected op: {}, Phase {:?} (Computer)",
+ op,
+ computer_phase
+ );
+ }
+ }
+ }
+ _ => {
+ log::warn!(
+ "eatyourgreens:: received unexpected op: {} for phase: {:?}",
+ op,
+ self.state.phase()
+ );
+ }
+ }
+ }
+
+ fn reset_round(&mut self, ctx: &context::Context, st: &mut state::State) {
+ log::info!("eatyourgreens:: reset_round");
+ self.state.start_round();
+
+ let computer = Computer::new(
+ ctx.render_width,
+ ctx.render_height,
+ &mut self.state.rng,
+ self.state.difficulty,
+ );
+
+ self.computer = computer;
+ self.explosions.clear();
+ self.greens_wiped_flash = 0.0;
+ if self.is_muted {
+ st.audio.stop_music();
+ }
+ self.last_time_ms = None;
+ self.finish_time_ms = None;
+ self.done_sent = false;
+ }
+
+ fn push_explosion(&mut self, x: f32, y: f32) {
+ self.explosions.push(Explosion::new(x, y));
+ }
+
+ fn update_explosions(&mut self, delta_ms: f32) {
+ for exp in &mut self.explosions {
+ exp.age_ms += delta_ms;
+ }
+ self.explosions.retain(|e| e.age_ms < e.duration_ms);
+ }
+
+ fn handle_state_event(&mut self, event: String, st: &mut state::State) {
+ log::info!("eatyourgreens:: handle_state_event: {}", event);
+ if let Some(coords) = event.strip_prefix("explode:") {
+ if !self.is_muted {
+ st.audio.play_sfx("explosion");
+ }
+ let (x, y): (f32, f32) = parse_coords(coords);
+ self.push_explosion(x, y);
+ self.greens_wiped_flash = 300.0;
+ return;
+ }
+
+ if let Some(coords) = event.strip_prefix("click_red:") {
+ if !self.is_muted {
+ st.audio.play_sfx("explosion");
+ }
+ let (x, y) = parse_coords(coords);
+ self.push_explosion(x, y);
+ return;
+ }
+ }
+
+ fn render_title(&mut self, ctx: &context::Context, st: &mut state::State) {
+ self.renderer
+ .bind_uber_2d(ctx, st, UberFlags::TEXTURE_COLOR | UberFlags::SPRITE);
+ self.renderer
+ .bind_texture(ctx, st, assets::Texture::Landing);
+ self.renderer.set_texture_offset(
+ ctx,
+ st,
+ 1,
+ 1,
+ LANDING_TEXTURE_WIDTH,
+ LANDING_TEXTURE_HEIGHT,
+ );
+ self.renderer
+ .set_position_2d(ctx, st, glam::Vec2::ZERO, st.render_dims);
+ self.renderer.set_f32(ctx, st, UI_UNIFORM_OPACITY_NAME, 0.5);
+ self.renderer.render_square(ctx, st);
+
+ let center_x: f32 = ctx.render_width / 2.0;
+ let mut y: f32 = ctx.render_height * 0.3;
+ let line_height: f32 = self.renderer.font_char_height(st) + 1.0;
+
+ self.draw_text_centered(
+ ctx,
+ st,
+ center_x,
+ y,
+ TITLE_HEADING_TEXT_COLOR,
+ &title_score_goal(),
+ );
+
+ y += line_height;
+ self.draw_text_centered(
+ ctx,
+ st,
+ center_x,
+ y,
+ TITLE_HEADING_TEXT_COLOR,
+ TITLE_CLICK_START_HINT,
+ );
+
+ y += line_height * 2.0;
+ if !self.is_embedded {
+ self.draw_button_centered(
+ ctx,
+ st,
+ center_x,
+ y,
+ START_BUTTON_TEXT_COLOR,
+ TITLE_START_BUTTON_LABEL,
+ );
+ } else {
+ self.start_button_rect = None;
+ }
+
+ y += line_height * 3.0;
+ self.draw_text_centered(
+ ctx,
+ st,
+ center_x,
+ y,
+ TITLE_DESCRIPTION_TEXT_COLOR,
+ TITLE_SCORING_HINT,
+ );
+
+ y += line_height;
+ self.draw_text_centered(
+ ctx,
+ st,
+ center_x,
+ y,
+ TITLE_DESCRIPTION_TEXT_COLOR,
+ TITLE_HINT,
+ );
+
+ self.draw_mute_icon(ctx, st);
+ }
+
+ fn render_background(&mut self, ctx: &context::Context, st: &mut state::State) {
+ ctx.clear_color(glam::Vec4::ZERO);
+ ctx.clear();
+ self.renderer.texture_screen(
+ ctx,
+ st,
+ assets::Texture::BackgroundMain,
+ glam::Vec2::ZERO,
+ glam::Vec2::new(ctx.render_width, ctx.render_height),
+ );
+ }
+
+ fn render_entities(&mut self, ctx: &context::Context, st: &mut state::State) {
+ let mapped_mouse = self.map_mouse_to_render(ctx, st);
+ let elapsed_ms = self.state.elapsed_ms();
+ for entity in self.state.entities() {
+ if !entity.alive {
+ continue;
+ }
+
+ let size: f32 = entity.radius * 2.0;
+ let pos: glam::Vec2 = glam::Vec2::new(entity.pos.x, entity.pos.y);
+ let dims: glam::Vec2 = glam::Vec2::new(size, size);
+ let topleft: glam::Vec2 = pos - dims / 2.0;
+
+ let mut display_color: EntityColor = entity.color;
+ if display_color == EntityColor::Green
+ && let Some(rogue) = &entity.rogue
+ && elapsed_ms < rogue.until_ms
+ && entity.pos.distance_squared(mapped_mouse) <= entity.radius * entity.radius
+ {
+ display_color = rogue.hover_color;
+ }
+
+ let texture = if entity.color == EntityColor::Bleu && entity.pacman_chase.is_some() {
+ assets::Texture::MrbleuLurking
+ } else {
+ display_color.texture()
+ };
+
+ self.renderer
+ .texture_screen(ctx, st, texture, topleft, dims);
+ }
+ }
+
+ fn render_red_countdowns(&mut self, ctx: &context::Context, st: &mut state::State) {
+ self.renderer.bind_uber_2d(ctx, st, UberFlags::empty());
+ self.renderer
+ .set_vec4(ctx, st, UI_UNIFORM_COLOR_NAME, RED_COUNTDOWN_BAR_COLOR);
+
+ for entity in self.state.entities() {
+ if !entity.alive || entity.color != EntityColor::Red {
+ continue;
+ }
+
+ if let Some(spawn_time) = entity.spawn_time_ms {
+ let elapsed = self.state.elapsed_ms() - spawn_time;
+ if elapsed < RED_COUNTDOWN_MS {
+ let remaining = RED_COUNTDOWN_MS - elapsed;
+ let fraction = remaining / RED_COUNTDOWN_MS;
+ let bar_width = 10.6;
+ let bar_height = 1.6;
+ let pos = glam::Vec2::new(
+ entity.pos.x - bar_width / 2.0,
+ entity.pos.y - entity.radius - 3.2,
+ );
+
+ self.renderer.set_position_2d(
+ ctx,
+ st,
+ pos,
+ glam::Vec2::new(bar_width * fraction, bar_height),
+ );
+ self.renderer.render_square(ctx, st);
+ }
+ }
+ }
+ }
+
+ fn render_explosions(&mut self, ctx: &context::Context, st: &mut state::State) {
+ self.renderer.bind_uber_2d(ctx, st, UberFlags::empty());
+
+ for exp in &self.explosions {
+ let t = exp.age_ms / exp.duration_ms;
+ let alpha = 1.0 - t;
+ let r = exp.radius * (0.5 + t * 0.5);
+ let color = glam::Vec4::new(1.0, (200.0 - t * 200.0) / 255.0, 0.0, alpha);
+ self.renderer.set_vec4(ctx, st, "color", color);
+
+ let size = r * 2.0;
+ let pos = glam::Vec2::new(exp.x - r, exp.y - r);
+ self.renderer
+ .set_position_2d(ctx, st, pos, glam::Vec2::new(size, size));
+ self.renderer.render_square(ctx, st);
+ }
+ }
+
+ fn render_flash(&mut self, ctx: &context::Context, st: &mut state::State) {
+ if self.greens_wiped_flash > 0.0 {
+ let flash_alpha = (self.greens_wiped_flash / 300.0) * 0.3;
+ let flash_color = glam::Vec4::new(
+ FLASH_SCREEN_BASE_COLOR.x,
+ FLASH_SCREEN_BASE_COLOR.y,
+ FLASH_SCREEN_BASE_COLOR.z,
+ flash_alpha,
+ );
+ self.renderer.color_screen(
+ ctx,
+ st,
+ flash_color,
+ glam::Vec2::ZERO,
+ glam::Vec2::new(ctx.render_width, ctx.render_height),
+ );
+ }
+ }
+
+ fn render_computer(&mut self, ctx: &context::Context, st: &mut state::State) {
+ let dims = glam::Vec2::new(COMPUTER_WIDTH, COMPUTER_HEIGHT);
+ let topleft = self.computer.coord - dims / 2.0;
+ self.renderer
+ .texture_screen(ctx, st, assets::Texture::Computer, topleft, dims);
+ }
+
+ fn render_disquette(&mut self, ctx: &context::Context, st: &mut state::State) {
+ if self.computer.already_used() || self.computer.disquette_inserted() {
+ return;
+ }
+
+ let size = self.computer.disquette.size;
+ let dims = glam::Vec2::splat(size);
+ let topleft = self.computer.disquette.coord - dims / 2.0;
+ self.renderer
+ .texture_screen(ctx, st, assets::Texture::Disquette, topleft, dims);
+ }
+
+ fn render_hud(&mut self, ctx: &context::Context, st: &mut state::State) {
+ self.renderer.text_colored_screen(
+ ctx,
+ st,
+ HUD_SCORE_POSITION,
+ HUD_TEXT_COLOR,
+ &format!(
+ "{}{}",
+ HUD_SCORE_LABEL_PREFIX,
+ format_args!("{}/{}", self.state.consumer_score(), NB_GREENS)
+ ),
+ );
+
+ let remaining_secs = (self.state.remaining_ms() / 1000.0).ceil() as i32;
+ let time_str = format!(
+ "{}{}{}",
+ HUD_TIME_LABEL_PREFIX, remaining_secs, HUD_TIME_LABEL_SUFFIX
+ );
+ let time_width = self.renderer.font_char_width(st) * time_str.len() as f32;
+
+ self.renderer.text_colored_screen(
+ ctx,
+ st,
+ glam::Vec2::new(ctx.render_width - time_width - 2.6, 6.6),
+ HUD_TEXT_COLOR,
+ &time_str,
+ );
+
+ self.renderer.text_colored_screen(
+ ctx,
+ st,
+ HUD_FPS_POSITION,
+ HUD_TEXT_COLOR,
+ &format!("{}{}", HUD_FPS_LABEL_PREFIX, st.fps),
+ );
+ }
+
+ fn render_game_over(&mut self, ctx: &context::Context, st: &mut state::State) {
+ st.audio.stop_music();
+ self.renderer.color_screen(
+ ctx,
+ st,
+ GAME_OVER_OVERLAY_COLOR,
+ glam::Vec2::ZERO,
+ glam::Vec2::new(ctx.render_width, ctx.render_height),
+ );
+
+ self.draw_text_centered(
+ ctx,
+ st,
+ ctx.render_width / 2.0,
+ ctx.render_height / 2.0 - 8.0,
+ GAME_OVER_TEXT_COLOR,
+ GAME_OVER_TITLE_TEXT,
+ );
+
+ let status_text: &str = self.state.round_result().into();
+
+ self.draw_text_centered(
+ ctx,
+ st,
+ ctx.render_width / 2.0,
+ ctx.render_height / 2.0 + 5.3,
+ GAME_OVER_TEXT_COLOR,
+ &format!("{}{}", GAME_OVER_RESULT_PREFIX, status_text),
+ );
+ self.draw_text_centered(
+ ctx,
+ st,
+ ctx.render_width / 2.0,
+ ctx.render_height / 2.0 + 14.6,
+ GAME_OVER_TEXT_COLOR,
+ &format!(
+ "{}{}",
+ HUD_SCORE_LABEL_PREFIX,
+ format_args!(
+ "{}/{}",
+ self.state.consumer_score(),
+ self.state.required_greens()
+ )
+ ),
+ );
+ }
+}
+
+impl teleia::state::Game for Game {
+ fn initialize(&mut self, _ctx: &context::Context, st: &mut state::State) -> Erm<()> {
+ log::info!("eatyourgreens:: entering initialize");
+
+ st.keybindings.insert(
+ state::Keycode::new(winit::keyboard::KeyCode::ArrowUp),
+ state::Key::Up,
+ );
+ st.keybindings.insert(
+ state::Keycode::new(winit::keyboard::KeyCode::ArrowDown),
+ state::Key::Down,
+ );
+ st.keybindings.insert(
+ state::Keycode::new(winit::keyboard::KeyCode::ArrowLeft),
+ state::Key::Left,
+ );
+ st.keybindings.insert(
+ state::Keycode::new(winit::keyboard::KeyCode::ArrowRight),
+ state::Key::Right,
+ );
+
+ log::info!("eatyourgreens:: exiting initialize");
+ Ok(())
+ }
+
+ fn initialize_audio(
+ &self,
+ _ctx: &context::Context,
+ _st: &state::State,
+ actx: &audio::Context,
+ ) -> HashMap<String, audio::Audio> {
+ let mut map = HashMap::new();
+ for (name, data) in AUDIO_ASSETS {
+ map.insert(name.to_string(), audio::Audio::new(actx, data));
+ }
+ map
+ }
+
+ fn mouse_move(
+ &mut self,
+ _ctx: &context::Context,
+ _st: &mut state::State,
+ x: i32,
+ y: i32,
+ ) -> Erm<()> {
+ self.mouse = glam::Vec2::new(x as f32, y as f32);
+ Ok(())
+ }
+
+ fn mouse_press(&mut self, ctx: &context::Context, st: &mut state::State) -> Erm<()> {
+ let mapped_mouse = self.map_mouse_to_render(ctx, st);
+ /*log::info!(
+ "eatyourgreens:: mouse at ({:?}), mapped to ({:?})",
+ self.mouse,
+ mapped_mouse
+ );*/
+
+ if !self.computer.already_used()
+ && self.computer.disquette_inserted()
+ && let Some(action) = self
+ .computer
+ .check_power_button(mapped_mouse, self.state.difficulty)
+ {
+ log::info!("eatyourgreens:: clicked power button {:?}", action);
+ if action == PowerButtonAction::On {
+ self.computer.boot();
+ self.state
+ .set_phase(GamePhase::Computer(ComputerPhase::Booting));
+ Os::boot(&mut self.state.rng);
+ //log::info!("eatyourgreens:: blah2");
+ }
+ }
+
+ if let Some(rect) = self.mute_button_rect
+ && rect.contains(mapped_mouse)
+ {
+ self.is_muted = !self.is_muted;
+ if self.is_muted {
+ st.audio.stop_music();
+ } else {
+ //play something
+ }
+ return Ok(());
+ }
+ match self.state.phase() {
+ GamePhase::Waiting => {
+ if let Some(rect) = self.start_button_rect
+ && rect.contains(mapped_mouse)
+ {
+ self.reset_round(ctx, st);
+ }
+ }
+ GamePhase::Playing => {
+ if let Some(ClickOutcome::Hit(color)) =
+ self.state.click_at(mapped_mouse.x, mapped_mouse.y)
+ {
+ log::info!("eatyourgreens:: Hit entity of color {:?}", color);
+ match color {
+ EntityColor::Green => {
+ if !self.is_muted {
+ st.audio.play_sfx("crunch");
+ }
+ }
+ _ => {
+ if !self.is_muted {
+ st.audio.play_sfx("fart");
+ }
+ }
+ }
+ }
+ }
+ GamePhase::Finished => {
+ if !self.is_embedded {
+ self.reset_round(ctx, st);
+ if !self.is_muted {
+ st.audio.stop_music();
+ }
+ }
+ }
+ GamePhase::Computer(_) => {
+ //nothing to do here we yielded to DA COMPUTTTA
+ }
+ #[allow(unreachable_patterns)]
+ _ => unreachable!(),
+ }
+
+ Ok(())
+ }
+
+ fn update(&mut self, ctx: &context::Context, st: &mut state::State) -> Erm<()> {
+ let now_ms = teleia::state::now(ctx) * 1000.0;
+ let last_time = self.last_time_ms.unwrap_or(now_ms);
+ self.last_time_ms = Some(now_ms);
+
+ if let GamePhase::Computer(ComputerPhase::On) = self.state.phase() {
+ // @TODO: play OS microgame here. For now, simulate its end immediately.
+ self.receive_op(ctx, st, "shutdown".to_string());
+ }
+
+ if self.state.phase() != GamePhase::Playing && self.state.phase() != GamePhase::Finished {
+ return Ok(());
+ }
+
+ if self.state.phase() == GamePhase::Playing {
+ // cap maximum time jump to 250ms,
+ // sometime the game lags when embedded in a Wcolonq wrapper, not sure why
+ // probbaly these copypasta all over the place make's it buggy
+ let real_delta = (now_ms - last_time).clamp(0.0, 250.0);
+ let dt = real_delta as f32;
+
+ let disquette_pos = if !self.computer.disquette.is_inserted() {
+ Some(self.computer.disquette.coord)
+ } else {
+ None
+ };
+ self.state.update_entities(
+ dt,
+ ctx.render_width,
+ ctx.render_height,
+ self.computer.disquette.is_inserted(),
+ disquette_pos,
+ );
+ self.state.advance_time(dt);
+ self.update_explosions(dt);
+
+ if self.greens_wiped_flash > 0.0 {
+ self.greens_wiped_flash = (self.greens_wiped_flash - dt).max(0.0);
+ }
+
+ let events = self.state.drain_events();
+ let mut disquette_consumed = false;
+ for event in events {
+ if event == "disquette_consumed" {
+ disquette_consumed = true;
+ } else {
+ self.handle_state_event(event, st);
+ }
+ }
+
+ if disquette_consumed {
+ let hitzone = self.computer.hit_zone(self.state.difficulty);
+ self.computer.disquette = crate::disquette::Disquette::new(
+ ctx.render_width,
+ ctx.render_height,
+ &mut self.state.rng,
+ Some(hitzone),
+ );
+ }
+
+ if !self.computer.disquette.is_inserted() {
+ let hitzone = self.computer.hit_zone(self.state.difficulty);
+ self.computer.disquette.update(
+ ctx.render_width,
+ ctx.render_height,
+ &st.keys,
+ dt,
+ self.state.difficulty,
+ Some(hitzone),
+ );
+
+ if self
+ .computer
+ .contains_disquette(&self.computer.disquette, self.state.difficulty)
+ {
+ self.computer.disquette.phase = DisquettePhase::Inserted;
+ }
+ }
+ }
+
+ if self.state.phase() == GamePhase::Finished && self.is_embedded && !self.done_sent {
+ let finish_at = *self.finish_time_ms.get_or_insert(now_ms);
+
+ if now_ms - finish_at >= RESULT_DISPLAY_DELAY_MS {
+ self.send_op(
+ "done",
+ None,
+ Some(self.state.round_result().into()),
+ Some(self.state.consumer_score()),
+ None,
+ );
+ self.done_sent = true;
+ }
+ }
+
+ Ok(())
+ }
+
+ fn render(&mut self, ctx: &context::Context, st: &mut state::State) -> Erm<()> {
+ if self.state.phase() == GamePhase::Waiting {
+ self.render_title(ctx, st);
+ return Ok(());
+ }
+
+ self.render_background(ctx, st);
+
+ self.draw_mute_icon(ctx, st);
+ self.render_computer(ctx, st);
+ self.render_entities(ctx, st);
+ self.render_red_countdowns(ctx, st);
+ self.render_explosions(ctx, st);
+ self.render_flash(ctx, st);
+ self.render_disquette(ctx, st);
+
+ self.render_hud(ctx, st);
+
+ if self.state.phase() == GamePhase::Finished {
+ self.render_game_over(ctx, st);
+ }
+
+ Ok(())
+ }
+}
+
+impl Game {
+ fn draw_text_centered(
+ &mut self,
+ ctx: &context::Context,
+ st: &mut state::State,
+ center_x: f32,
+ y: f32,
+ color: glam::Vec3,
+ text: &str,
+ ) {
+ let w = self.renderer.font_char_width(st) * text.len() as f32;
+ let x = (center_x - w / 2.0).round();
+ self.renderer
+ .text_colored_screen(ctx, st, glam::Vec2::new(x, y), color, text);
+ }
+
+ fn draw_button_centered(
+ &mut self,
+ ctx: &context::Context,
+ st: &mut state::State,
+ center_x: f32,
+ y: f32,
+ color: glam::Vec3,
+ text: &str,
+ ) {
+ let text_width = self.renderer.font_char_width(st) * text.len() as f32;
+ let padding_x = 4.8;
+ let padding_y = 3.2;
+ let char_height = self.renderer.font_char_height(st);
+ let height = char_height + padding_y * 2.0;
+ let width = text_width + padding_x * 2.0;
+ let x = (center_x - width / 2.0).round();
+
+ let border_thickness = 1.0;
+ let inner_color = BUTTON_FILL_COLOR;
+
+ self.renderer.color_screen(
+ ctx,
+ st,
+ inner_color,
+ glam::Vec2::new(x + border_thickness, y + border_thickness),
+ glam::Vec2::new(
+ width - border_thickness * 2.0,
+ height - border_thickness * 2.0,
+ ),
+ );
+
+ self.draw_text_centered(
+ ctx,
+ st,
+ center_x,
+ y + (height - char_height) / 2.0,
+ color,
+ text,
+ );
+
+ self.start_button_rect = Some(Rectangle::from_xywh(x, y, width, height));
+ }
+
+ fn draw_mute_icon(&mut self, ctx: &context::Context, st: &mut state::State) {
+ let tex = if self.is_muted {
+ assets::Texture::Mute
+ } else {
+ assets::Texture::Unmute
+ };
+
+ let size = glam::Vec2::new(MUTE_ICON_SIZE, MUTE_ICON_SIZE);
+ let topleft = glam::Vec2::new(
+ MUTE_ICON_MARGIN,
+ ctx.render_height - MUTE_ICON_SIZE - MUTE_ICON_MARGIN,
+ );
+ self.renderer.texture_screen(ctx, st, tex, topleft, size);
+
+ self.mute_button_rect = Some(Rectangle::from_xywh(topleft.x, topleft.y, size.x, size.y));
+ }
+
+ // mapping of raw physical mouse coordinates to logical internal rendering coordinates.
+ // 1) subtract screen offsets to adjust to window margins.
+ // 2) scale the position by the ratio of the logical render resolution to the
+ // physical screen dimensions.
+ // 3) round and clamp the result point to guarantee it falls strictly within
+ // the valid rendering bounds [0, render_width] and [0, render_height].
+ fn map_mouse_to_render(&self, ctx: &context::Context, st: &state::State) -> glam::Vec2 {
+ let x =
+ ((self.mouse.x - st.screen.offsets.x) * ctx.render_width / st.screen.dims.x).round();
+ let y =
+ ((self.mouse.y - st.screen.offsets.y) * ctx.render_height / st.screen.dims.y).round();
+ glam::Vec2::new(
+ x.clamp(0.0, ctx.render_width),
+ y.clamp(0.0, ctx.render_height),
+ )
+ }
+
+ pub(crate) fn send_op(
+ &self,
+ op: &str,
+ verb: Option<&str>,
+ win: Option<bool>,
+ score: Option<i32>,
+ video_url: Option<String>,
+ ) {
+ // we send_op only if embedded
+ if !self.is_embedded {
+ return;
+ }
+ if let Some(window) = web_sys::window()
+ && let Some(parent) = window.parent().ok().flatten()
+ {
+ log::info!(
+ "eatyourgreens:: send op: {} with verb {:?} win {:?} score {:?}",
+ op,
+ verb,
+ win,
+ score
+ );
+ let msg = Message {
+ op,
+ verb,
+ win,
+ score,
+ video_url,
+ };
+ Message::post(&parent, &msg);
+ }
+ }
+}
diff --git a/2026/games_submissions/rpc2dot0/src/lib.rs b/2026/games_submissions/rpc2dot0/src/lib.rs new file mode 100644 index 0000000..31e4d1e --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/lib.rs @@ -0,0 +1,40 @@ +use crate::constants::{HEIGHT, WIDTH}; +use wasm_bindgen::prelude::*; +mod assets; +pub(crate) mod collision; +pub(crate) mod color; +pub(crate) mod computer; +pub(crate) mod constants; +pub(crate) mod disquette; +pub(crate) mod effects; +pub(crate) mod entity; +pub(crate) mod errors; +mod game; +pub(crate) mod math; +pub(crate) mod message; +pub(crate) mod random; +pub(crate) mod state; + +#[wasm_bindgen] +pub fn main_js(is_embedded: bool) { + teleia::run( + WIDTH, + HEIGHT, + teleia::Options::FULLSCREEN_MOUSE, + move |ctx| { + let game = game::Game::new(ctx, is_embedded); + game.send_op("ready", None, None, None, None); + game + }, + ); +} + +#[wasm_bindgen] +pub fn set_difficulty_js(difficulty: f32) { + teleia::contextualize(|_ctx, _st, game: &mut game::Game| game.set_difficulty(difficulty)) +} + +#[wasm_bindgen] +pub fn receive_op_js(op: String) { + teleia::contextualize(|ctx, st, game: &mut game::Game| game.receive_op(ctx, st, op.clone())) +} diff --git a/2026/games_submissions/rpc2dot0/src/math.rs b/2026/games_submissions/rpc2dot0/src/math.rs new file mode 100644 index 0000000..555204f --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/math.rs @@ -0,0 +1,55 @@ +pub use glam::Vec2;
+
+pub trait BoundingCircle {
+ fn center(&self) -> Vec2;
+ fn radius(&self) -> f32;
+
+ // Intersection between two bounding circles.
+ // compares squared distance to squared sum of radiuSUS (*insert mrGreen.png*),
+ // tl;dr: a naive collision detection.
+ fn overlaps_with(&self, other: &impl BoundingCircle) -> bool {
+ let radius_sum = self.radius() + other.radius();
+ self.center().distance_squared(other.center()) <= radius_sum * radius_sum
+ }
+}
+
+#[derive(Clone, Copy)]
+pub struct Rectangle {
+ pub min: Vec2,
+ pub max: Vec2,
+}
+
+pub trait ContainsPoint {
+ fn contains(&self, point: Vec2) -> bool;
+}
+
+impl ContainsPoint for Rectangle {
+ fn contains(&self, point: Vec2) -> bool {
+ point.cmpge(self.min).all() && point.cmple(self.max).all()
+ }
+}
+
+impl Rectangle {
+ pub const fn from_xywh(x: f32, y: f32, width: f32, height: f32) -> Self {
+ Self {
+ min: Vec2::new(x, y),
+ max: Vec2::new(x + width, y + height),
+ }
+ }
+
+ pub const fn from_min_max(min: Vec2, max: Vec2) -> Self {
+ Self { min, max }
+ }
+
+ #[allow(dead_code)]
+ pub fn overlaps(&self, other: &Rectangle) -> bool {
+ self.min.cmple(other.max).all() && self.max.cmpge(other.min).all()
+ }
+}
+
+pub fn parse_coords(coords: &str) -> (f32, f32) {
+ let mut parts = coords.split(',');
+ let x: f32 = parts.next().unwrap_or("0").parse().unwrap_or(0.0);
+ let y: f32 = parts.next().unwrap_or("0").parse().unwrap_or(0.0);
+ (x, y)
+}
diff --git a/2026/games_submissions/rpc2dot0/src/message.rs b/2026/games_submissions/rpc2dot0/src/message.rs new file mode 100644 index 0000000..d960b67 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/message.rs @@ -0,0 +1,26 @@ +use serde::Serialize;
+use std::fmt::Debug;
+
+#[derive(Serialize, Debug)]
+pub struct Message<'a> {
+ pub op: &'a str,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub verb: Option<&'a str>,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub win: Option<bool>,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub score: Option<i32>,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub video_url: Option<String>,
+}
+
+impl<'a> Message<'a> {
+ pub fn post<MSG>(window: &web_sys::Window, msg: &MSG)
+ where
+ MSG: Serialize + Debug,
+ {
+ log::info!("eatyourgreens:: post message: {:?}", msg);
+ let js_value = serde_wasm_bindgen::to_value(msg).unwrap();
+ let _ = window.post_message(&js_value, "*");
+ }
+}
diff --git a/2026/games_submissions/rpc2dot0/src/random.rs b/2026/games_submissions/rpc2dot0/src/random.rs new file mode 100644 index 0000000..14a9f78 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/random.rs @@ -0,0 +1,107 @@ +use crate::color::EntityColor;
+use crate::constants::get_baseline_ratio;
+use crate::math::Vec2;
+
+use rand::{Rng, RngCore, SeedableRng};
+use rand_chacha::ChaCha8Rng;
+
+#[derive(Debug, Clone)]
+pub struct RandomState {
+ rng: ChaCha8Rng,
+}
+
+impl RandomState {
+ /// RandomState::new(0x67676767) when debugging
+ pub fn new(seed: usize) -> Self {
+ log::info!("eatyourgreens:: RandomState new seed is {:?}", seed);
+ Self {
+ rng: ChaCha8Rng::seed_from_u64(seed as u64),
+ }
+ }
+
+ pub fn next_u32(&mut self) -> u32 {
+ self.rng.next_u32()
+ }
+
+ pub fn next_f32(&mut self) -> f32 {
+ self.rng.r#gen::<f32>()
+ }
+
+ pub fn next_range(&mut self, min: f32, max: f32) -> f32 {
+ self.rng.gen_range(min..max)
+ }
+
+ pub fn next_unit_vector(&mut self) -> Vec2 {
+ let angle = self.rng.gen_range(0.0..std::f32::consts::TAU);
+ Vec2::new(angle.cos(), angle.sin())
+ }
+
+ pub fn next_bool(&mut self, p: f64) -> bool {
+ self.rng.gen_bool(p)
+ }
+
+ // this is used for rogue colors,
+ // when used for random spawn, there is a risk
+ // of color overcrowding. (like too much green or whatever)
+ pub fn random_color(&mut self) -> EntityColor {
+ let next_color_prob = self.next_f32();
+ match next_color_prob {
+ x if x < 0.60 => EntityColor::Green,
+ x if x < 0.80 => EntityColor::Yellow,
+ x if x < 0.90 => EntityColor::Red,
+ _ => EntityColor::Bleu,
+ }
+ }
+
+ // don't give it too much toughts this is designed by a clanker (cause too much math hurts my soul, I am not sorry)
+ // coded by yours truely something within the spirit of
+ // wiki :
+ // https://en.wikipedia.org/wiki/Fitness_proportionate_selection
+ // https://en.wikipedia.org/wiki/Reservoir_sampling#Weighted_random_sampling
+
+ // we try to have a basline that is adjustable by difficulty
+ // then we have weights for our biased random picker
+ // used to spanwing entities
+ // seed compatiable aka : reproducible behaviour with a fixed D and S (D=difficulty, S=seed)
+ /*
+ difficulty 1.0 => Green: 0.60 Red: 0.10 (baseline, no shift)
+ difficulty 1.5 => Green: 0.525 Red: 0.175 (shift = 0.075)
+ difficulty 2.0 => Green: 0.45 Red: 0.25 (shift = 0.15)
+ difficulty 3.0 => Green: 0.30 Red: 0.40 (shift = 0.30)
+ difficulty 5.0 => Green: 0.05 Red: 0.65 (capped: Green can't go below 5%)
+ */
+ // not tested and I won't test it, fuck that.
+ pub fn random_color_biased(&mut self, counts: [u32; 4], difficulty: f32) -> EntityColor {
+ let baseline: [f32; 4] = {
+ let mut b = [0.0f32; 4];
+ b[EntityColor::Red as usize] = get_baseline_ratio(EntityColor::Red, difficulty);
+ b[EntityColor::Green as usize] = get_baseline_ratio(EntityColor::Green, difficulty);
+ b[EntityColor::Bleu as usize] = get_baseline_ratio(EntityColor::Bleu, difficulty);
+ b[EntityColor::Yellow as usize] = get_baseline_ratio(EntityColor::Yellow, difficulty);
+ b
+ };
+
+ let total = counts.iter().sum::<u32>().max(1) as f32;
+
+ let mut weights = [0.0f32; 4];
+ for i in 0..4 {
+ let actual_ratio = counts[i] as f32 / total;
+ weights[i] = (2.0 * baseline[i] - actual_ratio).max(0.05);
+ }
+ let sum: f32 = weights.iter().sum();
+ let roll: f32 = self.next_f32() * sum;
+ let mut cumulative: f32 = 0.0f32;
+ for (i, &w) in weights.iter().enumerate() {
+ cumulative += w;
+ if roll < cumulative {
+ return match i {
+ 0 => EntityColor::Red,
+ 1 => EntityColor::Green,
+ 2 => EntityColor::Bleu,
+ _ => EntityColor::Yellow,
+ };
+ }
+ }
+ unreachable!("Should never happen")
+ }
+}
diff --git a/2026/games_submissions/rpc2dot0/src/state.rs b/2026/games_submissions/rpc2dot0/src/state.rs new file mode 100644 index 0000000..c084bfc --- /dev/null +++ b/2026/games_submissions/rpc2dot0/src/state.rs @@ -0,0 +1,484 @@ +use crate::collision::process_collisions;
+use crate::color::EntityColor;
+use crate::computer::ComputerPhase;
+use crate::constants::{
+ BASE_SPEED, ENTITY_RADIUS, ENTITY_SCALE_FACTOR, GAME_DURATION_MS, INITIAL_SPAWN,
+ INITIAL_SPAWN_SPREAD_MS, JITTER_STRENGTH, MAX_ENTITIES, MAX_SPEED, PACMAN_CHASE_PROB,
+ PACMAN_CHASE_SPEED_MULT, RED_COUNTDOWN_MS, ROGUE_DURATION_MS, SPAWN_PADDING, SPAWN_RATE_MAX_MS,
+ SPAWN_RATE_MIN_MS,
+};
+use crate::effects::{PacmanChase, Rogue};
+use crate::entity::{Entity, Update};
+use crate::errors::ClickOutcome;
+use crate::math::Vec2;
+use crate::random::RandomState;
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum GamePhase {
+ Waiting,
+ Playing,
+ Computer(ComputerPhase),
+ Finished,
+}
+
+impl GamePhase {
+ #[allow(dead_code)]
+ pub fn phase(&self) -> &'static str {
+ match self {
+ GamePhase::Waiting => "waiting",
+ GamePhase::Playing => "playing",
+ GamePhase::Computer(_) => "computer",
+ GamePhase::Finished => "finished",
+ }
+ }
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum RoundResult {
+ Ok,
+ Ko,
+}
+
+impl From<RoundResult> for &'static str {
+ fn from(value: RoundResult) -> Self {
+ match value {
+ RoundResult::Ok => "Ok",
+ RoundResult::Ko => "Ko",
+ }
+ }
+}
+
+impl From<RoundResult> for bool {
+ fn from(value: RoundResult) -> Self {
+ match value {
+ RoundResult::Ok => true,
+ RoundResult::Ko => false,
+ }
+ }
+}
+
+#[derive(Debug, Clone)]
+pub struct GameState {
+ consumer_score: i32,
+ pub(crate) elapsed_ms: f32,
+ phase: GamePhase,
+ pub(crate) entities: Vec<Entity>,
+ pub(crate) next_entity_id: u32,
+ pub(crate) rng: RandomState,
+ spawn_timer_ms: f32,
+ initial_spawn_remaining: u32,
+ next_spawn_delay_ms: f32,
+ pub(crate) collision_buffer: Vec<(usize, usize)>,
+ pub(crate) events: Vec<String>,
+ pub(crate) difficulty: f32,
+}
+
+impl Default for GameState {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl GameState {
+ pub fn new() -> Self {
+ Self {
+ consumer_score: 0,
+ elapsed_ms: 0.0,
+ phase: GamePhase::Waiting,
+ entities: Vec::new(),
+ next_entity_id: 1,
+ #[cfg(debug_assertions)]
+ rng: RandomState::new(0x67676767),
+ #[cfg(not(debug_assertions))]
+ rng: RandomState::new((js_sys::Date::now() as u64) as usize),
+ spawn_timer_ms: 0.0,
+ initial_spawn_remaining: INITIAL_SPAWN,
+ next_spawn_delay_ms: (INITIAL_SPAWN_SPREAD_MS / INITIAL_SPAWN as f32).max(1.0),
+ collision_buffer: Vec::new(),
+ events: Vec::new(),
+ difficulty: 1.0,
+ }
+ }
+
+ pub fn set_difficulty(&mut self, difficulty: f32) {
+ self.difficulty = difficulty;
+ }
+
+ pub fn game_duration_ms(&self) -> f32 {
+ GAME_DURATION_MS as f32 / self.difficulty
+ }
+
+ pub fn required_greens(&self) -> i32 {
+ 5.max((15.0 / self.difficulty.sqrt()).round() as i32)
+ }
+
+ pub const fn base_speed(&self) -> f32 {
+ BASE_SPEED * self.difficulty
+ }
+
+ pub fn max_speed(&self) -> f32 {
+ MAX_SPEED * self.difficulty
+ }
+
+ pub fn spawn_rate_min_ms(&self) -> u32 {
+ (SPAWN_RATE_MIN_MS as f32 / self.difficulty) as u32
+ }
+
+ pub fn spawn_rate_max_ms(&self) -> u32 {
+ (SPAWN_RATE_MAX_MS as f32 / self.difficulty) as u32
+ }
+
+ pub fn entity_radius(&self) -> f32 {
+ ENTITY_RADIUS / (1.0 + (self.difficulty - 1.0) * 0.25)
+ }
+
+ pub fn start_round(&mut self) {
+ self.consumer_score = 0;
+ self.elapsed_ms = 0.0;
+ self.phase = GamePhase::Playing;
+ self.entities.clear();
+ self.next_entity_id = 1;
+ self.spawn_timer_ms = 0.0;
+ self.initial_spawn_remaining = INITIAL_SPAWN;
+ self.next_spawn_delay_ms = (INITIAL_SPAWN_SPREAD_MS / INITIAL_SPAWN as f32).max(1.0);
+ self.events.clear();
+ }
+ pub fn set_phase(&mut self, phase: GamePhase) {
+ self.phase = phase;
+ }
+ /*
+ pub fn boot_computer(&mut self) {
+ if self.phase == GamePhase::Playing {
+ self.phase = GamePhase::Computer(ComputerPhase::Booting);
+ }
+ }
+
+ pub fn shutdown_computer(&mut self) {
+ if self.phase == GamePhase::Computer(ComputerPhase::On) {
+ self.phase = GamePhase::Computer(ComputerPhase::ShutDown);
+ }
+ }
+ */
+
+ pub fn spawn_entity(
+ &mut self,
+ pos: Vec2,
+ vel: Vec2,
+ color: EntityColor,
+ disquette_inserted: bool,
+ ) {
+ if self.get_entity_count() >= MAX_ENTITIES {
+ return;
+ }
+ let speed = self.base_speed();
+ let radius = self.entity_radius() * ENTITY_SCALE_FACTOR;
+ let mut entity = Entity::new(self.next_entity_id, pos, vel, color, speed, radius);
+ if color == EntityColor::Red {
+ entity.spawn_time_ms = Some(self.elapsed_ms);
+ }
+ if color == EntityColor::Green {
+ let base_prob = 0.25;
+ let prob = (base_prob * self.difficulty).min(0.85);
+ if self.rng.next_bool(prob as f64) {
+ let rogue_duration = ROGUE_DURATION_MS / self.difficulty;
+ let mut hover_color = self.rng.random_color();
+ while hover_color == EntityColor::Green {
+ hover_color = self.rng.random_color();
+ }
+ entity.rogue = Some(Rogue::new(self.elapsed_ms + rogue_duration, hover_color));
+ }
+ }
+
+ if !disquette_inserted
+ && color == EntityColor::Bleu
+ && self.rng.next_bool(PACMAN_CHASE_PROB)
+ {
+ let chase_speed = self.base_speed() * PACMAN_CHASE_SPEED_MULT;
+ entity.pacman_chase = Some(PacmanChase::new(chase_speed));
+ }
+ self.next_entity_id = self.next_entity_id.wrapping_add(1);
+ self.entities.push(entity);
+ }
+ pub fn update_entities(
+ &mut self,
+ delta_ms: f32,
+ area_width: f32,
+ area_height: f32,
+ disquette_inserted: bool,
+ disquette_pos: Option<Vec2>,
+ ) {
+ self.update_spawning(delta_ms, area_width, area_height, disquette_inserted);
+
+ let current_max_speed = self.max_speed();
+ for entity in &mut self.entities {
+ if !entity.alive {
+ continue;
+ }
+ if let Some(chase) = &entity.pacman_chase {
+ if let Some(target) = disquette_pos {
+ let dx = target.x - entity.pos.x;
+ let dy = target.y - entity.pos.y;
+ let dist = (dx * dx + dy * dy).sqrt();
+ if dist > f32::EPSILON {
+ entity.vel.x = (dx / dist) * chase.speed;
+ entity.vel.y = (dy / dist) * chase.speed;
+ }
+ } else {
+ entity.apply_jitter(Vec2::new(
+ self.rng.next_range(-JITTER_STRENGTH, JITTER_STRENGTH),
+ self.rng.next_range(-JITTER_STRENGTH, JITTER_STRENGTH),
+ ));
+ }
+ } else {
+ entity.apply_jitter(Vec2::new(
+ self.rng.next_range(-JITTER_STRENGTH, JITTER_STRENGTH),
+ self.rng.next_range(-JITTER_STRENGTH, JITTER_STRENGTH),
+ ));
+ }
+
+ entity.update(delta_ms);
+ entity.dampen_speed(current_max_speed);
+ entity.bounds_bounce(area_width, area_height);
+ }
+ if let Some(target) = disquette_pos {
+ const DISQUETTE_HALF_SIZE: f32 = 3.2;
+ let mut consumed = false;
+ for entity in &self.entities {
+ if entity.alive
+ && entity.pacman_chase.is_some()
+ && entity.pos.distance_squared(target)
+ <= (entity.radius + DISQUETTE_HALF_SIZE).powi(2)
+ {
+ consumed = true;
+ break;
+ }
+ }
+ if consumed {
+ self.events.push("disquette_consumed".to_string());
+ }
+ }
+
+ process_collisions(
+ &mut self.entities,
+ &mut self.rng,
+ &mut self.next_entity_id,
+ &mut self.collision_buffer,
+ self.elapsed_ms,
+ &mut self.events,
+ );
+
+ // Check red countdown timers (explode if expired)
+ let mut greens_to_kill = false;
+ for entity in &mut self.entities {
+ if entity.alive
+ && entity.color == EntityColor::Red
+ && let Some(spawn_time) = entity.spawn_time_ms
+ && self.elapsed_ms >= spawn_time + RED_COUNTDOWN_MS
+ {
+ entity.alive = false;
+ self.events
+ .push(format!("explode:{},{}", entity.pos.x, entity.pos.y));
+ greens_to_kill = true;
+ }
+ }
+ if greens_to_kill {
+ for entity in &mut self.entities {
+ if entity.alive && entity.color == EntityColor::Green {
+ entity.alive = false;
+ }
+ }
+ }
+
+ self.entities.retain(|e| e.alive);
+ }
+
+ pub fn entities(&self) -> &[Entity] {
+ &self.entities
+ }
+
+ fn schedule_next_spawn(&mut self) {
+ self.next_spawn_delay_ms = if self.initial_spawn_remaining > 0 {
+ (INITIAL_SPAWN_SPREAD_MS / INITIAL_SPAWN as f32).max(1.0)
+ } else {
+ self.rng
+ .next_range(
+ self.spawn_rate_min_ms() as f32,
+ self.spawn_rate_max_ms() as f32,
+ )
+ .round()
+ .max(1.0)
+ };
+ }
+
+ fn position_overlaps(&self, pos: Vec2) -> bool {
+ let scaled_radius = self.entity_radius() * ENTITY_SCALE_FACTOR;
+ self.entities.iter().any(|entity| {
+ let distance_sq = entity.pos.distance_squared(pos);
+ distance_sq < (entity.radius + scaled_radius + SPAWN_PADDING).powi(2)
+ })
+ }
+
+ fn generate_spawn_position(&mut self, area_width: f32, area_height: f32) -> Vec2 {
+ let scaled_radius = self.entity_radius() * ENTITY_SCALE_FACTOR;
+ const MAX_ATTEMPTS: usize = 16;
+ for _ in 0..MAX_ATTEMPTS {
+ let pos = Vec2::new(
+ self.rng
+ .next_range(scaled_radius, area_width - scaled_radius),
+ self.rng
+ .next_range(scaled_radius, area_height - scaled_radius),
+ );
+ if !self.position_overlaps(pos) {
+ return pos;
+ }
+ }
+ Vec2::new(
+ self.rng
+ .next_range(scaled_radius, area_width - scaled_radius),
+ self.rng
+ .next_range(scaled_radius, area_height - scaled_radius),
+ )
+ }
+
+ fn spawn_random_entity(&mut self, area_width: f32, area_height: f32, disquette_inserted: bool) {
+ if self.get_entity_count() >= MAX_ENTITIES {
+ return;
+ }
+
+ let pos = self.generate_spawn_position(area_width, area_height);
+ let dir = self.rng.next_unit_vector();
+ let vel = dir * self.base_speed();
+
+ let mut color_counts = [0u32; 4];
+ for entity in &self.entities {
+ if entity.alive {
+ color_counts[entity.color as usize] += 1;
+ }
+ }
+ let color = self.rng.random_color_biased(color_counts, self.difficulty);
+ self.spawn_entity(pos, vel, color, disquette_inserted);
+ }
+
+ fn update_spawning(
+ &mut self,
+ delta_ms: f32,
+ area_width: f32,
+ area_height: f32,
+ disquette_inserted: bool,
+ ) {
+ if self.phase != GamePhase::Playing || area_width <= 0.0 || area_height <= 0.0 {
+ return;
+ }
+
+ self.spawn_timer_ms += delta_ms;
+ while self.spawn_timer_ms >= self.next_spawn_delay_ms {
+ self.spawn_timer_ms -= self.next_spawn_delay_ms;
+ if self.get_entity_count() >= MAX_ENTITIES {
+ self.spawn_timer_ms = 0.0;
+ break;
+ }
+
+ if self.initial_spawn_remaining > 0 {
+ self.spawn_random_entity(area_width, area_height, disquette_inserted);
+ self.initial_spawn_remaining = self.initial_spawn_remaining.saturating_sub(1);
+ } else {
+ self.spawn_random_entity(area_width, area_height, disquette_inserted);
+ }
+
+ self.schedule_next_spawn();
+ }
+ }
+
+ fn entity_at_point(&self, point: Vec2) -> Option<usize> {
+ self.entities
+ .iter()
+ .enumerate()
+ .rev()
+ .find(|(_, e)| e.alive && e.pos.distance_squared(point) <= e.radius * e.radius)
+ .map(|(idx, _)| idx)
+ }
+
+ pub fn click_at(&mut self, x: f32, y: f32) -> Option<ClickOutcome> {
+ //log::info!("eatyourgreens:: click_at(x={x},y={y})");
+ if self.phase != GamePhase::Playing {
+ return None;
+ }
+
+ let target = self.entity_at_point(Vec2::new(x, y));
+ if let Some(idx) = target {
+ let color = self.entities[idx].color;
+
+ let mut effective_color = color;
+ if color == EntityColor::Green
+ && let Some(rogue) = &self.entities[idx].rogue
+ && self.elapsed_ms < rogue.until_ms
+ {
+ effective_color = rogue.hover_color;
+ }
+
+ self.entities[idx].alive = false;
+ match effective_color {
+ EntityColor::Green => self.change_score(1),
+ EntityColor::Yellow | EntityColor::Red | EntityColor::Bleu => self.change_score(-1),
+ }
+
+ if effective_color == EntityColor::Red {
+ self.events.push(format!("click_red:{},{}", x, y));
+ }
+ return Some(ClickOutcome::Hit(effective_color));
+ }
+ Some(ClickOutcome::Miss)
+ }
+
+ pub fn consumer_score(&self) -> i32 {
+ self.consumer_score
+ }
+
+ pub fn elapsed_ms(&self) -> f32 {
+ self.elapsed_ms
+ }
+
+ pub fn remaining_ms(&self) -> f32 {
+ self.game_duration_ms() - self.elapsed_ms
+ }
+
+ pub fn phase(&self) -> GamePhase {
+ self.phase
+ }
+
+ pub fn round_result(&self) -> RoundResult {
+ if self.consumer_score >= self.required_greens() {
+ RoundResult::Ok
+ } else {
+ RoundResult::Ko
+ }
+ }
+
+ pub fn advance_time(&mut self, delta_ms: f32) {
+ if self.phase != GamePhase::Playing {
+ return;
+ }
+
+ self.elapsed_ms += delta_ms;
+ let duration = self.game_duration_ms();
+ if self.elapsed_ms >= duration {
+ self.elapsed_ms = duration;
+ self.phase = GamePhase::Finished;
+ }
+ }
+
+ pub fn drain_events(&mut self) -> Vec<String> {
+ std::mem::take(&mut self.events)
+ }
+
+ pub fn get_entity_count(&self) -> u32 {
+ self.entities.iter().filter(|e| e.alive).count() as u32
+ }
+
+ pub fn change_score(&mut self, delta: i32) {
+ if self.phase != GamePhase::Playing {
+ return;
+ }
+ self.consumer_score = self.consumer_score.saturating_add(delta);
+ }
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/.dir-locals.el b/2026/games_submissions/rpc2dot0/vendor/teleia/.dir-locals.el new file mode 100644 index 0000000..45e0286 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/.dir-locals.el @@ -0,0 +1,7 @@ +((rust-ts-mode .
+ ((eglot-workspace-configuration .
+ (:rust-analyzer
+ ( :check (:command "clippy")
+ :cargo (;; :target "wasm32-unknown-unknown"
+ :targetDir t)
+ :hover (:show (:fields 10))))))))
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/.envrc b/2026/games_submissions/rpc2dot0/vendor/teleia/.envrc new file mode 100644 index 0000000..063b56f --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/.envrc @@ -0,0 +1 @@ +use_flake
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/.gitignore b/2026/games_submissions/rpc2dot0/vendor/teleia/.gitignore new file mode 100644 index 0000000..2049df0 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/.gitignore @@ -0,0 +1,5 @@ +/.direnv
+/target
+/.cargo
+/dist
+/result
\ No newline at end of file diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/.gitmodules b/2026/games_submissions/rpc2dot0/vendor/teleia/.gitmodules new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/.gitmodules diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/Cargo.lock b/2026/games_submissions/rpc2dot0/vendor/teleia/Cargo.lock new file mode 100644 index 0000000..71d423b --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/Cargo.lock @@ -0,0 +1,3344 @@ +# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "ab_glyph"
+version = "0.2.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "80179d7dd5d7e8c285d67c4a1e652972a92de7475beddfb92028c76463b13225"
+dependencies = [
+ "ab_glyph_rasterizer",
+ "owned_ttf_parser",
+]
+
+[[package]]
+name = "ab_glyph_rasterizer"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c71b1793ee61086797f5c80b6efa2b8ffa6d5dd703f118545808a7f2e27f7046"
+
+[[package]]
+name = "adler2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
+
+[[package]]
+name = "ahash"
+version = "0.8.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b79b82693f705137f8fb9b37871d99e4f9a7df12b917eed79c3d3954830a60b"
+dependencies = [
+ "cfg-if",
+ "getrandom",
+ "once_cell",
+ "version_check",
+ "zerocopy",
+]
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "allocator-api2"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
+
+[[package]]
+name = "alsa"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed7572b7ba83a31e20d1b48970ee402d2e3e0537dcfe0a3ff4d6eb7508617d43"
+dependencies = [
+ "alsa-sys",
+ "bitflags 2.6.0",
+ "cfg-if",
+ "libc",
+]
+
+[[package]]
+name = "alsa-sys"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db8fee663d06c4e303404ef5f40488a53e062f89ba8bfed81f42325aafad1527"
+dependencies = [
+ "libc",
+ "pkg-config",
+]
+
+[[package]]
+name = "android-activity"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee91c0c2905bae44f84bfa4e044536541df26b7703fd0888deeb9060fcc44289"
+dependencies = [
+ "android-properties",
+ "bitflags 2.6.0",
+ "cc",
+ "cesu8",
+ "jni",
+ "jni-sys",
+ "libc",
+ "log",
+ "ndk",
+ "ndk-context",
+ "ndk-sys",
+ "num_enum",
+ "thiserror 1.0.57",
+]
+
+[[package]]
+name = "android-properties"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc7eb209b1518d6bb87b283c20095f5228ecda460da70b44f0802523dea6da04"
+
+[[package]]
+name = "anstream"
+version = "0.6.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23a1e53f0f5d86382dafe1cf314783b2044280f406e7e1506368220ad11b1338"
+dependencies = [
+ "anstyle",
+ "anstyle-parse",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is_terminal_polyfill",
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8365de52b16c035ff4fcafe0092ba9390540e3e352870ac09933bebcaa2c8c56"
+
+[[package]]
+name = "anstyle-parse"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b2d16507662817a6a20a9ea92df6652ee4f94f914589377d69f3b21bc5798a9"
+dependencies = [
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle-query"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79947af37f4177cfead1110013d678905c37501914fba0efea834c3fe9a8d60c"
+dependencies = [
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "anstyle-wincon"
+version = "3.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2109dbce0e72be3ec00bed26e6a7479ca384ad226efdd66db8fa2e3a38c83125"
+dependencies = [
+ "anstyle",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "approx"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cab112f0a86d568ea0e627cc1d6be74a1e9cd55214684db5561995f6dad897c6"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "arrayref"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b4930d2cb77ce62f89ee5d5289b4ac049559b1c45539271f5ed4fdc7db34545"
+
+[[package]]
+name = "arrayvec"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711"
+
+[[package]]
+name = "as-raw-xcb-connection"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "175571dd1d178ced59193a6fc02dde1b972eb0bc56c892cde9beeceac5bf0f6b"
+
+[[package]]
+name = "atomic-waker"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
+
+[[package]]
+name = "autocfg"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+
+[[package]]
+name = "base64"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
+
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
+[[package]]
+name = "bimap"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "230c5f1ca6a325a32553f8640d31ac9b49f2411e901e427570154868b46da4f7"
+
+[[package]]
+name = "bincode"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36eaf5d7b090263e8150820482d5d93cd964a81e4019913c972f4edcc6edb740"
+dependencies = [
+ "bincode_derive",
+ "serde",
+ "unty",
+]
+
+[[package]]
+name = "bincode_derive"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf95709a440f45e986983918d0e8a1f30a9b1df04918fc828670606804ac3c09"
+dependencies = [
+ "virtue",
+]
+
+[[package]]
+name = "bindgen"
+version = "0.70.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f49d8fed880d473ea71efb9bf597651e77201bdd4893efe54c9e5d65ae04ce6f"
+dependencies = [
+ "bitflags 2.6.0",
+ "cexpr",
+ "clang-sys",
+ "itertools",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "rustc-hash 1.1.0",
+ "shlex",
+ "syn",
+]
+
+[[package]]
+name = "bit-vec"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2c54ff287cfc0a34f38a6b832ea1bd8e448a330b3e40a50859e6488bee07f22"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bitflags"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "block-sys"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae85a0696e7ea3b835a453750bf002770776609115e6d25c6d2ff28a8200f7e7"
+dependencies = [
+ "objc-sys",
+]
+
+[[package]]
+name = "block2"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15b55663a85f33501257357e6421bb33e769d5c9ffb5ba0921c975a123e35e68"
+dependencies = [
+ "block-sys",
+ "objc2 0.4.1",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.15.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ea184aa71bb362a1157c896979544cc23974e08fd265f29ea96b59f0b4a555b"
+
+[[package]]
+name = "bytemuck"
+version = "1.14.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2ef034f05691a48569bd920a96c81b9d91bbad1ab5ac7c4616c1f6ef36cb79f"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "byteorder-lite"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495"
+
+[[package]]
+name = "bytes"
+version = "1.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "428d9aa8fbc0670b7b8d6030a7fadd0f86151cae55e4dbbece15f3780a3dfaf3"
+
+[[package]]
+name = "calloop"
+version = "0.12.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fba7adb4dd5aa98e5553510223000e7148f621165ec5f9acd7113f6ca4995298"
+dependencies = [
+ "bitflags 2.6.0",
+ "log",
+ "polling",
+ "rustix 0.38.31",
+ "slab",
+ "thiserror 1.0.57",
+]
+
+[[package]]
+name = "calloop-wayland-source"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f0ea9b9476c7fad82841a8dbb380e2eae480c21910feba80725b46931ed8f02"
+dependencies = [
+ "calloop",
+ "rustix 0.38.31",
+ "wayland-backend",
+ "wayland-client",
+]
+
+[[package]]
+name = "cc"
+version = "1.1.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b16803a61b81d9eabb7eae2588776c4c1e584b738ede45fdbb4c972cec1e9945"
+dependencies = [
+ "jobserver",
+ "libc",
+ "shlex",
+]
+
+[[package]]
+name = "cesu8"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c"
+
+[[package]]
+name = "cexpr"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
+dependencies = [
+ "nom",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "cfg_aliases"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e"
+
+[[package]]
+name = "clang-sys"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4"
+dependencies = [
+ "glob",
+ "libc",
+ "libloading",
+]
+
+[[package]]
+name = "colorchoice"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b63caa9aa9397e2d9480a9b13673856c78d8ac123288526c37d7839f2a86990"
+
+[[package]]
+name = "combine"
+version = "4.6.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "35ed6e9d84f0b51a7f52daf1c7d71dd136fd7a3f41a8462b8cdb8c78d920fad4"
+dependencies = [
+ "bytes",
+ "memchr",
+]
+
+[[package]]
+name = "concurrent-queue"
+version = "2.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d16048cd947b08fa32c24458a22f5dc5e835264f689f4f5653210c69fd107363"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "console_error_panic_hook"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "console_log"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be8aed40e4edbf4d3b4431ab260b63fdc40f5780a4766824329ea0f1eefe3c0f"
+dependencies = [
+ "log",
+ "web-sys",
+]
+
+[[package]]
+name = "core-foundation"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f"
+
+[[package]]
+name = "core-graphics"
+version = "0.23.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "970a29baf4110c26fedbc7f82107d42c23f7e88e404c4577ed73fe99ff85a212"
+dependencies = [
+ "bitflags 1.3.2",
+ "core-foundation",
+ "core-graphics-types",
+ "foreign-types 0.5.0",
+ "libc",
+]
+
+[[package]]
+name = "core-graphics-types"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "45390e6114f68f718cc7a830514a96f903cccd70d02a8f6d9f643ac4ba45afaf"
+dependencies = [
+ "bitflags 1.3.2",
+ "core-foundation",
+ "libc",
+]
+
+[[package]]
+name = "coreaudio-rs"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "321077172d79c662f64f5071a03120748d5bb652f5231570141be24cfcd2bace"
+dependencies = [
+ "bitflags 1.3.2",
+ "core-foundation-sys",
+ "coreaudio-sys",
+]
+
+[[package]]
+name = "coreaudio-sys"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ce857aa0b77d77287acc1ac3e37a05a8c95a2af3647d23b15f263bdaeb7562b"
+dependencies = [
+ "bindgen",
+]
+
+[[package]]
+name = "cpal"
+version = "0.15.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "873dab07c8f743075e57f524c583985fbaf745602acbe916a01539364369a779"
+dependencies = [
+ "alsa",
+ "core-foundation-sys",
+ "coreaudio-rs",
+ "dasp_sample",
+ "jni",
+ "js-sys",
+ "libc",
+ "mach2",
+ "ndk",
+ "ndk-context",
+ "oboe",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+ "windows",
+]
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crc32fast"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b3855a8a784b474f333699ef2bbca9db2c4a1f6d9088a90a2d25b1eb53111eaa"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "crossbeam"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1137cd7e7fc0fb5d3c5a8678be38ec56e819125d8d7907411fe24ccb943faca8"
+dependencies = [
+ "crossbeam-channel",
+ "crossbeam-deque",
+ "crossbeam-epoch",
+ "crossbeam-queue",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "613f8cc01fe9cf1a3eb3d7f488fd2fa8388403e97039e2f73692932e291a770d"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-queue"
+version = "0.3.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f58bbc28f91df819d0aa2a2c00cd19754769c2fad90579b3592b1c9ba7a3115"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "cursor-icon"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96a6ac251f4a2aca6b3f91340350eab87ae57c3f127ffeb585e92bd336717991"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "dasp_sample"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c87e182de0887fd5361989c677c4e8f5000cd9491d6d563161a8f3a5519fc7f"
+
+[[package]]
+name = "data-encoding"
+version = "2.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7a1e2f27636f116493b8b860f5546edb47c8d8f8ea73e1d2a20be88e28d1fea"
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
+[[package]]
+name = "directories"
+version = "6.0.0"
+source = "git+https://github.com/lcolonq/directories-rs#164536daab2c07265167715934081cb1942387b0"
+dependencies = [
+ "dirs-sys",
+]
+
+[[package]]
+name = "dirs-sys"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e01a3366d27ee9890022452ee61b2b63a67e6f13f58900b651ff5665f0bb1fab"
+dependencies = [
+ "libc",
+ "option-ext",
+ "redox_users",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "dispatch"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd0c93bb4b0c6d9b77f4435b0ae98c24d17f1c45b2ff844c6151a07256ca923b"
+
+[[package]]
+name = "dlib"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "330c60081dcc4c72131f8eb70510f1ac07223e5d4163db481a04a0befcffa412"
+dependencies = [
+ "libloading",
+]
+
+[[package]]
+name = "downcast-rs"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ea835d29036a4087793836fa931b08837ad5e957da9e23886b29586fb9b6650"
+
+[[package]]
+name = "either"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11157ac094ffbdde99aa67b23417ebdd801842852b500e395a45a9c0aac03e4a"
+
+[[package]]
+name = "ena"
+version = "0.14.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d248bdd43ce613d87415282f69b9bb99d947d290b10962dd6c56233312c2ad5"
+dependencies = [
+ "log",
+]
+
+[[package]]
+name = "encoding_rs"
+version = "0.8.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b45de904aa0b010bce2ab45264d0631681847fa7b6f2eaa7dab7619943bc4f59"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "enum-map"
+version = "2.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6866f3bfdf8207509a033af1a75a7b08abda06bbaaeae6669323fd5a097df2e9"
+dependencies = [
+ "enum-map-derive",
+]
+
+[[package]]
+name = "enum-map-derive"
+version = "0.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f282cfdfe92516eb26c2af8589c274c7c17681f5ecc03c18255fe741c6aa64eb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "env"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc95de49ad098572c02d3fbf368c9a020bfff5ae78483685b77f51d8a7e9486d"
+dependencies = [
+ "num_threads",
+]
+
+[[package]]
+name = "env_filter"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4f2c92ceda6ceec50f43169f9ee8424fe2db276791afde7b2cd8bc084cb376ab"
+dependencies = [
+ "log",
+ "regex",
+]
+
+[[package]]
+name = "env_logger"
+version = "0.11.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e13fa619b91fb2381732789fc5de83b45675e882f66623b7d8cb4f643017018d"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "env_filter",
+ "humantime",
+ "log",
+]
+
+[[package]]
+name = "equivalent"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
+
+[[package]]
+name = "errno"
+version = "0.3.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "extended"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af9673d8203fcb076b19dfd17e38b3d4ae9f44959416ea532ce72415a6020365"
+
+[[package]]
+name = "eyre"
+version = "0.6.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7cd915d99f24784cdc19fd37ef22b97e3ff0ae756c7e492e9fbfe897d61e2aec"
+dependencies = [
+ "indenter",
+ "once_cell",
+]
+
+[[package]]
+name = "fastrand"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
+
+[[package]]
+name = "fdeflate"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4f9bfee30e4dedf0ab8b422f03af778d9612b63f502710fc500a334ebe2de645"
+dependencies = [
+ "simd-adler32",
+]
+
+[[package]]
+name = "flate2"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "foldhash"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+
+[[package]]
+name = "foreign-types"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
+dependencies = [
+ "foreign-types-shared 0.1.1",
+]
+
+[[package]]
+name = "foreign-types"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d737d9aa519fb7b749cbc3b962edcf310a8dd1f4b67c91c4f83975dbdd17d965"
+dependencies = [
+ "foreign-types-macros",
+ "foreign-types-shared 0.3.1",
+]
+
+[[package]]
+name = "foreign-types-macros"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a5c6c585bc94aaf2c7b51dd4c2ba22680844aba4c687be581871a6f518c5742"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "foreign-types-shared"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
+
+[[package]]
+name = "foreign-types-shared"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b"
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "gethostname"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0176e0459c2e4a1fe232f984bca6890e681076abb9934f6cea7c326f3fc47818"
+dependencies = [
+ "libc",
+ "windows-targets 0.48.5",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "190092ea657667030ac6a35e305e62fc4dd69fd98ac98631e5d3a2b1575a12b5"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "libc",
+ "wasi",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "glam"
+version = "0.29.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc46dd3ec48fdd8e693a98d2b8bafae273a2d54c1de02a2a7e3d57d501f39677"
+dependencies = [
+ "mint",
+]
+
+[[package]]
+name = "glfw"
+version = "0.59.0"
+source = "git+https://github.com/lcolonq/glfw-rs#1ce13a2bcf3ef3bf6184bcb4c2a90d9034956841"
+dependencies = [
+ "bitflags 1.3.2",
+ "objc2 0.5.2",
+ "raw-window-handle",
+ "serde",
+ "winapi",
+]
+
+[[package]]
+name = "glob"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8d1add55171497b4705a648c6b583acafb01d58050a51727785f0b2c8e0a2b2"
+
+[[package]]
+name = "glow"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd348e04c43b32574f2de31c8bb397d96c9fcfa1371bd4ca6d8bdc464ab121b1"
+dependencies = [
+ "js-sys",
+ "slotmap",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "gltf"
+version = "1.4.1"
+source = "git+https://github.com/lcolonq/gltf#9763a5abe8c168eb1282a037ff16668542fe2a6d"
+dependencies = [
+ "base64 0.13.1",
+ "byteorder",
+ "gltf-json",
+ "image",
+ "lazy_static",
+ "serde_json",
+ "urlencoding",
+]
+
+[[package]]
+name = "gltf-derive"
+version = "1.4.1"
+source = "git+https://github.com/lcolonq/gltf#9763a5abe8c168eb1282a037ff16668542fe2a6d"
+dependencies = [
+ "inflections",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "gltf-json"
+version = "1.4.1"
+source = "git+https://github.com/lcolonq/gltf#9763a5abe8c168eb1282a037ff16668542fe2a6d"
+dependencies = [
+ "gltf-derive",
+ "serde",
+ "serde_derive",
+ "serde_json",
+]
+
+[[package]]
+name = "hash32"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47d60b12902ba28e2730cd37e95b8c9223af2808df9e902d4df49588d1470606"
+dependencies = [
+ "byteorder",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.15.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289"
+dependencies = [
+ "allocator-api2",
+ "equivalent",
+ "foldhash",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4f467dd6dccf739c208452f8014c75c18bb8301b050ad1cfb27153803edb0f51"
+
+[[package]]
+name = "heapless"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bfb9eb618601c89945a70e254898da93b13be0388091d42117462b265bb3fad"
+dependencies = [
+ "hash32",
+ "stable_deref_trait",
+]
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "hermit-abi"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
+
+[[package]]
+name = "http"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a"
+dependencies = [
+ "bytes",
+ "itoa",
+]
+
+[[package]]
+name = "httparse"
+version = "1.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
+
+[[package]]
+name = "humantime"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
+
+[[package]]
+name = "icrate"
+version = "0.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99d3aaff8a54577104bafdf686ff18565c3b6903ca5782a2026ef06e2c7aa319"
+dependencies = [
+ "block2",
+ "dispatch",
+ "objc2 0.4.1",
+]
+
+[[package]]
+name = "image"
+version = "0.25.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85ab80394333c02fe689eaf900ab500fbd0c2213da414687ebf995a65d5a6104"
+dependencies = [
+ "bytemuck",
+ "byteorder-lite",
+ "moxcms",
+ "num-traits",
+ "png",
+ "zune-core",
+ "zune-jpeg",
+]
+
+[[package]]
+name = "indenter"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce23b50ad8242c51a442f3ff322d56b02f08852c77e4c0b4d3fd684abc89c683"
+
+[[package]]
+name = "indexmap"
+version = "2.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.17.0",
+]
+
+[[package]]
+name = "inflections"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a257582fdcde896fd96463bf2d40eefea0580021c0712a0e2b028b60b47a837a"
+
+[[package]]
+name = "is_terminal_polyfill"
+version = "1.70.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
+
+[[package]]
+name = "itertools"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
+
+[[package]]
+name = "jni"
+version = "0.21.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a87aa2bb7d2af34197c04845522473242e1aa17c12f4935d5856491a7fb8c97"
+dependencies = [
+ "cesu8",
+ "cfg-if",
+ "combine",
+ "jni-sys",
+ "log",
+ "thiserror 1.0.57",
+ "walkdir",
+ "windows-sys 0.45.0",
+]
+
+[[package]]
+name = "jni-sys"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130"
+
+[[package]]
+name = "jobserver"
+version = "0.1.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48d1dbcbbeb6a7fec7e059840aa538bd62aaccf972c7346c4d9d2059312853d0"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "js-sys"
+version = "0.3.77"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1cfaf33c695fc6e08064efbc1f72ec937429614f25eef83af942d0e227c3a28f"
+dependencies = [
+ "once_cell",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "kira"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb5a9f9dff5e262540b628b00d5e1a772270a962d6869f8695bb24832ff3b394"
+dependencies = [
+ "cpal",
+ "glam",
+ "mint",
+ "paste",
+ "ringbuf",
+ "send_wrapper",
+ "symphonia",
+ "triple_buffer",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "libc"
+version = "0.2.184"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48f5d2a454e16a5ea0f4ced81bd44e4cfc7bd3a507b61887c99fd3538b28e4af"
+
+[[package]]
+name = "libloading"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2caa5afb8bf9f3a2652760ce7d4f62d21c4d5a423e68466fca30df82f2330164"
+dependencies = [
+ "cfg-if",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "libm"
+version = "0.2.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8355be11b20d696c8f18f6cc018c4e372165b1fa8126cef092399c9951984ffa"
+
+[[package]]
+name = "libredox"
+version = "0.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3af92c55d7d839293953fcd0fda5ecfe93297cfde6ffbdec13b41d99c0ba6607"
+dependencies = [
+ "bitflags 2.6.0",
+ "libc",
+ "redox_syscall 0.4.1",
+]
+
+[[package]]
+name = "libredox"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
+dependencies = [
+ "bitflags 2.6.0",
+ "libc",
+]
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01cda141df6706de531b6c46c3a33ecca755538219bd484262fa09410c13539c"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
+
+[[package]]
+name = "litrs"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11d3d7f243d5c5a8b9bb5d6dd2b1602c0cb0b9db1621bafc7ed66e35ff9fe092"
+
+[[package]]
+name = "log"
+version = "0.4.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c"
+
+[[package]]
+name = "mach2"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19b955cdeb2a02b9117f121ce63aa52d08ade45de53e48fe6a38b39c10f6f709"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "matrixmultiply"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9380b911e3e96d10c1f415da0876389aaf1b56759054eeb0de7df940c456ba1a"
+dependencies = [
+ "autocfg",
+ "rawpointer",
+]
+
+[[package]]
+name = "memchr"
+version = "2.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "523dc4f511e55ab87b694dc30d0f820d60906ef06413f93d4d7a1385599cc149"
+
+[[package]]
+name = "memmap2"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fe751422e4a8caa417e13c3ea66452215d7d63e19e604f4980461212f3ae1322"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
+[[package]]
+name = "miniz_oxide"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
+dependencies = [
+ "adler2",
+ "simd-adler32",
+]
+
+[[package]]
+name = "mint"
+version = "0.5.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e53debba6bda7a793e5f99b8dacf19e626084f525f7829104ba9898f367d85ff"
+
+[[package]]
+name = "moxcms"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb85c154ba489f01b25c0d36ae69a87e4a1c73a72631fc6c0eb6dde34a73e44b"
+dependencies = [
+ "num-traits",
+ "pxfm",
+]
+
+[[package]]
+name = "nalgebra"
+version = "0.33.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26aecdf64b707efd1310e3544d709c5c0ac61c13756046aaaba41be5c4f66a3b"
+dependencies = [
+ "approx",
+ "glam",
+ "matrixmultiply",
+ "nalgebra-macros",
+ "num-complex",
+ "num-rational",
+ "num-traits",
+ "simba",
+ "typenum",
+]
+
+[[package]]
+name = "nalgebra-macros"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "254a5372af8fc138e36684761d3c0cdb758a4410e938babcff1c860ce14ddbfc"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "native-tls"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87de3442987e9dbec73158d5c715e7ad9072fda936bb03d19d7fa10e00520f0e"
+dependencies = [
+ "libc",
+ "log",
+ "openssl",
+ "openssl-probe",
+ "openssl-sys",
+ "schannel",
+ "security-framework",
+ "security-framework-sys",
+ "tempfile",
+]
+
+[[package]]
+name = "ndk"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2076a31b7010b17a38c01907c45b945e8f11495ee4dd588309718901b1f7a5b7"
+dependencies = [
+ "bitflags 2.6.0",
+ "jni-sys",
+ "log",
+ "ndk-sys",
+ "num_enum",
+ "raw-window-handle",
+ "thiserror 1.0.57",
+]
+
+[[package]]
+name = "ndk-context"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27b02d87554356db9e9a873add8782d4ea6e3e58ea071a9adb9a2e8ddb884a8b"
+
+[[package]]
+name = "ndk-sys"
+version = "0.5.0+25.2.9519653"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c196769dd60fd4f363e11d948139556a344e79d451aeb2fa2fd040738ef7691"
+dependencies = [
+ "jni-sys",
+]
+
+[[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
+[[package]]
+name = "num-bigint"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-complex"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-derive"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-rational"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824"
+dependencies = [
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+ "libm",
+]
+
+[[package]]
+name = "num_enum"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02339744ee7253741199f897151b38e72257d13802d4ee837285cc2990a90845"
+dependencies = [
+ "num_enum_derive",
+]
+
+[[package]]
+name = "num_enum_derive"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "681030a937600a36906c185595136d26abfebb4aa9c65701cefcaf8578bb982b"
+dependencies = [
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "num_threads"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c7398b9c8b70908f6371f47ed36737907c87c52af34c268fed0bf0ceb92ead9"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "objc-sys"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdb91bdd390c7ce1a8607f35f3ca7151b65afc0ff5ff3b34fa350f7d7c7e4310"
+
+[[package]]
+name = "objc2"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "559c5a40fdd30eb5e344fbceacf7595a81e242529fb4e21cf5f43fb4f11ff98d"
+dependencies = [
+ "objc-sys",
+ "objc2-encode 3.0.0",
+]
+
+[[package]]
+name = "objc2"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46a785d4eeff09c14c487497c162e92766fbb3e4059a71840cecc03d9a50b804"
+dependencies = [
+ "objc-sys",
+ "objc2-encode 4.1.0",
+]
+
+[[package]]
+name = "objc2-encode"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d079845b37af429bfe5dfa76e6d087d788031045b25cfc6fd898486fd9847666"
+
+[[package]]
+name = "objc2-encode"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33"
+
+[[package]]
+name = "oboe"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8b61bebd49e5d43f5f8cc7ee2891c16e0f41ec7954d36bcb6c14c5e0de867fb"
+dependencies = [
+ "jni",
+ "ndk",
+ "ndk-context",
+ "num-derive",
+ "num-traits",
+ "oboe-sys",
+]
+
+[[package]]
+name = "oboe-sys"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c8bb09a4a2b1d668170cfe0a7d5bc103f8999fb316c98099b6a9939c9f2e79d"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
+
+[[package]]
+name = "openssl"
+version = "0.10.75"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08838db121398ad17ab8531ce9de97b244589089e290a384c900cb9ff7434328"
+dependencies = [
+ "bitflags 2.6.0",
+ "cfg-if",
+ "foreign-types 0.3.2",
+ "libc",
+ "once_cell",
+ "openssl-macros",
+ "openssl-sys",
+]
+
+[[package]]
+name = "openssl-macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "openssl-probe"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e"
+
+[[package]]
+name = "openssl-sys"
+version = "0.9.111"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82cab2d520aa75e3c58898289429321eb788c3106963d0dc886ec7a5f4adc321"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "option-ext"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
+
+[[package]]
+name = "orbclient"
+version = "0.3.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52f0d54bde9774d3a51dcf281a5def240c71996bc6ca05d2c847ec8b2b216166"
+dependencies = [
+ "libredox 0.0.2",
+]
+
+[[package]]
+name = "ordered-float"
+version = "4.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7bb71e1b3fa6ca1c61f383464aaf2bb0e2f8e772a1f01d486832464de363b951"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "owned_ttf_parser"
+version = "0.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4586edfe4c648c71797a74c84bacb32b52b212eff5dfe2bb9f2c599844023e7"
+dependencies = [
+ "ttf-parser",
+]
+
+[[package]]
+name = "parry3d"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecb572cea5c76b06bc744aaefdbb9e6ea9e5695f50f79c0227bddecd6ec925a4"
+dependencies = [
+ "approx",
+ "arrayvec",
+ "bitflags 2.6.0",
+ "downcast-rs",
+ "either",
+ "ena",
+ "log",
+ "nalgebra",
+ "num-derive",
+ "num-traits",
+ "ordered-float",
+ "rstar",
+ "rustc-hash 2.1.1",
+ "simba",
+ "slab",
+ "smallvec",
+ "spade",
+ "thiserror 1.0.57",
+]
+
+[[package]]
+name = "paste"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8afb450f006bf6385ca15ef45d71d2288452bc3683ce2e2cacc0d18e4be60b58"
+
+[[package]]
+name = "pkg-config"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec"
+
+[[package]]
+name = "png"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60769b8b31b2a9f263dae2776c37b1b28ae246943cf719eb6946a1db05128a61"
+dependencies = [
+ "bitflags 2.6.0",
+ "crc32fast",
+ "fdeflate",
+ "flate2",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "polling"
+version = "3.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218"
+dependencies = [
+ "cfg-if",
+ "concurrent-queue",
+ "hermit-abi",
+ "pin-project-lite",
+ "rustix 1.1.4",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
+
+[[package]]
+name = "proc-macro-crate"
+version = "3.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d37c51ca738a55da99dc0c4a34860fd675453b8b36209178c2249bb13651284"
+dependencies = [
+ "toml_edit",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.93"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60946a68e5f9d28b0dc1c21bb8a97ee7d018a8b322fa57838ba31cc878e22d99"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "profiling"
+version = "1.0.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "afbdc74edc00b6f6a218ca6a5364d6226a259d4b8ea1af4a0ea063f27e179f4d"
+dependencies = [
+ "profiling-procmacros",
+]
+
+[[package]]
+name = "profiling-procmacros"
+version = "1.0.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a65f2e60fbf1063868558d69c6beacf412dc755f9fc020f514b7955fc914fe30"
+dependencies = [
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pxfm"
+version = "0.1.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5a041e753da8b807c9255f28de81879c78c876392ff2469cde94799b2896b9d"
+
+[[package]]
+name = "quick-xml"
+version = "0.31.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1004a344b30a54e2ee58d66a71b32d2db2feb0a31f9a2d302bf0536f15de2a33"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "rapier3d"
+version = "0.23.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37d84644f385b81f065576058bc8f7e3d64e56a66f2f5fc40bfd917774659e12"
+dependencies = [
+ "approx",
+ "arrayvec",
+ "bit-vec",
+ "bitflags 2.6.0",
+ "crossbeam",
+ "downcast-rs",
+ "log",
+ "nalgebra",
+ "num-derive",
+ "num-traits",
+ "ordered-float",
+ "parry3d",
+ "profiling",
+ "rustc-hash 2.1.1",
+ "simba",
+ "thiserror 1.0.57",
+]
+
+[[package]]
+name = "raw-window-handle"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42a9830a0e1b9fb145ebb365b8bc4ccd75f290f98c0247deafbbe2c75cefb544"
+
+[[package]]
+name = "rawpointer"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3"
+
+[[package]]
+name = "redox_syscall"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "567664f262709473930a4bf9e51bf2ebf3348f2e748ccc50dea20646858f8f29"
+dependencies = [
+ "bitflags 1.3.2",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"
+dependencies = [
+ "bitflags 1.3.2",
+]
+
+[[package]]
+name = "redox_users"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd6f9d3d47bdd2ad6945c5015a226ec6155d0bcdfd8f7cd29f86b71f8de99d2b"
+dependencies = [
+ "getrandom",
+ "libredox 0.1.3",
+ "thiserror 2.0.11",
+]
+
+[[package]]
+name = "regex"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "368758f23274712b504848e9d5a6f010445cc8b87a7cdb4d7cbee666c1288da3"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
+
+[[package]]
+name = "ringbuf"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79abed428d1fd2a128201cec72c5f6938e2da607c6f3745f769fabea399d950a"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "robust"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cbf4a6aa5f6d6888f39e980649f3ad6b666acdce1d78e95b8a2cb076e687ae30"
+
+[[package]]
+name = "rstar"
+version = "0.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "421400d13ccfd26dfa5858199c30a5d76f9c54e0dba7575273025b43c5175dbb"
+dependencies = [
+ "heapless",
+ "num-traits",
+ "smallvec",
+]
+
+[[package]]
+name = "rustc-hash"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
+
+[[package]]
+name = "rustc-hash"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
+
+[[package]]
+name = "rustix"
+version = "0.38.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ea3e1a662af26cd7a3ba09c0297a31af215563ecf42817c98df621387f4e949"
+dependencies = [
+ "bitflags 2.6.0",
+ "errno",
+ "libc",
+ "linux-raw-sys 0.4.13",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "rustix"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
+dependencies = [
+ "bitflags 2.6.0",
+ "errno",
+ "libc",
+ "linux-raw-sys 0.12.1",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eded382c5f5f786b989652c49544c4877d9f015cc22e145a5ea8ea66c2921cd2"
+
+[[package]]
+name = "ryu"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
+
+[[package]]
+name = "safe_arch"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96b02de82ddbe1b636e6170c21be622223aea188ef2e139be0a5b219ec215323"
+dependencies = [
+ "bytemuck",
+]
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "schannel"
+version = "0.1.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "891d81b926048e76efe18581bf793546b4c0eaf8448d72be8de2bbee5fd166e1"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "scoped-tls"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
+
+[[package]]
+name = "sctk-adwaita"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82b2eaf3a5b264a521b988b2e73042e742df700c4f962cde845d1541adb46550"
+dependencies = [
+ "ab_glyph",
+ "log",
+ "memmap2",
+ "smithay-client-toolkit",
+ "tiny-skia",
+]
+
+[[package]]
+name = "security-framework"
+version = "2.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
+dependencies = [
+ "bitflags 2.6.0",
+ "core-foundation",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
+
+[[package]]
+name = "security-framework-sys"
+version = "2.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc1f0cbffaac4852523ce30d8bd3c5cdc873501d96ff467ca09b6767bb8cd5c0"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "send_wrapper"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd0b0ec5f1c1ca621c432a25813d8d60c88abe6d3e08a3eb9cf37d97a0fe3d73"
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.128"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ff5456707a1de34e7e37f2a6fd3d3f808c318259cbd01ab6377795054b483d8"
+dependencies = [
+ "itoa",
+ "memchr",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "sha1"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "sharded-slab"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6"
+dependencies = [
+ "lazy_static",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "simba"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b3a386a501cd104797982c15ae17aafe8b9261315b5d07e3ec803f2ea26be0fa"
+dependencies = [
+ "approx",
+ "num-complex",
+ "num-traits",
+ "paste",
+ "wide",
+]
+
+[[package]]
+name = "simd-adler32"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe"
+
+[[package]]
+name = "simple-eyre"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b561532e8ffe7ecf09108c4f662896a9ec3eac4999eba84015ec3dcb8cc630a"
+dependencies = [
+ "eyre",
+ "indenter",
+]
+
+[[package]]
+name = "slab"
+version = "0.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "slotmap"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dbff4acf519f630b3a3ddcfaea6c06b42174d9a44bc70c620e9ed1649d58b82a"
+dependencies = [
+ "version_check",
+]
+
+[[package]]
+name = "smallvec"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6ecd384b10a64542d77071bd64bd7b231f4ed5940fba55e98c3de13824cf3d7"
+
+[[package]]
+name = "smithay-client-toolkit"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "922fd3eeab3bd820d76537ce8f582b1cf951eceb5475c28500c7457d9d17f53a"
+dependencies = [
+ "bitflags 2.6.0",
+ "calloop",
+ "calloop-wayland-source",
+ "cursor-icon",
+ "libc",
+ "log",
+ "memmap2",
+ "rustix 0.38.31",
+ "thiserror 1.0.57",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-csd-frame",
+ "wayland-cursor",
+ "wayland-protocols",
+ "wayland-protocols-wlr",
+ "wayland-scanner",
+ "xkeysym",
+]
+
+[[package]]
+name = "smol_str"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6845563ada680337a52d43bb0b29f396f2d911616f6573012645b9e3d048a49"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "spade"
+version = "2.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ece03ff43cd2a9b57ebf776ea5e78bd30b3b4185a619f041079f4109f385034"
+dependencies = [
+ "hashbrown 0.15.2",
+ "num-traits",
+ "robust",
+ "smallvec",
+]
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
+
+[[package]]
+name = "strict-num"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6637bab7722d379c8b41ba849228d680cc12d0a45ba1fa2b48f2a30577a06731"
+
+[[package]]
+name = "strum"
+version = "0.27.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f64def088c51c9510a8579e3c5d67c65349dcf755e5479ad3d010aa6454e2c32"
+dependencies = [
+ "strum_macros",
+]
+
+[[package]]
+name = "strum_macros"
+version = "0.27.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c77a8c5abcaf0f9ce05d62342b7d298c346515365c36b673df4ebe3ced01fde8"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "rustversion",
+ "syn",
+]
+
+[[package]]
+name = "symphonia"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "815c942ae7ee74737bb00f965fa5b5a2ac2ce7b6c01c0cc169bbeaf7abd5f5a9"
+dependencies = [
+ "lazy_static",
+ "symphonia-bundle-mp3",
+ "symphonia-codec-pcm",
+ "symphonia-codec-vorbis",
+ "symphonia-core",
+ "symphonia-format-ogg",
+ "symphonia-format-riff",
+ "symphonia-metadata",
+]
+
+[[package]]
+name = "symphonia-bundle-mp3"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c01c2aae70f0f1fb096b6f0ff112a930b1fb3626178fba3ae68b09dce71706d4"
+dependencies = [
+ "lazy_static",
+ "log",
+ "symphonia-core",
+ "symphonia-metadata",
+]
+
+[[package]]
+name = "symphonia-codec-pcm"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f395a67057c2ebc5e84d7bb1be71cce1a7ba99f64e0f0f0e303a03f79116f89b"
+dependencies = [
+ "log",
+ "symphonia-core",
+]
+
+[[package]]
+name = "symphonia-codec-vorbis"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a98765fb46a0a6732b007f7e2870c2129b6f78d87db7987e6533c8f164a9f30"
+dependencies = [
+ "log",
+ "symphonia-core",
+ "symphonia-utils-xiph",
+]
+
+[[package]]
+name = "symphonia-core"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "798306779e3dc7d5231bd5691f5a813496dc79d3f56bf82e25789f2094e022c3"
+dependencies = [
+ "arrayvec",
+ "bitflags 1.3.2",
+ "bytemuck",
+ "lazy_static",
+ "log",
+]
+
+[[package]]
+name = "symphonia-format-ogg"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ada3505789516bcf00fc1157c67729eded428b455c27ca370e41f4d785bfa931"
+dependencies = [
+ "log",
+ "symphonia-core",
+ "symphonia-metadata",
+ "symphonia-utils-xiph",
+]
+
+[[package]]
+name = "symphonia-format-riff"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05f7be232f962f937f4b7115cbe62c330929345434c834359425e043bfd15f50"
+dependencies = [
+ "extended",
+ "log",
+ "symphonia-core",
+ "symphonia-metadata",
+]
+
+[[package]]
+name = "symphonia-metadata"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc622b9841a10089c5b18e99eb904f4341615d5aa55bbf4eedde1be721a4023c"
+dependencies = [
+ "encoding_rs",
+ "lazy_static",
+ "log",
+ "symphonia-core",
+]
+
+[[package]]
+name = "symphonia-utils-xiph"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "484472580fa49991afda5f6550ece662237b00c6f562c7d9638d1b086ed010fe"
+dependencies = [
+ "symphonia-core",
+ "symphonia-metadata",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.98"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36147f1a48ae0ec2b5b3bc5b537d267457555a10dc06f3dbc8cb11ba3006d3b1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "teleia"
+version = "0.1.0"
+dependencies = [
+ "ahash",
+ "base64 0.22.1",
+ "bimap",
+ "bincode",
+ "bitflags 2.6.0",
+ "byteorder",
+ "bytes",
+ "console_error_panic_hook",
+ "console_log",
+ "directories",
+ "enum-map",
+ "env_logger",
+ "getrandom",
+ "glam",
+ "glfw",
+ "glow",
+ "gltf",
+ "image",
+ "js-sys",
+ "kira",
+ "log",
+ "nalgebra",
+ "parry3d",
+ "polling",
+ "rand",
+ "rapier3d",
+ "serde",
+ "serde_json",
+ "simple-eyre",
+ "strum",
+ "tobj",
+ "tracing-wasm",
+ "tungstenite",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+ "winit",
+]
+
+[[package]]
+name = "teleia_macros"
+version = "0.1.0"
+dependencies = [
+ "env",
+ "heck",
+ "litrs",
+ "walkdir",
+]
+
+[[package]]
+name = "tempfile"
+version = "3.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04cbcdd0c794ebb0d4cf35e88edd2f7d2c4c3e9a5a6dab322839b321c6a87a64"
+dependencies = [
+ "cfg-if",
+ "fastrand",
+ "once_cell",
+ "rustix 0.38.31",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.57"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e45bcbe8ed29775f228095caf2cd67af7a4ccf756ebff23a306bf3e8b47b24b"
+dependencies = [
+ "thiserror-impl 1.0.57",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d452f284b73e6d76dd36758a0c8684b1d5be31f92b89d07fd5822175732206fc"
+dependencies = [
+ "thiserror-impl 2.0.11",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.57"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a953cb265bef375dae3de6663da4d3804eee9682ea80d8e2542529b73c531c81"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26afc1baea8a989337eeb52b6e72a039780ce45c3edfcc9c5b9d112feeb173c2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "thread_local"
+version = "1.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b9ef9bad013ada3808854ceac7b46812a6465ba368859a37e2100283d2d719c"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+]
+
+[[package]]
+name = "tiny-skia"
+version = "0.11.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83d13394d44dae3207b52a326c0c85a8bf87f1541f23b0d143811088497b09ab"
+dependencies = [
+ "arrayref",
+ "arrayvec",
+ "bytemuck",
+ "cfg-if",
+ "log",
+ "tiny-skia-path",
+]
+
+[[package]]
+name = "tiny-skia-path"
+version = "0.11.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c9e7fc0c2e86a30b117d0462aa261b72b7a99b7ebd7deb3a14ceda95c5bdc93"
+dependencies = [
+ "arrayref",
+ "bytemuck",
+ "strict-num",
+]
+
+[[package]]
+name = "tobj"
+version = "4.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f7ca3ec0405b0f2f95e0dbcced28882190dc79b0dac63ff82533d256d770223"
+dependencies = [
+ "ahash",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3550f4e9685620ac18a50ed434eb3aec30db8ba93b0287467bca5826ea25baf1"
+
+[[package]]
+name = "toml_edit"
+version = "0.21.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a8534fd7f78b5405e860340ad6575217ce99f38d4d5c8f2442cb5ecb50090e1"
+dependencies = [
+ "indexmap",
+ "toml_datetime",
+ "winnow",
+]
+
+[[package]]
+name = "tracing"
+version = "0.1.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef"
+dependencies = [
+ "pin-project-lite",
+ "tracing-attributes",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-attributes"
+version = "0.1.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54"
+dependencies = [
+ "once_cell",
+]
+
+[[package]]
+name = "tracing-subscriber"
+version = "0.3.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad0f048c97dbd9faa9b7df56362b8ebcaa52adb06b498c050d2f4e32f90a7a8b"
+dependencies = [
+ "sharded-slab",
+ "thread_local",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-wasm"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4575c663a174420fa2d78f4108ff68f65bf2fbb7dd89f33749b6e826b3626e07"
+dependencies = [
+ "tracing",
+ "tracing-subscriber",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "triple_buffer"
+version = "8.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e66931c8eca6381f0d34656a9341f09bd462010488c1a3bc0acd3f2d08dffce"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "ttf-parser"
+version = "0.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "17f77d76d837a7830fe1d4f12b7b4ba4192c1888001c7164257e4bc6d21d96b4"
+
+[[package]]
+name = "tungstenite"
+version = "0.24.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18e5b8366ee7a95b16d32197d0b2604b43a0be89dc5fac9f8e96ccafbaedda8a"
+dependencies = [
+ "byteorder",
+ "bytes",
+ "data-encoding",
+ "http",
+ "httparse",
+ "log",
+ "native-tls",
+ "rand",
+ "sha1",
+ "thiserror 1.0.57",
+ "utf-8",
+]
+
+[[package]]
+name = "typenum"
+version = "1.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1dccffe3ce07af9386bfd29e80c0ab1a8205a2fc34e4bcd40364df902cfa8f3f"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+
+[[package]]
+name = "unicode-segmentation"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4c87d22b6e3f4a18d4d40ef354e97c90fcb14dd91d7dc0aa9d8a1172ebf7202"
+
+[[package]]
+name = "unty"
+version = "0.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d49784317cd0d1ee7ec5c716dd598ec5b4483ea832a2dced265471cc0f690ae"
+
+[[package]]
+name = "urlencoding"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da"
+
+[[package]]
+name = "utf-8"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
+
+[[package]]
+name = "utf8parse"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
+[[package]]
+name = "version_check"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+
+[[package]]
+name = "virtue"
+version = "0.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "051eb1abcf10076295e815102942cc58f9d5e3b4560e46e53c21e8ff6f3af7b1"
+
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6"
+dependencies = [
+ "bumpalo",
+ "log",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-futures"
+version = "0.4.41"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877b9c3f61ceea0e56331985743b13f3d25c406a7098d45180fb5f09bc19ed97"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "wayland-backend"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d50fa61ce90d76474c87f5fc002828d81b32677340112b4ef08079a9d459a40"
+dependencies = [
+ "cc",
+ "downcast-rs",
+ "rustix 0.38.31",
+ "scoped-tls",
+ "smallvec",
+ "wayland-sys",
+]
+
+[[package]]
+name = "wayland-client"
+version = "0.31.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82fb96ee935c2cea6668ccb470fb7771f6215d1691746c2d896b447a00ad3f1f"
+dependencies = [
+ "bitflags 2.6.0",
+ "rustix 0.38.31",
+ "wayland-backend",
+ "wayland-scanner",
+]
+
+[[package]]
+name = "wayland-csd-frame"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "625c5029dbd43d25e6aa9615e88b829a5cad13b2819c4ae129fdbb7c31ab4c7e"
+dependencies = [
+ "bitflags 2.6.0",
+ "cursor-icon",
+ "wayland-backend",
+]
+
+[[package]]
+name = "wayland-cursor"
+version = "0.31.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "71ce5fa868dd13d11a0d04c5e2e65726d0897be8de247c0c5a65886e283231ba"
+dependencies = [
+ "rustix 0.38.31",
+ "wayland-client",
+ "xcursor",
+]
+
+[[package]]
+name = "wayland-protocols"
+version = "0.31.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f81f365b8b4a97f422ac0e8737c438024b5951734506b0e1d775c73030561f4"
+dependencies = [
+ "bitflags 2.6.0",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-scanner",
+]
+
+[[package]]
+name = "wayland-protocols-plasma"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23803551115ff9ea9bce586860c5c5a971e360825a0309264102a9495a5ff479"
+dependencies = [
+ "bitflags 2.6.0",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-protocols",
+ "wayland-scanner",
+]
+
+[[package]]
+name = "wayland-protocols-wlr"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad1f61b76b6c2d8742e10f9ba5c3737f6530b4c243132c2a2ccc8aa96fe25cd6"
+dependencies = [
+ "bitflags 2.6.0",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-protocols",
+ "wayland-scanner",
+]
+
+[[package]]
+name = "wayland-scanner"
+version = "0.31.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63b3a62929287001986fb58c789dce9b67604a397c15c611ad9f747300b6c283"
+dependencies = [
+ "proc-macro2",
+ "quick-xml",
+ "quote",
+]
+
+[[package]]
+name = "wayland-sys"
+version = "0.31.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15a0c8eaff5216d07f226cb7a549159267f3467b289d9a2e52fd3ef5aae2b7af"
+dependencies = [
+ "dlib",
+ "log",
+ "once_cell",
+ "pkg-config",
+]
+
+[[package]]
+name = "web-sys"
+version = "0.3.68"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96565907687f7aceb35bc5fc03770a8a0471d82e479f25832f54a0e3f4b28446"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "web-time"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa30049b1c872b72c89866d458eae9f20380ab280ffd1b1e18df2d3e2d98cfe0"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "wide"
+version = "0.7.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41b5576b9a81633f3e8df296ce0063042a73507636cbe956c61133dd7034ab22"
+dependencies = [
+ "bytemuck",
+ "safe_arch",
+]
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f29e6f9198ba0d26b4c9f07dbe6f9ed633e1f3d5b8b414090084349e46a52596"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows"
+version = "0.54.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9252e5725dbed82865af151df558e754e4a3c2c30818359eb17465f1346a1b49"
+dependencies = [
+ "windows-core",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.54.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12661b9c89351d684a50a8a643ce5f608e20243b9fb84687800163429f161d65"
+dependencies = [
+ "windows-result",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-result"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e383302e8ec8515204254685643de10811af0ed97ea37210dc26fb0032647f8"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.45.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
+dependencies = [
+ "windows-targets 0.42.2",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+dependencies = [
+ "windows-targets 0.48.5",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
+dependencies = [
+ "windows_aarch64_gnullvm 0.42.2",
+ "windows_aarch64_msvc 0.42.2",
+ "windows_i686_gnu 0.42.2",
+ "windows_i686_msvc 0.42.2",
+ "windows_x86_64_gnu 0.42.2",
+ "windows_x86_64_gnullvm 0.42.2",
+ "windows_x86_64_msvc 0.42.2",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
+dependencies = [
+ "windows_aarch64_gnullvm 0.48.5",
+ "windows_aarch64_msvc 0.48.5",
+ "windows_i686_gnu 0.48.5",
+ "windows_i686_msvc 0.48.5",
+ "windows_x86_64_gnu 0.48.5",
+ "windows_x86_64_gnullvm 0.48.5",
+ "windows_x86_64_msvc 0.48.5",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "winit"
+version = "0.29.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d59ad965a635657faf09c8f062badd885748428933dad8e8bdd64064d92e5ca"
+dependencies = [
+ "ahash",
+ "android-activity",
+ "atomic-waker",
+ "bitflags 2.6.0",
+ "bytemuck",
+ "calloop",
+ "cfg_aliases",
+ "core-foundation",
+ "core-graphics",
+ "cursor-icon",
+ "icrate",
+ "js-sys",
+ "libc",
+ "log",
+ "memmap2",
+ "ndk",
+ "ndk-sys",
+ "objc2 0.4.1",
+ "once_cell",
+ "orbclient",
+ "percent-encoding",
+ "raw-window-handle",
+ "redox_syscall 0.3.5",
+ "rustix 0.38.31",
+ "sctk-adwaita",
+ "serde",
+ "smithay-client-toolkit",
+ "smol_str",
+ "unicode-segmentation",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-protocols",
+ "wayland-protocols-plasma",
+ "web-sys",
+ "web-time",
+ "windows-sys 0.48.0",
+ "x11-dl",
+ "x11rb",
+ "xkbcommon-dl",
+]
+
+[[package]]
+name = "winnow"
+version = "0.5.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f593a95398737aeed53e489c785df13f3618e41dbcd6718c6addbf1395aa6876"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "x11-dl"
+version = "2.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38735924fedd5314a6e548792904ed8c6de6636285cb9fec04d5b1db85c1516f"
+dependencies = [
+ "libc",
+ "once_cell",
+ "pkg-config",
+]
+
+[[package]]
+name = "x11rb"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8f25ead8c7e4cba123243a6367da5d3990e0d3affa708ea19dce96356bd9f1a"
+dependencies = [
+ "as-raw-xcb-connection",
+ "gethostname",
+ "libc",
+ "libloading",
+ "once_cell",
+ "rustix 0.38.31",
+ "x11rb-protocol",
+]
+
+[[package]]
+name = "x11rb-protocol"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e63e71c4b8bd9ffec2c963173a4dc4cbde9ee96961d4fcb4429db9929b606c34"
+
+[[package]]
+name = "xcursor"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a0ccd7b4a5345edfcd0c3535718a4e9ff7798ffc536bb5b5a0e26ff84732911"
+
+[[package]]
+name = "xkbcommon-dl"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d039de8032a9a8856a6be89cea3e5d12fdd82306ab7c94d74e6deab2460651c5"
+dependencies = [
+ "bitflags 2.6.0",
+ "dlib",
+ "log",
+ "once_cell",
+ "xkeysym",
+]
+
+[[package]]
+name = "xkeysym"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "054a8e68b76250b253f671d1268cb7f1ae089ec35e195b2efb2a4e9a836d0621"
+
+[[package]]
+name = "zerocopy"
+version = "0.7.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74d4d3961e53fa4c9a25a8637fc2bfaf2595b3d3ae34875568a5cf64787716be"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.7.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "zune-core"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb8a0807f7c01457d0379ba880ba6322660448ddebc890ce29bb64da71fb40f9"
+
+[[package]]
+name = "zune-jpeg"
+version = "0.5.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27bc9d5b815bc103f142aa054f561d9187d191692ec7c2d1e2b4737f8dbd7296"
+dependencies = [
+ "zune-core",
+]
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/Cargo.toml b/2026/games_submissions/rpc2dot0/vendor/teleia/Cargo.toml new file mode 100644 index 0000000..f5037ea --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/Cargo.toml @@ -0,0 +1,19 @@ +[workspace]
+resolver = "2"
+members = ["crates/*"]
+
+[workspace.package]
+version = "0.1.0"
+edition = "2024"
+authors = ["LLLL Colonq <llll@colonq.computer>"]
+
+[workspace.metadata.crane]
+name = "teleia"
+
+[profile.dev.package."*"]
+opt-level = 2
+
+[workspace.lints.clippy]
+all = "deny"
+pedantic = "deny"
+nursery = "deny"
\ No newline at end of file diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/Cargo.toml b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/Cargo.toml new file mode 100644 index 0000000..90a0cca --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/Cargo.toml @@ -0,0 +1,53 @@ +[package]
+name = "teleia"
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+strum = { version = "0.27.1", features = ["derive"] } # utility macros for enums
+glow = { version = "=0.13.1", features = [] } # rendering
+tobj = "=4.0.1" # loader for .obj meshes loader
+ahash = "=0.8.10" # dependency of tobj
+gltf = { git = "https://github.com/lcolonq/gltf", features = ["extras", "import", "names", "utils"] } # loader for .gltf scenes
+image = { version = "0.25.10", default-features = false, features = ["jpeg", "png"] } # texture loader
+# cosmic-text = { version = "*", default-features = false, features = ["std", "swash"] } # advanced text rendering
+glam = "0.29.2" # linear algebra
+log = "0.4.21" # logging
+rand = { version = "=0.8.5", features = ["small_rng"] } # rng
+serde = { version = "1.0.228", features = ["derive"] } # serialization
+serde_json = "1.0.128" # serialize JSON
+bincode = { version = "2.0.1", features = ["serde"] } # binary serialization
+enum-map = "2.7.3" # fast maps with enums as keys
+bimap = "0.6.3" # bijective maps
+# reqwest = "*" # http requests
+bytes = "*" # bytes for http responses
+bitflags = { version = "2.6.0", features = ["serde"] } # bitwise flags
+simple-eyre = { version = "0.3.1", default-features = false } # error reporting and formatting
+rapier3d = "0.23.1" # rigid-body physics
+parry3d = "0.18.0" # collision detection
+nalgebra = {version = "0.33.2", features = ["convert-glam029"]} # linear algebra library for rapier3d
+byteorder = "1.5.0" # read numbers in particular endianness
+base64 = "0.22.1" # encode/decode base64
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+winit = {version = "=0.29.15", features = ["serde"]} # windowing and events
+getrandom = {version = "*", features = ["js"]} # rng in the browser
+console_log = "*" # log to browser console
+console_error_panic_hook = "*" # log to browser console on panic
+tracing-wasm = "*" # trace performance in browser
+wasm-bindgen = "=0.2.100" # interface with javascript
+wasm-bindgen-futures = "*" # interface with async javascript
+js-sys = "*" # browser APIs to interact with JS runtime (e.g. run WASM)
+web-sys = { version = "*", features = ["Document", "Window", "Element", "HtmlCanvasElement", "WebGl2RenderingContext", "Headers", "Request", "RequestInit", "RequestMode", "Response", "Performance", "PerformanceTiming", "AudioContext", "AudioNode", "GainNode", "AudioParam", "AudioDestinationNode", "AudioBuffer", "AudioBufferSourceNode", "BinaryType", "Blob", "CloseEvent", "ErrorEvent", "FileReader", "MessageEvent", "ProgressEvent", "WebSocket", "Storage"] }
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+env_logger = "0.11.5" # configurable logging to stdout
+glfw = { git = "https://github.com/lcolonq/glfw-rs", features = ["serde"] } # window management
+kira = { version = "=0.9.6", default-features = false, features = ["cpal", "ogg", "mp3", "wav"] } # audio
+directories = { git = "https://github.com/lcolonq/directories-rs" } # standard system directories
+polling = "3.11.0" # interface to epoll
+tungstenite = { version = "0.24.0", features = ["native-tls"] } # websockets
\ No newline at end of file diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/build.rs b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/build.rs new file mode 100644 index 0000000..42743ce --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/build.rs @@ -0,0 +1,15 @@ +fn main() {
+ /*println!("cargo::rerun-if-changed=../../flake.lock");
+ match &*std::env::var("CARGO_CFG_TARGET_ARCH").unwrap() {
+ "x86_64" => if let Ok(p) = std::env::var("LIBCOLONQ_PIT_NATIVE") {
+ println!("cargo::rustc-link-search={}", p);
+ },
+ "wasm32" => if let Ok(p) = std::env::var("LIBCOLONQ_PIT_WASM") {
+
+ println!("cargo::rustc-link-search={}", p);
+ },
+ _ => eprintln!("warning: building for unknown architecture!"),
+ }
+ println!("cargo::rustc-link-lib=static=colonq-pit");*/
+ eprint!("we are not using pit at all, this is a fork of teleia where scripting is disabled");
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/fonts/default.png b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/fonts/default.png Binary files differnew file mode 100644 index 0000000..7b1d2a3 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/fonts/default.png diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/fonts/small.png b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/fonts/small.png Binary files differnew file mode 100644 index 0000000..1d020f7 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/fonts/small.png diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/meshes/square.obj b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/meshes/square.obj new file mode 100644 index 0000000..7acdef6 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/meshes/square.obj @@ -0,0 +1,15 @@ +# Blender 3.6.2
+# www.blender.org
+o Cube
+v -1.000000 -1.000000 0.000000
+v 1.000000 -1.000000 0.000000
+v -1.000000 1.000000 0.000000
+v 1.000000 1.000000 0.000000
+vn -0.0000 -0.0000 -1.0000
+vt 0.0 1.0
+vt 1.0 0.0
+vt 0.0 0.0
+vt 1.0 1.0
+s 0
+f 3/1/1 2/2/1 1/3/1
+f 3/1/1 4/4/1 2/2/1
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/bitmap/frag.glsl b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/bitmap/frag.glsl new file mode 100644 index 0000000..fbc8d71 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/bitmap/frag.glsl @@ -0,0 +1,15 @@ +#version 300 es
+precision highp float;
+
+uniform sampler2D texture_data;
+
+in vec2 vertex_texcoord;
+in vec3 vertex_color;
+out vec4 frag_color;
+
+void main() {
+ vec4 texel = texture(texture_data, vertex_texcoord);
+ if (texel.rgb == vec3(0.0, 0.0, 0.0)) discard;
+ texel.rgb = vertex_color;
+ frag_color = texel;
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/bitmap/vert.glsl b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/bitmap/vert.glsl new file mode 100644 index 0000000..eee22fc --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/bitmap/vert.glsl @@ -0,0 +1,20 @@ +#version 300 es
+precision highp float;
+
+in vec3 vertex;
+in vec2 texcoord;
+in vec3 color;
+
+uniform mat4 view;
+uniform mat4 position;
+uniform mat4 projection;
+
+out vec2 vertex_texcoord;
+out vec3 vertex_color;
+
+void main() {
+ vertex_texcoord = texcoord;
+ vertex_color = color;
+ vec3 pos = (position * vec4(vertex, 1.0)).xyz;
+ gl_Position = projection * view * vec4(pos, 1.0);
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/common/frag.glsl b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/common/frag.glsl new file mode 100644 index 0000000..fee9b80 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/common/frag.glsl @@ -0,0 +1,160 @@ +#version 300 es
+precision highp float;
+
+uniform vec3 camera_pos;
+uniform float time;
+
+uniform vec3 light_ambient_color;
+uniform vec3 light_dir;
+uniform vec3 light_dir_color;
+uniform int light_count;
+uniform vec3 light_pos[5];
+uniform vec3 light_color[5];
+uniform vec2 light_attenuation[5];
+uniform highp sampler2DShadow light_shadowbuffer_dir;
+uniform samplerCube light_shadowbuffer_point[5];
+
+uniform int has_point_shadows;
+
+in vec2 vertex_texcoord;
+in vec3 vertex_normal;
+in vec3 vertex_fragpos;
+in vec4 vertex_fragpos_shadow_dir;
+in vec3 vertex_view_vector;
+
+out vec4 frag_color;
+
+mat3 compute_tbn() {
+ vec3 p = -vertex_view_vector;
+ vec3 normal = normalize(vertex_normal);
+ vec3 dpx = dFdx(p);
+ vec3 dpy = dFdy(p);
+ vec2 duvx = dFdx(vertex_texcoord);
+ vec2 duvy = dFdy(vertex_texcoord);
+ vec3 dpyperp = cross(dpy, normal);
+ vec3 dpxperp = cross(normal, dpx);
+ vec3 tangent = dpyperp * duvx.x + dpxperp * duvy.x;
+ vec3 bitangent = dpyperp * duvx.y + dpxperp * duvy.y;
+ float invmax = inversesqrt(max(dot(bitangent, bitangent), dot(bitangent, bitangent)));
+ return mat3(-tangent * invmax, -bitangent * invmax, normal);
+}
+
+vec4 normal_as_color(vec3 n) {
+ float r = (128.0 + 127.0 * n.r) / 255.0;
+ float g = (128.0 + 127.0 * n.g) / 255.0;
+ float b = (128.0 + 127.0 * n.b) / 255.0;
+ return vec4(r, g, b, 1.0);
+}
+
+vec3 dir_light(vec3 normal) {
+ return max(dot(normal, -normalize(light_dir)), 0.0) * light_dir_color;
+}
+
+float dir_shadow(vec3 normal) {
+ vec3 proj = vertex_fragpos_shadow_dir.xyz / vertex_fragpos_shadow_dir.w;
+ float bias = 0.002;
+ // float current_depth = proj.z;
+ // float bias = max(0.05 * (1.0 - dot(normal, -normalize(light_dir))), 0.005);
+ proj.z -= bias;
+ proj *= 0.5; proj += 0.5;
+ if (proj.z > 1.0) return 0.0;
+ return 1.0 - texture(light_shadowbuffer_dir, proj.xyz);
+}
+
+float point_shadow(vec3 normal, vec3 shadow_vector, float closest_depth) {
+ closest_depth *= 25.0;
+ float current_depth = length(shadow_vector);
+ float bias = max(0.1 * (1.0 - dot(normal, normalize(shadow_vector))), 0.005);
+ bias = min(bias + current_depth * 0.01, 0.2);
+ float shadow = current_depth - bias > closest_depth ? 1.0 : 0.0;
+ return shadow;
+}
+
+vec3 point_light(vec3 normal, const int idx) {
+ vec3 pos = light_pos[idx];
+ vec3 color = light_color[idx];
+ float linear = light_attenuation[idx].x;
+ float quadratic = light_attenuation[idx].y;
+ vec3 light_vector = pos - vertex_fragpos;
+ float distance = length(light_vector);
+ float attenuation = 1.0 / (1.0 + distance * linear + distance * distance * quadratic);
+
+ float directional = max(dot(normal.xyz, normalize(light_vector)), 0.0);
+ vec3 directional_light = color * directional;
+
+ vec3 view_dir = normalize(camera_pos - vertex_fragpos);
+ vec3 reflect_dir = reflect(-normalize(light_vector), normalize(normal.xyz));
+ float specular = pow(max(dot(view_dir, reflect_dir), 0.0), 32.0);
+ vec3 specular_light = 0.5 * specular * color;
+ // return (directional_light + specular_light) * attenuation;
+ return directional_light * attenuation;
+}
+
+vec3 point_light_billboard(const int idx) {
+ vec3 pos = light_pos[idx];
+ vec3 color = light_color[idx];
+ float linear = light_attenuation[idx].x;
+ float quadratic = light_attenuation[idx].y;
+ vec3 light_vector = pos - vertex_fragpos;
+ float distance = length(light_vector);
+ float attenuation = 1.0 / (1.0 + distance * linear + distance * distance * quadratic);
+
+ return color * attenuation;
+}
+
+vec3 compute_lighting(vec3 normal) {
+ vec3 ambient_light = light_ambient_color;
+
+ vec3 from_dir = dir_light(normal) * (1.0 - dir_shadow(normal));
+
+ vec3 shadow_vector[5];
+ for (int i = 0; i < light_count; ++i) {
+ shadow_vector[i] = vertex_fragpos - light_pos[i];
+ shadow_vector[i].x *= -1.0;
+ }
+
+ // can only index array of samplers with a constant, hence the weird setup
+ #define SAMPLE_SHADOW(n) n < light_count ? texture(light_shadowbuffer_point[n], shadow_vector[n]).r : 1.0
+ float shadow_depth[5];
+ shadow_depth[0] = SAMPLE_SHADOW(0);
+ shadow_depth[1] = SAMPLE_SHADOW(1);
+ shadow_depth[2] = SAMPLE_SHADOW(2);
+ shadow_depth[3] = SAMPLE_SHADOW(3);
+ shadow_depth[4] = SAMPLE_SHADOW(4);
+
+ vec3 from_points = vec3(0.0, 0.0, 0.0);
+ for (int i = 0; i < light_count; ++i) {
+ from_points += has_point_shadows != 0
+ ? point_light(normal, i) * (1.0 - point_shadow(normal, shadow_vector[i], shadow_depth[i]))
+ : point_light(normal, i);
+ }
+
+ return (ambient_light + from_dir + from_points);
+}
+
+vec3 compute_lighting_noshadow(vec3 normal) {
+ vec3 ambient_light = light_ambient_color;
+
+ vec3 from_dir = dir_light(normal);
+
+ vec3 from_points = vec3(0.0, 0.0, 0.0);
+ for (int i = 0; i < light_count; ++i) {
+ from_points += point_light(normal, i);
+ }
+
+ return (ambient_light + from_dir + from_points);
+}
+
+vec3 compute_lighting_billboard(vec3 normal) {
+ vec3 ambient_light = light_ambient_color;
+
+ vec3 from_dir = light_dir_color / 2.0;
+
+ vec3 from_points = vec3(0.0, 0.0, 0.0);
+ for (int i = 0; i < light_count; ++i) {
+ from_points += point_light_billboard(i);
+ }
+
+ return (ambient_light + from_dir + from_points);
+}
+#line 0
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/common/vert.glsl b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/common/vert.glsl new file mode 100644 index 0000000..06f7e30 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/common/vert.glsl @@ -0,0 +1,30 @@ +#version 300 es
+precision highp float;
+
+in vec3 vertex;
+in vec3 normal;
+in vec2 texcoord;
+
+uniform mat4 view;
+uniform mat4 position;
+uniform mat4 projection;
+uniform mat4 normal_matrix;
+uniform mat4 lightspace_matrix;
+uniform vec3 camera_pos;
+
+out vec2 vertex_texcoord;
+out vec3 vertex_normal;
+out vec3 vertex_fragpos;
+out vec4 vertex_fragpos_shadow_dir;
+out vec3 vertex_view_vector;
+
+void default_main()
+{
+ vertex_texcoord = texcoord;
+ vertex_normal = (normal_matrix * vec4(normal, 1.0)).xyz;
+ vec3 pos = (position * vec4(vertex, 1.0)).xyz;
+ vertex_fragpos = pos;
+ vertex_fragpos_shadow_dir = lightspace_matrix * vec4(pos, 1.0);
+ vertex_view_vector = camera_pos - pos;
+ gl_Position = projection * view * vec4(pos, 1.0);
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/flat/frag.glsl b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/flat/frag.glsl new file mode 100644 index 0000000..fa305e6 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/flat/frag.glsl @@ -0,0 +1,12 @@ +uniform sampler2D texture_data;
+
+uniform float transparency;
+
+void main()
+{
+ float opacity = 1.0 - clamp(transparency, 0.0, 1.0);
+ vec2 tcfull = vec2(vertex_texcoord.x, 1.0 - vertex_texcoord.y);
+ vec4 texel = texture(texture_data, tcfull);
+ texel.a *= opacity;
+ frag_color = texel;
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/flat/vert.glsl b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/flat/vert.glsl new file mode 100644 index 0000000..6e796cc --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/flat/vert.glsl @@ -0,0 +1,4 @@ +void main()
+{
+ default_main();
+}
\ No newline at end of file diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/scale/frag.glsl b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/scale/frag.glsl new file mode 100644 index 0000000..257c1b7 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/scale/frag.glsl @@ -0,0 +1,12 @@ +#version 300 es
+precision highp float;
+
+uniform sampler2D texture_data;
+
+in vec2 vertex_texcoord;
+out vec4 frag_color;
+
+void main() {
+ vec4 texel = texture(texture_data, vertex_texcoord);
+ frag_color = texel;
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/scale/vert.glsl b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/scale/vert.glsl new file mode 100644 index 0000000..d48f78d --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/scale/vert.glsl @@ -0,0 +1,22 @@ +#version 300 es
+precision highp float;
+
+out vec2 vertex_texcoord;
+
+void main() {
+ const vec2 positions[4] = vec2[](
+ vec2(-1, -1),
+ vec2(+1, -1),
+ vec2(-1, +1),
+ vec2(+1, +1)
+ );
+ const vec2 coords[4] = vec2[](
+ vec2(0, 0),
+ vec2(1, 0),
+ vec2(0, 1),
+ vec2(1, 1)
+ );
+
+ vertex_texcoord = coords[gl_VertexID];
+ gl_Position = vec4(positions[gl_VertexID], 0.0, 1.0);
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/scene/frag.glsl b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/scene/frag.glsl new file mode 100644 index 0000000..554c25d --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/scene/frag.glsl @@ -0,0 +1,11 @@ +uniform sampler2D texture_data;
+
+void main()
+{
+ vec4 texel = texture(texture_data, vertex_texcoord);
+ if (texel.a != 1.0) {
+ discard;
+ }
+
+ frag_color = vec4(texel.rgb, texel.a);
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/scene/vert.glsl b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/scene/vert.glsl new file mode 100644 index 0000000..c66a816 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/scene/vert.glsl @@ -0,0 +1,18 @@ +in vec4 joint;
+in vec4 weight;
+
+uniform mat4 joint_matrices[128];
+
+void main()
+{
+ vertex_texcoord = texcoord;
+ vertex_normal = (normal_matrix * vec4(normal, 1.0)).xyz;
+ mat4 skin
+ = weight.x * joint_matrices[int(joint.x)]
+ + weight.y * joint_matrices[int(joint.y)]
+ + weight.z * joint_matrices[int(joint.z)]
+ + weight.w * joint_matrices[int(joint.w)];
+ vec3 pos = (position * skin * vec4(vertex, 1.0)).xyz;
+ vertex_view_vector = camera_pos - pos;
+ gl_Position = projection * view * vec4(pos, 1.0);
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/test/frag.glsl b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/test/frag.glsl new file mode 100644 index 0000000..954a9d2 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/test/frag.glsl @@ -0,0 +1,23 @@ +// uniform int has_normal_map;
+// uniform sampler2D normal_map;
+
+uniform sampler2D texture_data;
+
+void main()
+{
+ vec2 inverted_texcoord = vec2(vertex_texcoord.x, 1.0 - vertex_texcoord.y);
+ vec4 texel = texture(texture_data, inverted_texcoord);
+ if (texel.a != 1.0) {
+ discard;
+ }
+
+ // mat3 tbn = compute_tbn();
+ // vec3 normal = has_normal_map != 0
+ // ? normalize(tbn * (texture(normal_map, inverted_texcoord).xyz * 2.0 - 1.0))
+ // : normalize(vertex_normal);
+ vec3 normal = normalize(vertex_normal);
+
+ vec3 lighting = compute_lighting_noshadow(normal);
+
+ frag_color = vec4(texel.rgb * lighting, texel.a);
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/test/vert.glsl b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/test/vert.glsl new file mode 100644 index 0000000..6e796cc --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/test/vert.glsl @@ -0,0 +1,4 @@ +void main()
+{
+ default_main();
+}
\ No newline at end of file diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/tiled/frag.glsl b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/tiled/frag.glsl new file mode 100644 index 0000000..257c1b7 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/tiled/frag.glsl @@ -0,0 +1,12 @@ +#version 300 es
+precision highp float;
+
+uniform sampler2D texture_data;
+
+in vec2 vertex_texcoord;
+out vec4 frag_color;
+
+void main() {
+ vec4 texel = texture(texture_data, vertex_texcoord);
+ frag_color = texel;
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/tiled/vert.glsl b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/tiled/vert.glsl new file mode 100644 index 0000000..a7567f4 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/tiled/vert.glsl @@ -0,0 +1,14 @@ +#version 300 es
+precision highp float;
+
+in vec2 vertex;
+in vec2 texcoord;
+
+uniform mat4 transform;
+
+out vec2 vertex_texcoord;
+
+void main() {
+ vertex_texcoord = texcoord;
+ gl_Position = transform * vec4(vertex, 0.0, 1.0);
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/truetype/frag.glsl b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/truetype/frag.glsl new file mode 100644 index 0000000..d472c09 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/truetype/frag.glsl @@ -0,0 +1,16 @@ +#version 300 es
+precision highp float;
+
+uniform sampler2D texture_data;
+
+in vec2 vertex_texcoord;
+in vec3 vertex_color;
+out vec4 frag_color;
+
+void main()
+{
+ float val = texture(texture_data, vertex_texcoord).r;
+ if (val == 0.0) discard;
+ vec4 texel = vec4(vertex_color, val);
+ frag_color = texel;
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/truetype/vert.glsl b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/truetype/vert.glsl new file mode 100644 index 0000000..a501e0a --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/truetype/vert.glsl @@ -0,0 +1,17 @@ +#version 300 es
+precision highp float;
+
+in vec2 vertex;
+in vec2 texcoord;
+in vec3 color;
+
+uniform mat4 transform;
+
+out vec2 vertex_texcoord;
+out vec3 vertex_color;
+
+void main() {
+ vertex_texcoord = texcoord;
+ vertex_color = color;
+ gl_Position = transform * vec4(vertex, 0.0, 1.0);
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/uber/frag.glsl b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/uber/frag.glsl new file mode 100644 index 0000000..8e7b752 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/uber/frag.glsl @@ -0,0 +1,193 @@ +uniform highp int flags;
+
+uniform vec3 camera_pos;
+uniform float time;
+
+uniform vec2 sprite_offset;
+uniform vec2 sprite_dims;
+
+uniform vec4 color;
+uniform sampler2D texture_color;
+uniform sampler2D texture_normal;
+uniform vec3 light_ambient_color;
+uniform vec3 light_dir;
+uniform vec3 light_dir_color;
+uniform int light_count;
+uniform vec3 light_pos[5];
+uniform vec3 light_color[5];
+uniform vec2 light_attenuation[5];
+
+uniform int effect_flip;
+uniform float effect_flash;
+uniform float effect_hueshift;
+uniform float effect_huescale;
+
+in vec2 vertex_texcoord;
+in vec3 vertex_color;
+in vec3 vertex_normal;
+in vec3 vertex_fragpos;
+in vec4 vertex_fragpos_shadow_dir;
+in vec3 vertex_view_vector;
+
+out vec4 frag_color;
+
+bool flag(int mask) {
+ return (flags & mask) != 0;
+}
+
+mat3 compute_tbn() {
+ vec3 p = -vertex_view_vector;
+ vec3 normal = normalize(vertex_normal);
+ vec3 dpx = dFdx(p);
+ vec3 dpy = dFdy(p);
+ vec2 duvx = dFdx(vertex_texcoord);
+ vec2 duvy = dFdy(vertex_texcoord);
+ vec3 dpyperp = cross(dpy, normal);
+ vec3 dpxperp = cross(normal, dpx);
+ vec3 tangent = dpyperp * duvx.x + dpxperp * duvy.x;
+ vec3 bitangent = dpyperp * duvx.y + dpxperp * duvy.y;
+ float invmax = inversesqrt(max(dot(bitangent, bitangent), dot(bitangent, bitangent)));
+ float flip = flag(FLIP_TEXTURE) ? 1.0 : -1.0;
+ return mat3(-tangent * invmax, flip * bitangent * invmax, normal);
+
+}
+
+vec4 normal_as_color(vec3 n) {
+ float r = (128.0 + 127.0 * n.r) / 255.0;
+ float g = (128.0 + 127.0 * n.g) / 255.0;
+ float b = (128.0 + 127.0 * n.b) / 255.0;
+ return vec4(r, g, b, 1.0);
+}
+
+vec3 dir_light(vec3 normal) {
+ return max(dot(normal, -normalize(light_dir)), 0.0) * light_dir_color;
+}
+
+vec3 point_light(vec3 normal, const int idx) {
+ vec3 pos = light_pos[idx];
+ vec3 color = light_color[idx];
+ float linear = light_attenuation[idx].x;
+ float quadratic = light_attenuation[idx].y;
+ vec3 light_vector = pos - vertex_fragpos;
+ float distance = length(light_vector);
+ float attenuation = 1.0 / (1.0 + distance * linear + distance * distance * quadratic);
+
+ float directional = max(dot(normal.xyz, normalize(light_vector)), 0.0);
+ vec3 directional_light = color * directional;
+
+ vec3 view_dir = normalize(camera_pos - vertex_fragpos);
+ vec3 reflect_dir = reflect(-normalize(light_vector), normalize(normal.xyz));
+ float specular = pow(max(dot(view_dir, reflect_dir), 0.0), 32.0);
+ vec3 specular_light = 0.5 * specular * color;
+ // return (directional_light + specular_light) * attenuation;
+ return directional_light * attenuation;
+}
+
+vec3 point_light_billboard(const int idx) {
+ vec3 pos = light_pos[idx];
+ vec3 color = light_color[idx];
+ float linear = light_attenuation[idx].x;
+ float quadratic = light_attenuation[idx].y;
+ vec3 light_vector = pos - vertex_fragpos;
+ float distance = length(light_vector);
+ float attenuation = 1.0 / (1.0 + distance * linear + distance * distance * quadratic);
+
+ return color * attenuation;
+}
+
+vec3 rgb_to_hsl(vec3 rgb) {
+ vec3 ret;
+ float min = min(min(rgb.r, rgb.g), rgb.b);
+ float max = max(max(rgb.r, rgb.g), rgb.b);
+ float lum = (max + min) / 2.0;
+ ret.z = lum;
+ if (max == min) {
+ ret.x = ret.y = 0.0;
+ } else {
+ float chroma = max - min;
+ ret.y = chroma / (1.0 - abs(2.0 * lum - 1.0));
+ if (max == rgb.r) {
+ ret.x = (rgb.g - rgb.b) / chroma + (rgb.g < rgb.b ? 6.0 : 0.0);
+ } else if (max == rgb.g) {
+ ret.x = (rgb.b - rgb.r) / chroma + 2.0;
+ } else {
+ ret.x = (rgb.r - rgb.g) / chroma + 4.0;
+ }
+ ret.x /= 6.0;
+ }
+ return ret;
+}
+
+float hue_to_rgb(float p, float q, float t) {
+ if (t < 0.0) t += 1.0;
+ if (t > 1.0) t -= 1.0;
+ if (t < 1.0/6.0) return p + (q - p) * 6.0 * t;
+ if (t < 1.0/2.0) return q;
+ if (t < 2.0/3.0) return p + (q - p) * (2.0/3.0 - t) * 6.0;
+ return p;
+}
+
+vec3 hsl_to_rgb(vec3 hsl) {
+ vec3 ret;
+ if (hsl.y == 0.0) {
+ ret.r = ret.g = ret.b = hsl.z;
+ } else {
+ float q = hsl.z < 0.5 ? hsl.z * (1.0 + hsl.y) : hsl.z + hsl.y - hsl.z * hsl.y;
+ float p = 2.0 * hsl.z - q;
+ ret.r = hue_to_rgb(p, q, hsl.x + 1.0/3.0);
+ ret.g = hue_to_rgb(p, q, hsl.x);
+ ret.b = hue_to_rgb(p, q, hsl.x - 1.0/3.0);
+ }
+ return ret;
+}
+
+void main() {
+ float tcy = flag(FLIP_TEXTURE) ? vertex_texcoord.y : 1.0 - vertex_texcoord.y;
+ vec2 tc = vec2(vertex_texcoord.x, tcy);
+ mat3 tbn = compute_tbn();
+ if (flag(EFFECTS)) {
+ float fbase = float(effect_flip);
+ float fmul = 1.0 - 2.0 * fbase;
+ tc = vec2(fbase + fmul * vertex_texcoord.x, tcy);
+ }
+ if (flag(SPRITE)) {
+ tc *= sprite_dims;
+ tc += sprite_offset;
+ }
+ frag_color = color;
+ if (flag(TEXTURE_COLOR)) {
+ frag_color = texture(texture_color, tc);
+ }
+ if (flag(EFFECTS)) {
+ vec3 hsl = rgb_to_hsl(frag_color.rgb);
+ hsl.x = mod(hsl.x * effect_huescale + effect_hueshift, 1.0);
+ vec3 p = hsl_to_rgb(hsl);
+ frag_color.rgb = vec3(p.r + effect_flash, p.g + effect_flash, p.b + effect_flash);
+ }
+ vec3 normal = vertex_normal;
+ if (flag(TEXTURE_NORMAL)) {
+ normal = normalize(tbn * (texture(texture_normal, tc).xyz * 2.0 - 1.0));
+ }
+ vec3 from_ambient = vec3(1.0, 1.0, 1.0);
+ if (flag(LIGHT_AMBIENT)) {
+ from_ambient = light_ambient_color;
+ }
+ vec3 from_dir = vec3(0.0, 0.0, 0.0);
+ if (flag(LIGHT_DIR)) {
+ from_dir = dir_light(normal);
+ }
+ vec3 from_points = vec3(0.0, 0.0, 0.0);
+ if (flag(LIGHT_POINT)) {
+ for (int i = 0; i < light_count; ++i) {
+ vec3 pl = point_light(normal, i);
+ from_points += pl;
+ }
+ }
+ frag_color.rgb *= (from_ambient + from_dir + from_points);
+ if (frag_color.a == 0.0) {
+ discard;
+ }
+ if (flag(VERTEX_COLOR)) {
+ frag_color.rgb = vertex_color;
+ }
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/uber/vert.glsl b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/uber/vert.glsl new file mode 100644 index 0000000..bd5ac60 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/assets/shaders/uber/vert.glsl @@ -0,0 +1,41 @@ +uniform highp int flags;
+
+in vec3 vertex;
+in vec3 normal;
+in vec2 texcoord;
+in vec3 color;
+
+uniform mat4 view;
+uniform mat4 position;
+uniform mat4 projection;
+uniform mat4 normal_matrix;
+uniform mat4 lightspace_matrix;
+uniform vec3 camera_pos;
+uniform vec3 offset;
+uniform float yskew;
+
+out vec2 vertex_texcoord;
+out vec3 vertex_color;
+out vec3 vertex_normal;
+out vec3 vertex_fragpos;
+out vec4 vertex_fragpos_shadow_dir;
+out vec3 vertex_view_vector;
+
+bool flag(int mask) {
+ return (flags & mask) != 0;
+}
+
+void main() {
+ vertex_texcoord = texcoord;
+ vertex_color = color;
+ vertex_normal = (normal_matrix * vec4(normal, 1.0)).xyz;
+ vec3 pos = (position * vec4(vertex, 1.0)).xyz;
+ vertex_fragpos = pos;
+ vertex_fragpos_shadow_dir = lightspace_matrix * vec4(pos, 1.0);
+ vertex_view_vector = camera_pos - pos;
+ gl_Position = projection * view * vec4(pos, 1.0);
+ gl_Position.xyz += offset;
+ if (flag(YSKEW)) {
+ gl_Position.y += yskew * pos.z;
+ }
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/audio.rs b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/audio.rs new file mode 100644 index 0000000..431b010 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/audio.rs @@ -0,0 +1,341 @@ +use std::collections::HashMap;
+
+use std::sync::{Arc, Mutex};
+
+#[cfg(target_arch = "wasm32")]
+pub struct Context {
+ pub audio: web_sys::AudioContext,
+}
+
+#[cfg(target_arch = "wasm32")]
+impl Context {
+ pub fn new() -> Self {
+ let audio = web_sys::AudioContext::new().expect("failed to create audio context");
+ Self { audio }
+ }
+}
+
+#[cfg(target_arch = "wasm32")]
+pub struct AudioPlayingHandle {
+ node: web_sys::AudioBufferSourceNode,
+ gain: web_sys::GainNode,
+}
+
+#[cfg(target_arch = "wasm32")]
+impl AudioPlayingHandle {
+ pub fn stop(&self, _ctx: &Context) {
+ self.node.stop().expect("failed to stop audio");
+ }
+ pub fn fade_out(&self, ctx: &Context, time: f32) {
+ self.gain
+ .gain()
+ .set_target_at_time(0.0, ctx.audio.current_time(), time as f64)
+ .expect("failed to fade out audio");
+ self.node
+ .stop_with_when(ctx.audio.current_time() + time as f64 + 1.0)
+ .expect("failed to stop audio while fading out");
+ }
+}
+
+#[cfg(target_arch = "wasm32")]
+pub struct Audio {
+ pub buffer: Arc<Mutex<Option<web_sys::AudioBuffer>>>,
+}
+
+#[cfg(target_arch = "wasm32")]
+impl Audio {
+ pub fn new(ctx: &Context, bytes: &[u8]) -> Self {
+ let sbuffer = Arc::new(Mutex::new(None));
+ let sclone = sbuffer.clone();
+ let ret = Audio { buffer: sclone };
+ let jsp = ctx
+ .audio
+ .decode_audio_data(&js_sys::Uint8Array::from(bytes).buffer())
+ .expect("failed to decode audio");
+ let promise = wasm_bindgen_futures::JsFuture::from(jsp);
+ wasm_bindgen_futures::spawn_local(async move {
+ if let Some(data) = promise.await.ok() {
+ *sbuffer.lock().unwrap() = Some(web_sys::AudioBuffer::from(data));
+ }
+ ()
+ });
+ ret
+ }
+
+ pub fn from_samples(ctx: &Context, sample_rate: f32, samples: &[f32]) -> Self {
+ let buf = ctx
+ .audio
+ .create_buffer(1, samples.len() as u32, sample_rate)
+ .expect("failed to create audio buffer");
+ buf.copy_to_channel(samples, 0)
+ .expect("failed to populate audio samples");
+ Audio {
+ buffer: Arc::new(Mutex::new(Some(buf))),
+ }
+ }
+
+ pub fn play(
+ &self,
+ ctx: &mut Context,
+ looping: Option<(Option<f64>, Option<f64>)>,
+ ) -> Option<AudioPlayingHandle> {
+ let source = ctx.audio.create_buffer_source().ok()?;
+ if let Some(ab) = &*self.buffer.lock().unwrap() {
+ source.set_buffer(Some(&ab));
+ } else {
+ return None;
+ };
+ if let Some((ms, me)) = looping {
+ source.set_loop(true);
+ if let Some(s) = ms {
+ source.set_loop_start(s)
+ }
+ if let Some(e) = me {
+ source.set_loop_end(e)
+ }
+ }
+ let gain = ctx.audio.create_gain().ok()?;
+ gain.gain()
+ .set_value_at_time(0.5, ctx.audio.current_time())
+ .ok()?;
+ gain.connect_with_audio_node(&ctx.audio.destination())
+ .ok()?;
+ source.connect_with_audio_node(&gain).ok()?;
+ source.start().ok()?;
+ Some(AudioPlayingHandle { node: source, gain })
+ }
+}
+
+#[cfg(target_arch = "wasm32")]
+pub struct Assets {
+ pub ctx: Context,
+ pub audio: HashMap<String, Audio>,
+ pub music_node: Option<AudioPlayingHandle>,
+}
+
+#[cfg(target_arch = "wasm32")]
+impl Assets {
+ pub fn new<F>(f: F) -> Self
+ where
+ F: Fn(&Context) -> HashMap<String, Audio>,
+ {
+ let ctx = Context::new();
+
+ let audio = f(&ctx);
+
+ Self {
+ ctx,
+ audio,
+ music_node: None,
+ }
+ }
+
+ pub fn play_sfx(&mut self, name: &str) {
+ if let Some(a) = self.audio.get(name) {
+ a.play(&mut self.ctx, None);
+ }
+ }
+
+ pub fn is_music_playing(&self) -> bool {
+ if let Some(ms) = &self.music_node {
+ ms.node.buffer().is_some()
+ } else {
+ false
+ }
+ }
+
+ pub fn play_music(&mut self, name: &str, start: Option<f64>, end: Option<f64>) {
+ if let Some(s) = &self.music_node {
+ let _ = s.stop(&self.ctx);
+ }
+ if let Some(a) = self.audio.get(name) {
+ self.music_node = a.play(&mut self.ctx, Some((start, end)));
+ }
+ }
+
+ pub fn stop_music(&mut self) {
+ if let Some(node) = &self.music_node {
+ let _ = node.stop(&self.ctx);
+ }
+ self.music_node = None;
+ }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub struct Context {
+ manager: kira::manager::AudioManager,
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+impl Context {
+ #[allow(clippy::new_without_default)]
+ pub fn new() -> Self {
+ Self {
+ manager: kira::manager::AudioManager::new(
+ kira::manager::AudioManagerSettings::default(),
+ )
+ .expect("failed to create audio manager"),
+ }
+ }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub struct AudioPlayingHandle {
+ handle: Arc<Mutex<kira::sound::static_sound::StaticSoundHandle>>,
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+impl AudioPlayingHandle {
+ pub fn stop(&self, _ctx: &Context) {
+ self.handle
+ .lock()
+ .unwrap()
+ .stop(kira::tween::Tween::default());
+ }
+ pub fn fade_out(&self, _ctx: &Context, time: f32) {
+ self.handle.lock().unwrap().stop(kira::tween::Tween {
+ duration: std::time::Duration::from_secs_f32(time + 0.5),
+ ..Default::default()
+ });
+ }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub struct Audio {
+ data: kira::sound::static_sound::StaticSoundData,
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+impl Audio {
+ pub fn new(_ctx: &Context, bytes: &[u8]) -> Self {
+ Self {
+ data: kira::sound::static_sound::StaticSoundData::from_cursor(std::io::Cursor::new(
+ bytes.to_owned(),
+ ))
+ .expect("failed to decode audio"),
+ }
+ }
+
+ pub fn from_samples(_ctx: &Context, sample_rate: f32, samples: &[f32]) -> Self {
+ let frames: Vec<kira::Frame> = samples
+ .iter()
+ .map(|f| kira::Frame {
+ left: *f,
+ right: *f,
+ })
+ .collect();
+ Self {
+ data: kira::sound::static_sound::StaticSoundData {
+ sample_rate: sample_rate as u32,
+ frames: frames.into(),
+ settings: kira::sound::static_sound::StaticSoundSettings::default(),
+ slice: None,
+ },
+ }
+ }
+
+ pub fn play(
+ &self,
+ ctx: &mut Context,
+ looping: Option<(Option<f64>, Option<f64>)>,
+ ) -> Option<AudioPlayingHandle> {
+ let sd = if let Some((ss, se)) = looping {
+ let start = ss.unwrap_or(0.0);
+ if let Some(e) = se {
+ self.data.loop_region(start..e)
+ } else {
+ self.data.loop_region(start..)
+ }
+ } else {
+ self.data.clone()
+ };
+ ctx.manager.play(sd).ok().map(|h| AudioPlayingHandle {
+ handle: Arc::new(Mutex::new(h)),
+ })
+ }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub struct Assets {
+ pub ctx: Context,
+ pub audio: HashMap<String, Audio>,
+ pub music_handle: Option<AudioPlayingHandle>,
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+impl Assets {
+ pub fn new<F>(f: F) -> Self
+ where
+ F: Fn(&Context) -> HashMap<String, Audio>,
+ {
+ let ctx = Context::new();
+ let audio = f(&ctx);
+ Self {
+ ctx,
+ audio,
+ music_handle: None,
+ }
+ }
+
+ pub fn play_sfx(&mut self, name: &str) {
+ if let Some(a) = self.audio.get(name) {
+ if a.play(&mut self.ctx, None).is_none() {
+ log::warn!("failed to play sound {}", name);
+ }
+ }
+ }
+
+ pub fn is_music_playing(&self) -> bool {
+ if let Some(mh) = &self.music_handle {
+ mh.handle.lock().unwrap().state() == kira::sound::PlaybackState::Playing
+ } else {
+ false
+ }
+ }
+
+ pub fn play_music(&mut self, name: &str, start: Option<f64>, end: Option<f64>) {
+ if let Some(s) = &mut self.music_handle {
+ s.stop(&self.ctx);
+ }
+ if let Some(a) = self.audio.get(name) {
+ match a.play(&mut self.ctx, Some((start, end))) {
+ Some(h) => {
+ self.music_handle = Some(h);
+ }
+ _ => {
+ log::warn!("failed to play music {}", name);
+ }
+ }
+ }
+ }
+
+ pub fn stop_music(&mut self) {
+ if let Some(h) = &mut self.music_handle {
+ h.stop(&self.ctx);
+ }
+ self.music_handle = None;
+ }
+}
+
+pub trait AudioPlayback {
+ fn play_sfx(&mut self, name: &str);
+ fn play_music(&mut self, name: &str, start: Option<f64>, end: Option<f64>);
+ fn stop_music(&mut self);
+}
+impl AudioPlayback for Option<Assets> {
+ fn play_sfx(&mut self, name: &str) {
+ if let Some(a) = self {
+ a.play_sfx(name);
+ }
+ }
+ fn play_music(&mut self, name: &str, start: Option<f64>, end: Option<f64>) {
+ if let Some(a) = self {
+ a.play_music(name, start, end);
+ }
+ }
+ fn stop_music(&mut self) {
+ if let Some(a) = self {
+ a.stop_music();
+ }
+ }
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/context.rs b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/context.rs new file mode 100644 index 0000000..34e0ad3 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/context.rs @@ -0,0 +1,302 @@ +use crate::Options;
+
+use glow::HasContext;
+
+#[cfg(not(target_arch = "wasm32"))]
+use glfw::Context as _;
+
+#[cfg(target_arch = "wasm32")]
+use wasm_bindgen::prelude::*;
+
+#[cfg(target_arch = "wasm32")]
+use winit::platform::web::WindowExtWebSys;
+
+#[cfg(target_arch = "wasm32")]
+#[wasm_bindgen(module = "/src/helpers.js")]
+extern {
+ fn js_track_resized_setup();
+ fn js_poll_resized() -> bool;
+ fn js_bundt_api_server() -> String;
+ fn js_bundt_secure_api_server() -> String;
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub struct Context {
+ pub render_width: f32,
+ pub render_height: f32,
+ pub options: Options,
+ pub glfw: std::cell::RefCell<glfw::Glfw>,
+ pub window: std::cell::RefCell<glfw::PWindow>,
+ pub gl: glow::Context,
+ pub emptyvao: glow::VertexArray,
+ pub start_instant: std::time::Instant,
+}
+
+
+#[cfg(target_arch = "wasm32")]
+pub struct Context {
+ pub render_width: f32,
+ pub render_height: f32,
+ pub options: Options,
+ pub window: winit::window::Window,
+ pub gl: glow::Context,
+ pub emptyvao: glow::VertexArray,
+ pub performance: web_sys::Performance,
+}
+
+impl Context {
+ pub fn compute_upscale(&self, windoww: u32, windowh: u32) -> u32 {
+ let mut ratio = 1;
+ loop {
+ if (self.render_width as u32) * ratio > windoww
+ || (self.render_height as u32) * ratio > windowh
+ {
+ break;
+ }
+ ratio += 1;
+ }
+ (ratio - 1).max(1)
+ }
+
+ #[cfg(not(target_arch = "wasm32"))]
+ pub fn new(glfw: std::cell::RefCell<glfw::Glfw>, window: std::cell::RefCell<glfw::PWindow>, gl: glow::Context, render_width: f32, render_height: f32, options: Options) -> Self {
+ let emptyvao = unsafe {
+ gl.create_vertex_array().expect("failed to initialize vao")
+ };
+ let ret = Self {
+ render_width, render_height,
+ options,
+ glfw, window,
+ gl,
+ emptyvao,
+ start_instant: std::time::Instant::now(),
+ };
+ ret.init();
+ ret
+ }
+
+ #[cfg(target_arch = "wasm32")]
+ pub fn new(window: winit::window::Window, gl: glow::Context, render_width: f32, render_height: f32, options: Options) -> Self {
+ let emptyvao = unsafe {
+ gl.create_vertex_array().expect("failed to initialize vao")
+ };
+
+ #[cfg(target_arch = "wasm32")]
+ js_track_resized_setup();
+
+ let ret = Self {
+ render_width, render_height,
+ options,
+ window,
+ gl,
+ emptyvao,
+
+ #[cfg(target_arch = "wasm32")]
+ performance: web_sys::window().expect("failed to find window")
+ .performance().expect("failed to get performance"),
+ };
+ ret.init();
+ ret
+ }
+
+ pub fn init(&self) {
+ unsafe {
+ self.gl.clear_color(0.1, 0.1, 0.1, 1.0);
+ self.gl.clear_depth_f32(1.0);
+
+ #[cfg(all(debug_assertions, not(target_arch = "wasm32")))]
+ self.gl.enable(glow::DEBUG_OUTPUT);
+
+ self.gl.enable(glow::DEPTH_TEST);
+ self.gl.depth_func(glow::LEQUAL);
+
+ self.gl.enable(glow::BLEND);
+ self.gl.blend_func(glow::SRC_ALPHA, glow::ONE_MINUS_SRC_ALPHA);
+
+ self.gl.enable(glow::STENCIL_TEST);
+
+ self.gl.cull_face(glow::FRONT);
+ }
+ }
+
+ #[cfg(target_arch = "wasm32")]
+ pub fn maximize_canvas(&self) {
+ if !self.options.contains(Options::NORESIZE) {
+ web_sys::window()
+ .and_then(|win| win.document())
+ .and_then(|doc| {
+ let inner_size = {
+ let browser_window = doc.default_view()
+ .or_else(web_sys::window)
+ .unwrap();
+ winit::dpi::PhysicalSize::new(
+ browser_window.inner_width().unwrap().as_f64().unwrap(),
+ browser_window.inner_height().unwrap().as_f64().unwrap(),
+ )
+ };
+ self.window.canvas().unwrap().set_width(inner_size.width as _);
+ self.window.canvas().unwrap().set_height(inner_size.height as _);
+ let _ = self.window.request_inner_size(inner_size);
+ Some(())
+ })
+ .expect("failed to resize canvas");
+ }
+ }
+
+ #[cfg(target_arch = "wasm32")]
+ pub fn resize_necessary(&self) -> bool { js_poll_resized() }
+ #[cfg(not(target_arch = "wasm32"))]
+ pub fn resize_necessary(&self) -> bool { false }
+
+ #[cfg(target_arch = "wasm32")]
+ pub fn bundt_api_server(&self) -> String { js_bundt_api_server() }
+ #[cfg(all(not(target_arch = "wasm32"), debug_assertions))]
+ pub fn bundt_api_server(&self) -> String { "http://localhost:8000/api".to_owned() }
+ #[cfg(all(not(target_arch = "wasm32"), not(debug_assertions)))]
+ pub fn bundt_api_server(&self) -> String { "https://api.colonq.computer/api".to_owned() }
+
+ #[cfg(target_arch = "wasm32")]
+ pub fn bundt_secure_api_server(&self) -> String { js_bundt_secure_api_server() }
+ #[cfg(all(not(target_arch = "wasm32"), debug_assertions))]
+ pub fn bundt_secure_api_server(&self) -> String { "http://localhost:8000/api".to_owned() }
+ #[cfg(all(not(target_arch = "wasm32"), not(debug_assertions)))]
+ pub fn bundt_secure_api_server(&self) -> String { "https://secure.colonq.computer/api".to_owned() }
+
+ pub fn clear_color(&self, color: glam::Vec4) {
+ unsafe {
+ self.gl.clear_color(color.x, color.y, color.z, color.w);
+ }
+ }
+
+ pub fn clear_depth(&self) {
+ unsafe {
+ self.gl.clear(glow::DEPTH_BUFFER_BIT);
+ }
+ }
+
+ pub fn clear(&self) {
+ unsafe {
+ self.gl.stencil_mask(0xff);
+ self.gl.clear(glow::COLOR_BUFFER_BIT | glow::DEPTH_BUFFER_BIT | glow::STENCIL_BUFFER_BIT);
+ }
+ }
+
+ pub fn depth_mask(&self, m: bool) {
+ unsafe {
+ self.gl.depth_mask(m);
+ }
+ }
+
+ pub fn begin_stencil(&self) {
+ unsafe {
+ self.gl.stencil_func(glow::ALWAYS, 1, 0xff);
+ self.gl.stencil_op(glow::KEEP, glow::KEEP, glow::REPLACE);
+ }
+ }
+
+ pub fn use_stencil(&self) {
+ unsafe {
+ self.gl.stencil_func(glow::EQUAL, 1, 0xff);
+ self.gl.stencil_op(glow::KEEP, glow::KEEP, glow::KEEP);
+ }
+ }
+
+ pub fn write_and_use_stencil(&self) {
+ unsafe {
+ self.gl.stencil_func(glow::EQUAL, 1, 0xff);
+ self.gl.stencil_op(glow::KEEP, glow::KEEP, glow::REPLACE);
+ }
+ }
+
+ pub fn use_inverse_stencil(&self) {
+ unsafe {
+ self.gl.stencil_func(glow::NOTEQUAL, 1, 0xff);
+ self.gl.stencil_op(glow::KEEP, glow::KEEP, glow::KEEP);
+ }
+ }
+
+ pub fn write_and_use_inverse_stencil(&self) {
+ unsafe {
+ self.gl.stencil_func(glow::NOTEQUAL, 1, 0xff);
+ self.gl.stencil_op(glow::KEEP, glow::KEEP, glow::REPLACE);
+ }
+ }
+
+ pub fn end_stencil(&self) {
+ unsafe {
+ self.gl.stencil_func(glow::ALWAYS, 1, 0xff);
+ self.gl.stencil_op(glow::KEEP, glow::KEEP, glow::KEEP);
+ }
+ }
+
+ pub fn render_no_geometry(&self) {
+ unsafe {
+ self.gl.bind_vertex_array(Some(self.emptyvao));
+ self.gl.draw_arrays(glow::TRIANGLE_STRIP, 0, 4);
+ }
+ }
+
+ pub fn reset_blend(&self) {
+ unsafe {
+ self.gl.blend_func(glow::SRC_ALPHA, glow::ONE_MINUS_SRC_ALPHA);
+ }
+ }
+
+ pub fn inverse_blend(&self) {
+ unsafe {
+ self.gl.blend_func(
+ glow::ONE_MINUS_DST_COLOR,
+ glow::ZERO,
+ );
+ }
+ }
+
+ pub fn flip_colors_blend(&self) {
+ unsafe {
+ self.gl.blend_func_separate(
+ glow::ONE_MINUS_DST_COLOR,
+ glow::ZERO,
+ glow::ZERO,
+ glow::ONE,
+ );
+ }
+ }
+
+ pub fn enable_culling(&self) {
+ unsafe {
+ self.gl.enable(glow::CULL_FACE);
+ }
+ }
+
+ pub fn disable_culling(&self) {
+ unsafe {
+ self.gl.disable(glow::CULL_FACE);
+ }
+ }
+
+ #[cfg(target_arch = "wasm32")]
+ pub fn lock_mouse(&self) {
+ let _ = self.window.set_cursor_grab(winit::window::CursorGrabMode::Locked);
+ self.window.set_cursor_visible(false);
+ }
+
+ #[cfg(not(target_arch = "wasm32"))]
+ pub fn lock_mouse(&self) {
+ unsafe {
+ glfw::ffi::glfwSetInputMode(
+ self.window.borrow_mut().window_ptr(),
+ glfw::ffi::CURSOR,
+ glfw::ffi::CURSOR_DISABLED,
+ );
+ }
+ }
+
+ pub fn check_error(&self) {
+ unsafe {
+ let err = self.gl.get_error();
+ if err != 0 {
+ log::warn!("gl error: {}", err);
+ }
+ }
+ }
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/font.rs b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/font.rs new file mode 100644 index 0000000..648bb47 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/font.rs @@ -0,0 +1,194 @@ +use crate::{context, mesh, state, texture};
+use glow::HasContext;
+
+pub struct BitmapParams<'color> {
+ pub color: &'color [glam::Vec3],
+ pub scale: glam::Vec2,
+ pub offset: glam::Vec2,
+}
+impl<'color> Default for BitmapParams<'color> {
+ fn default() -> Self {
+ Self {
+ color: &[],
+ scale: glam::Vec2::ONE,
+ offset: glam::Vec2::ZERO,
+ }
+ }
+}
+pub struct Bitmap {
+ pub char_width: i32,
+ pub char_height: i32,
+ pub font_width: i32,
+ pub font_height: i32,
+ pub font: texture::Texture,
+ pub vao: glow::VertexArray,
+ pub vertex_buf: glow::Buffer,
+ pub texcoords_buf: glow::Buffer,
+ pub colors_buf: glow::Buffer,
+ pub index_buf: glow::Buffer,
+}
+
+impl Bitmap {
+ pub fn from_image(
+ ctx: &context::Context,
+ char_width: i32, char_height: i32,
+ font_width: i32, font_height: i32,
+ data: &[u8],
+ ) -> Self {
+ let font = texture::Texture::new(ctx, data);
+ unsafe {
+ let vao = ctx.gl.create_vertex_array().expect("failed to initialize vao");
+ ctx.gl.bind_vertex_array(Some(vao));
+ let vertex_buf = ctx.gl.create_buffer().expect("failed to create buffer object");
+ ctx.gl.bind_buffer(glow::ARRAY_BUFFER, Some(vertex_buf));
+ ctx.gl.vertex_attrib_pointer_f32(mesh::ATTRIB_VERTEX, 2, glow::FLOAT, false, 0, 0);
+ ctx.gl.enable_vertex_attrib_array(mesh::ATTRIB_VERTEX);
+ let texcoords_buf = ctx.gl.create_buffer().expect("failed to create buffer object");
+ ctx.gl.bind_buffer(glow::ARRAY_BUFFER, Some(texcoords_buf));
+ ctx.gl.vertex_attrib_pointer_f32(mesh::ATTRIB_TEXCOORD, 2, glow::FLOAT, false, 0, 0);
+ ctx.gl.enable_vertex_attrib_array(mesh::ATTRIB_TEXCOORD);
+ let colors_buf = ctx.gl.create_buffer().expect("failed to create buffer object");
+ ctx.gl.bind_buffer(glow::ARRAY_BUFFER, Some(colors_buf));
+ ctx.gl.vertex_attrib_pointer_f32(mesh::ATTRIB_COLOR, 3, glow::FLOAT, false, 0, 0);
+ ctx.gl.enable_vertex_attrib_array(mesh::ATTRIB_COLOR);
+ let index_buf = ctx.gl.create_buffer().expect("failed to create buffer object");
+ ctx.gl.bind_buffer(glow::ELEMENT_ARRAY_BUFFER, Some(index_buf));
+ Self {
+ char_width, char_height,
+ font_width, font_height,
+ font,
+ vao,
+ vertex_buf,
+ texcoords_buf,
+ colors_buf,
+ index_buf,
+ }
+ }
+ }
+
+ pub fn default(ctx: &context::Context) -> Self {
+ Self::from_image(ctx, 7, 9, 112, 54, include_bytes!("assets/fonts/default.png"))
+ }
+
+ pub fn small(ctx: &context::Context) -> Self {
+ Self::from_image(ctx, 6, 7, 96, 42, include_bytes!("assets/fonts/small.png"))
+ }
+
+ pub fn render_text_parameterized(&self,
+ ctx: &context::Context, _st: &state::State,
+ text: &str,
+ params: BitmapParams,
+ ) {
+ let mut cur = params.offset;
+ let mut vertices = Vec::new();
+ let mut texcoords = Vec::new();
+ let mut colors = Vec::new();
+ let mut indices = Vec::new();
+ let cwidth = self.char_width as f32 / self.font_width as f32;
+ let cheight = self.char_height as f32 / self.font_height as f32;
+ let sdims = glam::Vec2::new(2.0, 2.0) * params.scale;
+ let row_len = self.font_width as u32 / self.char_width as u32;
+ for (i, c) in text.chars().enumerate() {
+ if c == '\n' {
+ cur.x = 0.0;
+ cur.y -= sdims.y;
+ } else {
+ let idx = vertices.len() as u32;
+ vertices.push(cur);
+ vertices.push(cur + glam::Vec2::new(sdims.x, 0.0));
+ vertices.push(cur + glam::Vec2::new(sdims.x, sdims.y));
+ vertices.push(cur + glam::Vec2::new(0.0, sdims.y));
+ let cidx = c as u32 - ' ' as u32;
+ let col = cidx % row_len;
+ let row = cidx / row_len;
+ let tcbase = glam::Vec2::new(col as f32 * cwidth, row as f32 * cheight);
+ texcoords.push(tcbase + glam::Vec2::new(0.0, cheight));
+ texcoords.push(tcbase + glam::Vec2::new(cwidth, cheight));
+ texcoords.push(tcbase + glam::Vec2::new(cwidth, 0.0));
+ texcoords.push(tcbase);
+ let c = if let Some(c) = params.color.get(if params.color.is_empty() { 0 } else { i % params.color.len() }) {
+ *c
+ } else {
+ glam::Vec3::new(1.0, 1.0, 1.0)
+ };
+ colors.push(c); colors.push(c); colors.push(c); colors.push(c);
+ indices.push(idx); indices.push(idx + 1); indices.push(idx + 2);
+ indices.push(idx); indices.push(idx + 3); indices.push(idx + 2);
+ cur.x += sdims.x;
+ }
+ }
+ let index_bytes: Vec<u8> = indices.iter().flat_map(|x| x.to_ne_bytes()).collect();
+ self.font.bind(ctx);
+ unsafe {
+ ctx.gl.bind_vertex_array(Some(self.vao));
+ ctx.gl.bind_buffer(glow::ARRAY_BUFFER, Some(self.vertex_buf));
+ ctx.gl.buffer_data_u8_slice(
+ glow::ARRAY_BUFFER,
+ std::slice::from_raw_parts(
+ vertices.as_ptr() as _,
+ vertices.len() * std::mem::size_of::<f32>() * 2,
+ ),
+ glow::STATIC_DRAW,
+ );
+ ctx.gl.bind_buffer(glow::ARRAY_BUFFER, Some(self.texcoords_buf));
+ ctx.gl.buffer_data_u8_slice(
+ glow::ARRAY_BUFFER,
+ std::slice::from_raw_parts(
+ texcoords.as_ptr() as _,
+ texcoords.len() * std::mem::size_of::<f32>() * 2,
+ ),
+ glow::STATIC_DRAW,
+ );
+ ctx.gl.bind_buffer(glow::ARRAY_BUFFER, Some(self.colors_buf));
+ ctx.gl.buffer_data_u8_slice(
+ glow::ARRAY_BUFFER,
+ std::slice::from_raw_parts(
+ colors.as_ptr() as _,
+ colors.len() * std::mem::size_of::<f32>() * 3,
+ ),
+ glow::STATIC_DRAW,
+ );
+ ctx.gl.bind_buffer(glow::ELEMENT_ARRAY_BUFFER, Some(self.index_buf));
+ ctx.gl.buffer_data_u8_slice(
+ glow::ELEMENT_ARRAY_BUFFER,
+ &index_bytes,
+ glow::STATIC_DRAW,
+ );
+ ctx.gl.draw_elements(glow::TRIANGLES, indices.len() as _, glow::UNSIGNED_INT, 0);
+ }
+ }
+
+ pub fn render_text_helper(&self,
+ ctx: &context::Context, st: &state::State,
+ text: &str, color: &[glam::Vec3]
+ ) {
+ self.render_text_parameterized(
+ ctx, st,
+ text,
+ BitmapParams {
+ color,
+ scale: glam::Vec2::ONE,
+ offset: glam::Vec2::ZERO,
+ }
+ )
+ }
+
+ pub fn render_text(&self,
+ ctx: &context::Context, st: &state::State,
+ text: &str
+ ) {
+ self.render_text_helper(ctx, st, text, &[]);
+ }
+
+ pub fn render_text_at(&self,
+ ctx: &context::Context, st: &mut state::State,
+ pos: glam::Vec2, text: &str,
+ params: BitmapParams,
+ ) {
+ st.bind_2d(ctx, &st.shader_text_bitmap);
+ let dims = glam::Vec2::new(self.char_width as f32, self.char_height as f32);
+ let fpos = pos + glam::Vec2::new(-dims.x / 2.0, dims.y / 2.0);
+ st.shader_text_bitmap.set_position_text_bitmap(ctx, st, self, &fpos);
+ self.render_text_parameterized(ctx, st, text, params);
+ }
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/framebuffer.rs b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/framebuffer.rs new file mode 100644 index 0000000..606fd6a --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/framebuffer.rs @@ -0,0 +1,158 @@ +use glow::HasContext;
+
+use crate::context;
+
+#[cfg(target_arch = "wasm32")]
+use crate::Options;
+
+pub struct Framebuffer {
+ pub tex: Option<glow::Texture>,
+ pub fbo: Option<glow::Framebuffer>,
+ pub dims: glam::Vec2,
+ pub offsets: glam::Vec2,
+}
+
+impl Framebuffer {
+ pub fn screen(ctx: &context::Context) -> Self {
+ #[cfg(target_arch = "wasm32")]
+ let (windoww, windowh): (f32, f32) = if !ctx.options.contains(Options::NORESIZE) {
+ ctx.window.inner_size().into()
+ } else {
+ (ctx.render_width, ctx.render_height)
+ };
+ #[cfg(not(target_arch = "wasm32"))]
+ let (windoww, windowh) = {
+ let (w, h) = ctx.window.borrow().get_size();
+ (w as f32, h as f32)
+ };
+ let ratio = ctx.compute_upscale(windoww as _, windowh as _) as f32;
+ let upscalew = ctx.render_width * ratio;
+ let upscaleh = ctx.render_height * ratio;
+ let offsetx = (windoww - upscalew) / 2.0;
+ let offsety = (windowh - upscaleh) / 2.0;
+ log::info!("resize window: {:?}, upscale: {:?}, offset: {:?}", (windoww, windowh), (upscalew, upscaleh), (offsetx, offsety));
+ Self {
+ tex: None,
+ fbo: None,
+ dims: glam::Vec2::new(upscalew, upscaleh),
+ offsets: glam::Vec2::new(offsetx, offsety),
+ }
+ }
+
+ pub fn new(ctx: &context::Context, dims: &glam::Vec2, offsets: &glam::Vec2) -> Self {
+ unsafe {
+ let fbo = ctx.gl.create_framebuffer()
+ .expect("failed to create framebuffer");
+ ctx.gl.bind_framebuffer(glow::FRAMEBUFFER, Some(fbo));
+
+ let depth_buffer = ctx.gl.create_renderbuffer()
+ .expect("failed to create depth buffer");
+ ctx.gl.bind_renderbuffer(glow::RENDERBUFFER, Some(depth_buffer));
+ ctx.gl.renderbuffer_storage(glow::RENDERBUFFER, glow::DEPTH_COMPONENT32F, dims.x as _, dims.y as _);
+ ctx.gl.framebuffer_renderbuffer(glow::FRAMEBUFFER, glow::DEPTH_ATTACHMENT, glow::RENDERBUFFER, Some(depth_buffer));
+
+ let stencil_buffer = ctx.gl.create_renderbuffer()
+ .expect("failed to create stencil buffer");
+ ctx.gl.bind_renderbuffer(glow::RENDERBUFFER, Some(stencil_buffer));
+ ctx.gl.renderbuffer_storage(glow::RENDERBUFFER, glow::DEPTH_STENCIL, dims.x as _, dims.y as _);
+ ctx.gl.framebuffer_renderbuffer(glow::FRAMEBUFFER, glow::DEPTH_STENCIL_ATTACHMENT, glow::RENDERBUFFER, Some(stencil_buffer));
+
+ let tex = ctx.gl.create_texture()
+ .expect("failed to create framebuffer texture");
+ ctx.gl.bind_texture(glow::TEXTURE_2D, Some(tex));
+ ctx.gl.tex_image_2d(
+ glow::TEXTURE_2D,
+ 0,
+ glow::RGBA as _,
+ dims.x as _,
+ dims.y as _,
+ 0,
+ glow::RGBA,
+ glow::UNSIGNED_BYTE,
+ None,
+ );
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_WRAP_S, glow::CLAMP_TO_EDGE as _);
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_WRAP_T, glow::CLAMP_TO_EDGE as _);
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_MIN_FILTER, glow::NEAREST as _);
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_MAG_FILTER, glow::NEAREST as _);
+ ctx.gl.framebuffer_texture_2d(glow::FRAMEBUFFER, glow::COLOR_ATTACHMENT0, glow::TEXTURE_2D, Some(tex), 0);
+ ctx.gl.draw_buffer(glow::COLOR_ATTACHMENT0);
+
+ let status = ctx.gl.check_framebuffer_status(glow::FRAMEBUFFER);
+ if status != glow::FRAMEBUFFER_COMPLETE {
+ panic!("error initializing framebuffer:\n{}", status);
+ }
+
+ Self {
+ tex: Some(tex),
+ fbo: Some(fbo),
+ dims: *dims,
+ offsets: *offsets,
+ }
+ }
+ }
+
+ pub fn bind_texture(&self, ctx: &context::Context) {
+ unsafe {
+ ctx.gl.active_texture(glow::TEXTURE0);
+ ctx.gl.bind_texture(glow::TEXTURE_2D, self.tex);
+ }
+ }
+
+ pub fn bind(&self, ctx: &context::Context) {
+ unsafe {
+ ctx.gl.bind_framebuffer(glow::FRAMEBUFFER, self.fbo);
+ ctx.gl.viewport(
+ self.offsets.x as _,
+ self.offsets.y as _,
+ self.dims.x as _,
+ self.dims.y as _,
+ );
+ }
+ }
+
+ pub fn blit(&self, ctx: &context::Context, dest: &Self, pos: &glam::Vec2, scale: &glam::Vec2) {
+ unsafe {
+ ctx.gl.bind_framebuffer(glow::READ_FRAMEBUFFER, self.fbo);
+ ctx.gl.bind_framebuffer(glow::DRAW_FRAMEBUFFER, dest.fbo);
+ ctx.gl.blit_framebuffer(
+ 0, 0, self.dims.x as _, self.dims.y as _,
+ pos.x as _, pos.y as _, (pos.x + scale.x) as _, (pos.y + scale.y) as _,
+ glow::COLOR_BUFFER_BIT, glow::NEAREST
+ );
+ }
+ }
+
+ pub fn get_pixels(&self, ctx: &context::Context, buf: &mut [glam::Vec3]) {
+ let w = self.dims.x as usize;
+ let h = self.dims.y as usize;
+ let tmp = vec![glam::Vec3::default(); w * h];
+ unsafe {
+ ctx.gl.bind_texture(glow::TEXTURE_2D, self.tex);
+ ctx.gl.get_tex_image(
+ glow::TEXTURE_2D, 0, glow::RGB, glow::FLOAT,
+ glow::PixelPackData::Slice(
+ std::slice::from_raw_parts_mut(
+ tmp.as_ptr() as *mut u8,
+ tmp.len() * std::mem::size_of::<glam::Vec3>()
+ )
+ ),
+ );
+ }
+ for y in 0..h {
+ for x in 0..w {
+ buf[x + (h - 1 - y) * w] = tmp[x + y * w];
+ }
+ }
+ }
+
+ pub fn get_pixels_raw(&self, ctx: &context::Context, buf: &mut [u8]) {
+ unsafe {
+ ctx.gl.bind_texture(glow::TEXTURE_2D, self.tex);
+ ctx.gl.get_tex_image(
+ glow::TEXTURE_2D, 0, glow::RGBA, glow::UNSIGNED_BYTE,
+ glow::PixelPackData::Slice(buf),
+ );
+ }
+ }
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/helpers.js b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/helpers.js new file mode 100644 index 0000000..d1b74b6 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/helpers.js @@ -0,0 +1,21 @@ +let resized = false;
+
+export async function js_track_resized_setup() {
+ window.addEventListener("resize", () => {
+ resized = true;
+ });
+}
+
+export function js_poll_resized() {
+ let ret = resized;
+ resized = false;
+ return ret;
+}
+
+export function js_bundt_api_server() {
+ return globalThis.apiServer || "http://localhost:8000/api";
+}
+
+export function js_bundt_secure_api_server() {
+ return globalThis.secureApiServer || "http://localhost:8000/api";
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/js/module.js b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/js/module.js new file mode 100644 index 0000000..03d0047 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/js/module.js @@ -0,0 +1,7 @@ +export function js_build_interface() {
+ return {
+ env: {
+ log_info: window.wasmBindings.log_info,
+ },
+ };
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/level2d.rs b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/level2d.rs new file mode 100644 index 0000000..b64213a --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/level2d.rs @@ -0,0 +1 @@ +pub mod tiled;
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/level2d/tiled.rs b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/level2d/tiled.rs new file mode 100644 index 0000000..2e8141e --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/level2d/tiled.rs @@ -0,0 +1,301 @@ +#![allow(dead_code)]
+
+use std::collections::HashMap;
+use serde::Deserialize;
+use glow::HasContext;
+
+use crate::{context, erm, mesh, shader, texture, Erm};
+
+#[derive(Debug)]
+pub enum Err {
+ LayerIndexOutOfBounds,
+ LayerDataTooSmall,
+ GIDNotFound(u32),
+ AssetNotFound(String),
+ GL(String),
+}
+impl std::error::Error for Err {}
+impl std::fmt::Display for Err {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ match self {
+ Self::LayerIndexOutOfBounds => write!(f, "layer index out of bounds"),
+ Self::LayerDataTooSmall => write!(f, "layer data too small for dimensions"),
+ Self::GIDNotFound(gid) => write!(f, "GID not found: {}", gid),
+ Self::AssetNotFound(ass) => write!(f, "asset not found: {}", ass),
+ Self::GL(msg) => write!(f, "GL error: {msg:}"),
+ }
+ }
+}
+
+#[derive(Debug, Deserialize)]
+pub enum LayerType {
+ #[serde(rename = "tilelayer")]
+ Tile,
+ #[serde(rename = "imagelayer")]
+ Image,
+ #[serde(rename = "objectgroup")]
+ ObjectGroup,
+ #[serde(rename = "group")]
+ Group,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct Layer {
+ name: String,
+ id: i32,
+ #[serde(rename = "type")] ty: LayerType,
+ width: i32, height: i32,
+ x: i32, y: i32,
+ opacity: f32,
+ visible: bool,
+ data: Vec<u32>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct LevelTileset {
+ firstgid: i32,
+ source: String,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct Level {
+ width: i32, height: i32,
+ tilewidth: i32, tileheight: i32,
+ layers: Vec<Layer>,
+ tilesets: Vec<LevelTileset>,
+}
+impl Level {
+ pub fn new(bytes: &str) -> Erm<Self> {
+ Ok(serde_json::from_str(bytes)?)
+ }
+}
+
+#[derive(Debug, Deserialize)]
+pub struct Tileset {
+ name: String,
+ imagewidth: i32, imageheight: i32,
+ tilewidth: i32, tileheight: i32,
+ margin: i32, spacing: i32,
+}
+impl Tileset {
+ pub fn new(bytes: &str) -> Erm<Self> {
+ Ok(serde_json::from_str(bytes)?)
+ }
+}
+
+// TODO
+pub enum Flip {
+ None,
+}
+
+pub struct Asset {
+ tileset: Tileset,
+ texture: texture::Texture,
+}
+#[derive(Default)]
+pub struct Assets {
+ entries: HashMap<String, Asset>,
+}
+impl Assets {
+ pub fn new() -> Self { Self::default() }
+ pub fn load(&mut self, ctx: &context::Context, nm: &str, ts: &str, img: &[u8]) -> Erm<()> {
+ let ass = Asset {
+ tileset: Tileset::new(ts)?,
+ texture: texture::Texture::new(ctx, img),
+ };
+ if self.entries.insert(nm.to_string(), ass).is_some() {
+ log::warn!("duplicate tileset entry named: {}", nm);
+ }
+ Ok(())
+ }
+ pub fn lookup_gid(&self, level: &Level, gid: u32) -> Erm<(i32, &Asset, Flip)> {
+ let offset = (gid & 0x0fffffff) as i32;
+ for lts in level.tilesets.iter().rev() {
+ if lts.firstgid <= offset {
+ return Ok((
+ offset - lts.firstgid,
+ self.entries.get(<s.source).ok_or(Err::AssetNotFound(lts.source.clone()))?,
+ Flip::None
+ ))
+ }
+ }
+ erm(Err::GIDNotFound(gid))
+ }
+}
+
+pub struct LayerRenderer {
+ pub vao: glow::VertexArray,
+ pub vertex_buf: glow::Buffer,
+ pub texcoords_buf: glow::Buffer,
+ pub index_buf: glow::Buffer,
+ pub index_count: usize,
+}
+impl LayerRenderer {
+ pub fn new(ctx: &context::Context) -> Erm<Self> {
+ unsafe {
+ let vao = ctx.gl.create_vertex_array().map_err(Err::GL)?;
+ ctx.gl.bind_vertex_array(Some(vao));
+ let vertex_buf = ctx.gl.create_buffer().map_err(Err::GL)?;
+ ctx.gl.bind_buffer(glow::ARRAY_BUFFER, Some(vertex_buf));
+ ctx.gl.vertex_attrib_pointer_f32(mesh::ATTRIB_VERTEX, 2, glow::FLOAT, false, 0, 0);
+ ctx.gl.enable_vertex_attrib_array(mesh::ATTRIB_VERTEX);
+ let texcoords_buf = ctx.gl.create_buffer().map_err(Err::GL)?;
+ ctx.gl.bind_buffer(glow::ARRAY_BUFFER, Some(texcoords_buf));
+ ctx.gl.vertex_attrib_pointer_f32(mesh::ATTRIB_TEXCOORD, 2, glow::FLOAT, false, 0, 0);
+ ctx.gl.enable_vertex_attrib_array(mesh::ATTRIB_TEXCOORD);
+ let index_buf = ctx.gl.create_buffer().map_err(Err::GL)?;
+ ctx.gl.bind_buffer(glow::ELEMENT_ARRAY_BUFFER, Some(index_buf));
+ Ok(Self {
+ vao,
+ vertex_buf,
+ texcoords_buf,
+ index_buf,
+ index_count: 0,
+ })
+ }
+ }
+}
+pub struct LevelRenderer {
+ pub layers: Vec<LayerRenderer>,
+ pub shader: shader::Shader,
+}
+impl LevelRenderer {
+ pub fn new(ctx: &context::Context, level: &Level) -> Erm<Self> {
+ let mut layers = Vec::new();
+ for _ in level.layers.iter() {
+ layers.push(LayerRenderer::new(ctx)?);
+ }
+ let shader = shader::Shader::new_nolib(
+ ctx,
+ include_str!("../assets/shaders/tiled/vert.glsl"),
+ include_str!("../assets/shaders/tiled/frag.glsl"),
+ );
+ Ok(Self {
+ layers,
+ shader,
+ })
+ }
+ pub fn populate_layer(
+ &mut self,
+ ctx: &context::Context,
+ assets: &Assets,
+ level: &Level,
+ lidx: usize
+ ) -> Erm<()> {
+ let lr = self.layers.get_mut(lidx).ok_or(Err::LayerIndexOutOfBounds)?;
+ let layer = level.layers.get(lidx).ok_or(Err::LayerIndexOutOfBounds)?;
+ let mut vertices = Vec::new();
+ let mut texcoords = Vec::new();
+ let mut indices = Vec::new();
+ for y in 0..layer.height {
+ for x in 0..layer.width {
+ let idx = x as usize + (y * layer.width) as usize;
+ let gid = *layer.data.get(idx).ok_or(Err::LayerDataTooSmall)?;
+ if gid == 0 { continue; }
+ let (lid, ass, _) = assets.lookup_gid(level, gid)?;
+ let cols = ass.tileset.imagewidth / ass.tileset.tilewidth;
+ let rows = ass.tileset.imageheight / ass.tileset.tileheight;
+ let col = lid % cols;
+ let row = lid / cols;
+ let twidth = 1.0 / cols as f32;
+ let theight = 1.0 / rows as f32;
+
+ let i = vertices.len() as u32;
+ let v = glam::Vec2::new(x as _, y as _);
+ vertices.push(v);
+ vertices.push(v + glam::Vec2::new(1.0, 0.0));
+ vertices.push(v + glam::Vec2::new(1.0, 1.0));
+ vertices.push(v + glam::Vec2::new(0.0, 1.0));
+ let uvbase = glam::Vec2::new(col as f32 / cols as f32, row as f32 / rows as f32);
+ texcoords.push(uvbase + glam::Vec2::new(0.0, theight));
+ texcoords.push(uvbase + glam::Vec2::new(twidth, theight));
+ texcoords.push(uvbase + glam::Vec2::new(twidth, 0.0));
+ texcoords.push(uvbase);
+ indices.push(i); indices.push(i + 1); indices.push(i + 2);
+ indices.push(i); indices.push(i + 3); indices.push(i + 2);
+ }
+ }
+ let index_bytes: Vec<u8> = indices.iter().flat_map(|x| x.to_ne_bytes()).collect();
+ unsafe {
+ ctx.gl.bind_vertex_array(Some(lr.vao));
+ ctx.gl.bind_buffer(glow::ARRAY_BUFFER, Some(lr.vertex_buf));
+ ctx.gl.buffer_data_u8_slice(
+ glow::ARRAY_BUFFER,
+ std::slice::from_raw_parts(
+ vertices.as_ptr() as _,
+ vertices.len() * std::mem::size_of::<f32>() * 2,
+ ),
+ glow::STATIC_DRAW,
+ );
+ ctx.gl.bind_buffer(glow::ARRAY_BUFFER, Some(lr.texcoords_buf));
+ ctx.gl.buffer_data_u8_slice(
+ glow::ARRAY_BUFFER,
+ std::slice::from_raw_parts(
+ texcoords.as_ptr() as _,
+ texcoords.len() * std::mem::size_of::<f32>() * 2,
+ ),
+ glow::STATIC_DRAW,
+ );
+ ctx.gl.bind_buffer(glow::ELEMENT_ARRAY_BUFFER, Some(lr.index_buf));
+ ctx.gl.buffer_data_u8_slice(
+ glow::ELEMENT_ARRAY_BUFFER,
+ &index_bytes,
+ glow::STATIC_DRAW,
+ );
+ lr.index_count = indices.len();
+ }
+ Ok(())
+ }
+ pub fn render_layer(
+ &self,
+ ctx: &context::Context,
+ assets: &Assets,
+ level: &Level,
+ lidx: usize,
+ ) -> Erm<()> {
+ let layer = level.layers.get(lidx).ok_or(Err::LayerIndexOutOfBounds)?;
+ let lr = self.layers.get(lidx).ok_or(Err::LayerIndexOutOfBounds)?;
+ // TODO: handle layers with multiple textures
+ let gid = *layer.data.iter().find(|g| **g > 0).unwrap();
+ let (_, ass, _) = assets.lookup_gid(level, gid)?;
+ ass.texture.bind(ctx);
+ unsafe {
+ ctx.gl.bind_vertex_array(Some(lr.vao));
+ ctx.gl.draw_elements(glow::TRIANGLES, lr.index_count as _, glow::UNSIGNED_INT, 0);
+ }
+ Ok(())
+ }
+ pub fn populate(
+ &mut self,
+ ctx: &context::Context,
+ assets: &Assets,
+ level: &Level,
+ ) -> Erm<()> {
+ for lidx in 0..level.layers.len() {
+ self.populate_layer(ctx, assets, level, lidx)?;
+ }
+ Ok(())
+ }
+ pub fn render(
+ &self,
+ ctx: &context::Context,
+ assets: &Assets,
+ level: &Level,
+ ) -> Erm<()> {
+ self.shader.bind(ctx);
+ let sx = 2.0 * level.tilewidth as f32 / ctx.render_width;
+ let sy = 2.0 * level.tileheight as f32 / ctx.render_height;
+ self.shader.set_mat4(
+ ctx, "transform",
+ &glam::Mat4::from_scale_rotation_translation(
+ glam::Vec3::new(sx, -sy, 1.0),
+ glam::Quat::IDENTITY,
+ glam::Vec3::new(0.0, 0.0, 0.0),
+ ),
+ );
+ for lidx in 0..level.layers.len() {
+ self.render_layer(ctx, assets, level, lidx)?;
+ }
+ Ok(())
+ }
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/lib.rs b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/lib.rs new file mode 100644 index 0000000..6b1564e --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/lib.rs @@ -0,0 +1,355 @@ +#![feature(try_blocks)]
+
+pub mod audio;
+pub mod context;
+pub mod font;
+pub mod framebuffer;
+pub mod level2d;
+pub mod mesh;
+pub mod net;
+pub mod physics;
+pub mod renderer;
+pub mod save;
+pub mod scene;
+pub mod shader;
+pub mod shadow;
+pub mod state;
+pub mod texture;
+pub mod ui;
+pub mod utils;
+
+pub use audio::AudioPlayback;
+pub use simple_eyre::eyre::WrapErr;
+pub use state::Tick;
+pub use utils::{Erm, erm, install_error_handler};
+
+#[cfg(target_arch = "wasm32")]
+use winit::platform::web::EventLoopExtWebSys;
+
+#[cfg(target_arch = "wasm32")]
+use winit::platform::web::WindowExtWebSys;
+
+#[cfg(target_arch = "wasm32")]
+use wasm_bindgen::JsCast;
+
+#[cfg(not(target_arch = "wasm32"))]
+use glfw::Context;
+
+use bitflags::bitflags;
+bitflags! {
+ pub struct Options: u32 {
+ const OVERLAY = 0b00000001;
+ const HIDDEN = 0b00000010;
+ const NORESIZE = 0b00000100;
+ const EGL = 0b00001000;
+ const FULLSCREEN_MOUSE = 0b00010000;
+ }
+}
+
+static mut CTX: Option<*const context::Context> = None;
+static mut ST: Option<*mut state::State> = None;
+static mut G: Option<*mut std::ffi::c_void> = None;
+
+pub fn contextualize<F, G, X>(mut f: F) -> X
+where
+ G: state::Game + 'static,
+ F: FnMut(&context::Context, &mut state::State, &mut G) -> X,
+{
+ unsafe {
+ match (CTX, ST, G) {
+ (Some(c), Some(s), Some(g)) => f(&*c, &mut *s, &mut *(g as *mut G)),
+ _ => panic!("context not set"),
+ }
+ }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub fn run<'a, F, G>(title: &str, w: u32, h: u32, options: Options, gnew: F) -> Erm<()>
+where
+ G: state::Game + 'static,
+ F: (FnOnce(&'a context::Context) -> G),
+{
+ env_logger::Builder::new()
+ .filter(None, log::LevelFilter::Info)
+ .init();
+ install_error_handler();
+
+ log::info!("hello computer, starting up...");
+
+ let (rglfw, rwindow, gl, events) = {
+ use glfw::fail_on_errors;
+ let mut glfw = glfw::init(glfw::fail_on_errors!()).expect("failed to initialize GLFW");
+
+ if options.contains(Options::EGL) {
+ glfw.window_hint(glfw::WindowHint::ContextCreationApi(
+ glfw::ContextCreationApi::Egl,
+ ));
+ }
+ // let gl_attr = video.gl_attr();
+ // gl_attr.set_context_profile(sdl2::video::GLProfile::Core);
+ // gl_attr.set_context_version(3, 0);
+ let (mut window, events) = glfw.with_primary_monitor(|glfw, primary| {
+ if options.contains(Options::HIDDEN) {
+ glfw.window_hint(glfw::WindowHint::Visible(false));
+ glfw.create_window(w as _, h as _, title, glfw::WindowMode::Windowed)
+ .expect("failed to create window")
+ } else if options.contains(Options::OVERLAY) {
+ let mon = primary.expect("failed to get monitor");
+ let mode = mon.get_video_mode().expect("failed to get video mode");
+ glfw.window_hint(glfw::WindowHint::RedBits(Some(mode.red_bits)));
+ glfw.window_hint(glfw::WindowHint::GreenBits(Some(mode.green_bits)));
+ glfw.window_hint(glfw::WindowHint::BlueBits(Some(mode.blue_bits)));
+ glfw.window_hint(glfw::WindowHint::RefreshRate(Some(mode.refresh_rate)));
+ glfw.window_hint(glfw::WindowHint::Resizable(false));
+ glfw.window_hint(glfw::WindowHint::Decorated(false));
+ glfw.window_hint(glfw::WindowHint::Floating(true));
+ glfw.window_hint(glfw::WindowHint::TransparentFramebuffer(true));
+ unsafe {
+ // glfw.window_hint(glfw::WindowHint::MousePassthrough(true));
+ glfw::ffi::glfwWindowHint(0x0002000D, 1); // mouse passthrough
+ }
+ glfw.create_window(
+ mode.width,
+ mode.height,
+ title,
+ glfw::WindowMode::FullScreen(mon),
+ )
+ .expect("failed to create window")
+ } else {
+ glfw.create_window(w as _, h as _, title, glfw::WindowMode::Windowed)
+ .expect("failed to create window")
+ }
+ });
+ window.make_current();
+ window.set_key_polling(true);
+ window.set_mouse_button_polling(true);
+ window.set_size_polling(true);
+ window.set_focus_polling(true);
+ window.set_cursor_pos_polling(true);
+ let gl = unsafe {
+ glow::Context::from_loader_function(|s| window.get_proc_address(s) as *const _)
+ };
+ glfw.set_swap_interval(glfw::SwapInterval::Sync(1));
+ (glfw, window, gl, events)
+ };
+ let glfw = std::cell::RefCell::new(rglfw);
+ let window = std::cell::RefCell::new(rwindow);
+
+ let ctx = Box::leak(Box::new(context::Context::new(
+ glfw, window, gl, w as f32, h as f32, options,
+ )));
+ let game = Box::leak(Box::new(gnew(ctx)));
+ let st = Box::leak(Box::new(state::State::new(ctx)));
+
+ unsafe {
+ CTX = Some(ctx as _);
+ ST = Some(st as _);
+ G = Some(game as *mut G as *mut std::ffi::c_void);
+ }
+
+ game.initialize(ctx, st)?;
+ st.initialize_audio(ctx, game)?;
+ 'running: loop {
+ if ctx.window.borrow().should_close() {
+ game.finalize(ctx, st)?;
+ log::info!("bye!");
+ break 'running;
+ }
+ ctx.glfw.borrow_mut().poll_events();
+ for (_, event) in glfw::flush_messages(&events) {
+ match event {
+ glfw::WindowEvent::Size(_, _) => st.handle_resize(ctx),
+ glfw::WindowEvent::Focus(false) => {
+ st.keys = state::Keys::new();
+ }
+ glfw::WindowEvent::CursorPos(x, y) => {
+ st.mouse_moved(ctx, x as f32, y as f32, game)?;
+ }
+ glfw::WindowEvent::MouseButton(_, glfw::Action::Press, _) => {
+ st.mouse_pressed(ctx, game)?;
+ }
+ glfw::WindowEvent::MouseButton(_, glfw::Action::Release, _) => {
+ st.mouse_released(ctx, game)?;
+ }
+ glfw::WindowEvent::Key(key, _, glfw::Action::Press, _) => {
+ st.key_pressed(ctx, game, state::Keycode::new(key))?;
+ }
+ glfw::WindowEvent::Key(key, _, glfw::Action::Release, _) => {
+ st.key_released(ctx, game, state::Keycode::new(key))?;
+ }
+ _ => {}
+ }
+ }
+ if ctx.resize_necessary() {
+ st.handle_resize(ctx);
+ }
+ // if let Some(f) = &mut st.request {
+ // match std::future::Future::poll(f.as_mut(), &mut st.waker_ctx) {
+ // std::task::Poll::Pending => {},
+ // std::task::Poll::Ready(res) => {
+ // st.request = None;
+ // match res {
+ // Ok(r) => st.request_returned(&ctx, game, r),
+ // Err(e) => log::warn!("error during HTTP request: {}", e),
+ // }
+ // },
+ // }
+ // }
+ st.run_update(ctx, game)?;
+ st.run_render(ctx, game)?;
+ ctx.window.borrow_mut().swap_buffers();
+ }
+ Ok(())
+}
+
+#[cfg(target_arch = "wasm32")]
+pub fn run<'a, F, G>(w: u32, h: u32, options: Options, gnew: F)
+where
+ G: state::Game + 'static,
+ F: (Fn(&'a context::Context) -> G),
+{
+ console_log::init_with_level(log::Level::Debug).unwrap();
+ console_error_panic_hook::set_once();
+ tracing_wasm::set_as_global_default();
+ // install_error_handler();
+
+ log::info!("hello computer, starting up...");
+
+ let event_loop = winit::event_loop::EventLoop::new().expect("failed to initialize event loop");
+
+ let resize = !options.contains(Options::NORESIZE);
+ let (window, gl) = {
+ let mut builder = winit::window::WindowBuilder::new()
+ .with_maximized(resize)
+ .with_decorations(false);
+ if options.contains(Options::OVERLAY) {
+ builder = builder.with_transparent(true);
+ }
+ let window = builder
+ .build(&event_loop)
+ .expect("failed to initialize window");
+ let gl = web_sys::window()
+ .and_then(|win| win.document())
+ .and_then(|doc| {
+ let dst = doc.get_element_by_id("teleia-parent")?;
+ let canvas =
+ web_sys::Element::from(window.canvas().expect("failed to find canvas"));
+ dst.append_child(&canvas).ok()?;
+ let c = canvas.dyn_into::<web_sys::HtmlCanvasElement>().ok()?;
+ let webgl2_context = c
+ .get_context("webgl2")
+ .ok()??
+ .dyn_into::<web_sys::WebGl2RenderingContext>()
+ .ok()?;
+ Some(glow::Context::from_webgl2_context(webgl2_context))
+ })
+ .expect("couldn't add canvas to document");
+ (window, gl)
+ };
+
+ let ctx = Box::leak(Box::new(context::Context::new(
+ window, gl, w as f32, h as f32, options,
+ )));
+ ctx.maximize_canvas();
+ let game = Box::leak(Box::new(gnew(ctx)));
+ let st = Box::leak(Box::new(state::State::new(&ctx)));
+
+ unsafe {
+ CTX = Some(ctx as _);
+ ST = Some(st as _);
+ G = Some(game as *mut G as *mut std::ffi::c_void);
+ }
+
+ let _ = game.initialize(ctx, st);
+ let _ = st.initialize_audio(ctx, game);
+ let res = std::rc::Rc::new(std::cell::RefCell::new(Ok(())));
+ let result = res.clone();
+ event_loop.set_control_flow(winit::event_loop::ControlFlow::Wait);
+ event_loop.spawn(move |event, elwt| {
+ let res: Erm<()> = contextualize(|ctx, st, game: &mut G| {
+ match &event {
+ winit::event::Event::WindowEvent {
+ event: wev,
+ window_id,
+ ..
+ } => match wev {
+ winit::event::WindowEvent::CloseRequested if *window_id == ctx.window.id() => {
+ elwt.exit()
+ }
+ winit::event::WindowEvent::Resized { .. } => {
+ #[cfg(target_arch = "wasm32")]
+ ctx.maximize_canvas();
+ st.handle_resize(&ctx);
+ }
+ winit::event::WindowEvent::Focused(false) => {
+ st.keys = state::Keys::new();
+ }
+ winit::event::WindowEvent::CursorMoved { position, .. } => {
+ st.mouse_moved(&ctx, position.x as f32, position.y as f32, game)?;
+ }
+ winit::event::WindowEvent::MouseInput { state, .. } => match state {
+ winit::event::ElementState::Pressed => {
+ st.mouse_pressed(&ctx, game)?;
+ }
+ winit::event::ElementState::Released => {
+ st.mouse_released(&ctx, game)?;
+ }
+ },
+ winit::event::WindowEvent::KeyboardInput {
+ event:
+ winit::event::KeyEvent {
+ physical_key: winit::keyboard::PhysicalKey::Code(key),
+ state,
+ repeat: false,
+ ..
+ },
+ ..
+ } => match state {
+ winit::event::ElementState::Pressed => {
+ st.key_pressed(&ctx, game, state::Keycode { kc: *key })?;
+ }
+ winit::event::ElementState::Released => {
+ st.key_released(&ctx, game, state::Keycode { kc: *key })?;
+ }
+ },
+ _ => {}
+ },
+
+ winit::event::Event::AboutToWait => {
+ if ctx.resize_necessary() {
+ #[cfg(target_arch = "wasm32")]
+ ctx.maximize_canvas();
+ st.handle_resize(&ctx);
+ }
+ // if let Some(f) = &mut st.request {
+ // match std::future::Future::poll(f.as_mut(), &mut st.waker_ctx) {
+ // std::task::Poll::Pending => {},
+ // std::task::Poll::Ready(res) => {
+ // st.request = None;
+ // match res {
+ // Ok(r) => st.request_returned(&ctx, game, r),
+ // Err(e) => log::warn!("error during HTTP request: {}", e),
+ // }
+ // },
+ // }
+ // // f.poll();
+ // }
+ st.run_update(&ctx, game)?;
+ st.run_render(&ctx, game)?;
+ ctx.window.request_redraw();
+ }
+
+ _ => {}
+ }
+ Ok(())
+ });
+ if let Err(e) = res {
+ *result.borrow_mut() = Err(e);
+ elwt.exit();
+ }
+ });
+ let _ = game.finalize(ctx, st);
+ if let Err(e) = res.replace(Ok(())) {
+ panic!("{}", e);
+ }
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/mesh.rs b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/mesh.rs new file mode 100644 index 0000000..ce34de4 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/mesh.rs @@ -0,0 +1,197 @@ +use glow::HasContext;
+
+use crate::context;
+
+pub const ATTRIB_VERTEX: u32 = 0;
+pub const ATTRIB_NORMAL: u32 = 1;
+pub const ATTRIB_TEXCOORD: u32 = 2;
+pub const ATTRIB_JOINT: u32 = 3;
+pub const ATTRIB_WEIGHT: u32 = 4;
+pub const ATTRIB_COLOR: u32 = 5;
+
+type Buffer = <glow::Context as glow::HasContext>::Buffer;
+
+pub struct Mesh {
+ pub vao: glow::VertexArray,
+ pub vbo_vertex: Buffer,
+ pub vbo_index: Buffer,
+ pub vbo_normal: Option<Buffer>,
+ pub vbo_texcoord: Option<Buffer>,
+ pub mode: u32, // glow::TRIANGLES, etc.
+ pub index_count: usize,
+ pub index_type: u32, // glow::BYTE, glow::FLOAT, etc.
+ pub index_offset: i32,
+}
+
+impl Mesh {
+ pub fn new_empty(ctx: &context::Context, normals: bool, texcoords: bool) -> Self {
+ unsafe {
+ let vao = ctx.gl.create_vertex_array().expect("failed to initialize vao");
+ ctx.gl.bind_vertex_array(Some(vao));
+
+ let vbo_vertex = ctx.gl.create_buffer().expect("failed to create buffer object");
+ ctx.gl.bind_buffer(glow::ARRAY_BUFFER, Some(vbo_vertex));
+ ctx.gl.vertex_attrib_pointer_f32(ATTRIB_VERTEX, 3, glow::FLOAT, false, 0, 0);
+ ctx.gl.enable_vertex_attrib_array(ATTRIB_VERTEX);
+
+ let vbo_index = ctx.gl.create_buffer().expect("failed to create buffer object");
+ ctx.gl.bind_buffer(glow::ELEMENT_ARRAY_BUFFER, Some(vbo_index));
+
+ let vbo_normal = if normals {
+ let vbo_normal = ctx.gl.create_buffer().expect("failed to create buffer object");
+ ctx.gl.bind_buffer(glow::ARRAY_BUFFER, Some(vbo_normal));
+ ctx.gl.vertex_attrib_pointer_f32(ATTRIB_NORMAL, 3, glow::FLOAT, false, 0, 0);
+ ctx.gl.enable_vertex_attrib_array(ATTRIB_NORMAL);
+ Some(vbo_normal)
+ } else { None };
+
+ let vbo_texcoord = if texcoords {
+ let vbo_texcoord = ctx.gl.create_buffer().expect("failed to create buffer object");
+ ctx.gl.bind_buffer(glow::ARRAY_BUFFER, Some(vbo_texcoord));
+ ctx.gl.vertex_attrib_pointer_f32(ATTRIB_TEXCOORD, 2, glow::FLOAT, false, 0, 0);
+ ctx.gl.enable_vertex_attrib_array(ATTRIB_TEXCOORD);
+ Some(vbo_texcoord)
+ } else { None };
+
+ Self {
+ vao,
+ vbo_vertex,
+ vbo_index,
+ vbo_normal,
+ vbo_texcoord,
+ mode: glow::TRIANGLES,
+ index_count: 0,
+ index_type: glow::UNSIGNED_INT,
+ index_offset: 0,
+ }
+ }
+ }
+ pub fn upload(
+ &mut self,
+ ctx: &context::Context,
+ vertices: &[f32],
+ indices: &[u32],
+ snormals: Option<&[f32]>,
+ stexcoords: Option<&[f32]>,
+ ) {
+ unsafe {
+ ctx.gl.bind_buffer(glow::ARRAY_BUFFER, Some(self.vbo_vertex));
+ ctx.gl.buffer_data_u8_slice(
+ glow::ARRAY_BUFFER,
+ std::slice::from_raw_parts(
+ vertices.as_ptr() as _,
+ std::mem::size_of_val(vertices),
+ ),
+ glow::STATIC_DRAW,
+ );
+ ctx.gl.bind_buffer(glow::ELEMENT_ARRAY_BUFFER, Some(self.vbo_index));
+ ctx.gl.buffer_data_u8_slice(
+ glow::ELEMENT_ARRAY_BUFFER,
+ std::slice::from_raw_parts(
+ indices.as_ptr() as _,
+ std::mem::size_of_val(indices),
+ ),
+ glow::STATIC_DRAW,
+ );
+
+ if let Some(vbo_normal) = self.vbo_normal && let Some(normals) = snormals {
+ ctx.gl.bind_buffer(glow::ARRAY_BUFFER, Some(vbo_normal));
+ ctx.gl.buffer_data_u8_slice(
+ glow::ARRAY_BUFFER,
+ std::slice::from_raw_parts(
+ normals.as_ptr() as _,
+ std::mem::size_of_val(normals),
+ ),
+ glow::STATIC_DRAW,
+ );
+ Some(vbo_normal)
+ } else { None };
+
+ if let Some(vbo_texcoord) = self.vbo_texcoord && let Some(texcoords) = stexcoords {
+ ctx.gl.bind_buffer(glow::ARRAY_BUFFER, Some(vbo_texcoord));
+ ctx.gl.buffer_data_u8_slice(
+ glow::ARRAY_BUFFER,
+ std::slice::from_raw_parts(
+ texcoords.as_ptr() as _,
+ std::mem::size_of_val(texcoords),
+ ),
+ glow::STATIC_DRAW,
+ );
+ Some(vbo_texcoord)
+ } else { None };
+ self.index_count = indices.len();
+ }
+ }
+
+ pub fn build(
+ ctx: &context::Context,
+ vertices: &[f32],
+ indices: &[u32],
+ snormals: Option<&[f32]>,
+ stexcoords: Option<&[f32]>,
+ ) -> Self {
+ let mut ret = Self::new_empty(ctx, snormals.is_some(), stexcoords.is_some());
+ ret.upload(ctx, vertices, indices, snormals, stexcoords);
+ ret
+ }
+
+ pub fn upload_obj(&mut self, ctx: &context::Context, mut bytes: &[u8]) {
+ let lopts = tobj::LoadOptions {
+ triangulate: true,
+ single_index: true,
+ ..Default::default()
+ };
+ let (meshes, _materials) = tobj::load_obj_buf(
+ &mut bytes,
+ &lopts,
+ |_| Err(tobj::LoadError::GenericFailure)
+ ).expect("failed to load mesh");
+ let mesh = meshes.into_iter().next()
+ .expect("failed to load mesh")
+ .mesh;
+ self.upload(
+ ctx,
+ &mesh.positions,
+ &mesh.indices,
+ Some(&mesh.normals),
+ Some(&mesh.texcoords),
+ )
+ }
+
+ pub fn from_obj(ctx: &context::Context, mut bytes: &[u8]) -> Self {
+ let lopts = tobj::LoadOptions {
+ triangulate: true,
+ single_index: true,
+ ..Default::default()
+ };
+ let (meshes, _materials) = tobj::load_obj_buf(
+ &mut bytes,
+ &lopts,
+ |_| Err(tobj::LoadError::GenericFailure)
+ ).expect("failed to load mesh");
+ let mesh = meshes.into_iter().next()
+ .expect("failed to load mesh")
+ .mesh;
+ Self::build(
+ ctx,
+ &mesh.positions,
+ &mesh.indices,
+ Some(&mesh.normals),
+ Some(&mesh.texcoords),
+ )
+ }
+
+ pub fn render(&self, ctx: &context::Context) {
+ unsafe {
+ ctx.gl.bind_vertex_array(Some(self.vao));
+ ctx.gl.draw_elements(self.mode, self.index_count as _, self.index_type, self.index_offset);
+ }
+ }
+
+ pub fn render_instanced(&self, ctx: &context::Context, count: u64) {
+ unsafe {
+ ctx.gl.bind_vertex_array(Some(self.vao));
+ ctx.gl.draw_elements_instanced(self.mode, self.index_count as _, self.index_type, self.index_offset, count as _);
+ }
+ }
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/net.rs b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/net.rs new file mode 100644 index 0000000..8758968 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/net.rs @@ -0,0 +1,4 @@ +pub mod ws;
+
+#[cfg(not(target_arch = "wasm32"))]
+pub mod fig;
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/net/fig.rs b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/net/fig.rs new file mode 100644 index 0000000..916cdc1 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/net/fig.rs @@ -0,0 +1,100 @@ +use std::io::{Read, Write};
+use byteorder::{LE, ReadBytesExt, WriteBytesExt};
+
+use crate::{Erm, WrapErr};
+
+const KEY: usize = 42;
+
+pub fn read_length_prefixed_utf8<R>(r: &mut R) -> Erm<String> where R: std::io::Read {
+ let len = r.read_u32::<LE>()?;
+ let mut bs = vec![0; len as usize];
+ r.read_exact(&mut bs)?;
+ Ok(String::from_utf8(bs)?)
+}
+
+#[derive(Debug, Clone)]
+pub struct BinaryMessage {
+ pub event: Vec<u8>,
+ pub data: Vec<u8>
+}
+
+pub struct BinaryClient {
+ in_buf: Vec<u8>,
+ out_buf: Vec<u8>,
+ socket: std::net::TcpStream,
+ poller: polling::Poller,
+}
+impl BinaryClient {
+ pub fn new(addr: &str, subs: &[&[u8]]) -> Erm<Self> {
+ let mut socket = std::net::TcpStream::connect(addr).wrap_err("failed to connect to message bus")?;
+ for s in subs {
+ write!(socket, "s").wrap_err("failed to send subscribe message to bus")?;
+ socket.write_u32::<byteorder::LE>(s.len() as u32).wrap_err("failed to send subscribe message length to bus")?;
+ socket.write_all(s).wrap_err("failed to send subscribe message to bus")?;
+ }
+ socket.set_nonblocking(true).wrap_err("failed to set message bus socket nonblocking")?;
+ socket.flush().wrap_err("failed to flush bus connection")?;
+ let in_buf = Vec::new();
+ let out_buf = Vec::new();
+ let poller = polling::Poller::new()?;
+ unsafe {
+ poller.add(&socket, polling::Event::all(KEY)).wrap_err("failed to add event to poll")?;
+ }
+ Ok(Self {
+ in_buf, out_buf,
+ socket,
+ poller,
+ })
+ }
+ fn write_length_prefixed(&mut self, buf: &[u8]) -> Erm<()> {
+ self.out_buf.write_u32::<byteorder::LE>(buf.len() as u32).wrap_err("failed to send message")?;
+ self.out_buf.write_all(buf).wrap_err("failed to send message")?;
+ Ok(())
+
+ }
+ pub fn publish(&mut self, ev: &[u8], data: &[u8]) -> Erm<()> {
+ write!(self.out_buf, "p").wrap_err("failed to send publish message to bus")?;
+ self.write_length_prefixed(ev)?;
+ self.write_length_prefixed(data)?;
+ Ok(())
+ }
+ fn pop_incoming_message(&mut self) -> Option<BinaryMessage> {
+ let mut reader = std::io::Cursor::new(&self.in_buf);
+ let event_len = reader.read_u32::<byteorder::LE>().ok()?;
+ let mut event = vec![0; event_len as usize];
+ reader.read_exact(&mut event).ok()?;
+ let data_len = reader.read_u32::<byteorder::LE>().ok()?;
+ let mut data = vec![0; data_len as usize];
+ reader.read_exact(&mut data).ok()?;
+ let len = reader.position() as usize;
+ self.in_buf.drain(..len);
+ Some(BinaryMessage { event, data })
+ }
+ pub fn pump(&mut self) -> Erm<Option<BinaryMessage>> {
+ let mut events = polling::Events::new();
+ events.clear();
+ self.poller.wait(&mut events, Some(std::time::Duration::from_secs(0)))
+ .wrap_err("failed to poll message bus")?;
+ for ev in events.iter() {
+ if ev.key == KEY {
+ if ev.readable {
+ let mut buf = [0; 1024];
+ match self.socket.read(&mut buf) {
+ Ok(sz) => self.in_buf.extend_from_slice(&buf[..sz]),
+ Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => {},
+ e => { e.wrap_err("failed to read from bus socket")?; },
+ }
+ }
+ if ev.writable && !self.out_buf.is_empty() {
+ match self.socket.write(&self.out_buf) {
+ Ok(sz) => { self.out_buf.drain(..sz); },
+ Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => {},
+ e => { e.wrap_err("failed to write to bus socket")?; },
+ }
+ }
+ self.poller.modify(&self.socket, polling::Event::all(KEY)).wrap_err("failed to update event to poll")?;
+ }
+ }
+ Ok(self.pop_incoming_message())
+ }
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/net/ws.rs b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/net/ws.rs new file mode 100644 index 0000000..b11df40 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/net/ws.rs @@ -0,0 +1,10 @@ +pub mod client;
+
+#[cfg(not(target_arch = "wasm32"))]
+pub mod server;
+
+#[derive(Debug, Clone)]
+pub enum Message {
+ Binary(Vec<u8>),
+ Text(String),
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/net/ws/client.rs b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/net/ws/client.rs new file mode 100644 index 0000000..fe9f957 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/net/ws/client.rs @@ -0,0 +1,9 @@ +#[cfg(target_arch = "wasm32")]
+pub mod wasm;
+#[cfg(target_arch = "wasm32")]
+pub use wasm::*;
+
+#[cfg(not(target_arch = "wasm32"))]
+pub mod native;
+#[cfg(not(target_arch = "wasm32"))]
+pub use native::*;
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/net/ws/client/native.rs b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/net/ws/client/native.rs new file mode 100644 index 0000000..eb94093 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/net/ws/client/native.rs @@ -0,0 +1,124 @@ +use std::sync::mpsc::{Sender, Receiver, channel};
+use std::sync::{Arc, Mutex};
+use std::thread::spawn;
+
+use crate::net::ws::Message;
+use crate::{utils, Erm, WrapErr};
+
+const KEY: usize = 42;
+
+type ClientChannels = (Sender<Message>, Receiver<Message>);
+#[derive(Default)]
+pub struct Client {
+ channels: Arc<Mutex<Option<ClientChannels>>>,
+}
+
+impl Client {
+ pub fn new() -> Self { Self::default() }
+ pub fn connect(&mut self, url: &str) {
+ let (mut socket, _resp) = if let Ok(v) = tungstenite::connect(url) { v } else {
+ log::warn!("failed to connect to websocket: {}", url);
+ return;
+ };
+ let poller = match polling::Poller::new() {
+ Ok(v) => v,
+ Err(e) => { log::warn!("failed to create poller: {}", e); return; }
+ };
+ let res: Erm<()> = try { match socket.get_ref() {
+ tungstenite::stream::MaybeTlsStream::Plain(s) => unsafe {
+ s.set_nonblocking(true).wrap_err("failed to set socket nonblocking")?;
+ poller.add(s, polling::Event::readable(KEY)).wrap_err("failed to add event to poll")?;
+ },
+ tungstenite::stream::MaybeTlsStream::NativeTls(s) => unsafe {
+ s.get_ref().set_nonblocking(true).wrap_err("failed to set socket nonblocking")?;
+ poller.add(s.get_ref(), polling::Event::readable(KEY)).wrap_err("failed to add event to poll")?;
+ },
+ _ => utils::erm_msg("unknown socket type; cannot poll!")?,
+ }};
+ if let Err(e) = res {
+ log::warn!("failed to add event to poll: {}", e);
+ let _ = socket.close(None);
+ return;
+ };
+ let (outgoing_sender, outgoing_receiver) = channel();
+ let (incoming_sender, incoming_receiver) = channel();
+ *self.channels.lock().unwrap() = Some((outgoing_sender, incoming_receiver));
+ let send_channels_ref = self.channels.clone();
+ let recv_channels_ref = self.channels.clone();
+ let send_socket_ref = Arc::new(Mutex::new(socket));
+ let recv_socket_ref = send_socket_ref.clone();
+ let mut events = polling::Events::new();
+ spawn(move || loop {
+ // write all outgoing messages
+ let res: Erm<()> = try {
+ while let Ok(msg) = outgoing_receiver.recv() {
+ match msg {
+ Message::Text(txt) => send_socket_ref.lock().unwrap()
+ .send(tungstenite::Message::Text(txt))
+ .wrap_err("failed to send websocket text")?,
+ Message::Binary(bytes) => send_socket_ref.lock().unwrap()
+ .send(tungstenite::Message::Binary(bytes))
+ .wrap_err("failed to send websocket bytes")?,
+ }
+ }
+ };
+ if let Err(e) = res {
+ log::warn!("error in websocket send thread: {}", e);
+ *send_channels_ref.lock().unwrap() = None;
+ return;
+ }
+ });
+ spawn(move || loop {
+ // wait for and receive all incoming messages
+ let res: Erm<()> = try {
+ events.clear();
+ poller.wait(&mut events, None).wrap_err("failed to wait on websocket poller")?;
+ for ev in events.iter() {
+ if ev.key == KEY {
+ if ev.readable { match recv_socket_ref.lock().unwrap().read().wrap_err("failed to recv on websocket")? {
+ tungstenite::Message::Text(txt) => incoming_sender.send(Message::Text(txt))
+ .wrap_err("failed to send incoming websocket message on channel")?,
+ tungstenite::Message::Binary(bytes) => incoming_sender.send(Message::Binary(bytes))
+ .wrap_err("failed to send incoming websocket message on channel")?,
+ tungstenite::Message::Ping(bs) => recv_socket_ref.lock().unwrap()
+ .send(tungstenite::Message::Pong(bs))
+ .wrap_err("failed to send websocket pong")?,
+ m => log::warn!("unhandled incoming websocket message: {}", m),
+ }}
+ match recv_socket_ref.lock().unwrap().get_ref() {
+ tungstenite::stream::MaybeTlsStream::Plain(s) =>
+ poller.modify(s, polling::Event::readable(KEY))
+ .wrap_err("failed to modify event to poll")?,
+ tungstenite::stream::MaybeTlsStream::NativeTls(s) =>
+ poller.modify(s.get_ref(), polling::Event::readable(KEY))
+ .wrap_err("failed to modify event to poll")?,
+ _ => log::warn!("unknown socket type; cannot modify polling!"),
+ }
+ }
+ }
+ };
+ if let Err(e) = res {
+ log::warn!("error in websocket recv thread: {}", e);
+ *recv_channels_ref.lock().unwrap() = None;
+ return;
+ }
+ });
+ }
+ pub fn is_connected(&self) -> bool {
+ self.channels.lock().unwrap().is_some()
+ }
+ pub fn poll(&mut self) -> Option<Message> {
+ if let Some((_, incoming)) = &*self.channels.lock().unwrap() {
+ incoming.try_recv().ok()
+ } else { None }
+ }
+ pub fn send(&self, msg: Message) {
+ if let Some((outgoing, _)) = &mut *self.channels.lock().unwrap() {
+ if let Err(e) = outgoing.send(msg) {
+ log::warn!("failed to send websocket message on channel: {}", e);
+ }
+ } else {
+ log::warn!("tried to send message, but websocket is not connected");
+ }
+ }
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/net/ws/client/wasm.rs b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/net/ws/client/wasm.rs new file mode 100644 index 0000000..f4faff7 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/net/ws/client/wasm.rs @@ -0,0 +1,73 @@ +use std::{collections::VecDeque, sync::{Arc, Mutex}};
+
+use wasm_bindgen::prelude::*;
+
+use crate::net::ws::Message;
+
+impl Message {
+ fn from_messageevent(e: web_sys::MessageEvent) -> Self {
+ if let Ok(abuf) = e.data().dyn_into::<js_sys::ArrayBuffer>() {
+ let array = js_sys::Uint8Array::new(&abuf).to_vec();
+ Message::Binary(array)
+ } else if let Ok(txt) = e.data().dyn_into::<js_sys::JsString>() {
+ Message::Text(txt.into())
+ } else {
+ panic!("received weird websocket message: {:?}", e);
+ }
+ }
+}
+
+pub struct Client {
+ ws: Arc<Mutex<Option<web_sys::WebSocket>>>,
+ messages: Arc<Mutex<VecDeque<Message>>>,
+}
+
+impl Client {
+ pub fn new() -> Self {
+ Self {
+ ws: Arc::new(Mutex::new(None)),
+ messages: Arc::new(Mutex::new(VecDeque::new())),
+ }
+ }
+ pub fn connect(&mut self, url: &str) {
+ let ws_ref = self.ws.clone();
+ let messages_ref = self.messages.clone();
+ let cb: Closure<dyn Fn(web_sys::MessageEvent)> = Closure::new(move |e: web_sys::MessageEvent| {
+ let msg = Message::from_messageevent(e);
+ log::info!("incoming: {:?}", msg);
+ messages_ref.lock().unwrap().push_back(msg);
+ });
+ let close_cb: Closure<dyn Fn(web_sys::MessageEvent)> = Closure::new(move |_: web_sys::MessageEvent| {
+ log::info!("closed!");
+ *ws_ref.lock().unwrap() = None;
+ });
+ let ws = web_sys::WebSocket::new(url).expect("failed to open websocket");
+ ws.set_onmessage(Some(cb.as_ref().unchecked_ref()));
+ ws.set_onclose(Some(close_cb.as_ref().unchecked_ref()));
+ cb.forget();
+ close_cb.forget();
+ *self.ws.lock().unwrap() = Some(ws);
+ }
+ pub fn is_connected(&self) -> bool {
+ self.ws.lock().unwrap().is_some()
+ }
+ pub fn poll(&mut self) -> Option<Message> {
+ self.messages.lock().unwrap().pop_front()
+ }
+ pub fn send(&self, msg: Message) {
+ if let Some(ws) = &*self.ws.lock().unwrap() {
+ match msg {
+ Message::Text(txt) => {
+ if let Err(e) = ws.send_with_str(&txt) {
+ log::warn!("failed to send string: {:?}", e);
+ }
+ },
+ Message::Binary(bytes) => {
+ if let Err(e) = ws.send_with_u8_array(&bytes) {
+ log::warn!("failed to send bytes: {:?}", e);
+ }
+ },
+ }
+ }
+ }
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/net/ws/server.rs b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/net/ws/server.rs new file mode 100644 index 0000000..9422aec --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/net/ws/server.rs @@ -0,0 +1,140 @@ +use std::collections::HashMap;
+use std::net::{TcpListener, TcpStream};
+use std::sync::mpsc::{Sender, Receiver, channel};
+use std::sync::{Arc, Mutex};
+use std::thread::spawn;
+
+use crate::net::ws::Message;
+use crate::{utils, Erm, WrapErr};
+
+const ACCEPT_KEY: usize = 1;
+
+type ClientId = usize;
+type ClientMessage = (ClientId, Message);
+
+type ServerChannels = (Sender<ClientMessage>, Receiver<ClientMessage>);
+#[derive(Default)]
+pub struct Server {
+ clients: Arc<Mutex<HashMap<ClientId, tungstenite::WebSocket<TcpStream>>>>,
+ channels: Arc<Mutex<Option<ServerChannels>>>,
+}
+
+impl Server {
+ pub fn new() -> Self { Self::default() }
+ pub fn start(&mut self, addr: &str) {
+ let recv_clients_ref = self.clients.clone();
+ let send_clients_ref = self.clients.clone();
+ let (outgoing_sender, outgoing_receiver) = channel();
+ let (incoming_sender, incoming_receiver) = channel();
+ *self.channels.lock().unwrap() = Some((outgoing_sender, incoming_receiver));
+ let channels_ref = self.channels.clone();
+ let listener = TcpListener::bind(addr).expect("failed to bind server socket");
+ let poller = polling::Poller::new().expect("failed to create poller for websocket server");
+ unsafe {
+ poller.add(&listener, polling::Event::readable(ACCEPT_KEY))
+ .expect("failed to add poll server socket");
+ }
+ let mut events = polling::Events::new();
+ let mut next_id = ACCEPT_KEY + 1;
+ spawn(move || loop {
+ // write all outgoing messages
+ while let Ok((cid, msg)) = outgoing_receiver.recv() {
+ let res: Erm<()> = try {
+ if let Some(sock) = send_clients_ref.lock().unwrap().get_mut(&cid) {
+ let res = match msg {
+ Message::Text(txt) => sock.send(tungstenite::Message::Text(txt)),
+ Message::Binary(bytes) => sock.send(tungstenite::Message::Binary(bytes))
+ };
+ match res {
+ Ok(_) => {},
+ Err(tungstenite::Error::Io(e)) if e.kind() == std::io::ErrorKind::WouldBlock => {
+ log::info!("client {} receive send block", cid);
+ },
+ Err(e) => utils::erm(e)?,
+ }
+ }
+ };
+ if let Err(e) = res {
+ log::warn!("error when sending to client {}, disconnecting: {}", cid, e);
+ send_clients_ref.lock().unwrap().remove(&cid);
+ }
+ }
+ });
+ spawn(move || loop {
+ // wait for and receive all new connections and incoming messages
+ let res: Erm<()> = try {
+ events.clear();
+ poller.wait(&mut events, None).wrap_err("failed to wait on websocket server poller")?;
+ for ev in events.iter() {
+ if ev.key == ACCEPT_KEY {
+ let (sock, client_addr) = listener.accept().wrap_err("failed to accept on socket")?;
+ let id = next_id; next_id += 1;
+ let res: Erm<()> = try {
+ unsafe { poller.add(&sock, polling::Event::readable(id))
+ .wrap_err("failed to add socket to poller")?; }
+ let conn = tungstenite::accept(sock).wrap_err("failed to upgrade to websocket")?;
+ recv_clients_ref.lock().unwrap().insert(id, conn);
+ log::info!("new connected client! {}", id);
+ };
+ if let Err(e) = res {
+ log::warn!("error during connection from {}: {}", client_addr, e);
+ };
+ poller.modify(&listener, polling::Event::readable(ACCEPT_KEY))
+ .wrap_err("failed to modify event to poll")?;
+ } else {
+ let res: Erm<()> = try {
+ if let Some(sock) = recv_clients_ref.lock().unwrap().get_mut(&ev.key) {
+ match sock.read() {
+ Ok(tungstenite::Message::Text(t)) =>
+ incoming_sender.send((ev.key, Message::Text(t)))
+ .wrap_err("failed to send incoming message on channel")?,
+ Ok(tungstenite::Message::Binary(b)) =>
+ incoming_sender.send((ev.key, Message::Binary(b)))
+ .wrap_err("failed to send incoming message on channel")?,
+ Ok(tungstenite::Message::Ping(x)) =>
+ sock.write(tungstenite::Message::Pong(x))
+ .wrap_err("failed to reply with pong")?,
+ Ok(m) => log::info!("received unhandled websocket message: {}", m),
+ Err(tungstenite::Error::Io(e)) if e.kind() == std::io::ErrorKind::WouldBlock => {
+ log::info!("client {} receive would block", ev.key);
+ },
+ Err(e) => utils::erm(e)?,
+ }
+ poller.modify(sock.get_ref(), polling::Event::readable(ev.key))
+ .wrap_err("failed to modify event to poll")?;
+ } else {
+ log::warn!("poller indicated event for unknown client: {}", ev.key);
+ }
+ };
+ if let Err(e) = res {
+ log::warn!("error on client {} connection, disconnecting: {}", ev.key, e);
+ recv_clients_ref.lock().unwrap().remove(&ev.key);
+ }
+ }
+ }
+ };
+ if let Err(e) = res {
+ log::warn!("unhandled error in websocket thread, stopping server: {}", e);
+ *channels_ref.lock().unwrap() = None;
+ return;
+ }
+ });
+ }
+ pub fn clients(&self) -> Vec<ClientId> {
+ self.clients.lock().unwrap().keys().copied().collect()
+ }
+ pub fn poll(&mut self) -> Option<(ClientId, Message)> {
+ if let Some((_, incoming)) = &*self.channels.lock().unwrap() {
+ incoming.try_recv().ok()
+ } else { None }
+ }
+ pub fn send(&self, client: ClientId, msg: Message) {
+ if let Some((outgoing, _)) = &mut *self.channels.lock().unwrap() {
+ if let Err(e) = outgoing.send((client, msg)) {
+ log::warn!("failed to send websocket message to client {} on channel: {}", client, e);
+ }
+ } else {
+ log::warn!("tried to send message to client {}, but websocket is not connected", client);
+ }
+ }
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/physics.rs b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/physics.rs new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/physics.rs diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/renderer.rs b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/renderer.rs new file mode 100644 index 0000000..c22c973 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/renderer.rs @@ -0,0 +1,337 @@ +use crate::{context, state, shader, texture, mesh};
+
+use bitflags::bitflags;
+
+bitflags! {
+ #[derive(Clone, Copy, Debug, PartialEq, Eq)]
+ pub struct UberFlags: u32 {
+ const TEXTURE_COLOR = 0b0000000001;
+ const TEXTURE_NORMAL = 0b0000000010;
+ const FLIP_TEXTURE = 0b0000000100;
+ const LIGHT_AMBIENT = 0b0000001000;
+ const LIGHT_DIR = 0b0000010000;
+ const LIGHT_POINT = 0b0000100000;
+ const SPRITE = 0b0001000000;
+ const EFFECTS = 0b0010000000;
+ const YSKEW = 0b0100000000;
+ const VERTEX_COLOR = 0b1000000000;
+ }
+}
+impl UberFlags {
+ fn prelude() -> String {
+ let mut s = String::new();
+ s += "#version 300 es\nprecision highp float;";
+ for (nm, f) in Self::all().iter_names() {
+ s += &format!("const int {} = {};\n", nm, f.bits());
+ }
+ s
+ }
+ fn set_flags(self, ctx: &context::Context, shader: &shader::Shader) {
+ shader.set_i32(ctx, "flags", self.bits() as i32);
+ }
+}
+
+pub trait Assets {
+ type Shader: PartialEq + Eq + Clone + Copy;
+ fn shader(&self, i: Self::Shader) -> &shader::Shader;
+ type Texture: PartialEq + Eq + Clone + Copy;
+ fn texture(&self, i: Self::Texture) -> &texture::Texture;
+ type Mesh: PartialEq + Eq + Clone + Copy;
+ fn mesh(&self, i: Self::Mesh) -> &mesh::Mesh;
+ type Material: PartialEq + Eq + Clone + Copy;
+ fn material(&self, i: Self::Material) -> &texture::Material;
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum ShaderMode { TwoDimension, ThreeDimension, ThreeDimensionOrth }
+#[derive(Debug, Clone, Copy)]
+enum BoundShader<A: Assets> { None, Uber(UberFlags, ShaderMode), Shader(A::Shader, ShaderMode) }
+impl<A: Assets> PartialEq for BoundShader<A> {
+ fn eq(&self, other: &Self) -> bool {
+ match (self, other) {
+ (Self::None, Self::None) => true,
+ (Self::Uber(sf, sm), Self::Uber(of, om)) => sf == of && sm == om,
+ (Self::Shader(ss, sm), Self::Shader(os, om)) => ss == os && sm == om,
+ _ => false,
+ }
+ }
+}
+#[derive(Debug, Clone, Copy)]
+enum BoundTexture<A: Assets> { None, Texture(A::Texture), Material(A::Material) }
+impl<A: Assets> PartialEq for BoundTexture<A> {
+ fn eq(&self, other: &Self) -> bool {
+ match (self, other) {
+ (Self::None, Self::None) => true,
+ (Self::Texture(s), Self::Texture(o)) => s == o,
+ (Self::Material(s), Self::Material(o)) => s == o,
+ _ => false,
+ }
+ }
+}
+pub struct Renderer<A: Assets> {
+ pub assets: A,
+ shader_uber: shader::Shader,
+ shader: BoundShader<A>,
+ texture: BoundTexture<A>,
+}
+impl<A: Assets> Renderer<A> {
+ pub fn new<F>(ctx: &context::Context, f: F) -> Self
+ where F: FnOnce(&context::Context) -> A {
+ let shader_uber = shader::Shader::new_nolib(ctx,
+ &format!("{}{}", UberFlags::prelude(), include_str!("assets/shaders/uber/vert.glsl")),
+ &format!("{}{}", UberFlags::prelude(), include_str!("assets/shaders/uber/frag.glsl")),
+ );
+ shader_uber.bind(ctx);
+ shader_uber.set_i32(ctx, "texture_normal", 1);
+ Self {
+ assets: f(ctx),
+ shader_uber,
+ shader: BoundShader::None,
+ texture: BoundTexture::None,
+ }
+ }
+ pub fn font_char_width(&self, st: &state::State) -> f32 { st.font_default.char_width as f32 }
+ pub fn font_char_height(&self, st: &state::State) -> f32 { st.font_default.char_height as f32 }
+ pub fn unbind_texture(&mut self, _ctx: &context::Context, _st: &mut state::State) {
+ self.texture = BoundTexture::None;
+ }
+ pub fn bind_texture(&mut self, ctx: &context::Context, _st: &mut state::State, texture: A::Texture) {
+ if self.texture != BoundTexture::Texture(texture) {
+ self.assets.texture(texture).bind(ctx);
+ self.texture = BoundTexture::Texture(texture);
+ }
+ }
+ pub fn bind_material(&mut self, ctx: &context::Context, _st: &mut state::State, mat: A::Material) {
+ if self.texture != BoundTexture::Material(mat) {
+ self.assets.material(mat).bind(ctx);
+ self.texture = BoundTexture::Material(mat);
+ }
+ }
+ fn shader(&self) -> Option<(&shader::Shader, ShaderMode)> {
+ match self.shader {
+ BoundShader::Uber(_, sm) => Some((&self.shader_uber, sm)),
+ BoundShader::Shader(s, sm) => Some((self.assets.shader(s), sm)),
+ _ => None,
+ }
+ }
+ fn bind_uber(&mut self,
+ ctx: &context::Context, st: &mut state::State,
+ flags: UberFlags, mode: ShaderMode,
+ ) {
+ if let BoundShader::Uber(f, sm) = self.shader && f == flags && sm == mode { return }
+ match mode {
+ ShaderMode::TwoDimension => st.bind_2d(ctx, &self.shader_uber),
+ ShaderMode::ThreeDimension => st.bind_3d(ctx, &self.shader_uber),
+ ShaderMode::ThreeDimensionOrth => st.bind_3d_orth(ctx, &self.shader_uber),
+ }
+ flags.set_flags(ctx, &self.shader_uber);
+ self.shader = BoundShader::Uber(flags, mode)
+ }
+ fn bind_shader(&mut self,
+ ctx: &context::Context, st: &mut state::State,
+ shader: A::Shader, mode: ShaderMode,
+ ) {
+ if let BoundShader::Shader(s, sm) = self.shader && s == shader && sm == mode { return }
+ match mode {
+ ShaderMode::TwoDimension => st.bind_2d(ctx, self.assets.shader(shader)),
+ ShaderMode::ThreeDimension => st.bind_3d(ctx, self.assets.shader(shader)),
+ ShaderMode::ThreeDimensionOrth => st.bind_3d_orth(ctx, self.assets.shader(shader)),
+ }
+ self.shader = BoundShader::Shader(shader, mode)
+ }
+ pub fn bind_uber_2d(&mut self, ctx: &context::Context, st: &mut state::State, flags: UberFlags) {
+ self.bind_uber(ctx, st, flags, ShaderMode::TwoDimension);
+ }
+ pub fn bind_uber_3d(&mut self, ctx: &context::Context, st: &mut state::State, flags: UberFlags) {
+ self.bind_uber(ctx, st, flags, ShaderMode::ThreeDimension);
+ }
+ pub fn bind_uber_3d_orth(&mut self, ctx: &context::Context, st: &mut state::State, flags: UberFlags) {
+ self.bind_uber(ctx, st, flags, ShaderMode::ThreeDimensionOrth);
+ }
+ pub fn bind_shader_2d(&mut self, ctx: &context::Context, st: &mut state::State, shader: A::Shader) {
+ self.bind_shader(ctx, st, shader, ShaderMode::TwoDimension);
+ }
+ pub fn bind_shader_3d(&mut self, ctx: &context::Context, st: &mut state::State, shader: A::Shader) {
+ self.bind_shader(ctx, st, shader, ShaderMode::ThreeDimension);
+ }
+ pub fn render(&self, ctx: &context::Context, _st: &state::State, mesh: A::Mesh) {
+ self.assets.mesh(mesh).render(ctx)
+ }
+ pub fn render_square(&self, ctx: &context::Context, st: &state::State) {
+ st.mesh_square.render(ctx)
+ }
+ pub fn set_position_2d_mat(&self, ctx: &context::Context, st: &state::State, pos: glam::Mat4) {
+ if let Some((s, sm)) = self.shader() {
+ debug_assert!(sm == ShaderMode::TwoDimension, "attempted to set_position_2d in wrong mode");
+ s.set_position_2d_mat(ctx, st, &pos);
+ }
+ }
+ pub fn set_position_2d_rotate(&self, ctx: &context::Context, st: &state::State, pos: glam::Vec2, dims: glam::Vec2, rot: glam::Quat) {
+ if let Some((s, sm)) = self.shader() {
+ debug_assert!(sm == ShaderMode::TwoDimension, "attempted to set_position_2d in wrong mode");
+ s.set_position_2d_helper(ctx, st, &pos, &dims, &rot)
+ }
+ }
+ pub fn set_position_2d(&self, ctx: &context::Context, st: &state::State, pos: glam::Vec2, dims: glam::Vec2) {
+ if let Some((s, sm)) = self.shader() {
+ debug_assert!(sm == ShaderMode::TwoDimension, "attempted to set_position_2d in wrong mode");
+ s.set_position_2d(ctx, st, &pos, &dims)
+ }
+ }
+ pub fn set_position_3d(&self, ctx: &context::Context, st: &state::State, pos: glam::Mat4) {
+ if let Some((s, sm)) = self.shader() {
+ debug_assert!(sm == ShaderMode::ThreeDimension || sm == ShaderMode::ThreeDimensionOrth,
+ "attempted to set_position_3d in wrong mode"
+ );
+ s.set_position_3d(ctx, st, &pos)
+ }
+ }
+ pub fn set_i32(&self, ctx: &context::Context, _st: &state::State, nm: &str, val: i32) {
+ if let Some((s, _)) = self.shader() { s.set_i32(ctx, nm, val) }
+ }
+ pub fn set_f32(&self, ctx: &context::Context, _st: &state::State, nm: &str, val: f32) {
+ if let Some((s, _)) = self.shader() { s.set_f32(ctx, nm, val) }
+ }
+ pub fn set_vec2(&self, ctx: &context::Context, _st: &state::State, nm: &str, val: glam::Vec2) {
+ if let Some((s, _)) = self.shader() { s.set_vec2(ctx, nm, &val) }
+ }
+ pub fn set_vec3(&self, ctx: &context::Context, _st: &state::State, nm: &str, val: glam::Vec3) {
+ if let Some((s, _)) = self.shader() { s.set_vec3(ctx, nm, &val) }
+ }
+ pub fn set_vec4(&self, ctx: &context::Context, _st: &state::State, nm: &str, val: glam::Vec4) {
+ if let Some((s, _)) = self.shader() { s.set_vec4(ctx, nm, &val) }
+ }
+ pub fn set_mat4(&self, ctx: &context::Context, _st: &state::State, nm: &str, val: glam::Mat4) {
+ if let Some((s, _)) = self.shader() { s.set_mat4(ctx, nm, &val) }
+ }
+ pub fn set_texture_offset(&self,
+ ctx: &context::Context, st: &state::State,
+ xinc: i32, yinc: i32,
+ x: i32, y: i32
+ ) {
+ let xcount = xinc as f32; let xratio = 1.0 / xcount;
+ let ycount = yinc as f32; let yratio = 1.0 / ycount;
+ self.set_vec2(
+ ctx, st, "sprite_dims",
+ glam::Vec2::new(xratio, yratio),
+ );
+ self.set_vec2(
+ ctx, st, "sprite_offset",
+ glam::Vec2::new((x % xinc) as f32 * xratio, (y % yinc) as f32 * yratio),
+ );
+ }
+
+ /// Common case: draw the given textured mesh in the world (units are world tiles)
+ pub fn textured_mesh_world(&mut self,
+ ctx: &context::Context, st: &mut state::State,
+ shader: A::Shader,
+ texture: A::Texture,
+ mesh: A::Mesh,
+ pos: glam::Mat4,
+ ) {
+ self.bind_shader_3d(ctx, st, shader);
+ self.bind_texture(ctx, st, texture);
+ self.set_position_3d(ctx, st, pos);
+ self.render(ctx, st, mesh);
+ }
+
+ /// Common case: draw the given color in a rectangle on the screen (units are pixels, pos is top left)
+ pub fn color_screen(&mut self,
+ ctx: &context::Context, st: &mut state::State,
+ color: glam::Vec4,
+ pos: glam::Vec2,
+ dims: glam::Vec2,
+ ) {
+ self.bind_uber_2d(ctx, st, UberFlags::empty());
+ self.set_vec4(ctx, st, "color", color);
+ self.set_position_2d(ctx, st, pos, dims);
+ self.render_square(ctx, st);
+ }
+
+ /// Common case: draw the given texture on the screen (units are pixels, pos is top left)
+ pub fn texture_screen(&mut self,
+ ctx: &context::Context, st: &mut state::State,
+ texture: A::Texture,
+ pos: glam::Vec2,
+ dims: glam::Vec2,
+ ) {
+ self.bind_uber_2d(ctx, st, UberFlags::TEXTURE_COLOR);
+ self.bind_texture(ctx, st, texture);
+ self.set_position_2d(ctx, st, pos, dims);
+ self.render_square(ctx, st);
+ }
+
+ pub fn texture_screen_rotate(&mut self,
+ ctx: &context::Context, st: &mut state::State,
+ texture: A::Texture,
+ pos: glam::Vec2,
+ dims: glam::Vec2,
+ rot: glam::Quat,
+ ) {
+ self.bind_uber_2d(ctx, st, UberFlags::TEXTURE_COLOR);
+ self.bind_texture(ctx, st, texture);
+ self.set_position_2d_rotate(ctx, st, pos, dims, rot);
+ self.render_square(ctx, st);
+ }
+
+ pub fn texture_screen_recolor(&mut self,
+ ctx: &context::Context, st: &mut state::State,
+ texture: A::Texture, hue: f32,
+ pos: glam::Vec2,
+ dims: glam::Vec2,
+ ) {
+ self.bind_uber_2d(ctx, st, UberFlags::TEXTURE_COLOR | UberFlags::EFFECTS);
+ self.bind_texture(ctx, st, texture);
+ self.set_f32(ctx, st, "effect_huescale", 0.0);
+ self.set_f32(ctx, st, "effect_hueshift", hue);
+ self.set_position_2d(ctx, st, pos, dims);
+ self.render_square(ctx, st);
+ self.set_f32(ctx, st, "effect_huescale", 1.0);
+ self.set_f32(ctx, st, "effect_hueshift", 0.0);
+ }
+
+ /// Common case: text in the default font (units are pixels, pos is top left)
+ pub fn text_screen(&mut self,
+ ctx: &context::Context, st: &mut state::State,
+ pos: glam::Vec2,
+ s: &str,
+ ) {
+ // drawing text might bind the texture
+ self.texture = BoundTexture::None;
+ self.bind_uber_2d(ctx, st, UberFlags::TEXTURE_COLOR | UberFlags::VERTEX_COLOR | UberFlags::FLIP_TEXTURE);
+ let dims = glam::Vec2::new(st.font_default.char_width as f32, st.font_default.char_height as f32);
+ let fpos = pos + glam::Vec2::new(-dims.x / 2.0, dims.y / 2.0);
+ self.set_position_2d(ctx, st, fpos, dims);
+ st.font_default.render_text(ctx, st, s);
+ }
+
+ /// Common case: text in the default font, with a color (units are pixels, pos is top left)
+ pub fn text_colored_screen(&mut self,
+ ctx: &context::Context, st: &mut state::State,
+ pos: glam::Vec2,
+ col: glam::Vec3,
+ s: &str,
+ ) {
+ self.texture = BoundTexture::None;
+ self.bind_uber_2d(ctx, st, UberFlags::TEXTURE_COLOR | UberFlags::VERTEX_COLOR | UberFlags::FLIP_TEXTURE);
+ let dims = glam::Vec2::new(st.font_default.char_width as f32, st.font_default.char_height as f32);
+ let fpos = pos + glam::Vec2::new(-dims.x / 2.0, st.font_default.char_height as f32 / 2.0);
+ self.set_position_2d(ctx, st, fpos, dims);
+ st.font_default.render_text_helper(ctx, st, s, &[col]);
+ }
+
+ /// Common case: text in the default font (units are pixels, pos is center)
+ pub fn text_centered_screen(&mut self,
+ ctx: &context::Context, st: &mut state::State,
+ pos: glam::Vec2,
+ s: &str,
+ ) {
+ self.texture = BoundTexture::None;
+ self.bind_uber_2d(ctx, st, UberFlags::TEXTURE_COLOR | UberFlags::VERTEX_COLOR | UberFlags::FLIP_TEXTURE);
+ let width = s.len() as f32 * st.font_default.char_width as f32;
+ let dims = glam::Vec2::new(st.font_default.char_width as f32, st.font_default.char_height as f32);
+ let fpos = pos + glam::Vec2::new(-dims.x / 2.0 - (width / 2.0).round(), st.font_default.char_height as f32 / 2.0);
+ self.set_position_2d(ctx, st, fpos, dims);
+ st.font_default.render_text(ctx, st, s);
+ }
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/save.rs b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/save.rs new file mode 100644 index 0000000..1297a1b --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/save.rs @@ -0,0 +1,47 @@ +#[cfg(target_arch = "wasm32")]
+use base64::prelude::*;
+
+#[cfg(target_arch = "wasm32")]
+pub fn save<W>(id: &str, data: &W) where W: serde::Serialize {
+ let window = web_sys::window().expect("failed to get window object");
+ let storage = window.local_storage()
+ .expect("failed to get local storage")
+ .expect("local storage not present");
+ let key = format!("{}_save", id);
+ let val = bincode::serde::encode_to_vec(data, bincode::config::standard()).expect("failed to serialize save");
+ let str = BASE64_STANDARD.encode(&val);
+ storage.set_item(&key, &str).expect("failed to set save");
+}
+
+#[cfg(target_arch = "wasm32")]
+pub fn load<W>(id: &str) -> Option<W> where W: serde::de::DeserializeOwned {
+ let window = web_sys::window().expect("failed to get window object");
+ let storage = window.local_storage()
+ .expect("failed to get local storage")
+ .expect("local storage not present");
+ let key = format!("{}_save", id);
+ let s = storage.get_item(&key).expect("failed to get save").expect("save not present");
+ let bytes = BASE64_STANDARD.decode(&s).expect("failed to decode base64 for save");
+ let (ret, _) = bincode::serde::decode_from_slice(&bytes, bincode::config::standard())
+ .expect("failed to deserialize save");
+ Some(ret)
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub fn save<W>(id: &str, data: &W) where W: serde::Serialize {
+ let pd = directories::ProjectDirs::from("", "milkfat", id).expect("failed to get save directory");
+ let _ = std::fs::create_dir_all(pd.data_dir());
+ let path = pd.data_dir().join("teleia.save");
+ let mut file = std::fs::File::create(&path).expect("failed to open save file");
+ bincode::serde::encode_into_std_write(data, &mut file, bincode::config::standard())
+ .expect("failed to write save file");
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub fn load<W>(id: &str) -> Option<W> where W: serde::de::DeserializeOwned {
+ let pd = directories::ProjectDirs::from("", "milkfat", id).expect("failed to get save directory");
+ let _ = std::fs::create_dir_all(pd.data_dir());
+ let path = pd.data_dir().join("teleia.save");
+ let mut file = std::fs::File::open(&path).ok()?;
+ bincode::serde::decode_from_std_read(&mut file, bincode::config::standard()).ok()
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/scene.rs b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/scene.rs new file mode 100644 index 0000000..a904bf1 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/scene.rs @@ -0,0 +1,401 @@ +use std::{collections::{HashMap, VecDeque}, mem::offset_of};
+
+use glow::HasContext;
+use image::EncodableLayout;
+
+use crate::{context, mesh, shader, texture};
+
+pub type Index = usize;
+
+pub struct Primitive {
+ pub mesh: mesh::Mesh,
+ pub material: Index,
+}
+
+pub struct Object {
+ pub primitives: Vec<Primitive>,
+}
+
+pub struct Material {
+ pub base_color_factor: glam::Vec4,
+ pub base_color_texture: Option<Index>,
+
+ pub metallic_factor: f32,
+ pub roughness_factor: f32,
+ pub metallic_roughness_texture: Option<Index>,
+
+ pub normal_texture: Option<Index>,
+
+ pub occlusion_texture: Option<Index>,
+
+ pub emissive_factor: glam::Vec3,
+ pub emissive_texture: Option<Index>,
+}
+
+pub struct Skin {
+ pub inverse_bind_matrices: Vec<glam::Mat4>,
+ pub joints: Vec<Index>,
+}
+
+pub enum ChannelValues {
+ Translation(Vec<glam::Vec3>),
+ Rotation(Vec<glam::Quat>),
+ Scale(Vec<glam::Vec3>),
+}
+
+pub enum Interpolation {
+ Linear,
+ Step,
+ CubicSpline,
+}
+
+pub struct Channel {
+ pub target: Index,
+ pub interpolation: Interpolation,
+ pub keyframes: Vec<f32>,
+ pub values: ChannelValues,
+}
+
+pub struct Animation {
+ pub channels: Vec<Channel>,
+}
+
+pub struct Node {
+ pub children: Vec<Index>,
+ pub object: Option<Index>,
+ pub skin: Option<Index>,
+ pub transform: glam::Mat4,
+}
+
+pub struct Scene {
+ pub objects: Vec<Object>,
+ pub textures: Vec<texture::Texture>,
+ pub materials: Vec<Material>,
+ pub skins: Vec<Skin>,
+ pub animations: HashMap<String, Animation>,
+ pub nodes: Vec<Node>,
+ pub nodes_by_name: HashMap<String, Index>,
+ pub scene_nodes: Vec<Index>,
+}
+
+impl Scene {
+ pub fn load_default_shader(ctx: &context::Context) -> shader::Shader {
+ shader::Shader::new(
+ ctx,
+ include_str!("assets/shaders/scene/vert.glsl"),
+ include_str!("assets/shaders/scene/frag.glsl")
+ )
+ }
+ pub fn from_gltf(ctx: &context::Context, bytes: &[u8]) -> Self {
+ let (gltf, buffers, images) = gltf::import_slice(bytes).expect("failed to parse GLTF");
+ let get_buffer_data = |b: gltf::Buffer| {
+ buffers.get(b.index()).map(|gltf::buffer::Data(bytes)| bytes.as_slice())
+ };
+ let objects = gltf.meshes().map(|m| {
+ let primitives = m.primitives().map(|p| {
+ let mode = match p.mode() {
+ gltf::mesh::Mode::Points => glow::POINTS,
+ gltf::mesh::Mode::Lines => glow::LINES,
+ gltf::mesh::Mode::LineLoop => glow::LINE_LOOP,
+ gltf::mesh::Mode::LineStrip => glow::LINE_STRIP,
+ gltf::mesh::Mode::Triangles => glow::TRIANGLES,
+ gltf::mesh::Mode::TriangleStrip => glow::TRIANGLE_STRIP,
+ gltf::mesh::Mode::TriangleFan => glow::TRIANGLE_FAN,
+ };
+ unsafe {
+ let vao = ctx.gl.create_vertex_array().expect("failed to initialize vao");
+ ctx.gl.bind_vertex_array(Some(vao));
+
+ // in the past, I've been lazy and just uploaded whole buffers to the GPU.
+ // this is certainly not the right thing to do in general.
+ // perhaps I am misunderstanding, but it feels like GLTF makes it pretty difficult to do
+ // that in general, on account of things like sparse accessors.
+ // instead, we'll use the gltf crate's handy "reader" abstraction to iterate over all of the
+ // data in the buffers, assemble it ourselves, and then upload that.
+ let reader = p.reader(get_buffer_data);
+
+ // on to the actual vertex data.
+ // this is the layout of a single vertex in the buffer we send to the GPU.
+ struct Vertex {
+ pos: glam::Vec3,
+ normal: glam::Vec3,
+ texcoord: glam::Vec2,
+ joints: glam::Vec4,
+ weights: glam::Vec4,
+ }
+
+ // vertices always have positions
+ let mut vertices = Vec::new();
+ for pos in reader.read_positions().expect("primitive has no positions") {
+ vertices.push(Vertex {
+ pos: glam::Vec3::from_array(pos),
+ normal: glam::Vec3::default(),
+ texcoord: glam::Vec2::default(),
+ joints: glam::Vec4::default(),
+ weights: glam::Vec4::default(),
+ });
+ }
+
+ // if we find indices, use those. otherwise generate indices
+ let indices: Vec<u32> = if let Some(ri) = reader.read_indices() {
+ ri.into_u32().collect()
+ } else {
+ vertices.iter().enumerate().map(|(i, _)| i as u32).collect()
+ };
+ let indices_bytes: Vec<u8> = indices.iter().flat_map(|x| x.to_ne_bytes()).collect();
+ let indices_buf = ctx.gl.create_buffer().expect("failed to create index buffer object");
+ ctx.gl.bind_buffer(glow::ELEMENT_ARRAY_BUFFER, Some(indices_buf));
+ ctx.gl.buffer_data_u8_slice(
+ glow::ELEMENT_ARRAY_BUFFER,
+ &indices_bytes,
+ glow::STATIC_DRAW,
+ );
+
+ // optionally, we might have some other vertex attributes too
+ if let Some(iter) = reader.read_normals() {
+ for (i, n) in iter.enumerate() {
+ vertices[i].normal = glam::Vec3::from_array(n)
+ }
+ }
+ if let Some(iter) = reader.read_tex_coords(0) {
+ for (i, uv) in iter.into_f32().enumerate() {
+ vertices[i].texcoord = glam::Vec2::from_array(uv)
+ }
+ }
+ if let Some(iter) = reader.read_joints(0) {
+ for (i, j) in iter.into_u16().enumerate() {
+ vertices[i].joints = glam::Vec4::from_slice(&j.into_iter().map(|x| x as f32).collect::<Vec<f32>>())
+ }
+ }
+ if let Some(iter) = reader.read_weights(0) {
+ for (i, w) in iter.into_f32().enumerate() {
+ vertices[i].weights = glam::Vec4::from_array(w)
+ }
+ }
+
+ let vertex_size = std::mem::size_of::<Vertex>() as i32;
+ let vertices_buf = ctx.gl.create_buffer().expect("failed to create buffer object");
+ ctx.gl.bind_buffer(glow::ARRAY_BUFFER, Some(vertices_buf));
+ ctx.gl.buffer_data_u8_slice(
+ glow::ARRAY_BUFFER,
+ std::slice::from_raw_parts(
+ vertices.as_ptr() as _,
+ vertices.len() * (vertex_size as usize),
+ ),
+ glow::STATIC_DRAW,
+ );
+ ctx.gl.enable_vertex_attrib_array(mesh::ATTRIB_VERTEX);
+ ctx.gl.vertex_attrib_pointer_f32(mesh::ATTRIB_VERTEX, 3, glow::FLOAT, false, vertex_size, offset_of!(Vertex, pos) as _);
+ ctx.gl.enable_vertex_attrib_array(mesh::ATTRIB_NORMAL);
+ ctx.gl.vertex_attrib_pointer_f32(mesh::ATTRIB_NORMAL, 3, glow::FLOAT, false, vertex_size, offset_of!(Vertex, normal) as _);
+ ctx.gl.enable_vertex_attrib_array(mesh::ATTRIB_TEXCOORD);
+ ctx.gl.vertex_attrib_pointer_f32(mesh::ATTRIB_TEXCOORD, 2, glow::FLOAT, false, vertex_size, offset_of!(Vertex, texcoord) as _);
+ ctx.gl.enable_vertex_attrib_array(mesh::ATTRIB_JOINT);
+ ctx.gl.vertex_attrib_pointer_f32(mesh::ATTRIB_JOINT, 4, glow::FLOAT, false, vertex_size, offset_of!(Vertex, joints) as _);
+ ctx.gl.enable_vertex_attrib_array(mesh::ATTRIB_WEIGHT);
+ ctx.gl.vertex_attrib_pointer_f32(mesh::ATTRIB_WEIGHT, 4, glow::FLOAT, false, vertex_size, offset_of!(Vertex, weights) as _);
+
+
+ Primitive {
+ mesh: mesh::Mesh {
+ vao,
+ vbo_vertex: vertices_buf,
+ vbo_index: indices_buf,
+ vbo_normal: None,
+ vbo_texcoord: None,
+ mode,
+ index_count: indices.len(),
+ index_type: glow::UNSIGNED_INT,
+ index_offset: 0,
+ },
+ material: p.material().index().unwrap(),
+ }
+ }
+ }).collect();
+ Object {
+ primitives,
+ }
+ }).collect();
+ let textures: Vec<texture::Texture> = images.into_iter().map(|bi| {
+ unsafe {
+ let i = bi.image.into_rgba8();
+ let tex = ctx.gl.create_texture().expect("failed to create texture");
+ ctx.gl.bind_texture(glow::TEXTURE_2D, Some(tex));
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_WRAP_S, glow::CLAMP_TO_EDGE as i32);
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_WRAP_T, glow::CLAMP_TO_EDGE as i32);
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_MIN_FILTER, glow::NEAREST as i32);
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_MAG_FILTER, glow::NEAREST as i32);
+ ctx.gl.tex_image_2d(
+ glow::TEXTURE_2D,
+ 0,
+ glow::RGBA as i32,
+ i.width() as i32,
+ i.height() as i32,
+ 0,
+ glow::RGBA,
+ glow::UNSIGNED_BYTE,
+ Some(i.as_bytes()),
+ );
+ ctx.gl.generate_mipmap(glow::TEXTURE_2D);
+ texture::Texture { tex, width: i.width() as i32, height: i.height() as i32 }
+ }
+ }).collect();
+ let materials: Vec<Material> = gltf.materials().map(|m| {
+ let pbr = m.pbr_metallic_roughness();
+ let [bcr, bcg, bcb, bca] = pbr.base_color_factor();
+ let [emx, emy, emz] = m.emissive_factor();
+ Material {
+ base_color_factor: glam::Vec4::new(bcr, bcg, bcb, bca),
+ base_color_texture: pbr.base_color_texture().map(|tex| tex.texture().source().index()),
+ metallic_factor: pbr.metallic_factor(),
+ roughness_factor: pbr.roughness_factor(),
+ metallic_roughness_texture: pbr.metallic_roughness_texture().map(|tex| tex.texture().source().index()),
+ normal_texture: m.normal_texture().map(|tex| tex.texture().source().index()),
+ occlusion_texture: m.occlusion_texture().map(|tex| tex.texture().source().index()),
+ emissive_factor: glam::Vec3::new(emx, emy, emz),
+ emissive_texture: m.emissive_texture().map(|tex| tex.texture().source().index()),
+ }
+ }).collect();
+
+ let skins = gltf.skins().map(|s| {
+ let ibm = s.reader(get_buffer_data).read_inverse_bind_matrices()
+ .expect("missing read inverse bind matrices")
+ .map(|m| glam::Mat4::from_cols_array_2d(&m)).collect();
+ Skin {
+ inverse_bind_matrices: ibm,
+ joints: s.joints().map(|j| j.index()).collect(),
+ }
+ }).collect();
+
+ let animations = HashMap::from_iter(gltf.animations().filter_map(|a| {
+ let channels = a.channels().map(|c| {
+ let read = c.reader(get_buffer_data);
+ Channel {
+ target: c.target().node().index(),
+ interpolation: match c.sampler().interpolation() {
+ gltf::animation::Interpolation::Linear => Interpolation::Linear,
+ gltf::animation::Interpolation::Step => Interpolation::Step,
+ gltf::animation::Interpolation::CubicSpline => Interpolation::CubicSpline,
+ },
+ keyframes: read.read_inputs().expect("channel has no inputs").collect(),
+ values: match read.read_outputs().expect("channel has no outputs") {
+ gltf::animation::util::ReadOutputs::Translations(ts) =>
+ ChannelValues::Translation(ts.map(glam::Vec3::from_array).collect()),
+ gltf::animation::util::ReadOutputs::Rotations(ts) =>
+ ChannelValues::Rotation(ts.into_f32().map(glam::Quat::from_array).collect()),
+ gltf::animation::util::ReadOutputs::Scales(ts) =>
+ ChannelValues::Scale(ts.map(glam::Vec3::from_array).collect()),
+ _ => panic!("unsupport channel outputs"),
+ },
+ }
+ }).collect();
+ a.name().map(|nm| (nm.to_owned(), Animation { channels }))
+ }));
+
+ let nodes = gltf.nodes().map(|n| {
+ Node {
+ children: n.children().map(|c| c.index()).collect(),
+ object: n.mesh().map(|m| m.index()),
+ skin: n.skin().map(|s| s.index()),
+ transform: glam::Mat4::from_cols_array_2d(&n.transform().matrix()),
+ }
+ }).collect();
+
+ let mut nodes_by_name = HashMap::new();
+ for n in gltf.nodes() {
+ if let Some(nm) = n.name() {
+ nodes_by_name.insert(nm.to_owned(), n.index());
+ }
+ }
+
+ let scene_nodes = gltf.default_scene().unwrap().nodes().map(|n| n.index()).collect();
+
+ Self {
+ objects,
+ textures,
+ materials,
+ skins,
+ animations,
+ nodes,
+ nodes_by_name,
+ scene_nodes,
+ }
+ }
+
+ pub fn compute_joint_matrices(&self, skin: &Skin) -> Vec<glam::Mat4> {
+ let mut q: VecDeque<(Index, glam::Mat4)> = VecDeque::new();
+ q.push_back((skin.joints[0], glam::Mat4::IDENTITY));
+ let mut transforms = vec![glam::Mat4::IDENTITY; self.nodes.len()];
+ while let Some((ni, m)) = q.pop_front() {
+ let n = &self.nodes[ni];
+ transforms[ni] = m.mul_mat4(&n.transform);
+ for ci in &n.children {
+ q.push_back((*ci, transforms[ni]));
+ }
+ }
+ let mut ret = vec![glam::Mat4::IDENTITY; skin.joints.len()];
+ for (idx, ni) in skin.joints.iter().enumerate() {
+ ret[idx] = transforms[*ni].mul_mat4(&skin.inverse_bind_matrices[idx]);
+ }
+ ret
+ }
+
+ fn render_node(&self, ctx: &context::Context, shader: &shader::Shader, n: &Node) {
+ if let Some(o) = n.object.and_then(|i| self.objects.get(i)) {
+ if let Some(s) = n.skin.and_then(|i| self.skins.get(i)) {
+ let jms = self.compute_joint_matrices(s);
+ shader.set_mat4_array(ctx, "joint_matrices[0]", &jms);
+ }
+ for p in &o.primitives {
+ if let Some(tex) = self.materials.get(p.material)
+ .and_then(|m| m.base_color_texture)
+ .and_then(|t| self.textures.get(t)) {
+ tex.bind(ctx);
+ } else {
+ texture::Texture::bind_initial(ctx);
+ }
+ p.mesh.render(ctx);
+ }
+ }
+ }
+
+ pub fn render(&self, ctx: &context::Context, shader: &shader::Shader) {
+ let mut q: VecDeque<Index> = VecDeque::new();
+ for sn in &self.scene_nodes {
+ q.push_back(*sn);
+ }
+ while let Some(ni) = q.pop_front() {
+ let n = &self.nodes[ni];
+ self.render_node(ctx, shader, n);
+ for ci in &n.children {
+ q.push_back(*ci);
+ }
+ }
+ }
+
+ pub fn reflect_animation(&mut self, nm: &str, time: f32) {
+ if let Some(anim) = self.animations.get(nm) {
+ for c in &anim.channels {
+ let (previ, nexti) = if let Some(nexti) = c.keyframes.iter().position(|x| *x > time) {
+ let previ = if nexti > 0 { nexti - 1 } else { c.keyframes.len() - 1 };
+ (previ, nexti)
+ } else {
+ (c.keyframes.len() - 1, 0)
+ };
+ if let ChannelValues::Rotation(vs) = &c.values {
+ let prevt = c.keyframes[previ];
+ let nextt = c.keyframes[nexti];
+ let prev = vs[previ];
+ let next = vs[nexti];
+ let new = prev.slerp(next, (time - prevt) / (nextt - prevt));
+ let (scale, _, trans) = self.nodes[c.target].transform.to_scale_rotation_translation();
+ self.nodes[c.target].transform = glam::Mat4::from_scale_rotation_translation(
+ scale,
+ new,
+ trans,
+ );
+ }
+ }
+ }
+ }
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/shader.rs b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/shader.rs new file mode 100644 index 0000000..d18ba27 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/shader.rs @@ -0,0 +1,260 @@ +use std::collections::HashMap;
+
+use glow::HasContext;
+
+use crate::{context, font, mesh, state};
+
+const COMMON_VERT: &str = include_str!("assets/shaders/common/vert.glsl");
+const COMMON_FRAG: &str = include_str!("assets/shaders/common/frag.glsl");
+
+#[derive(Clone)]
+pub struct Shader {
+ pub program: glow::Program,
+ pub uniforms: std::rc::Rc<HashMap<String, glow::UniformLocation>>
+}
+
+impl Shader {
+ pub fn new_helper(ctx: &context::Context, vsrc: &str, fsrc: &str) -> Result<Self, String> {
+ unsafe {
+ let program = ctx.gl.create_program()?;
+
+ let vert = ctx.gl.create_shader(glow::VERTEX_SHADER)?;
+ ctx.gl.shader_source(vert, vsrc);
+ ctx.gl.compile_shader(vert);
+ if !ctx.gl.get_shader_compile_status(vert) {
+ return Err(format!(
+ "failed to compile vertex shader:\n{}",
+ ctx.gl.get_shader_info_log(vert)
+ ));
+ }
+ ctx.gl.attach_shader(program, vert);
+
+ let frag = ctx.gl.create_shader(glow::FRAGMENT_SHADER)?;
+ ctx.gl.shader_source(frag, fsrc);
+ ctx.gl.compile_shader(frag);
+ if !ctx.gl.get_shader_compile_status(frag) {
+ return Err(format!(
+ "failed to compile fragment shader:\n{}",
+ ctx.gl.get_shader_info_log(frag)
+ ));
+ }
+ ctx.gl.attach_shader(program, frag);
+
+ ctx.gl.bind_attrib_location(program, mesh::ATTRIB_VERTEX, "vertex");
+ ctx.gl.bind_attrib_location(program, mesh::ATTRIB_NORMAL, "normal");
+ ctx.gl.bind_attrib_location(program, mesh::ATTRIB_TEXCOORD, "texcoord");
+ ctx.gl.bind_attrib_location(program, mesh::ATTRIB_JOINT, "joint");
+ ctx.gl.bind_attrib_location(program, mesh::ATTRIB_WEIGHT, "weight");
+ ctx.gl.bind_attrib_location(program, mesh::ATTRIB_COLOR, "color");
+
+ ctx.gl.link_program(program);
+ if !ctx.gl.get_program_link_status(program) {
+ return Err(format!(
+ "failed to link shader program:\n{}",
+ ctx.gl.get_program_info_log(program),
+ ));
+ }
+
+ ctx.gl.detach_shader(program, vert);
+ ctx.gl.delete_shader(vert);
+ ctx.gl.detach_shader(program, frag);
+ ctx.gl.delete_shader(frag);
+
+ ctx.gl.use_program(Some(program));
+
+ let mut uniforms = HashMap::new();
+ for index in 0..ctx.gl.get_active_uniforms(program) {
+ if let Some(active) = ctx.gl.get_active_uniform(program, index) {
+ if let Some(loc) = ctx.gl.get_uniform_location(program, &active.name) {
+ uniforms.insert(active.name, loc);
+ } else {
+ log::warn!("failed to get location for uniform: {}", active.name);
+ }
+ } else {
+ log::warn!("failed to get active uniform for index: {}", index);
+ }
+ }
+
+ Ok(Self {
+ program,
+ uniforms: std::rc::Rc::new(uniforms),
+ })
+ }
+ }
+
+ pub fn new_nolib(ctx: &context::Context, vsrc: &str, fsrc: &str) -> Self {
+ match Self::new_helper(ctx, vsrc, fsrc) {
+ Ok(x) => x,
+ Err(e) => panic!("failed to load no-library shader: {}", e)
+ }
+ }
+
+ pub fn new(ctx: &context::Context, vsrcstr: &str, fsrcstr: &str) -> Self {
+ let vsrc = format!("{}\n{}\n", COMMON_VERT, vsrcstr);
+ let fsrc = format!("{}\n{}\n", COMMON_FRAG, fsrcstr);
+ Self::new_nolib(ctx, &vsrc, &fsrc)
+ }
+
+ pub fn delete(&mut self, ctx: &context::Context) {
+ unsafe { ctx.gl.delete_program(self.program); }
+ }
+
+ pub fn replace(&mut self, ctx: &context::Context, vsrc: &str, fsrc: &str) -> Result<(), String> {
+ self.delete(ctx);
+ *self = Self::new_helper(ctx, vsrc, fsrc)?;
+ Ok(())
+ }
+
+ pub fn set_i32(&self, ctx: &context::Context, name: &str, val: i32) {
+ if let Some(loc) = self.uniforms.get(name) {
+ unsafe { ctx.gl.uniform_1_i32(Some(loc), val) }
+ }
+ }
+
+ pub fn set_i32_array(&self, ctx: &context::Context, name: &str, val: &[i32]) {
+ if let Some(loc) = self.uniforms.get(name) {
+ unsafe {
+ ctx.gl.uniform_1_i32_slice(Some(loc), val)
+ }
+ }
+ }
+
+ pub fn set_f32(&self, ctx: &context::Context, name: &str, val: f32) {
+ if let Some(loc) = self.uniforms.get(name) {
+ unsafe { ctx.gl.uniform_1_f32(Some(loc), val) }
+ }
+ }
+
+ pub fn set_vec2(&self, ctx: &context::Context, name: &str, val: &glam::Vec2) {
+ if let Some(loc) = self.uniforms.get(name) {
+ unsafe {
+ ctx.gl.uniform_2_f32(
+ Some(loc),
+ val.x,
+ val.y,
+ );
+ }
+ }
+ }
+
+ pub fn set_vec2_array(&self, ctx: &context::Context, name: &str, val: &[glam::Vec2]) {
+ if let Some(loc) = self.uniforms.get(name) {
+ let vs: Vec<f32> = val.iter().flat_map(|v| [v.x, v.y]).collect();
+ unsafe {
+ ctx.gl.uniform_2_f32_slice(
+ Some(loc),
+ &vs,
+ );
+ }
+ }
+ }
+
+ pub fn set_vec3(&self, ctx: &context::Context, name: &str, val: &glam::Vec3) {
+ if let Some(loc) = self.uniforms.get(name) {
+ unsafe {
+ ctx.gl.uniform_3_f32(
+ Some(loc),
+ val.x,
+ val.y,
+ val.z,
+ );
+ }
+ }
+ }
+
+ pub fn set_vec3_array(&self, ctx: &context::Context, name: &str, val: &[glam::Vec3]) {
+ if let Some(loc) = self.uniforms.get(name) {
+ let vs: Vec<f32> = val.iter().flat_map(|v| [v.x, v.y, v.z]).collect();
+ unsafe {
+ ctx.gl.uniform_3_f32_slice(
+ Some(loc),
+ &vs,
+ );
+ }
+ }
+ }
+
+ pub fn set_vec4(&self, ctx: &context::Context, name: &str, val: &glam::Vec4) {
+ if let Some(loc) = self.uniforms.get(name) {
+ unsafe {
+ ctx.gl.uniform_4_f32(
+ Some(loc),
+ val.x,
+ val.y,
+ val.z,
+ val.w,
+ );
+ }
+ }
+ }
+
+ pub fn set_mat4(&self, ctx: &context::Context, name: &str, val: &glam::Mat4) {
+ if let Some(loc) = self.uniforms.get(name) {
+ unsafe {
+ ctx.gl.uniform_matrix_4_f32_slice(
+ Some(loc),
+ false,
+ &val.to_cols_array(),
+ );
+ }
+ }
+ }
+
+ pub fn set_mat4_array(&self, ctx: &context::Context, name: &str, val: &[glam::Mat4]) {
+ if let Some(loc) = self.uniforms.get(name) {
+ let vs: Vec<f32> = val.iter().flat_map(|m| m.to_cols_array()).collect();
+ unsafe {
+ ctx.gl.uniform_matrix_4_f32_slice(
+ Some(loc),
+ false,
+ &vs,
+ );
+ }
+ }
+ }
+
+ pub fn set_position_3d(&self, ctx: &context::Context, _st: &state::State, position: &glam::Mat4) {
+ self.set_mat4(ctx, "position", position);
+ self.set_mat4(ctx, "normal_matrix", &position.inverse().transpose());
+ }
+
+ pub fn set_position_2d_mat(&self, ctx: &context::Context, st: &state::State, position: &glam::Mat4) {
+ self.set_mat4(ctx, "position", position);
+ }
+
+ pub fn set_position_2d_helper(&self, ctx: &context::Context, st: &state::State, pos: &glam::Vec2, dims: &glam::Vec2, rot: &glam::Quat) {
+ let halfwidth = dims.x / 2.0;
+ let halfheight = dims.y / 2.0;
+ self.set_mat4(
+ ctx, "position",
+ &glam::Mat4::from_scale_rotation_translation(
+ glam::Vec3::new(halfwidth, halfheight, 1.0),
+ *rot,
+ glam::Vec3::new(
+ -st.render_dims.x / 2.0 + pos.x + halfwidth,
+ st.render_dims.y / 2.0 - pos.y - halfheight,
+ 0.0,
+ ),
+ )
+ );
+ }
+
+ pub fn set_position_2d(&self, ctx: &context::Context, st: &state::State, pos: &glam::Vec2, dims: &glam::Vec2) {
+ self.set_position_2d_helper(ctx, st, pos, dims, &glam::Quat::IDENTITY)
+ }
+
+ pub fn set_position_text_bitmap(&self,
+ ctx: &context::Context, st: &state::State,
+ font: &font::Bitmap,
+ pos: &glam::Vec2
+ ) {
+ let dims = glam::Vec2::new(font.char_width as f32, font.char_height as f32);
+ self.set_position_2d_helper(ctx, st, pos, &dims, &glam::Quat::IDENTITY)
+ }
+
+ pub fn bind(&self, ctx: &context::Context) {
+ unsafe {
+ ctx.gl.use_program(Some(self.program));
+ }
+ }
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/shadow.rs b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/shadow.rs new file mode 100644 index 0000000..8482179 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/shadow.rs @@ -0,0 +1,127 @@ +use glow::HasContext;
+
+use crate::context;
+
+pub struct ShadowBuffer {
+ pub fbo: glow::Framebuffer,
+ pub depth_tex: glow::Texture,
+ pub width: i32,
+ pub height: i32,
+}
+
+impl ShadowBuffer {
+ pub fn new(ctx: &context::Context, w: i32, h: i32) -> Self {
+ unsafe {
+ // generate and bind FBO
+ let fbo = ctx.gl.create_framebuffer().expect("failed to create framebuffer");
+ ctx.gl.bind_framebuffer(glow::FRAMEBUFFER, Some(fbo));
+
+ // generate and attach depth buffer
+ let depth_tex = ctx.gl.create_texture().expect("failed to create texture");
+ ctx.gl.bind_texture(glow::TEXTURE_2D, Some(depth_tex));
+ ctx.gl.tex_image_2d(
+ glow::TEXTURE_2D,
+ 0,
+ glow::DEPTH_COMPONENT as i32,
+ w,
+ h,
+ 0,
+ glow::DEPTH_COMPONENT,
+ glow::FLOAT,
+ None,
+ );
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_MIN_FILTER, glow::LINEAR as i32);
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_MAG_FILTER, glow::LINEAR as i32);
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_WRAP_S, glow::CLAMP_TO_BORDER as i32);
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_WRAP_T, glow::CLAMP_TO_BORDER as i32);
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_COMPARE_MODE, glow::COMPARE_REF_TO_TEXTURE as i32);
+ ctx.gl.tex_parameter_f32_slice(glow::TEXTURE_2D, glow::TEXTURE_BORDER_COLOR, &[1.0, 1.0, 1.0, 1.0]);
+ ctx.gl.framebuffer_texture_2d(glow::FRAMEBUFFER, glow::DEPTH_ATTACHMENT, glow::TEXTURE_2D, Some(depth_tex), 0);
+ ctx.gl.draw_buffer(glow::NONE);
+ ctx.gl.read_buffer(glow::NONE);
+
+ let status = ctx.gl.check_framebuffer_status(glow::FRAMEBUFFER);
+ if status != glow::FRAMEBUFFER_COMPLETE {
+ panic!("error initializing framebuffer: {}", status);
+ }
+ Self {
+ fbo,
+ depth_tex,
+ width: w,
+ height: h,
+ }
+ }
+ }
+
+ pub fn bind(&self, ctx: &context::Context) {
+ unsafe {
+ ctx.gl.bind_framebuffer(glow::FRAMEBUFFER, Some(self.fbo));
+ ctx.gl.viewport(0, 0, self.width as _, self.height as _);
+ ctx.gl.clear(glow::DEPTH_BUFFER_BIT);
+
+ }
+ }
+}
+
+pub struct ShadowBuffer3D {
+ pub fbo: glow::Framebuffer,
+ pub depth_cubemap: glow::Texture,
+ pub width: i32,
+ pub height: i32,
+}
+
+impl ShadowBuffer3D {
+ pub fn new(ctx: &context::Context, w: i32, h: i32) -> Self {
+ unsafe {
+ // generate and bind FBO
+ let fbo = ctx.gl.create_framebuffer().expect("failed to create framebuffer");
+ ctx.gl.bind_framebuffer(glow::FRAMEBUFFER, Some(fbo));
+
+ // generate and attach depth buffer
+ let depth_cubemap = ctx.gl.create_texture().expect("failed to create texture");
+ ctx.gl.bind_texture(glow::TEXTURE_CUBE_MAP, Some(depth_cubemap));
+ for i in 0..6 {
+ ctx.gl.tex_image_2d(
+ glow::TEXTURE_CUBE_MAP_POSITIVE_X + i,
+ 0,
+ glow::DEPTH_COMPONENT as i32,
+ w,
+ h,
+ 0,
+ glow::DEPTH_COMPONENT,
+ glow::FLOAT,
+ None,
+ );
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_CUBE_MAP, glow::TEXTURE_MIN_FILTER, glow::LINEAR as i32);
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_CUBE_MAP, glow::TEXTURE_MAG_FILTER, glow::LINEAR as i32);
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_CUBE_MAP, glow::TEXTURE_WRAP_S, glow::CLAMP_TO_EDGE as i32);
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_CUBE_MAP, glow::TEXTURE_WRAP_T, glow::CLAMP_TO_EDGE as i32);
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_CUBE_MAP, glow::TEXTURE_WRAP_R, glow::CLAMP_TO_EDGE as i32);
+ }
+
+ ctx.gl.framebuffer_texture(glow::FRAMEBUFFER, glow::DEPTH_ATTACHMENT, Some(depth_cubemap), 0);
+ ctx.gl.draw_buffer(glow::NONE);
+ ctx.gl.read_buffer(glow::NONE);
+
+ let status = ctx.gl.check_framebuffer_status(glow::FRAMEBUFFER);
+ if status != glow::FRAMEBUFFER_COMPLETE {
+ panic!("error initializing framebuffer: {}", status);
+ }
+ Self {
+ fbo,
+ depth_cubemap,
+ width: w,
+ height: h,
+ }
+ }
+ }
+
+ pub fn bind(&self, ctx: &context::Context) {
+ unsafe {
+ ctx.gl.bind_framebuffer(glow::FRAMEBUFFER, Some(self.fbo));
+ ctx.gl.viewport(0, 0, self.width as _, self.height as _);
+ ctx.gl.clear(glow::DEPTH_BUFFER_BIT);
+
+ }
+ }
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/state.rs b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/state.rs new file mode 100644 index 0000000..3353f33 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/state.rs @@ -0,0 +1,735 @@ +#![allow(dead_code, unused_variables)]
+use bimap::BiHashMap;
+use enum_map::{Enum, EnumMap, enum_map};
+use serde::{Deserialize, Serialize};
+use std::{collections::HashMap, fmt::Display};
+use strum::EnumIter;
+
+#[cfg(not(target_arch = "wasm32"))]
+use glow::HasContext;
+
+use crate::{audio, context, font, framebuffer, mesh, shader, utils};
+
+pub type Tick = u64;
+
+const DELTA_TIME: f64 = 0.016; // todo
+
+pub const ORTH_WIDTH: f32 = 7.55869;
+pub const ORTH_HEIGHT: f32 = 5.03913;
+
+pub trait Game {
+ fn initialize(&mut self, ctx: &context::Context, st: &mut State) -> utils::Erm<()> {
+ Ok(())
+ }
+ fn finalize(&mut self, ctx: &context::Context, st: &mut State) -> utils::Erm<()> {
+ Ok(())
+ }
+ fn initialize_audio(
+ &self,
+ ctx: &context::Context,
+ st: &State,
+ actx: &audio::Context,
+ ) -> HashMap<String, audio::Audio> {
+ HashMap::new()
+ }
+ fn keybindings_were_reset(&mut self, ctx: &context::Context, st: &mut State) -> utils::Erm<()> {
+ Ok(())
+ }
+ fn mouse_move(
+ &mut self,
+ ctx: &context::Context,
+ st: &mut State,
+ x: i32,
+ y: i32,
+ ) -> utils::Erm<()> {
+ Ok(())
+ }
+ fn mouse_press(&mut self, ctx: &context::Context, st: &mut State) -> utils::Erm<()> {
+ Ok(())
+ }
+ fn mouse_released(&mut self, ctx: &context::Context, st: &mut State) -> utils::Erm<()> {
+ Ok(())
+ }
+ fn update(&mut self, ctx: &context::Context, st: &mut State) -> utils::Erm<()> {
+ Ok(())
+ }
+ fn render(&mut self, ctx: &context::Context, st: &mut State) -> utils::Erm<()> {
+ Ok(())
+ }
+}
+
+#[derive(Debug, Enum, EnumIter, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum Key {
+ Up,
+ Down,
+ Left,
+ Right,
+ A,
+ B,
+ X,
+ Y,
+ L,
+ R,
+ Start,
+ Select,
+ Debug,
+}
+#[derive(Default)]
+pub struct Keys {
+ pub pressed: EnumMap<Key, bool>,
+ pub new: EnumMap<Key, bool>,
+}
+impl Keys {
+ pub fn new() -> Self {
+ Self::default()
+ }
+ pub fn up(&self) -> bool {
+ self.pressed[Key::Up]
+ }
+ pub fn down(&self) -> bool {
+ self.pressed[Key::Down]
+ }
+ pub fn left(&self) -> bool {
+ self.pressed[Key::Left]
+ }
+ pub fn right(&self) -> bool {
+ self.pressed[Key::Right]
+ }
+ pub fn a(&self) -> bool {
+ self.pressed[Key::A]
+ }
+ pub fn b(&self) -> bool {
+ self.pressed[Key::B]
+ }
+ pub fn x(&self) -> bool {
+ self.pressed[Key::X]
+ }
+ pub fn y(&self) -> bool {
+ self.pressed[Key::Y]
+ }
+ pub fn l(&self) -> bool {
+ self.pressed[Key::L]
+ }
+ pub fn r(&self) -> bool {
+ self.pressed[Key::R]
+ }
+ pub fn start(&self) -> bool {
+ self.pressed[Key::Start]
+ }
+ pub fn select(&self) -> bool {
+ self.pressed[Key::Select]
+ }
+ pub fn debug(&self) -> bool {
+ self.pressed[Key::Debug]
+ }
+ pub fn new_up(&mut self) -> bool {
+ let ret = self.new[Key::Up];
+ self.new[Key::Up] = false;
+ ret
+ }
+ pub fn new_down(&mut self) -> bool {
+ let ret = self.new[Key::Down];
+ self.new[Key::Down] = false;
+ ret
+ }
+ pub fn new_left(&mut self) -> bool {
+ let ret = self.new[Key::Left];
+ self.new[Key::Left] = false;
+ ret
+ }
+ pub fn new_right(&mut self) -> bool {
+ let ret = self.new[Key::Right];
+ self.new[Key::Right] = false;
+ ret
+ }
+ pub fn new_a(&mut self) -> bool {
+ let ret = self.new[Key::A];
+ self.new[Key::A] = false;
+ ret
+ }
+ pub fn new_b(&mut self) -> bool {
+ let ret = self.new[Key::B];
+ self.new[Key::B] = false;
+ ret
+ }
+ pub fn new_x(&mut self) -> bool {
+ let ret = self.new[Key::X];
+ self.new[Key::X] = false;
+ ret
+ }
+ pub fn new_y(&mut self) -> bool {
+ let ret = self.new[Key::Y];
+ self.new[Key::Y] = false;
+ ret
+ }
+ pub fn new_l(&mut self) -> bool {
+ let ret = self.new[Key::L];
+ self.new[Key::L] = false;
+ ret
+ }
+ pub fn new_r(&mut self) -> bool {
+ let ret = self.new[Key::R];
+ self.new[Key::R] = false;
+ ret
+ }
+ pub fn new_start(&mut self) -> bool {
+ let ret = self.new[Key::Start];
+ self.new[Key::Start] = false;
+ ret
+ }
+ pub fn new_select(&mut self) -> bool {
+ let ret = self.new[Key::Select];
+ self.new[Key::Select] = false;
+ ret
+ }
+ pub fn new_debug(&mut self) -> bool {
+ let ret = self.new[Key::Debug];
+ self.new[Key::Debug] = false;
+ ret
+ }
+}
+
+pub struct PointLight {
+ pub pos: glam::Vec3,
+ pub color: glam::Vec3,
+ pub attenuation: glam::Vec2,
+}
+
+type Timestamp = f64;
+
+#[cfg(target_arch = "wasm32")]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct Keycode {
+ pub kc: winit::keyboard::KeyCode,
+}
+#[cfg(target_arch = "wasm32")]
+impl Keycode {
+ pub fn new(kc: winit::keyboard::KeyCode) -> Self {
+ Self { kc }
+ }
+}
+#[cfg(target_arch = "wasm32")]
+impl Display for Keycode {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ write!(f, "{:?}", self.kc)
+ }
+}
+#[cfg(target_arch = "wasm32")]
+impl Serialize for Keycode {
+ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: serde::Serializer,
+ {
+ self.kc.serialize(serializer)
+ }
+}
+#[cfg(target_arch = "wasm32")]
+impl<'de> Deserialize<'de> for Keycode {
+ fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+ where
+ D: serde::Deserializer<'de>,
+ {
+ let kc = winit::keyboard::KeyCode::deserialize(deserializer)?;
+ Ok(Self { kc })
+ }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct Keycode {
+ pub kc: glfw::Key,
+}
+#[cfg(not(target_arch = "wasm32"))]
+impl Keycode {
+ pub fn new(kc: glfw::Key) -> Self {
+ Self { kc }
+ }
+}
+#[cfg(not(target_arch = "wasm32"))]
+impl Display for Keycode {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ write!(f, "{:?}", self.kc)
+ }
+}
+#[cfg(not(target_arch = "wasm32"))]
+impl Serialize for Keycode {
+ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: serde::Serializer,
+ {
+ (self.kc as i32).serialize(serializer)
+ }
+}
+#[cfg(not(target_arch = "wasm32"))]
+impl<'de> Deserialize<'de> for Keycode {
+ fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+ where
+ D: serde::Deserializer<'de>,
+ {
+ i32::deserialize(deserializer).map(|x| unsafe { std::mem::transmute(x) })
+ }
+}
+
+pub struct State {
+ pub tick: Tick,
+ pub nextframe: Timestamp,
+ pub fps: u32,
+ pub frames_this_second: u32,
+ pub start_this_second: Timestamp,
+
+ pub rebinding: Option<Key>,
+ pub keybindings: BiHashMap<Keycode, Key>,
+ pub keys: Keys,
+
+ pub screen: framebuffer::Framebuffer,
+ pub render_framebuffer: framebuffer::Framebuffer,
+ pub render_dims: glam::Vec2,
+ pub shader_upscale: shader::Shader,
+ pub shader_text_bitmap: shader::Shader,
+ pub mesh_square: mesh::Mesh,
+ pub font_default: font::Bitmap,
+ pub font_small: font::Bitmap,
+ pub audio: Option<audio::Assets>,
+
+ pub projection: glam::Mat4,
+ pub projection_orth: glam::Mat4,
+ pub camera: (glam::Vec3, glam::Vec3, glam::Vec3),
+ pub lighting: (glam::Vec3, glam::Vec3, glam::Vec3),
+ pub point_lights: Vec<PointLight>,
+}
+
+#[cfg(target_arch = "wasm32")]
+pub fn now(ctx: &context::Context) -> Timestamp {
+ ctx.performance.now() / 1000.0
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub fn now(ctx: &context::Context) -> Timestamp {
+ let elapsed = ctx.start_instant.elapsed();
+ let ms = elapsed.as_millis();
+ (ms as f64) / 1000.0
+}
+
+#[cfg(target_arch = "wasm32")]
+pub fn default_keybindings() -> BiHashMap<Keycode, Key> {
+ BiHashMap::from_iter(vec![
+ (Keycode::new(winit::keyboard::KeyCode::KeyW), Key::Up),
+ (Keycode::new(winit::keyboard::KeyCode::KeyS), Key::Down),
+ (Keycode::new(winit::keyboard::KeyCode::KeyA), Key::Left),
+ (Keycode::new(winit::keyboard::KeyCode::KeyD), Key::Right),
+ (Keycode::new(winit::keyboard::KeyCode::Digit1), Key::A),
+ (Keycode::new(winit::keyboard::KeyCode::Digit2), Key::B),
+ (Keycode::new(winit::keyboard::KeyCode::Digit3), Key::X),
+ (Keycode::new(winit::keyboard::KeyCode::Digit4), Key::Y),
+ (Keycode::new(winit::keyboard::KeyCode::KeyQ), Key::L),
+ (Keycode::new(winit::keyboard::KeyCode::KeyE), Key::R),
+ (Keycode::new(winit::keyboard::KeyCode::Tab), Key::Start),
+ (Keycode::new(winit::keyboard::KeyCode::Space), Key::Select),
+ (
+ Keycode::new(winit::keyboard::KeyCode::Backquote),
+ Key::Debug,
+ ),
+ ])
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub fn default_keybindings() -> BiHashMap<Keycode, Key> {
+ BiHashMap::from_iter(vec![
+ (Keycode::new(glfw::Key::W), Key::Up),
+ (Keycode::new(glfw::Key::S), Key::Down),
+ (Keycode::new(glfw::Key::A), Key::Left),
+ (Keycode::new(glfw::Key::D), Key::Right),
+ (Keycode::new(glfw::Key::Num1), Key::A),
+ (Keycode::new(glfw::Key::Num2), Key::B),
+ (Keycode::new(glfw::Key::Num3), Key::X),
+ (Keycode::new(glfw::Key::Num4), Key::Y),
+ (Keycode::new(glfw::Key::Q), Key::L),
+ (Keycode::new(glfw::Key::E), Key::R),
+ (Keycode::new(glfw::Key::Tab), Key::Start),
+ (Keycode::new(glfw::Key::Space), Key::Select),
+ (Keycode::new(glfw::Key::GraveAccent), Key::Debug),
+ ])
+}
+
+impl State {
+ pub fn new(ctx: &context::Context) -> Self {
+ let screen = framebuffer::Framebuffer::screen(ctx);
+ let render_framebuffer = framebuffer::Framebuffer::new(
+ ctx,
+ &glam::Vec2::new(ctx.render_width, ctx.render_height),
+ &glam::Vec2::new(0.0, 0.0),
+ );
+ let shader_upscale = shader::Shader::new_nolib(
+ ctx,
+ include_str!("assets/shaders/scale/vert.glsl"),
+ include_str!("assets/shaders/scale/frag.glsl"),
+ );
+ let shader_text_bitmap = shader::Shader::new_nolib(
+ ctx,
+ include_str!("assets/shaders/bitmap/vert.glsl"),
+ include_str!("assets/shaders/bitmap/frag.glsl"),
+ );
+ let mesh_square = mesh::Mesh::from_obj(ctx, include_bytes!("assets/meshes/square.obj"));
+
+ let nextframe = now(ctx);
+
+ Self {
+ // we initialize the tick to 1000, which allows us to use "0" as the default time for
+ // various animation starts on entities without having them all play at game start
+ tick: 1000,
+
+ nextframe,
+ fps: 0,
+ frames_this_second: 0,
+ start_this_second: nextframe,
+
+ rebinding: None,
+ keybindings: default_keybindings(),
+ keys: Keys::new(),
+
+ screen,
+ render_framebuffer,
+ render_dims: glam::Vec2::new(ctx.render_width, ctx.render_height),
+ shader_upscale,
+ shader_text_bitmap,
+ mesh_square,
+ font_default: font::Bitmap::default(ctx),
+ font_small: font::Bitmap::small(ctx),
+ audio: None,
+
+ projection: glam::Mat4::perspective_lh(
+ std::f32::consts::PI / 4.0,
+ ctx.render_width / ctx.render_height,
+ // 0.1,
+ 0.5,
+ 50.0,
+ ),
+ projection_orth: glam::Mat4::orthographic_lh(
+ -ORTH_WIDTH,
+ ORTH_WIDTH,
+ -ORTH_HEIGHT,
+ ORTH_HEIGHT,
+ 0.5,
+ 50.0,
+ ),
+ camera: (
+ glam::Vec3::new(0.0, 0.0, 0.0),
+ glam::Vec3::new(0.0, 0.0, 1.0),
+ glam::Vec3::new(0.0, 1.0, 0.0),
+ ),
+ lighting: (
+ glam::Vec3::new(1.0, 1.0, 1.0),
+ glam::Vec3::new(1.0, 1.0, 1.0),
+ glam::Vec3::new(1.0, -1.0, 1.0),
+ ),
+ point_lights: Vec::new(),
+ // waker_ctx,
+ // http_client: reqwest::Client::new(),
+ // request: None,
+ }
+ }
+
+ pub fn handle_resize(&mut self, ctx: &context::Context) {
+ self.screen = framebuffer::Framebuffer::screen(ctx);
+ }
+
+ pub fn move_camera(
+ &mut self,
+ _ctx: &context::Context,
+ pos: &glam::Vec3,
+ dir: &glam::Vec3,
+ up: &glam::Vec3,
+ ) {
+ self.camera = (*pos, *dir, *up);
+ }
+
+ pub fn bind_framebuffer(&mut self, ctx: &context::Context, fb: &framebuffer::Framebuffer) {
+ fb.bind(ctx);
+ self.render_dims = fb.dims;
+ }
+
+ pub fn bind_render_framebuffer(&mut self, ctx: &context::Context) {
+ self.render_framebuffer.bind(ctx);
+ self.render_dims = self.render_framebuffer.dims;
+ }
+
+ pub fn bind_screen(&mut self, ctx: &context::Context) {
+ self.screen.bind(ctx);
+ self.render_dims = self.screen.dims;
+ }
+
+ pub fn set_lighting(
+ &mut self,
+ _ctx: &context::Context,
+ ambient: &glam::Vec3,
+ color: &glam::Vec3,
+ dir: &glam::Vec3,
+ ) {
+ self.lighting = (*ambient, *color, *dir);
+ }
+
+ pub fn add_point_light(
+ &mut self,
+ _ctx: &context::Context,
+ pos: &glam::Vec3,
+ color: &glam::Vec3,
+ attenuation: &glam::Vec2,
+ ) {
+ self.point_lights.push(PointLight {
+ pos: *pos,
+ color: *color,
+ attenuation: *attenuation,
+ });
+ }
+
+ pub fn clear_point_lights(&mut self, _ctx: &context::Context) {
+ self.point_lights.clear();
+ }
+
+ pub fn view(&self) -> glam::Mat4 {
+ glam::Mat4::look_to_lh(self.camera.0, self.camera.1, self.camera.2)
+ }
+
+ pub fn bind_3d_helper(
+ &self,
+ ctx: &context::Context,
+ shader: &shader::Shader,
+ plc: usize,
+ orth: bool,
+ ) {
+ shader.bind(ctx);
+ shader.set_mat4(
+ ctx,
+ "projection",
+ if orth {
+ &self.projection_orth
+ } else {
+ &self.projection
+ },
+ );
+ shader.set_mat4(ctx, "view", &self.view());
+ shader.set_vec3(ctx, "light_ambient_color", &self.lighting.0);
+ shader.set_vec3(ctx, "light_dir_color", &self.lighting.1);
+ shader.set_vec3(ctx, "light_dir", &self.lighting.2.normalize());
+ shader.set_i32(ctx, "light_count", plc as _);
+ }
+
+ pub fn bind_3d_no_point_lights(&self, ctx: &context::Context, shader: &shader::Shader) {
+ self.bind_3d_helper(ctx, shader, 0, false);
+ }
+
+ pub fn bind_3d_with_point_lights(
+ &self,
+ ctx: &context::Context,
+ shader: &shader::Shader,
+ orth: bool,
+ ) {
+ let plc = self.point_lights.len().min(5);
+ self.bind_3d_helper(ctx, shader, plc, orth);
+ if plc > 0 {
+ let lpos: Vec<_> = self.point_lights.iter().take(plc).map(|l| l.pos).collect();
+ shader.set_vec3_array(ctx, "light_pos[0]", &lpos);
+ let lcolor: Vec<_> = self
+ .point_lights
+ .iter()
+ .take(plc)
+ .map(|l| l.color)
+ .collect();
+ shader.set_vec3_array(ctx, "light_color[0]", &lcolor);
+ let lattenuation: Vec<_> = self
+ .point_lights
+ .iter()
+ .take(plc)
+ .map(|l| l.attenuation)
+ .collect();
+ shader.set_vec2_array(ctx, "light_attenuation[0]", &lattenuation);
+ }
+ }
+
+ pub fn bind_3d(&self, ctx: &context::Context, shader: &shader::Shader) {
+ self.bind_3d_with_point_lights(ctx, shader, false)
+ }
+
+ pub fn bind_3d_orth(&self, ctx: &context::Context, shader: &shader::Shader) {
+ self.bind_3d_with_point_lights(ctx, shader, true)
+ }
+
+ pub fn bind_2d(&self, ctx: &context::Context, shader: &shader::Shader) {
+ shader.bind(ctx);
+ shader.set_mat4(ctx, "projection", &glam::Mat4::IDENTITY);
+ shader.set_mat4(
+ ctx,
+ "view",
+ &glam::Mat4::from_scale(glam::Vec3::new(
+ 2.0 / ctx.render_width,
+ 2.0 / ctx.render_height,
+ 1.0,
+ )),
+ );
+ }
+
+ pub fn initialize_audio<G>(&mut self, ctx: &context::Context, game: &mut G) -> utils::Erm<()>
+ where
+ G: Game,
+ {
+ if self.audio.is_none() {
+ self.audio = Some(audio::Assets::new(|actx| {
+ game.initialize_audio(ctx, self, actx)
+ }));
+ }
+ Ok(())
+ }
+
+ pub fn mouse_moved<G>(
+ &mut self,
+ ctx: &context::Context,
+ x: f32,
+ y: f32,
+ game: &mut G,
+ ) -> utils::Erm<()>
+ where
+ G: Game,
+ {
+ if ctx.options.contains(crate::Options::FULLSCREEN_MOUSE) {
+ game.mouse_move(
+ ctx,
+ self,
+ (x * ctx.render_width / self.screen.dims.x) as i32,
+ (y * ctx.render_height / self.screen.dims.y) as i32,
+ )?;
+ } else {
+ let rx = ((x - self.screen.offsets.x) * ctx.render_width / self.screen.dims.x) as i32;
+ let ry = ((y - self.screen.offsets.y) * ctx.render_height / self.screen.dims.y) as i32;
+ if !(rx < 0
+ || rx >= ctx.render_width as i32
+ || ry < 0
+ || ry >= ctx.render_height as i32)
+ {
+ game.mouse_move(ctx, self, rx, ry)?;
+ }
+ }
+ Ok(())
+ }
+
+ pub fn mouse_pressed<G>(&mut self, ctx: &context::Context, game: &mut G) -> utils::Erm<()>
+ where
+ G: Game,
+ {
+ self.initialize_audio(ctx, game)?;
+ game.mouse_press(ctx, self)?;
+ Ok(())
+ }
+
+ pub fn mouse_released<G>(&mut self, ctx: &context::Context, game: &mut G) -> utils::Erm<()>
+ where
+ G: Game,
+ {
+ game.mouse_released(ctx, self)?;
+ Ok(())
+ }
+
+ pub fn key_pressed<G>(
+ &mut self,
+ ctx: &context::Context,
+ game: &mut G,
+ key: Keycode,
+ ) -> utils::Erm<()>
+ where
+ G: Game,
+ {
+ #[cfg(target_arch = "wasm32")]
+ let rebind = key.kc == winit::keyboard::KeyCode::F12;
+ #[cfg(not(target_arch = "wasm32"))]
+ let rebind = key.kc == glfw::Key::F12;
+ if rebind {
+ self.keybindings = default_keybindings();
+ self.rebinding = None;
+ game.keybindings_were_reset(ctx, self)?;
+ } else if let Some(k) = self.rebinding {
+ self.keybindings.insert(key, k);
+ self.rebinding = None;
+ } else if let Some(k) = self.keybindings.get_by_left(&key) {
+ self.keys.pressed[*k] = true;
+ self.keys.new[*k] = true;
+ }
+ Ok(())
+ }
+
+ pub fn key_released<G>(
+ &mut self,
+ _ctx: &context::Context,
+ _game: &mut G,
+ key: Keycode,
+ ) -> utils::Erm<()>
+ where
+ G: Game,
+ {
+ if let Some(k) = self.keybindings.get_by_left(&key) {
+ self.keys.pressed[*k] = false;
+ }
+ Ok(())
+ }
+
+ /// Return the first keybinding for the given virtual key
+ pub fn keybinding_for(&self, k: Key) -> Option<String> {
+ self.keybindings
+ .get_by_right(&k)
+ .map(|kc| format!("{}", kc))
+ }
+
+ pub fn rebind_key(&mut self, k: Key) {
+ self.rebinding = Some(k);
+ }
+
+ pub fn run_update<G>(&mut self, ctx: &context::Context, game: &mut G) -> utils::Erm<()>
+ where
+ G: Game,
+ {
+ let now = now(ctx);
+ if now > self.nextframe {
+ while self.nextframe < now {
+ // find the next target frame that isn't in the past
+ self.nextframe += DELTA_TIME;
+ }
+ self.tick += 1;
+ self.frames_this_second += 1;
+ game.update(ctx, self)?;
+ self.keys.new = enum_map! { _ => false };
+ }
+ if now - self.start_this_second > 1.0 {
+ // track FPS
+ self.start_this_second = now;
+ self.fps = self.frames_this_second;
+ self.frames_this_second = 0;
+ }
+ Ok(())
+ }
+
+ pub fn run_render<G>(&mut self, ctx: &context::Context, game: &mut G) -> utils::Erm<()>
+ where
+ G: Game,
+ {
+ self.bind_screen(ctx);
+ ctx.clear_color(if ctx.options.contains(crate::Options::OVERLAY) {
+ glam::Vec4::new(0.0, 0.0, 0.0, 0.0)
+ } else {
+ glam::Vec4::new(0.0, 0.0, 0.0, 1.0)
+ });
+ ctx.clear();
+
+ game.render(ctx, self)?;
+
+ #[cfg(all(debug_assertions, not(target_arch = "wasm32")))]
+ {
+ let err = unsafe { ctx.gl.get_error() };
+ if err != glow::NO_ERROR {
+ log::warn!("opengl error: {}", err);
+ }
+ // let log = unsafe { ctx.gl.get_debug_message_log(5) };
+ // for m in log {
+ // log::warn!("opengl debug message: {:?}", m);
+ // }
+ }
+ Ok(())
+ }
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/texture.rs b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/texture.rs new file mode 100644 index 0000000..b9749a2 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/texture.rs @@ -0,0 +1,156 @@ +use glow::HasContext;
+use image::EncodableLayout;
+
+use crate::context;
+
+pub struct Texture {
+ pub tex: glow::Texture,
+ pub width: i32,
+ pub height: i32,
+}
+
+impl Texture {
+ pub fn new_empty(ctx: &context::Context) -> Self {
+ unsafe {
+ let tex = ctx.gl.create_texture().expect("failed to create texture");
+ ctx.gl.bind_texture(glow::TEXTURE_2D, Some(tex));
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_WRAP_S, glow::CLAMP_TO_EDGE as i32);
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_WRAP_T, glow::CLAMP_TO_EDGE as i32);
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_MIN_FILTER, glow::NEAREST as i32);
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_MAG_FILTER, glow::NEAREST as i32);
+ Self {
+ tex,
+ width: 0, height: 0,
+ }
+ }
+ }
+
+ pub fn new(ctx: &context::Context, bytes: &[u8]) -> Self {
+ let rgba = image::ImageReader::new(std::io::Cursor::new(bytes))
+ .with_guessed_format()
+ .expect("failed to guess image format")
+ .decode()
+ .expect("failed to decode image")
+ .into_rgba8();
+ let pixels = rgba.as_bytes();
+ unsafe {
+ let tex = ctx.gl.create_texture().expect("failed to create texture");
+ ctx.gl.bind_texture(glow::TEXTURE_2D, Some(tex));
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_WRAP_S, glow::CLAMP_TO_EDGE as i32);
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_WRAP_T, glow::CLAMP_TO_EDGE as i32);
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_MIN_FILTER, glow::NEAREST as i32);
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_MAG_FILTER, glow::NEAREST as i32);
+ ctx.gl.tex_image_2d(
+ glow::TEXTURE_2D,
+ 0,
+ glow::RGBA as i32,
+ rgba.width() as i32,
+ rgba.height() as i32,
+ 0,
+ glow::RGBA,
+ glow::UNSIGNED_BYTE,
+ Some(pixels),
+ );
+ ctx.gl.generate_mipmap(glow::TEXTURE_2D);
+
+ Self {
+ tex,
+ width: rgba.width() as i32,
+ height: rgba.height() as i32,
+ }
+ }
+ }
+
+ pub fn upload(&mut self, ctx: &context::Context, bytes: &[u8]) {
+ let rgba = image::ImageReader::new(std::io::Cursor::new(bytes))
+ .with_guessed_format()
+ .expect("failed to guess image format")
+ .decode()
+ .expect("failed to decode image")
+ .into_rgba8();
+ let pixels = rgba.as_bytes();
+ self.upload_rgba8(ctx, rgba.width() as i32, rgba.height() as i32, pixels);
+ }
+
+ pub fn upload_rgba8(&mut self, ctx: &context::Context, width: i32, height: i32, data: &[u8]) {
+ unsafe {
+ ctx.gl.bind_texture(glow::TEXTURE_2D, Some(self.tex));
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_WRAP_S, glow::CLAMP_TO_EDGE as i32);
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_WRAP_T, glow::CLAMP_TO_EDGE as i32);
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_MIN_FILTER, glow::NEAREST as i32);
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_MAG_FILTER, glow::NEAREST as i32);
+ ctx.gl.tex_image_2d(
+ glow::TEXTURE_2D,
+ 0,
+ glow::RGBA as i32,
+ width,
+ height,
+ 0,
+ glow::RGBA,
+ glow::UNSIGNED_BYTE,
+ Some(data),
+ );
+ ctx.gl.generate_mipmap(glow::TEXTURE_2D);
+ }
+ self.width = width;
+ self.height = height;
+ }
+
+ pub fn set_repeat(&self, ctx: &context::Context) {
+ unsafe {
+ ctx.gl.bind_texture(glow::TEXTURE_2D, Some(self.tex));
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_WRAP_S, glow::REPEAT as i32);
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_WRAP_T, glow::REPEAT as i32);
+ }
+ }
+
+ pub fn set_anisotropic_filtering(&self, ctx: &context::Context) {
+ unsafe {
+ ctx.gl.bind_texture(glow::TEXTURE_2D, Some(self.tex));
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_WRAP_S, glow::REPEAT as i32);
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_WRAP_T, glow::REPEAT as i32);
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_MIN_FILTER, glow::LINEAR_MIPMAP_LINEAR as i32);
+ ctx.gl.tex_parameter_i32(glow::TEXTURE_2D, glow::TEXTURE_MAG_FILTER, glow::LINEAR as i32);
+ ctx.gl.tex_parameter_f32(glow::TEXTURE_2D, glow::TEXTURE_MAX_ANISOTROPY_EXT, 4.0);
+ }
+ }
+
+ pub fn bind(&self, ctx: &context::Context) {
+ unsafe {
+ ctx.gl.active_texture(glow::TEXTURE0);
+ ctx.gl.bind_texture(glow::TEXTURE_2D, Some(self.tex));
+ }
+ }
+
+ pub fn bind_initial(ctx: &context::Context) {
+ unsafe {
+ ctx.gl.active_texture(glow::TEXTURE0);
+ ctx.gl.bind_texture(glow::TEXTURE_2D, None);
+ }
+ }
+
+ pub fn bind_index(&self, ctx: &context::Context, idx: u32) {
+ unsafe {
+ ctx.gl.active_texture(glow::TEXTURE0 + idx);
+ ctx.gl.bind_texture(glow::TEXTURE_2D, Some(self.tex));
+ }
+ }
+}
+
+pub struct Material {
+ pub color: Texture,
+ pub normal: Texture,
+}
+impl Material {
+ pub fn new(ctx: &context::Context, color_bytes: &[u8], normal_bytes: &[u8]) -> Self {
+ let color = Texture::new(ctx, color_bytes);
+ let normal = Texture::new(ctx, normal_bytes);
+ color.set_anisotropic_filtering(ctx);
+ normal.set_anisotropic_filtering(ctx);
+ Self { color, normal }
+ }
+ pub fn bind(&self, ctx: &context::Context) {
+ self.color.bind(ctx);
+ self.normal.bind_index(ctx, 1);
+ }
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/ui.rs b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/ui.rs new file mode 100644 index 0000000..8607fb6 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/ui.rs @@ -0,0 +1,169 @@ +use crate::{state, utils};
+use crate::state::Tick;
+
+fn compute_reverse(frames: Tick, tick: Tick, start: Tick) -> Tick {
+ let leftover = frames - (tick - start)
+ .clamp(0, frames);
+ tick - leftover
+}
+
+pub enum ModeToggle {
+ Inactive { start: Tick },
+ Active { start: Tick },
+}
+
+pub struct Mode {
+ frames: Tick,
+ toggle: ModeToggle,
+}
+
+impl Mode {
+ pub fn new(frames: Tick) -> Self {
+ Self {
+ frames,
+ toggle: ModeToggle::Inactive { start: 0 },
+ }
+ }
+
+ /// Is the current state active?
+ pub fn is_active(&self) -> bool {
+ match self.toggle {
+ ModeToggle::Inactive {..} => false,
+ ModeToggle::Active {..} => true,
+ }
+ }
+
+ /// Has the current transition finished?
+ pub fn is_ready(&self, tick: Tick) -> bool {
+ let started = match self.toggle {
+ ModeToggle::Inactive { start } => start,
+ ModeToggle::Active { start } => start,
+ };
+ tick - started > self.frames
+ }
+
+ pub fn progress(&self, tick: Tick) -> f32 {
+ match self.toggle {
+ ModeToggle::Inactive { start } => {
+ 1.0 - (((tick - start) as f32) / self.frames as f32)
+ .clamp(0.0, 1.0)
+ },
+ ModeToggle::Active { start } => {
+ (((tick - start) as f32) / self.frames as f32)
+ .clamp(0.0, 1.0)
+ }
+ }
+ }
+
+ pub fn reset(&mut self) {
+ self.toggle = ModeToggle::Inactive { start: 0 };
+ }
+
+ pub fn toggle(&mut self, tick: Tick) {
+ match self.toggle {
+ ModeToggle::Inactive { start } => {
+ self.toggle = ModeToggle::Active {
+ start: compute_reverse(self.frames, tick, start)
+ };
+ },
+ ModeToggle::Active { start } => {
+ self.toggle = ModeToggle::Inactive {
+ start: compute_reverse(self.frames, tick, start)
+ };
+ },
+ }
+ }
+}
+
+pub struct Cursor {
+ pub index: i32,
+ pub prev_index: i32,
+ pub change_started: Tick,
+ pub bound: i32,
+ pub frames: Tick,
+}
+
+impl Cursor {
+ pub fn new(bound: i32, frames: Tick) -> Self {
+ Self {
+ index: 0,
+ prev_index: 0,
+ change_started: 0,
+ bound,
+ frames,
+ }
+ }
+
+ pub fn animation_index(&self, tick: Tick) -> f32 {
+ let progress = ((tick - self.change_started) as f32)
+ / (self.frames as f32 / 2.0);
+ utils::lerp(
+ self.prev_index as f32,
+ self.index as f32,
+ progress
+ )
+ }
+
+ pub fn is_ready(&self, tick: Tick) -> bool {
+ tick - self.change_started > self.frames
+ }
+
+ pub fn set(&mut self, val: i32, tick: Tick) -> bool {
+ if self.is_ready(tick) {
+ self.change_started = tick;
+ self.prev_index = self.index;
+ self.index = val;
+ self.index %= self.bound;
+ true
+ } else { false }
+ }
+ pub fn increment(&mut self, tick: Tick) -> bool { self.set(self.index + 1, tick) }
+ pub fn decrement(&mut self, tick: Tick) -> bool { self.set(self.index + self.bound - 1, tick) }
+
+ pub fn set_unlocked(&mut self, val: i32, tick: Tick) {
+ self.change_started = tick;
+ self.prev_index = self.index;
+ self.index = val;
+ self.index %= self.bound;
+ }
+ pub fn increment_unlocked(&mut self, tick: Tick) -> bool { self.set_unlocked(self.index + 1, tick); true }
+ pub fn decrement_unlocked(&mut self, tick: Tick) -> bool { self.set_unlocked(self.index + self.bound - 1, tick); true }
+
+ /// Read keypresses to update this cursor (assuming that the left/right keys decrement/increment)
+ /// Returns true if an update was performed (e.g. to determine whether to play a sound).
+ pub fn update_horizontal(&mut self, st: &mut state::State) -> bool {
+ if st.keys.new_left() {
+ self.decrement_unlocked(st.tick)
+ } else if st.keys.new_right() {
+ self.increment_unlocked(st.tick)
+ } else if st.keys.left() {
+ self.decrement(st.tick)
+ } else if st.keys.right() {
+ self.increment(st.tick)
+ } else { false }
+ }
+
+ pub fn update_vertical(&mut self, st: &mut state::State) -> bool {
+ if st.keys.new_up() {
+ self.decrement_unlocked(st.tick)
+ } else if st.keys.new_down() {
+ self.increment_unlocked(st.tick)
+ } else if st.keys.up() {
+ self.decrement(st.tick)
+ } else if st.keys.down() {
+ self.increment(st.tick)
+ } else { false }
+ }
+
+ pub fn update_lr(&mut self, st: &mut state::State) -> bool {
+ if st.keys.new_l() {
+ self.decrement_unlocked(st.tick)
+ } else if st.keys.new_r() {
+ self.increment_unlocked(st.tick)
+ } else if st.keys.l() {
+ self.decrement(st.tick)
+ } else if st.keys.r() {
+ self.increment(st.tick)
+ } else { false }
+ }
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/utils.rs b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/utils.rs new file mode 100644 index 0000000..14a7fdf --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia/src/utils.rs @@ -0,0 +1,147 @@ +use std::f32::consts::PI;
+
+use enum_map::Enum;
+use serde::{Serialize, Deserialize};
+use strum::EnumIter;
+
+pub type Erm<T> = simple_eyre::Result<T>;
+
+pub fn erm<E, T>(e: E) -> Erm<T> where E: std::error::Error + std::marker::Send + std::marker::Sync + 'static {
+ Err(e.into())
+}
+
+#[derive(Debug)]
+pub struct Error {
+ pub msg: String
+}
+impl std::fmt::Display for Error {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ write!(f, "teleia error: {}", self.msg)
+ }
+}
+impl std::error::Error for Error {}
+
+pub fn erm_msg<T>(msg: &str) -> Erm<T> {
+ Err(Error {
+ msg: msg.to_owned(),
+ }.into())
+}
+
+pub struct ErrorHandler;
+impl simple_eyre::eyre::EyreHandler for ErrorHandler {
+ fn debug(
+ &self,
+ error: &(dyn std::error::Error + 'static),
+ f: &mut core::fmt::Formatter<'_>,
+ ) -> core::fmt::Result {
+ if f.alternate() {
+ return core::fmt::Debug::fmt(error, f);
+ }
+ let mut first = true;
+ if let Some(s) = error.source() {
+ let errors: Vec<_> = std::iter::successors(Some(s), |e| (*e).source()).collect();
+ for err in errors.iter().rev() {
+ writeln!(f)?; write!(f, "{}{}", if first {""} else {" - "}, err)?;
+ first = false;
+ }
+ }
+ writeln!(f)?; write!(f, "{}{}", if first {""} else {" - "}, error)?;
+ Ok(())
+ }
+}
+
+pub fn install_error_handler() {
+ simple_eyre::eyre::set_hook(Box::new(move |_| Box::new(ErrorHandler))).expect("failed to install error handler");
+}
+
+#[derive(Clone, Copy, Debug, Enum, EnumIter, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub enum Cardinal {
+ North,
+ South,
+ West,
+ East,
+}
+
+impl Cardinal {
+ pub fn to_string(&self) -> &'static str {
+ match self {
+ Self::North => "north",
+ Self::South => "south",
+ Self::West => "west",
+ Self::East => "east",
+ }
+ }
+
+ pub fn turn_cw(&self) -> Self {
+ match self {
+ Self::North => Self::East,
+ Self::South => Self::West,
+ Self::West => Self::North,
+ Self::East => Self::South,
+ }
+ }
+
+ pub fn turn_ccw(&self) -> Self {
+ match self {
+ Self::North => Self::West,
+ Self::South => Self::East,
+ Self::West => Self::South,
+ Self::East => Self::North,
+ }
+ }
+
+ pub fn dir(&self) -> glam::Vec3 {
+ match self {
+ Self::North => glam::Vec3::new(0.0, 1.0, 0.0),
+ Self::South => glam::Vec3::new(0.0, -1.0, 0.0),
+ Self::West => glam::Vec3::new(-1.0, 0.0, 0.0),
+ Self::East => glam::Vec3::new(1.0, 0.0, 0.0),
+ }
+ }
+
+ pub fn offsets(&self) -> (i32, i32) {
+ match self {
+ Self::North => (0, 1),
+ Self::South => (0, -1),
+ Self::West => (-1, 0),
+ Self::East => (1, 0),
+ }
+ }
+
+ pub fn angle(&self) -> f32 {
+ match self {
+ Self::North => 0.0,
+ Self::South => PI,
+ Self::West => PI / 2.0,
+ Self::East => 3.0 * PI / 2.0,
+ }
+ }
+
+ pub fn turn_by(&self, o: Self) -> Self {
+ match o {
+ Self::North => *self,
+ Self::South => self.turn_cw().turn_cw(),
+ Self::West => self.turn_cw(),
+ Self::East => self.turn_ccw(),
+ }
+ }
+
+ pub fn angle_between(&self, o: &Self) -> f32 {
+ if o == &self.turn_cw() { -PI / 2.0 }
+ else if o == &self.turn_ccw() { PI / 2.0 }
+ else if o == &self.turn_cw().turn_cw() { PI }
+ else { 0.0 }
+ }
+}
+
+pub fn lerp(a: f32, b: f32, t: f32) -> f32 {
+ a + t.clamp(0.0, 1.0) * (b - a)
+}
+
+pub fn dir_lerp(a: glam::Vec3, b: glam::Vec3, t: f32) -> glam::Vec3 {
+ let dirrotaxis = a.cross(b).normalize();
+ let dirrotangle = a.angle_between(b);
+ let dirrotfull = glam::Quat::from_axis_angle(dirrotaxis, dirrotangle);
+ let dirrot = glam::Quat::IDENTITY.slerp(dirrotfull, t);
+ dirrot.mul_vec3(a)
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia_macros/Cargo.toml b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia_macros/Cargo.toml new file mode 100644 index 0000000..3ef969e --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia_macros/Cargo.toml @@ -0,0 +1,14 @@ +[package]
+name = "teleia_macros"
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+
+[lib]
+proc-macro = true
+
+[dependencies]
+env = "1.0.1"
+walkdir = "2.5.0"
+heck = "0.5.0"
+litrs = "1.0.0"
\ No newline at end of file diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia_macros/src/lib.rs b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia_macros/src/lib.rs new file mode 100644 index 0000000..5b6c0b9 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/crates/teleia_macros/src/lib.rs @@ -0,0 +1,231 @@ +use heck::ToUpperCamelCase;
+use proc_macro::TokenStream;
+use std::collections::HashSet;
+use std::path::Path;
+use walkdir::WalkDir;
+
+#[derive(Debug, Hash, PartialEq, Eq)]
+struct Designator {
+ path: String,
+ parts: Vec<String>,
+}
+impl Designator {
+ fn new(fbase: &str, mut path: &Path, shorten: bool) -> Self {
+ let mut parts: Vec<_> = path
+ .strip_prefix(fbase)
+ .unwrap()
+ .with_extension("")
+ .components()
+ .filter_map(|c| match c {
+ std::path::Component::Normal(o) => Some(o.to_str().unwrap().to_owned()),
+ _ => None,
+ })
+ .collect();
+ if shorten {
+ parts.pop();
+ path = path.parent().expect("path has no parent");
+ }
+ Self {
+ path: path
+ .to_str()
+ .expect("path is not a string")
+ .replace("\\", "/"),
+ parts,
+ }
+ }
+ fn enum_entry(&self, fnm: &str) -> String {
+ let singular = match fnm {
+ "meshes" => "mesh",
+ "textures" => "texture",
+ "materials" => "material",
+ "shaders" => "shader",
+ _ => fnm,
+ };
+ let mut ret = format!("\n#[doc=\"newton-{}: {}\"]\n", singular, self.path);
+ ret += &self.parts.join(" ").to_upper_camel_case();
+ ret
+ }
+ fn enum_element(&self, _fnm: &str) -> String {
+ self.parts.join(" ").to_upper_camel_case()
+ }
+ fn load_expr(&self, fnm: &str) -> Option<String> {
+ let i = format!("assets/{}/{}", fnm, self.parts.join("/"));
+ match fnm {
+ "meshes" => Some(format!(
+ "teleia::mesh::Mesh::from_obj(ctx, include_bytes!(\"{}.obj\"))",
+ i
+ )),
+ "textures" => Some(format!(
+ "teleia::texture::Texture::new(ctx, include_bytes!(\"{}.png\"))",
+ i
+ )),
+ "materials" => Some(format!(
+ "teleia::texture::Material::new(ctx, include_bytes!(\"{}/color.jpg\"), include_bytes!(\"{}/normal.jpg\"))",
+ i, i
+ )),
+ "shaders" => {
+ if self.parts.contains(&"nolib".to_owned()) {
+ Some(format!(
+ "teleia::shader::Shader::new_nolib(ctx, include_str!(\"{}/vert.glsl\"), include_str!(\"{}/frag.glsl\"))",
+ i, i
+ ))
+ } else {
+ Some(format!(
+ "teleia::shader::Shader::new(ctx, include_str!(\"{}/vert.glsl\"), include_str!(\"{}/frag.glsl\"))",
+ i, i
+ ))
+ }
+ }
+ _ => None,
+ }
+ }
+}
+
+#[derive(Debug)]
+struct Field {
+ nm: String,
+ entries: HashSet<Designator>,
+}
+impl Field {
+ fn new(base: &str, nm: &str) -> Self {
+ let mut entries = HashSet::new();
+ let fbase = format!("{}{}", base, nm);
+ for f in WalkDir::new(&fbase).into_iter().flatten() {
+ if f.file_type().is_file() {
+ entries.insert(Designator::new(
+ &fbase,
+ f.path(),
+ nm == "shaders" || nm == "materials",
+ ));
+ }
+ }
+ Self {
+ nm: nm.to_owned(),
+ entries,
+ }
+ }
+ fn generate(&self) -> Option<(String, String, String)> {
+ let mut ents = Vec::new();
+ for d in self.entries.iter() {
+ if let Some(exp) = d.load_expr(&self.nm) {
+ ents.push((d.enum_entry(&self.nm), d.enum_element(&self.nm), exp));
+ }
+ }
+ let (enm, ty) = match self.nm.as_str() {
+ "meshes" => ("Mesh", "teleia::mesh::Mesh"),
+ "textures" => ("Texture", "teleia::texture::Texture"),
+ "materials" => ("Material", "teleia::texture::Material"),
+ "shaders" => ("Shader", "teleia::shader::Shader"),
+ _ => return None,
+ };
+ let enums: Vec<_> = ents.iter().map(|(e, _, _)| e.clone()).collect();
+ let edecl = format!("#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize, enum_map::Enum)]
+pub enum {} {{ {} }}", enm, enums.join(", "));
+ let decl = format!("pub {}: enum_map::EnumMap<{}, {}>", self.nm, enm, ty);
+ let inits: Vec<_> = ents
+ .into_iter()
+ .map(|(_, e, exp)| format!("{}::{} => {}", enm, e, exp))
+ .collect();
+ let init = format!("{}: enum_map::enum_map!({})", self.nm, inits.join(", "));
+ Some((edecl, decl, init))
+ }
+}
+
+#[derive(Debug)]
+struct AssetData {
+ fields: Vec<Field>,
+}
+impl AssetData {
+ fn new(base: &str) -> Self {
+ let mut fields = Vec::new();
+ let dirs = std::fs::read_dir(base)
+ .unwrap_or_else(|_| panic!("failed to read assets directory: {}", base));
+ let (mut has_meshes, mut has_textures, mut has_materials, mut has_shaders) =
+ (false, false, false, false);
+ for d in dirs.flatten() {
+ let nm = d.file_name().into_string().unwrap();
+ fields.push(Field::new(base, &nm));
+ match &*nm {
+ "meshes" => has_meshes = true,
+ "textures" => has_textures = true,
+ "materials" => has_materials = true,
+ "shaders" => has_shaders = true,
+ _ => {}
+ };
+ }
+ if !has_meshes {
+ fields.push(Field {
+ nm: "meshes".to_owned(),
+ entries: HashSet::new(),
+ });
+ }
+ if !has_textures {
+ fields.push(Field {
+ nm: "textures".to_owned(),
+ entries: HashSet::new(),
+ });
+ }
+ if !has_materials {
+ fields.push(Field {
+ nm: "materials".to_owned(),
+ entries: HashSet::new(),
+ });
+ }
+ if !has_shaders {
+ fields.push(Field {
+ nm: "shaders".to_owned(),
+ entries: HashSet::new(),
+ });
+ }
+ Self { fields }
+ }
+ fn generate(&self) -> String {
+ let mut res = String::new();
+ let fdata: Vec<_> = self.fields.iter().filter_map(|f| f.generate()).collect();
+ for (edecl, _, _) in fdata.iter() {
+ res += edecl;
+ res += "\n";
+ }
+ res += "pub struct Assets {\n";
+ for (_, decl, _) in fdata.iter() {
+ res += decl;
+ res += ",\n";
+ }
+ res += "}\nimpl Assets {\npub fn new(ctx: &teleia::context::Context) -> Self {\nSelf {\n";
+ for (_, _, init) in fdata.iter() {
+ res += init;
+ res += ",\n";
+ }
+ res += "}\n}\n}\n";
+ res += "impl teleia::renderer::Assets for Assets {\n";
+ res += "type Shader = Shader;\n";
+ res +=
+ "fn shader(&self, i: Self::Shader) -> &teleia::shader::Shader { &self.shaders[i] }\n";
+ res += "type Texture = Texture;\n";
+ res += "fn texture(&self, i: Self::Texture) -> &teleia::texture::Texture { &self.textures[i] }\n";
+ res += "type Material = Material;\n";
+ res += "fn material(&self, i: Self::Material) -> &teleia::texture::Material { &self.materials[i] }\n";
+ res += "type Mesh = Mesh;\n";
+ res += "fn mesh(&self, i: Self::Mesh) -> &teleia::mesh::Mesh { &self.meshes[i] }\n";
+ res += "}\n";
+ res
+ }
+}
+
+#[proc_macro]
+pub fn generate_assets(s: TokenStream) -> TokenStream {
+ let token = s
+ .into_iter()
+ .next()
+ .expect("must pass asset base path as a string literal");
+ let lit = litrs::StringLit::try_from(token).expect("argument was not a string literal");
+ let base = lit.value();
+ let manifest = env::var("CARGO_MANIFEST_DIR").expect("failed to get manifest path");
+ let assets = AssetData::new(&format!("{}/{}", manifest, base));
+ // println!("{}", assets.generate());
+ assets
+ .generate()
+ .to_string()
+ .parse()
+ .expect("failed to parse generate_assets result")
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/examples/assets/fonts/ComicNeue-Regular.ttf b/2026/games_submissions/rpc2dot0/vendor/teleia/examples/assets/fonts/ComicNeue-Regular.ttf Binary files differnew file mode 100644 index 0000000..d454f46 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/examples/assets/fonts/ComicNeue-Regular.ttf diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/examples/assets/meshes/cube.obj b/2026/games_submissions/rpc2dot0/vendor/teleia/examples/assets/meshes/cube.obj new file mode 100644 index 0000000..02851e8 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/examples/assets/meshes/cube.obj @@ -0,0 +1,38 @@ +# Blender 4.1.1
+# www.blender.org
+o Cube
+v 1.000000 1.000000 -1.000000
+v 1.000000 -1.000000 -1.000000
+v 1.000000 1.000000 1.000000
+v 1.000000 -1.000000 1.000000
+v -1.000000 1.000000 -1.000000
+v -1.000000 -1.000000 -1.000000
+v -1.000000 1.000000 1.000000
+v -1.000000 -1.000000 1.000000
+vn -0.0000 1.0000 -0.0000
+vn -0.0000 -0.0000 1.0000
+vn -1.0000 -0.0000 -0.0000
+vn -0.0000 -1.0000 -0.0000
+vn 1.0000 -0.0000 -0.0000
+vn -0.0000 -0.0000 -1.0000
+vt 0.625000 0.500000
+vt 0.875000 0.500000
+vt 0.875000 0.750000
+vt 0.625000 0.750000
+vt 0.375000 0.750000
+vt 0.625000 1.000000
+vt 0.375000 1.000000
+vt 0.375000 0.000000
+vt 0.625000 0.000000
+vt 0.625000 0.250000
+vt 0.375000 0.250000
+vt 0.125000 0.500000
+vt 0.375000 0.500000
+vt 0.125000 0.750000
+s 0
+f 1/1/1 5/2/1 7/3/1 3/4/1
+f 4/5/2 3/4/2 7/6/2 8/7/2
+f 8/8/3 7/9/3 5/10/3 6/11/3
+f 6/12/4 2/13/4 4/5/4 8/14/4
+f 2/13/5 1/1/5 3/4/5 4/5/5
+f 6/11/6 5/10/6 1/1/6 2/13/6
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/examples/assets/scenes/fox.glb b/2026/games_submissions/rpc2dot0/vendor/teleia/examples/assets/scenes/fox.glb Binary files differnew file mode 100644 index 0000000..1ef5c0d --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/examples/assets/scenes/fox.glb diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/examples/assets/textures/test.png b/2026/games_submissions/rpc2dot0/vendor/teleia/examples/assets/textures/test.png Binary files differnew file mode 100644 index 0000000..0752be0 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/examples/assets/textures/test.png diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/examples/fox.rs b/2026/games_submissions/rpc2dot0/vendor/teleia/examples/fox.rs new file mode 100644 index 0000000..eff9345 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/examples/fox.rs @@ -0,0 +1,72 @@ +use teleia::*;
+
+use std::ops::Rem;
+
+pub struct TestGame {
+ font: font::Bitmap,
+ tt: font::TrueType,
+ // cube: mesh::Mesh,
+ fox: scene::Scene,
+ tex: texture::Texture,
+ shader: shader::Shader,
+}
+
+impl TestGame {
+ pub async fn new(ctx: &context::Context) -> Self {
+ Self {
+ font: font::Bitmap::new(ctx),
+ tt: font::TrueType::new(ctx, 12.0, include_bytes!("assets/fonts/ComicNeue-Regular.ttf")),
+ // cube: mesh::Mesh::from_obj(ctx, include_bytes!("assets/meshes/cube.obj")),
+ fox: scene::Scene::from_gltf(ctx, include_bytes!("assets/scenes/fox.glb")),
+ // fox: scene::Scene::from_gltf(ctx, include_bytes!("/home/llll/src/colonq/assets/lcolonq_flat.vrm")),
+ tex: texture::Texture::new(ctx, include_bytes!("assets/textures/test.png")),
+ shader: scene::Scene::load_default_shader(ctx),
+ }
+ }
+}
+
+impl state::Game for TestGame {
+ fn update(&mut self, ctx: &context::Context, st: &mut state::State) -> Erm<()> {
+ st.move_camera(
+ ctx,
+ &glam::Vec3::new(0.0, 0.0, -1.0),
+ &glam::Vec3::new(0.0, 0.0, 1.0),
+ &glam::Vec3::new(0.0, 1.0, 0.0),
+ );
+ Ok(())
+ }
+ fn render(&mut self, ctx: &context::Context, st: &mut state::State) -> Erm<()> {
+ // if let Some(n) = self.fox.nodes_by_name.get("J_Bip_C_Neck").and_then(|i| self.fox.nodes.get_mut(*i)) {
+ // n.transform *= glam::Mat4::from_rotation_z(0.05);
+ // }
+ ctx.clear();
+ self.fox.reflect_animation("Run", (st.tick as f32 / 60.0).rem(3.0));
+ st.bind_3d(ctx, &self.shader);
+ self.shader.set_position_3d(
+ ctx,
+ &glam::Mat4::from_scale_rotation_translation(
+ glam::Vec3::new(0.005, 0.005, 0.005),
+ // glam::Vec3::new(1.0, 1.0, 1.0),
+ glam::Quat::from_rotation_y(st.tick as f32 / 60.0),
+ glam::Vec3::new(0.0, -0.2, 0.0),
+ ),
+ );
+ self.tex.bind(ctx);
+ self.fox.render(ctx, &self.shader);
+ self.font.render_text(ctx, &glam::Vec2::new(0.0, 10.0), "he's all FIXED up");
+ self.tt.render_text_helper(
+ ctx, &glam::Vec2::new(10.0, 60.0), &glam::Vec2::new(20.0, 30.0),
+ "tESTge",
+ &[
+ glam::Vec3::new(1.0, 0.0, 0.0),
+ glam::Vec3::new(0.0, 1.0, 0.0),
+ ],
+ );
+ Ok(())
+ }
+}
+
+#[tokio::main]
+pub async fn main() {
+ run("teleia test", 240, 160, Options::empty(), TestGame::new).await;
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/flake.lock b/2026/games_submissions/rpc2dot0/vendor/teleia/flake.lock new file mode 100644 index 0000000..687db1d --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/flake.lock @@ -0,0 +1,153 @@ +{
+ "nodes": {
+ "crane": {
+ "locked": {
+ "lastModified": 1754269165,
+ "narHash": "sha256-0tcS8FHd4QjbCVoxN9jI+PjHgA4vc/IjkUSp+N3zy0U=",
+ "owner": "ipetkov",
+ "repo": "crane",
+ "rev": "444e81206df3f7d92780680e45858e31d2f07a08",
+ "type": "github"
+ },
+ "original": {
+ "owner": "ipetkov",
+ "repo": "crane",
+ "type": "github"
+ }
+ },
+ "flake-utils": {
+ "inputs": {
+ "systems": "systems"
+ },
+ "locked": {
+ "lastModified": 1731533236,
+ "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
+ "owner": "numtide",
+ "repo": "flake-utils",
+ "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
+ "type": "github"
+ },
+ "original": {
+ "owner": "numtide",
+ "repo": "flake-utils",
+ "type": "github"
+ }
+ },
+ "flake-utils_2": {
+ "inputs": {
+ "systems": "systems_2"
+ },
+ "locked": {
+ "lastModified": 1731533236,
+ "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
+ "owner": "numtide",
+ "repo": "flake-utils",
+ "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
+ "type": "github"
+ },
+ "original": {
+ "owner": "numtide",
+ "repo": "flake-utils",
+ "type": "github"
+ }
+ },
+ "nixpkgs": {
+ "locked": {
+ "lastModified": 1777425547,
+ "narHash": "sha256-d57AbflkNfZNoFaZDzssEq1RfPoM9dLtOGI2O+N/68Q=",
+ "owner": "NixOS",
+ "repo": "nixpkgs",
+ "rev": "ebc08544afa77957cc348ba72dc490ec73b87f68",
+ "type": "github"
+ },
+ "original": {
+ "owner": "NixOS",
+ "ref": "nixpkgs-unstable",
+ "repo": "nixpkgs",
+ "type": "github"
+ }
+ },
+ "pit": {
+ "inputs": {
+ "flake-utils": "flake-utils_2",
+ "nixpkgs": [
+ "nixpkgs"
+ ]
+ },
+ "locked": {
+ "lastModified": 1778890311,
+ "narHash": "sha256-JZx/jh/E16SlAATrzQvB7kZcbBBfXX0zCqpwgw+Qlfc=",
+ "owner": "lcolonq",
+ "repo": "pit",
+ "rev": "48ab2cb8e3de88dbd0722337bd4617ad22de1a12",
+ "type": "github"
+ },
+ "original": {
+ "owner": "lcolonq",
+ "repo": "pit",
+ "type": "github"
+ }
+ },
+ "root": {
+ "inputs": {
+ "crane": "crane",
+ "flake-utils": "flake-utils",
+ "nixpkgs": "nixpkgs",
+ "pit": "pit",
+ "rust-overlay": "rust-overlay"
+ }
+ },
+ "rust-overlay": {
+ "inputs": {
+ "nixpkgs": [
+ "nixpkgs"
+ ]
+ },
+ "locked": {
+ "lastModified": 1766717007,
+ "narHash": "sha256-ZjLiHCHgoH2maP5ZAKn0anrHymbjGOS5/PZqfJUK8Ik=",
+ "owner": "oxalica",
+ "repo": "rust-overlay",
+ "rev": "a18efe8a9112175e43397cf870fb6bc1ca480548",
+ "type": "github"
+ },
+ "original": {
+ "owner": "oxalica",
+ "repo": "rust-overlay",
+ "type": "github"
+ }
+ },
+ "systems": {
+ "locked": {
+ "lastModified": 1681028828,
+ "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+ "owner": "nix-systems",
+ "repo": "default",
+ "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+ "type": "github"
+ },
+ "original": {
+ "owner": "nix-systems",
+ "repo": "default",
+ "type": "github"
+ }
+ },
+ "systems_2": {
+ "locked": {
+ "lastModified": 1681028828,
+ "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+ "owner": "nix-systems",
+ "repo": "default",
+ "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+ "type": "github"
+ },
+ "original": {
+ "owner": "nix-systems",
+ "repo": "default",
+ "type": "github"
+ }
+ }
+ },
+ "root": "root",
+ "version": 7
+}
diff --git a/2026/games_submissions/rpc2dot0/vendor/teleia/flake.nix b/2026/games_submissions/rpc2dot0/vendor/teleia/flake.nix new file mode 100644 index 0000000..878d687 --- /dev/null +++ b/2026/games_submissions/rpc2dot0/vendor/teleia/flake.nix @@ -0,0 +1,250 @@ +{
+ inputs = {
+ nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
+ crane.url = "github:ipetkov/crane";
+ flake-utils.url = "github:numtide/flake-utils";
+ rust-overlay = {
+ url = "github:oxalica/rust-overlay";
+ inputs = {
+ nixpkgs.follows = "nixpkgs";
+ };
+ };
+ pit = {
+ url = "github:lcolonq/pit";
+ inputs.nixpkgs.follows = "nixpkgs";
+ };
+ };
+
+ outputs = inputs@{ self, nixpkgs, ... }:
+ let
+ system = "x86_64-linux";
+ pkgs = import nixpkgs {
+ inherit system;
+ overlays = [ (import inputs.rust-overlay) ];
+ };
+ inherit (pkgs) lib;
+
+ rustToolchainFor = p: p.rust-bin.nightly.latest.default.override {
+ targets = [
+ "wasm32-unknown-unknown"
+ "x86_64-unknown-linux-gnu"
+ "x86_64-pc-windows-gnu"
+ ];
+ };
+ craneLib = (inputs.crane.mkLib pkgs).overrideToolchain rustToolchainFor;
+
+ glfw = pkgs.glfw.overrideAttrs (cur: prev: {
+ cmakeFlags = []; # by default, static linking is disabled here
+ # for some reason, the default glfw package hardcodes a nix store path to libGL
+ # see: https://github.com/NixOS/nixpkgs/pull/47175
+ # this makes it impossible to run the binary on another system
+ # I'd much rather just load whatever we find on LD_LIBRARY_PATH etc, since this is much easier to control
+ env = {};
+ postPatch = "true";
+ });
+
+ LIBCOLONQ_PIT_NATIVE="${inputs.pit.packages.x86_64-linux.default}/lib";
+ LIBCOLONQ_PIT_WASM="${inputs.pit.packages.x86_64-linux.wasm}/lib";
+ LIBCOLONQ_PIT_WINDOWS="${inputs.pit.packages.x86_64-linux.windows}/lib";
+
+ native = rec {
+ nativeBuildInputs = [
+ pkgs.pkg-config
+ ];
+ buildInputs = [
+ pkgs.openssl.dev
+ glfw
+ pkgs.libX11
+ pkgs.libXcursor
+ pkgs.libXi
+ pkgs.libXrandr
+ pkgs.libXinerama
+ pkgs.libxkbcommon
+ pkgs.libxcb
+ pkgs.libglvnd
+ pkgs.alsa-lib
+ ];
+ deps = path: nm:
+ let
+ src = lib.cleanSourceWith {
+ src = path;
+ filter = path: type:
+ (lib.hasSuffix "\.html" path) ||
+ (lib.hasSuffix "\.js" path) ||
+ (lib.hasSuffix "\.css" path) ||
+ (lib.hasInfix "/assets/" path) ||
+ (craneLib.filterCargoSources path type)
+ ;
+ };
+ commonArgs = {
+ inherit src nativeBuildInputs buildInputs;
+ inherit LIBCOLONQ_PIT_NATIVE;
+ strictDeps = true;
+ CARGO_BUILD_TARGET = "x86_64-unknown-linux-gnu";
+ CARGO_BUILD_RUSTFLAGS="-L ${glfw}/lib -L ${LIBCOLONQ_PIT_NATIVE}";
+ inherit (craneLib.crateNameFromCargoToml { inherit src; }) version;
+ };
+ cargoArtifacts = craneLib.buildDepsOnly (commonArgs // {
+ doCheck = false;
+ });
+ in
+ cargoArtifacts;
+ build = path: nm:
+ let
+ src = lib.cleanSourceWith {
+ src = path;
+ filter = path: type:
+ (lib.hasSuffix "\.html" path) ||
+ (lib.hasSuffix "\.js" path) ||
+ (lib.hasSuffix "\.css" path) ||
+ (lib.hasInfix "/assets/" path) ||
+ (craneLib.filterCargoSources path type)
+ ;
+ };
+ commonArgs = {
+ inherit src nativeBuildInputs buildInputs;
+ inherit LIBCOLONQ_PIT_NATIVE;
+ strictDeps = true;
+ CARGO_BUILD_TARGET = "x86_64-unknown-linux-gnu";
+ CARGO_BUILD_RUSTFLAGS="-L ${glfw}/lib -L ${LIBCOLONQ_PIT_NATIVE}";
+ inherit (craneLib.crateNameFromCargoToml { inherit src; }) version;
+ };
+ cargoArtifacts = craneLib.buildDepsOnly (commonArgs // {
+ doCheck = false;
+ cargoExtraArgs = "-p ${nm}";
+ });
+ in
+ craneLib.buildPackage (commonArgs // {
+ inherit cargoArtifacts;
+ pname = nm;
+ cargoExtraArgs = "-p ${nm}";
+ });
+ };
+
+ wasm = rec {
+ buildAtUrlInDir = path: nm: url: dir:
+ let
+ src = lib.cleanSourceWith {
+ src = path;
+ filter = path: type:
+ (lib.hasSuffix "\.html" path) ||
+ (lib.hasSuffix "\.js" path) ||
+ (lib.hasSuffix "\.css" path) ||
+ (lib.hasInfix "/assets/" path) ||
+ (craneLib.filterCargoSources path type)
+ ;
+ };
+ commonArgs = {
+ inherit src;
+ inherit LIBCOLONQ_PIT_WASM;
+ strictDeps = true;
+ CARGO_BUILD_TARGET = "wasm32-unknown-unknown";
+ CARGO_BUILD_RUSTFLAGS="-L ${LIBCOLONQ_PIT_WASM}";
+ buildInputs = [];
+ inherit (craneLib.crateNameFromCargoToml { inherit src; }) version;
+ wasm-bindgen-cli = pkgs.buildWasmBindgenCli rec {
+ src = pkgs.fetchCrate {
+ pname = "wasm-bindgen-cli";
+ version = "0.2.100";
+ hash = "sha256-3RJzK7mkYFrs7C/WkhW9Rr4LdP5ofb2FdYGz1P7Uxog=";
+ };
+ cargoDeps = pkgs.rustPlatform.fetchCargoVendor {
+ inherit src;
+ inherit (src) pname version;
+ hash = "sha256-qsO12332HSjWCVKtf1cUePWWb9IdYUmT+8OPj/XP2WE=";
+ };
+ };
+ };
+ in
+ craneLib.buildTrunkPackage (commonArgs // rec {
+ pname = nm;
+ cargoExtraArgs = "-p ${nm}";
+ trunkExtraBuildArgs = "--public-url ${url}";
+ cargoArtifacts = craneLib.buildDepsOnly (commonArgs // {
+ inherit cargoExtraArgs;
+ doCheck = false;
+ });
+ preBuild = ''
+ pushd ${dir}
+ '';
+ postBuild = ''
+ popd
+ mv ${dir}/dist .
+ '';
+ });
+ buildAtUrl = path: nm: url: buildAtUrlInDir path nm url ".";
+ build = path: nm: buildAtUrl path nm "";
+ };
+
+ windows = rec {
+ glfw = pkgs.pkgsCross.mingwW64.glfw.overrideAttrs (cur: prev: {
+ cmakeFlags = [];
+ env = {};
+ postPatch = "true";
+ });
+ rustflags = "-L ${glfw}/lib -L ${LIBCOLONQ_PIT_WINDOWS} -L ${pkgs.pkgsCross.mingwW64.windows.pthreads}/lib";
+ shell = craneLib.devShell {
+ packages = [
+ pkgs.pkgsCross.mingwW64.buildPackages.gcc
+ ];
+ RUSTFLAGS = rustflags;
+ };
+ build = path: nm:
+ let
+ src = lib.cleanSourceWith {
+ src = path;
+ filter = path: type:
+ (lib.hasSuffix "\.html" path) ||
+ (lib.hasSuffix "\.js" path) ||
+ (lib.hasSuffix "\.css" path) ||
+ (lib.hasInfix "/assets/" path) ||
+ (craneLib.filterCargoSources path type)
+ ;
+ };
+ commonArgs = {
+ inherit src;
+ strictDeps = true;
+ CARGO_BUILD_TARGET = "x86_64-pc-windows-gnu";
+ CARGO_BUILD_RUSTFLAGS = rustflags;
+ CARGO_TARGET_X86_64_PC_WINDOWS_GNU_LINKER = "${pkgs.pkgsCross.mingwW64.stdenv.cc}/bin/${pkgs.pkgsCross.mingwW64.stdenv.cc.targetPrefix}cc";
+ depsBuildBuild = with pkgs; [
+ pkgsCross.mingwW64.buildPackages.gcc
+ ];
+ inherit (craneLib.crateNameFromCargoToml { inherit src; }) version;
+ };
+ cargoArtifacts = craneLib.buildDepsOnly (commonArgs // {
+ doCheck = false;
+ });
+ in
+ craneLib.buildPackage (commonArgs // {
+ inherit cargoArtifacts;
+ pname = nm;
+ cargoExtraArgs = "-p ${nm}";
+ doCheck = false;
+ });
+ };
+
+ shell = craneLib.devShell {
+ packages = [
+ pkgs.trunk
+ pkgs.rust-analyzer
+ pkgs.cargo-flamegraph
+ pkgs.cmake
+ pkgs.mold
+ ] ++ native.nativeBuildInputs ++ native.buildInputs;
+ LIBRARY_PATH = "$LIBRARY_PATH:${pkgs.lib.makeLibraryPath native.buildInputs}";
+ RUSTFLAGS="-L ${glfw}/lib";
+ LD_LIBRARY_PATH = "$LD_LIBRARY_PATH:${pkgs.lib.makeLibraryPath native.buildInputs}";
+ inherit LIBCOLONQ_PIT_NATIVE LIBCOLONQ_PIT_WASM;
+ };
+ in {
+ inherit shell native wasm windows;
+ devShells.${system} = {
+ default = shell;
+ windows = windows.shell;
+ };
+ packages.${system} = {
+ default = native.deps ./. "teleia";
+ };
+ };
+}
diff --git a/2026/games_submissions/steeledshield/LICENSE.txt b/2026/games_submissions/steeledshield/LICENSE.txt new file mode 100644 index 0000000..9c1aa69 --- /dev/null +++ b/2026/games_submissions/steeledshield/LICENSE.txt @@ -0,0 +1,21 @@ +MIT License
+
+Copyright (c) 2026 Steeledshield
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
\ No newline at end of file diff --git a/2026/games_submissions/steeledshield/assets/Clonk.png b/2026/games_submissions/steeledshield/assets/Clonk.png Binary files differnew file mode 100644 index 0000000..67cde0d --- /dev/null +++ b/2026/games_submissions/steeledshield/assets/Clonk.png diff --git a/2026/games_submissions/steeledshield/assets/Eat.wav b/2026/games_submissions/steeledshield/assets/Eat.wav Binary files differnew file mode 100644 index 0000000..20d03c8 --- /dev/null +++ b/2026/games_submissions/steeledshield/assets/Eat.wav diff --git a/2026/games_submissions/steeledshield/assets/Explode.wav b/2026/games_submissions/steeledshield/assets/Explode.wav Binary files differnew file mode 100644 index 0000000..a2f4a40 --- /dev/null +++ b/2026/games_submissions/steeledshield/assets/Explode.wav diff --git a/2026/games_submissions/steeledshield/assets/Mod.png b/2026/games_submissions/steeledshield/assets/Mod.png Binary files differnew file mode 100644 index 0000000..3389fc7 --- /dev/null +++ b/2026/games_submissions/steeledshield/assets/Mod.png diff --git a/2026/games_submissions/steeledshield/assets/Win.wav b/2026/games_submissions/steeledshield/assets/Win.wav Binary files differnew file mode 100644 index 0000000..26e548d --- /dev/null +++ b/2026/games_submissions/steeledshield/assets/Win.wav diff --git a/2026/games_submissions/steeledshield/assets/click_image.png b/2026/games_submissions/steeledshield/assets/click_image.png Binary files differnew file mode 100644 index 0000000..f9a6e5a --- /dev/null +++ b/2026/games_submissions/steeledshield/assets/click_image.png diff --git a/2026/games_submissions/steeledshield/assets/feeding_friend-zy_beat.wav b/2026/games_submissions/steeledshield/assets/feeding_friend-zy_beat.wav Binary files differnew file mode 100644 index 0000000..2644a45 --- /dev/null +++ b/2026/games_submissions/steeledshield/assets/feeding_friend-zy_beat.wav diff --git a/2026/games_submissions/steeledshield/assets/friend.png b/2026/games_submissions/steeledshield/assets/friend.png Binary files differnew file mode 100644 index 0000000..8658706 --- /dev/null +++ b/2026/games_submissions/steeledshield/assets/friend.png diff --git a/2026/games_submissions/steeledshield/assets/friend_happy.png b/2026/games_submissions/steeledshield/assets/friend_happy.png Binary files differnew file mode 100644 index 0000000..8ee01b9 --- /dev/null +++ b/2026/games_submissions/steeledshield/assets/friend_happy.png diff --git a/2026/games_submissions/steeledshield/index.html b/2026/games_submissions/steeledshield/index.html new file mode 100644 index 0000000..2916def --- /dev/null +++ b/2026/games_submissions/steeledshield/index.html @@ -0,0 +1,31 @@ +<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="UTF-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <title>Feeding Friend-zy</title>
+ <link rel="stylesheet" href="style.css">
+ <link rel="preconnect" href="https://fonts.googleapis.com">
+ <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+ <link href="https://fonts.googleapis.com/css2?family=VT323&display=swap" rel="stylesheet">
+</head>
+<body>
+ <div id="layout">
+ <p id="counter"></p>
+ <img id="Clonk" src="assets/Clonk.png">
+ <img id="Mod" src="assets/Mod.png">
+ <img id="click_image" src="assets/click_image.png" alt="">
+ <div id="game">
+ <div id="container">
+ <div id="bomb" class="objects">💣</div>
+ <div id="blank" class="objects"></div>
+ <div id="food" class="objects"></div>
+ </div>
+ <div id="friend">
+ <img src="assets/friend.png">
+ </div>
+ </div>
+ </div>
+</body>
+<script src="script.js"></script>
+</html>
\ No newline at end of file diff --git a/2026/games_submissions/steeledshield/script.js b/2026/games_submissions/steeledshield/script.js new file mode 100644 index 0000000..6ccfe0a --- /dev/null +++ b/2026/games_submissions/steeledshield/script.js @@ -0,0 +1,200 @@ +//Assets & Elements
+var bomb = document.getElementById("bomb");
+var food = document.getElementById("food");
+var blank = document.getElementById("blank");
+var friend = document.getElementById("friend");
+var container = document.getElementById("container");
+const objects = document.querySelectorAll(".objects");
+var explode = new Audio('assets/Explode.wav');
+var eat = new Audio('assets/Eat.wav');
+var win = new Audio('assets/Win.wav');
+var music = new Audio('assets/feeding_friend-zy_beat.wav');
+music.loop = true;
+music.volume = 0.33;
+
+//Score counter
+var counter = 0;
+
+//Randomizes food & bombs, as well as food emoji
+var random = Math.floor(Math.random() * 3);
+var foodItemRand = Math.floor(Math.random() * 3);
+
+//Iterator
+let i = 0;
+
+//result & randoStart ensure that food & bomb start on either side of friend,
+//this will make it so that a bomb doesn't spawn immediatley oncoming to the player
+const result = Math.floor(Math.random() * 2) * 2;
+
+function randoStart(){for (i; i < objects.length; i++) {
+ objects[0].style.order = result;
+ objects[1].style.order = 1;
+ if(result == 0){
+ objects[2].style.order = 2;
+ }
+ else{
+ objects[2].style.order = 0;
+ }
+ food.innerHTML = foodItem[foodItemRand];
+
+}};
+
+//Moves the food & bomb
+function objectMove(){
+ for (let i = 0; i < objects.length; i++) {
+ objects[i].style.animation = "slide 1.5s infinite";
+ }
+}
+
+//Pauses food & bomb scrolling
+function objectStop(){
+ for (let i = 0; i < objects.length; i++) {
+ objects[i].style.animation = "none";
+ }
+}
+
+//Pauses food & bomb scrolling
+objectStop();
+
+
+//Pauses the game to show instructions
+//Once the message has been received from Clonk's harness the game will begin
+function clonkload(){
+ //for the love of god Steeled, do NOT touch this line of code
+ //it is finally working now
+ window.parent.postMessage({op: "ready"});
+ //this one too, this is a load-bearing eventlistener
+ //game will fall apart like a jenga™ structure if this eventlistener is broken
+ window.addEventListener("message", ev => {
+ window.parent.postMessage({op: "started", verb: "Feed Friend!"}),
+ setTimeout(() => {
+ objectMove(),
+ document.getElementById("counter").innerHTML = "Foods eated: " + counter,
+ document.getElementById("counter").style.width = "75px"
+ }, 2000)
+ });
+}
+
+//Food emojis, purely visual, has no gameplay effect
+const foodItem = [];
+foodItem[0]= "🍌";
+foodItem[1]= "🍎";
+foodItem[2]= "🍊";
+
+//Loads instructions, randomizes the bomb & food positions and runs the harness check
+document.addEventListener("load",
+ randoStart(),
+ clonkload(),
+ document.getElementById("counter").innerHTML = "Feed Friend! <br> Avoid the Bombs!",
+ document.getElementById("counter").style.width = "100%"
+);
+
+//Prevents context menu on right click, so that the player can move right without issues
+document.addEventListener('contextmenu', (event) => {
+ event.preventDefault();
+});
+
+function moveLeft(){
+ let left = parseInt(window.getComputedStyle(friend)
+ .getPropertyValue("left"));
+ left -= 32;
+ if(left>=0){
+ friend.style.left = left + "px";
+ };
+ music.play();
+}
+
+function moveRight(){
+ let left = parseInt(window.getComputedStyle(friend)
+ .getPropertyValue("left"));
+ left += 32;
+ if(left<96){
+ friend.style.left = left + "px";
+ };
+ music.play();
+}
+
+//Checks mouse input, to get direction of movement
+document.addEventListener('mousedown', (event) => {
+ switch (event.button) {
+ case 0:
+ moveLeft();
+ break;
+ case 2:
+ moveRight();
+ break;
+ }
+});
+
+//Moves the food & bomb row back to the top once it reaches the bottom of the game screen
+setInterval(function(){for (let i = 0; i < objects.length; i++) {
+ objects[i].addEventListener('animationiteration', () => {
+ random = Math.floor(Math.random() * 3) + 1;
+ foodItemRand = Math.floor(Math.random() * 3);
+ objects[i].style.order = random;
+ food.innerHTML = foodItem[foodItemRand];
+})}},125);
+
+//Underlying collision code to be used for both food & bombs
+function isCollide(a, b) {
+ var aRect = a.getBoundingClientRect();
+ var bRect = b.getBoundingClientRect();
+
+ return !(
+ ((aRect.top + aRect.height) < (bRect.top)) ||
+ (aRect.top > (bRect.top + bRect.height)) ||
+ ((aRect.left + aRect.width) < bRect.left) ||
+ (aRect.left > (bRect.left + bRect.width))
+ );
+}
+
+//Checks collisions on an interval
+setInterval(function(){
+ //Food collision check
+ if(isCollide(friend, food)){
+ friend.innerHTML = "<img src='assets/friend_happy.png'>";
+ counter++;
+ eat.play();
+ document.getElementById("counter").innerHTML = "Foods eated: " + counter;
+ //Ends game at 10 food eaten
+ if(counter>9){
+ win.play();
+ container.style.visibility = "hidden";
+ objectStop();
+ document.getElementById("counter").style.width = "100%";
+ document.getElementById("counter").innerHTML = "YOU WIN! CONGLATURATIONS!";
+ //Tells harness that the game is won and resets, to await the harness check again
+ setTimeout(function(){
+ window.parent.postMessage({op: "done", win: true}),
+ location.reload()
+ },2000);
+ }
+ else{
+ //Makes friend a happy fella :) on collision with food
+ setTimeout(function(){
+ friend.innerHTML = "<img src='assets/friend.png'>";
+ },1000);
+ }
+ }
+ //Bomb collsion check
+ if(isCollide(friend, bomb)){
+ container.style.visibility = "hidden";
+ objectStop();
+ explode.play();
+ document.getElementById("counter").style.width = "100%";
+ document.getElementById("counter").innerHTML = "oh no...";
+ //Makes friend explode :( on collision with bomb
+ friend.innerHTML = "💥";
+ setTimeout(function(){
+ //Tells harness that the game is lost and resets, to await the harness check again
+ window.parent.postMessage({op: "done", win: false}),
+ location.reload()
+ },2000);
+ }
+},250);
+
+//Hate. Let me tell you how much I've come to hate Javascript since I began to jam.
+//There are 5771 characters contained in the total lines of code that fill my script.js file.
+//If the word 'hate' was engraved on each subpixel of those 5771 characters
+//it would not equal one one-billionth of the hate I feel for javascript at this micro-instant.
+//For js. Hate. Hate.
\ No newline at end of file diff --git a/2026/games_submissions/steeledshield/style.css b/2026/games_submissions/steeledshield/style.css new file mode 100644 index 0000000..b046eff --- /dev/null +++ b/2026/games_submissions/steeledshield/style.css @@ -0,0 +1,197 @@ +:root {
+ --crt-red: rgb(218, 49, 49);
+ --crt-green: rgb(112, 159, 115);
+ --crt-blue: rgb(40, 129, 206);
+}
+
+body{
+ margin: 0;
+ height: 100vh;
+ font-family: "VT323", monospace;
+ font-weight: 400;
+ font-style: bold;
+ user-select: none; /* standard syntax */
+ -webkit-user-select: none; /* webkit (safari, chrome) browsers */
+ -moz-user-select: none; /* mozilla browsers */
+ -khtml-user-select: none; /* webkit (konqueror) browsers */
+ -ms-user-select: none; /* IE10+ */
+}
+
+#layout{
+ width: 240px;
+ height: 160px;
+ margin: auto;
+ border: 1px solid black;
+ background: linear-gradient(270deg, #03A688, #014040);
+ background-size: 400% 400%;
+
+ -webkit-animation: AnimationName 2s ease infinite;
+ -moz-animation: AnimationName 2s ease infinite;
+ animation: AnimationName 2s ease infinite;
+ background-color: rgb(25, 25, 30);
+ text-shadow: 0 0 0.2em currentColor, 1px 1px rgba(255, 0, 255, 0.5),
+ -1px -1px rgba(0, 255, 255, 0.4);
+ position: relative;
+ &:before,
+ &:after {
+ content: "";
+ transform: translateZ(0);
+ pointer-events: none;
+ opacity: 0.5;
+ mix-blend-mode: overlay;
+ position: absolute;
+ height: 100%;
+ width: 100%;
+ left: 0;
+ top: 0;
+ z-index: 2;
+ }
+
+ &:before {
+ background: repeating-linear-gradient(
+ var(--crt-red) 0px,
+ var(--crt-green) 2px,
+ var(--crt-blue) 4px
+ );
+ }
+ &:after {
+ background: repeating-linear-gradient(
+ 90deg,
+ var(--crt-red) 1px,
+ var(--crt-green) 2px,
+ var(--crt-blue) 3px
+ );
+ }
+}
+
+@-webkit-keyframes AnimationName {
+ 0%{background-position:0% 50%}
+ 50%{background-position:100% 50%}
+ 100%{background-position:0% 50%}
+}
+@-moz-keyframes AnimationName {
+ 0%{background-position:0% 50%}
+ 50%{background-position:100% 50%}
+ 100%{background-position:0% 50%}
+}
+@keyframes AnimationName {
+ 0%{background-position:0% 50%}
+ 50%{background-position:100% 50%}
+ 100%{background-position:0% 50%}
+}
+
+#game{
+ width: 40%;
+ height: 100%;
+ margin: auto;
+ overflow: hidden;
+ background: linear-gradient(270deg, #abe2b8, #C2F2CE);
+ background-size: 400% 400%;
+
+ -webkit-animation: AnimationName 2s ease infinite;
+ -moz-animation: AnimationName 2s ease infinite;
+ animation: AnimationName 2s ease infinite;
+}
+
+@-webkit-keyframes AnimationName {
+ 0%{background-position:0% 50%}
+ 50%{background-position:100% 50%}
+ 100%{background-position:0% 50%}
+}
+@-moz-keyframes AnimationName {
+ 0%{background-position:0% 50%}
+ 50%{background-position:100% 50%}
+ 100%{background-position:0% 50%}
+}
+@keyframes AnimationName {
+ 0%{background-position:0% 50%}
+ 50%{background-position:100% 50%}
+ 100%{background-position:0% 50%}
+}
+
+#friend{
+ width: 32px;
+ height: 32px;
+ position: relative;
+ top: 67%;
+ left: 32px;
+ font-size: 28px;
+ text-align: center;
+}
+
+#friend img{
+ width: 32px;
+ height: 32px;
+}
+
+#container{
+ display: flex;
+}
+
+#bomb{
+ width: 22%;
+ height: 22%;
+ font-size: auto;
+}
+
+#blank{
+ width: 22%;
+ height: 22%;
+ font-size: auto;
+}
+
+#food{
+ width: 22%;
+ height: 22%;
+ font-size: auto;
+}
+
+.objects{
+ position: relative;
+ animation: none;
+ animation-timing-function: linear;
+ text-align: center;
+ margin: auto;
+}
+
+#counter{
+ position: absolute;
+ width: 75px;
+ font-size: 25px;
+ top: -10%;
+ color: white;
+ text-align: center;
+ -webkit-text-stroke-width: 6px;
+ -webkit-text-stroke-color: black;
+ paint-order: stroke fill;
+ z-index: 1;
+}
+
+#click_image{
+ position: absolute;
+ width: 50px;
+ right: 10px;
+ top: 10px;
+ z-index: 0;
+}
+
+@keyframes slide {
+ 0% {top: -26.6px;}
+ 100% {top: 200px;}
+}
+#Clonk{
+ position: absolute;
+ width: 30%;
+ height:60%;
+ bottom: 0;
+ opacity: 0.5;
+}
+
+#Mod{
+ position: absolute;
+ width: 30%;
+ height:60%;
+ right: 0;
+ bottom: 0;
+ opacity: 0.5;
+}
\ No newline at end of file diff --git a/2026/games_submissions/sunshoes/assets/BitmapFont-CoN36Cy_.js b/2026/games_submissions/sunshoes/assets/BitmapFont-CoN36Cy_.js new file mode 100644 index 0000000..e5df6a3 --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/BitmapFont-CoN36Cy_.js @@ -0,0 +1,6 @@ +import{E as q,d as B,v as k,T as O,f as j,b as E,C as P,R as H,c as $,I as J,g as K,e as V,h as L,i as Z,j as Q,k as ee,l as Y,m as te,n as se,o as C,w as ie,p as ne}from"./index-DvAPfvr6.js";class D extends q{constructor(){super(...arguments),this.chars=Object.create(null),this.lineHeight=0,this.fontFamily="",this.fontMetrics={fontSize:0,ascent:0,descent:0},this.baseLineOffset=0,this.distanceField={type:"none",range:0},this.pages=[],this.applyFillAsTint=!0,this.baseMeasurementFontSize=100,this.baseRenderedFontSize=100}get font(){return B(k,"BitmapFont.font is deprecated, please use BitmapFont.fontFamily instead."),this.fontFamily}get pageTextures(){return B(k,"BitmapFont.pageTextures is deprecated, please use BitmapFont.pages instead."),this.pages}get size(){return B(k,"BitmapFont.size is deprecated, please use BitmapFont.fontMetrics.fontSize instead."),this.fontMetrics.fontSize}get distanceFieldRange(){return B(k,"BitmapFont.distanceFieldRange is deprecated, please use BitmapFont.distanceField.range instead."),this.distanceField.range}get distanceFieldType(){return B(k,"BitmapFont.distanceFieldType is deprecated, please use BitmapFont.distanceField.type instead."),this.distanceField.type}destroy(e=!1){var t;this.emit("destroy",this),this.removeAllListeners();for(const s in this.chars)(t=this.chars[s].texture)==null||t.destroy();this.chars=null,e&&(this.pages.forEach(s=>s.texture.destroy(!0)),this.pages=null)}}const U=class G extends D{constructor(e){super(),this.resolution=1,this.pages=[],this._padding=0,this._measureCache=Object.create(null),this._currentChars=[],this._currentX=0,this._currentY=0,this._currentMaxCharHeight=0,this._currentPageIndex=-1,this._skipKerning=!1;const t={...G.defaultOptions,...e};this._textureSize=t.textureSize,this._mipmap=t.mipmap;const s=t.style.clone();t.overrideFill&&(s._fill.color=16777215,s._fill.alpha=1,s._fill.texture=O.WHITE,s._fill.fill=null),this.applyFillAsTint=t.overrideFill;const i=s.fontSize;s.fontSize=this.baseMeasurementFontSize;const n=j(s);t.overrideSize?(s._stroke&&(s._stroke.width*=this.baseRenderedFontSize/i),s.dropShadow&&(s.dropShadow.blur*=this.baseRenderedFontSize/i,s.dropShadow.distance*=this.baseRenderedFontSize/i)):s.fontSize=this.baseRenderedFontSize=i,this._style=s,this._skipKerning=t.skipKerning??!1,this.resolution=t.resolution??1,this._padding=t.padding??4,t.textureStyle&&(this._textureStyle=t.textureStyle instanceof E?t.textureStyle:new E(t.textureStyle)),this.fontMetrics=P.measureFont(n),this.lineHeight=s.lineHeight||this.fontMetrics.fontSize||s.fontSize}ensureCharacters(e){var _,v;const t=P.graphemeSegmenter(e).filter(y=>!this._currentChars.includes(y)).filter((y,m,d)=>d.indexOf(y)===m);if(!t.length)return;this._currentChars=[...this._currentChars,...t];let s;this._currentPageIndex===-1?s=this._nextPage():s=this.pages[this._currentPageIndex];let{canvas:i,context:n}=s.canvasAndContext,a=s.texture.source;const o=this._style;let r=this._currentX,h=this._currentY,l=this._currentMaxCharHeight;const f=this.baseRenderedFontSize/this.baseMeasurementFontSize,w=(((_=o.dropShadow)==null?void 0:_.distance)??0)+(((v=o._stroke)==null?void 0:v.width)??0),F=this._padding+w;let x=!1;const z=i.width/this.resolution,b=i.height/this.resolution;for(let y=0;y<t.length;y++){const m=t[y],d=P.measureText(m,o,i,!1);d.lineHeight=d.height;const p=d.width*f,g=Math.ceil((o.fontStyle==="italic"?2:1)*p),u=d.height*f,W=g+F*2,M=u+F*2;if(x=!1,m!==` +`&&m!=="\r"&&m!==" "&&m!==" "&&(x=!0,l=Math.ceil(Math.max(M,l))),r+W>z&&(h+=l,l=M,r=0,h+l>b)){a.update();const S=this._nextPage();i=S.canvasAndContext.canvas,n=S.canvasAndContext.context,a=S.texture.source,r=0,h=0,l=0}const T=n.measureText(m).width/f;if(this.chars[m]={id:m.codePointAt(0),xOffset:-(F/f),yOffset:-(F/f),xAdvance:T,kerning:{}},x){this._drawGlyph(n,d,r+F,h+F,f,o);const S=a.width*f,I=a.height*f,R=new H(r/S*a.width,h/I*a.height,W/S*a.width,M/I*a.height);this.chars[m].texture=new O({source:a,frame:R}),r+=Math.ceil(W)}}a.update(),this._currentX=r,this._currentY=h,this._currentMaxCharHeight=l,this._skipKerning||this._applyKerning(t,n,f)}get pageTextures(){return B(k,"BitmapFont.pageTextures is deprecated, please use BitmapFont.pages instead."),this.pages}_applyKerning(e,t,s){const i=this._measureCache;for(let n=0;n<e.length;n++){const a=e[n];for(let o=0;o<this._currentChars.length;o++){const r=this._currentChars[o];let h=i[a];h||(h=i[a]=t.measureText(a).width);let l=i[r];l||(l=i[r]=t.measureText(r).width);let f=t.measureText(a+r).width,w=f-(h+l);w&&this.chars[a]&&(this.chars[a].kerning[r]=w/s),f=t.measureText(a+r).width,w=f-(h+l),w&&this.chars[r]&&(this.chars[r].kerning[a]=w/s)}}}_nextPage(){this._currentPageIndex++;const e=this.resolution,t=$.getOptimalCanvasAndContext(this._textureSize,this._textureSize,e);this._setupContext(t.context,this._style,e);const s=e*(this.baseRenderedFontSize/this.baseMeasurementFontSize),i=new O({source:new J({resource:t.canvas,resolution:s,alphaMode:"premultiply-alpha-on-upload",autoGenerateMipmaps:this._mipmap})});this._textureStyle&&(i.source.style=this._textureStyle);const n={canvasAndContext:t,texture:i};return this.pages[this._currentPageIndex]=n,n}_setupContext(e,t,s){t.fontSize=this.baseRenderedFontSize,e.scale(s,s),e.font=j(t),t.fontSize=this.baseMeasurementFontSize,e.textBaseline=t.textBaseline;const i=t._stroke,n=(i==null?void 0:i.width)??0;if(i&&(e.lineWidth=n,e.lineJoin=i.join,e.miterLimit=i.miterLimit,e.strokeStyle=K(i,e)),t._fill&&(e.fillStyle=K(t._fill,e)),t.dropShadow){const a=t.dropShadow,o=V.shared.setValue(a.color).toArray(),r=a.blur*s,h=a.distance*s;e.shadowColor=`rgba(${o[0]*255},${o[1]*255},${o[2]*255},${a.alpha})`,e.shadowBlur=r,e.shadowOffsetX=Math.cos(a.angle)*h,e.shadowOffsetY=Math.sin(a.angle)*h}else e.shadowColor="black",e.shadowBlur=0,e.shadowOffsetX=0,e.shadowOffsetY=0}_drawGlyph(e,t,s,i,n,a){const o=t.text,r=t.fontProperties,h=a._stroke,l=((h==null?void 0:h.width)??0)*n,f=s+l/2,w=i-l/2,F=r.descent*n,x=t.lineHeight*n;let z=!1;a.stroke&&l&&(z=!0,e.strokeText(o,f,w+x-F));const{shadowBlur:b,shadowOffsetX:_,shadowOffsetY:v}=e;a._fill&&(z&&(e.shadowBlur=0,e.shadowOffsetX=0,e.shadowOffsetY=0),e.fillText(o,f,w+x-F)),z&&(e.shadowBlur=b,e.shadowOffsetX=_,e.shadowOffsetY=v)}destroy(){super.destroy();for(let e=0;e<this.pages.length;e++){const{canvasAndContext:t,texture:s}=this.pages[e];$.returnCanvasAndContext(t),s.destroy(!0)}this.pages=null}};U.defaultOptions={textureSize:512,style:new L,mipmap:!0};let N=U;function ae(c,e,t,s){var y,m;const i={width:0,height:0,offsetY:0,scale:e.fontSize/t.baseMeasurementFontSize,lines:[{width:0,charPositions:[],spaceWidth:0,spacesIndex:[],chars:[]}]};i.offsetY=t.baseLineOffset;let n=i.lines[0],a=null,o=!0;const r={width:0,start:0,index:0,positions:[],chars:[]},h=t.baseMeasurementFontSize/e.fontSize,l=e.letterSpacing*h,f=e.wordWrapWidth*h,w=e.lineHeight?e.lineHeight*h:t.lineHeight,F=e.wordWrap&&e.breakWords,x=Z(e.whiteSpace),z=Q(e.whiteSpace);if(x||z){const d=[];let p=x;for(let g=0;g<c.length;g++){let u=c[g];if(u==="\r"||u===` +`)if(z)u==="\r"&&c[g+1]===` +`&&g++,u=" ";else{x&&(p=!0),d.push(u);continue}if(ee(u))if(x&&Y(u)){if(p)continue;p=!0,d.push(" ")}else p=!1,d.push(u);else p=!1,d.push(u)}c=d}const b=d=>{const p=n.width;for(let g=0;g<r.index;g++){const u=d.positions[g];n.chars.push(d.chars[g]),n.charPositions.push(u+p)}n.width+=d.width,(r.index>0||!x)&&(o=!1),r.width=0,r.index=0,r.chars.length=0},_=()=>{let d=n.chars.length-1;if(s){let p=n.chars[d];for(;Y(p);)n.width-=t.chars[p].xAdvance,n.spacesIndex.pop(),p=n.chars[--d]}i.width=Math.max(i.width,n.width),n={width:0,charPositions:[],chars:[],spaceWidth:0,spacesIndex:[]},o=!0,i.lines.push(n),i.height+=w},v=d=>d-l>f;for(let d=0;d<c.length+1;d++){let p;const g=d===c.length;g||(p=c[d]);const u=t.chars[p];if(/(?:\s)/.test(p)||p==="\r"||p===` +`||g){if(!o&&e.wordWrap&&v(n.width+r.width)?(_(),b(r),!g&&u&&n.charPositions.push(0)):(r.start=n.width,b(r),!g&&u&&n.charPositions.push(0)),p==="\r"||p===` +`)_();else if(!g&&u){const S=u.xAdvance+(((y=u.kerning)==null?void 0:y[a])||0)+l;n.width+=S,n.spaceWidth=S,n.spacesIndex.push(n.charPositions.length),n.chars.push(p)}}else if(u){const T=((m=u.kerning)==null?void 0:m[a])||0,S=u.xAdvance+T+l;F&&v(r.width+S)&&(o||_(),b(r),_()),r.positions[r.index++]=r.width+T,r.chars.push(p),r.width+=S,te(p)&&(!o&&e.wordWrap&&v(n.width+r.width)&&_(),b(r))}a=p}return _(),e.align==="center"?re(i):e.align==="right"?oe(i):e.align==="justify"&&he(i),i}function re(c){for(let e=0;e<c.lines.length;e++){const t=c.lines[e],s=c.width/2-t.width/2;for(let i=0;i<t.charPositions.length;i++)t.charPositions[i]+=s}}function oe(c){for(let e=0;e<c.lines.length;e++){const t=c.lines[e],s=c.width-t.width;for(let i=0;i<t.charPositions.length;i++)t.charPositions[i]+=s}}function he(c){const e=c.width;for(let t=0;t<c.lines.length-2;t++){const s=c.lines[t];let i=0,n=s.spacesIndex[i++],a=0;const o=s.spacesIndex.length,h=(e-s.width)/o;for(let l=0;l<s.charPositions.length;l++)l===n&&(n=s.spacesIndex[i++],a+=h),s.charPositions[l]+=a}}function le(c){if(c==="")return[];typeof c=="string"&&(c=[c]);const e=[];for(let t=0,s=c.length;t<s;t++){const i=c[t];if(Array.isArray(i)){if(i.length!==2)throw new Error(`[BitmapFont]: Invalid character range length, expecting 2 got ${i.length}.`);if(i[0].length===0||i[1].length===0)throw new Error("[BitmapFont]: Invalid character delimiter.");const n=i[0].charCodeAt(0),a=i[1].charCodeAt(0);if(a<n)throw new Error("[BitmapFont]: Invalid character range.");for(let o=n,r=a;o<=r;o++)e.push(String.fromCharCode(o))}else e.push(...Array.from(i))}if(e.length===0)throw new Error("[BitmapFont]: Empty set when resolving characters.");return e}let A=0;class ce{constructor(){this.ALPHA=[["a","z"],["A","Z"]," "],this.NUMERIC=[["0","9"]],this.ALPHANUMERIC=[["a","z"],["A","Z"],["0","9"]," "],this.ASCII=[[" ","~"]],this.defaultOptions={chars:this.ALPHANUMERIC,resolution:1,padding:4,skipKerning:!1,textureStyle:null},this.measureCache=se(1e3)}getFont(e,t){var a,o;let s=`${t.fontFamily}-bitmap`,i=!0;if(C.has(s)){const r=C.get(s);return(a=r.ensureCharacters)==null||a.call(r,e),r}if(t._fill.fill&&!t._stroke?(s+=t._fill.fill.styleKey,i=!1):(t._stroke||t.dropShadow)&&(s=`${t.styleKey}-bitmap`,i=!1),s+=`-${t.fontStyle}`,s+=`-${t.fontVariant}`,s+=`-${t.fontWeight}`,!C.has(s)){const r=Object.create(t);r._lineHeight=0;const h=new N({style:r,overrideFill:i,overrideSize:!0,...this.defaultOptions});A++,A>50&&ie("BitmapText",`You have dynamically created ${A} bitmap fonts, this can be inefficient. Try pre installing your font styles using \`BitmapFont.install({name:"style1", style})\``),h.once("destroy",()=>{A--,C.remove(s)}),C.set(s,h)}const n=C.get(s);return(o=n.ensureCharacters)==null||o.call(n,e),n}getLayout(e,t,s=!0){const i=this.getFont(e,t),n=`${e}-${t.styleKey}-${s}`;if(this.measureCache.has(n))return this.measureCache.get(n);const a=P.graphemeSegmenter(e),o=ae(a,t,i,s);return this.measureCache.set(n,o),o}measureText(e,t,s=!0){return this.getLayout(e,t,s)}install(...e){var h,l,f,w;let t=e[0];typeof t=="string"&&(t={name:t,style:e[1],chars:(h=e[2])==null?void 0:h.chars,resolution:(l=e[2])==null?void 0:l.resolution,padding:(f=e[2])==null?void 0:f.padding,skipKerning:(w=e[2])==null?void 0:w.skipKerning},B(k,"BitmapFontManager.install(name, style, options) is deprecated, use BitmapFontManager.install({name, style, ...options})"));const s=t==null?void 0:t.name;if(!s)throw new Error("[BitmapFontManager] Property `name` is required.");t={...this.defaultOptions,...t};const i=t.style,n=i instanceof L?i:new L(i),a=t.dynamicFill??this._canUseTintForStyle(n),o=new N({style:n,overrideFill:a,skipKerning:t.skipKerning,padding:t.padding,resolution:t.resolution,overrideSize:!1,textureStyle:t.textureStyle}),r=le(t.chars);return o.ensureCharacters(r.join("")),C.set(`${s}-bitmap`,o),o.once("destroy",()=>C.remove(`${s}-bitmap`)),o}uninstall(e){const t=`${e}-bitmap`,s=C.get(t);s&&s.destroy()}_canUseTintForStyle(e){return!e._stroke&&(!e.dropShadow||e.dropShadow.color===0)&&!e._fill.fill&&e._fill.color===16777215}}const X=new ce;class pe extends D{constructor(e,t){super();const{textures:s,data:i}=e;Object.keys(i.pages).forEach(n=>{const a=i.pages[parseInt(n,10)],o=s[a.id];this.pages.push({texture:o})}),Object.keys(i.chars).forEach(n=>{const a=i.chars[n],{frame:o,source:r,rotate:h}=s[a.page],l=ne.transformRectCoords(a,o,h,new H),f=new O({frame:l,orig:new H(0,0,a.width,a.height),source:r,rotate:h});this.chars[n]={id:n.codePointAt(0),xOffset:a.xOffset,yOffset:a.yOffset,xAdvance:a.xAdvance,kerning:a.kerning??{},texture:f}}),this.baseRenderedFontSize=i.fontSize,this.baseMeasurementFontSize=i.fontSize,this.fontMetrics={ascent:0,descent:0,fontSize:i.fontSize},this.baseLineOffset=i.baseLineOffset,this.lineHeight=i.lineHeight,this.fontFamily=i.fontFamily,this.distanceField=i.distanceField??{type:"none",range:0},this.url=t}destroy(){super.destroy();for(let e=0;e<this.pages.length;e++){const{texture:t}=this.pages[e];t.destroy(!0)}this.pages=null}static install(e){X.install(e)}static uninstall(e){X.uninstall(e)}}export{pe as BitmapFont}; diff --git a/2026/games_submissions/sunshoes/assets/BufferResource-BZpoqTVb.js b/2026/games_submissions/sunshoes/assets/BufferResource-BZpoqTVb.js new file mode 100644 index 0000000..0aef32c --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/BufferResource-BZpoqTVb.js @@ -0,0 +1,185 @@ +import{w as U,q as g,r as c,u as S,B as _,s as m,E as I,t as p}from"./index-DvAPfvr6.js";const x={name:"local-uniform-bit",vertex:{header:` + + struct LocalUniforms { + uTransformMatrix:mat3x3<f32>, + uColor:vec4<f32>, + uRound:f32, + } + + @group(1) @binding(0) var<uniform> localUniforms : LocalUniforms; + `,main:` + vColor *= localUniforms.uColor; + modelMatrix *= localUniforms.uTransformMatrix; + `,end:` + if(localUniforms.uRound == 1) + { + vPosition = vec4(roundPixels(vPosition.xy, globalUniforms.uResolution), vPosition.zw); + } + `}},C={...x,vertex:{...x.vertex,header:x.vertex.header.replace("group(1)","group(2)")}},D={name:"local-uniform-bit",vertex:{header:` + + uniform mat3 uTransformMatrix; + uniform vec4 uColor; + uniform float uRound; + `,main:` + vColor *= uColor; + modelMatrix = uTransformMatrix; + `,end:` + if(uRound == 1.) + { + gl_Position.xy = roundPixels(gl_Position.xy, uResolution); + } + `}},O={name:"texture-bit",vertex:{header:` + + struct TextureUniforms { + uTextureMatrix:mat3x3<f32>, + } + + @group(2) @binding(2) var<uniform> textureUniforms : TextureUniforms; + `,main:` + uv = (textureUniforms.uTextureMatrix * vec3(uv, 1.0)).xy; + `},fragment:{header:` + @group(2) @binding(0) var uTexture: texture_2d<f32>; + @group(2) @binding(1) var uSampler: sampler; + + + `,main:` + outColor = textureSample(uTexture, uSampler, vUV); + `}},R={name:"texture-bit",vertex:{header:` + uniform mat3 uTextureMatrix; + `,main:` + uv = (uTextureMatrix * vec3(uv, 1.0)).xy; + `},fragment:{header:` + uniform sampler2D uTexture; + + + `,main:` + outColor = texture(uTexture, vUV); + `}};function A(e,t){for(const a in e.attributes){const s=e.attributes[a],r=t[a];r?(s.format??(s.format=r.format),s.offset??(s.offset=r.offset),s.instance??(s.instance=r.instance)):U(`Attribute ${a} is not present in the shader, but is present in the geometry. Unable to infer attribute details.`)}M(e)}function M(e){const{buffers:t,attributes:a}=e,s={},r={};for(const n in t){const o=t[n];s[o.uid]=0,r[o.uid]=0}for(const n in a){const o=a[n];s[o.buffer.uid]+=g(o.format).stride}for(const n in a){const o=a[n];o.stride??(o.stride=s[o.buffer.uid]),o.start??(o.start=r[o.buffer.uid]),r[o.buffer.uid]+=g(o.format).stride}}const l=[];l[c.NONE]=void 0;l[c.DISABLED]={stencilWriteMask:0,stencilReadMask:0};l[c.RENDERING_MASK_ADD]={stencilFront:{compare:"equal",passOp:"increment-clamp"},stencilBack:{compare:"equal",passOp:"increment-clamp"}};l[c.RENDERING_MASK_REMOVE]={stencilFront:{compare:"equal",passOp:"decrement-clamp"},stencilBack:{compare:"equal",passOp:"decrement-clamp"}};l[c.MASK_ACTIVE]={stencilWriteMask:0,stencilFront:{compare:"equal",passOp:"keep"},stencilBack:{compare:"equal",passOp:"keep"}};l[c.INVERSE_MASK_ACTIVE]={stencilWriteMask:0,stencilFront:{compare:"not-equal",passOp:"keep"},stencilBack:{compare:"not-equal",passOp:"keep"}};class B{constructor(t){this._syncFunctionHash=Object.create(null),this._adaptor=t,this._systemCheck()}_systemCheck(){if(!S())throw new Error("Current environment does not allow unsafe-eval, please use pixi.js/unsafe-eval module to enable support.")}ensureUniformGroup(t){const a=this.getUniformGroupData(t);t.buffer||(t.buffer=new _({data:new Float32Array(a.layout.size/4),usage:m.UNIFORM|m.COPY_DST}))}getUniformGroupData(t){return this._syncFunctionHash[t._signature]||this._initUniformGroup(t)}_initUniformGroup(t){const a=t._signature;let s=this._syncFunctionHash[a];if(!s){const r=Object.keys(t.uniformStructures).map(d=>t.uniformStructures[d]),n=this._adaptor.createUboElements(r),o=this._generateUboSync(n.uboElements);s=this._syncFunctionHash[a]={layout:n,syncFunction:o}}return this._syncFunctionHash[a]}_generateUboSync(t){return this._adaptor.generateUboSync(t)}syncUniformGroup(t,a,s){const r=this.getUniformGroupData(t);t.buffer||(t.buffer=new _({data:new Float32Array(r.layout.size/4),usage:m.UNIFORM|m.COPY_DST}));let n=null;return a||(a=t.buffer.data,n=t.buffer.dataInt32),s||(s=0),r.syncFunction(t.uniforms,a,n,s),!0}updateUniformGroup(t){if(t.isStatic&&!t._dirtyId)return!1;t._dirtyId=0;const a=this.syncUniformGroup(t);return t.buffer.update(),a}destroy(){this._syncFunctionHash=null}}const h=[{type:"mat3x3<f32>",test:e=>e.value.a!==void 0,ubo:` + var matrix = uv[name].toArray(true); + data[offset] = matrix[0]; + data[offset + 1] = matrix[1]; + data[offset + 2] = matrix[2]; + data[offset + 4] = matrix[3]; + data[offset + 5] = matrix[4]; + data[offset + 6] = matrix[5]; + data[offset + 8] = matrix[6]; + data[offset + 9] = matrix[7]; + data[offset + 10] = matrix[8]; + `,uniform:` + gl.uniformMatrix3fv(ud[name].location, false, uv[name].toArray(true)); + `},{type:"vec4<f32>",test:e=>e.type==="vec4<f32>"&&e.size===1&&e.value.width!==void 0,ubo:` + v = uv[name]; + data[offset] = v.x; + data[offset + 1] = v.y; + data[offset + 2] = v.width; + data[offset + 3] = v.height; + `,uniform:` + cv = ud[name].value; + v = uv[name]; + if (cv[0] !== v.x || cv[1] !== v.y || cv[2] !== v.width || cv[3] !== v.height) { + cv[0] = v.x; + cv[1] = v.y; + cv[2] = v.width; + cv[3] = v.height; + gl.uniform4f(ud[name].location, v.x, v.y, v.width, v.height); + } + `},{type:"vec2<f32>",test:e=>e.type==="vec2<f32>"&&e.size===1&&e.value.x!==void 0,ubo:` + v = uv[name]; + data[offset] = v.x; + data[offset + 1] = v.y; + `,uniform:` + cv = ud[name].value; + v = uv[name]; + if (cv[0] !== v.x || cv[1] !== v.y) { + cv[0] = v.x; + cv[1] = v.y; + gl.uniform2f(ud[name].location, v.x, v.y); + } + `},{type:"vec4<f32>",test:e=>e.type==="vec4<f32>"&&e.size===1&&e.value.red!==void 0,ubo:` + v = uv[name]; + data[offset] = v.red; + data[offset + 1] = v.green; + data[offset + 2] = v.blue; + data[offset + 3] = v.alpha; + `,uniform:` + cv = ud[name].value; + v = uv[name]; + if (cv[0] !== v.red || cv[1] !== v.green || cv[2] !== v.blue || cv[3] !== v.alpha) { + cv[0] = v.red; + cv[1] = v.green; + cv[2] = v.blue; + cv[3] = v.alpha; + gl.uniform4f(ud[name].location, v.red, v.green, v.blue, v.alpha); + } + `},{type:"vec3<f32>",test:e=>e.type==="vec3<f32>"&&e.size===1&&e.value.red!==void 0,ubo:` + v = uv[name]; + data[offset] = v.red; + data[offset + 1] = v.green; + data[offset + 2] = v.blue; + `,uniform:` + cv = ud[name].value; + v = uv[name]; + if (cv[0] !== v.red || cv[1] !== v.green || cv[2] !== v.blue) { + cv[0] = v.red; + cv[1] = v.green; + cv[2] = v.blue; + gl.uniform3f(ud[name].location, v.red, v.green, v.blue); + } + `}];function k(e,t,a,s){const r=[` + var v = null; + var v2 = null; + var t = 0; + var index = 0; + var name = null; + var arrayOffset = null; + `];let n=0;for(let d=0;d<e.length;d++){const f=e[d],b=f.data.name;let y=!1,i=0;for(let u=0;u<h.length;u++)if(h[u].test(f.data)){i=f.offset/4,r.push(`name = "${b}";`,`offset += ${i-n};`,h[u][t]||h[u].ubo),y=!0;break}if(!y)if(f.data.size>1)i=f.offset/4,r.push(a(f,i-n));else{const u=s[f.data.type];i=f.offset/4,r.push(` + v = uv.${b}; + offset += ${i-n}; + ${u}; + `)}n=i}const o=r.join(` +`);return new Function("uv","data","dataInt32","offset",o)}function v(e,t){return` + for (let i = 0; i < ${e*t}; i++) { + data[offset + (((i / ${e})|0) * 4) + (i % ${e})] = v[i]; + } + `}const F={f32:` + data[offset] = v;`,i32:` + dataInt32[offset] = v;`,"vec2<f32>":` + data[offset] = v[0]; + data[offset + 1] = v[1];`,"vec3<f32>":` + data[offset] = v[0]; + data[offset + 1] = v[1]; + data[offset + 2] = v[2];`,"vec4<f32>":` + data[offset] = v[0]; + data[offset + 1] = v[1]; + data[offset + 2] = v[2]; + data[offset + 3] = v[3];`,"vec2<i32>":` + dataInt32[offset] = v[0]; + dataInt32[offset + 1] = v[1];`,"vec3<i32>":` + dataInt32[offset] = v[0]; + dataInt32[offset + 1] = v[1]; + dataInt32[offset + 2] = v[2];`,"vec4<i32>":` + dataInt32[offset] = v[0]; + dataInt32[offset + 1] = v[1]; + dataInt32[offset + 2] = v[2]; + dataInt32[offset + 3] = v[3];`,"mat2x2<f32>":` + data[offset] = v[0]; + data[offset + 1] = v[1]; + data[offset + 4] = v[2]; + data[offset + 5] = v[3];`,"mat3x3<f32>":` + data[offset] = v[0]; + data[offset + 1] = v[1]; + data[offset + 2] = v[2]; + data[offset + 4] = v[3]; + data[offset + 5] = v[4]; + data[offset + 6] = v[5]; + data[offset + 8] = v[6]; + data[offset + 9] = v[7]; + data[offset + 10] = v[8];`,"mat4x4<f32>":` + for (let i = 0; i < 16; i++) { + data[offset + i] = v[i]; + }`,"mat3x2<f32>":v(3,2),"mat4x2<f32>":v(4,2),"mat2x3<f32>":v(2,3),"mat4x3<f32>":v(4,3),"mat2x4<f32>":v(2,4),"mat3x4<f32>":v(3,4)},w={...F,"mat2x2<f32>":` + data[offset] = v[0]; + data[offset + 1] = v[1]; + data[offset + 2] = v[2]; + data[offset + 3] = v[3]; + `};class P extends I{constructor({buffer:t,offset:a,size:s}){super(),this.uid=p("buffer"),this._resourceType="bufferResource",this._touched=0,this._resourceId=p("resource"),this._bufferResource=!0,this.destroyed=!1,this.buffer=t,this.offset=a|0,this.size=s,this.buffer.on("change",this.onBufferChange,this)}onBufferChange(){this._resourceId=p("resource"),this.emit("change",this)}destroy(t=!1){this.destroyed=!0,t&&this.buffer.destroy(),this.emit("change",this),this.buffer=null,this.removeAllListeners()}}export{P as B,l as G,B as U,x as a,F as b,k as c,h as d,A as e,D as f,R as g,C as l,O as t,w as u}; diff --git a/2026/games_submissions/sunshoes/assets/CanvasRenderer-Yf_04ykh.js b/2026/games_submissions/sunshoes/assets/CanvasRenderer-Yf_04ykh.js new file mode 100644 index 0000000..72bfc86 --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/CanvasRenderer-Yf_04ykh.js @@ -0,0 +1 @@ +import{x as vt,y as ne,z as _,A as Dt,D as re,F as z,H as ae,V as oe,J as ot,d as E,v as W,K as T,p as At,L as Ft,M as ct,N as L,w as ie,O as Ut,P as Ht,Q as le,e as Et,T as Wt,U as ce,W as he,X as de,Y as ue,Z as Lt,_ as pe,$ as fe}from"./index-DvAPfvr6.js";import{c as me,R as xe,S as ge,B as Ce,a as _e,b as ye,d as ve,A as be,C as Te}from"./RenderTargetSystem-Cp6tD-lP.js";import{S as qt}from"./Filter-BiIvpnZm.js";class Se{constructor(){this.isBatchable=!1}reset(){this.isBatchable=!1,this.context=null,this.graphicsData&&(this.graphicsData.destroy(),this.graphicsData=null)}destroy(){this.reset()}}class Pe{constructor(){this.instructions=new ne}init(){this.instructions.reset()}destroy(){this.instructions.destroy(),this.instructions=null}}const bt=class yt{constructor(t){this._renderer=t,this._managedContexts=new vt({renderer:t,type:"resource",name:"graphicsContext"})}init(t){yt.defaultOptions.bezierSmoothness=(t==null?void 0:t.bezierSmoothness)??yt.defaultOptions.bezierSmoothness}getContextRenderData(t){return this.getGpuContext(t).graphicsData||this._initContextRenderData(t)}updateGpuContext(t){const e=t._gpuData,s=!!e[this._renderer.uid],n=e[this._renderer.uid]||this._initContext(t);return(t.dirty||!s)&&(s&&n.reset(),n.isBatchable=!1,t.dirty=!1),n}getGpuContext(t){return t._gpuData[this._renderer.uid]||this._initContext(t)}_initContextRenderData(t){const e=new Pe,s=this.getGpuContext(t);return s.graphicsData=e,e.init(),e}_initContext(t){const e=new Se;return e.context=t,t._gpuData[this._renderer.uid]=e,this._managedContexts.add(t),e}destroy(){this._managedContexts.destroy(),this._renderer=null}};bt.extension={type:[_.CanvasSystem],name:"graphicsContext"};bt.defaultOptions={bezierSmoothness:.5};let Me=bt;class Ot{constructor(t,e){this.state=qt.for2d(),this.renderer=t,this._adaptor=e,this.renderer.runners.contextChange.add(this),this._managedGraphics=new vt({renderer:t,type:"renderable",priority:-1,name:"graphics"})}contextChange(){this._adaptor.contextChange(this.renderer)}validateRenderable(t){return!1}addRenderable(t,e){this._managedGraphics.add(t),this.renderer.renderPipes.batch.break(e),e.add(t)}updateRenderable(t){}execute(t){t.isRenderable&&this._adaptor.execute(this,t)}destroy(){this._managedGraphics.destroy(),this.renderer=null,this._adaptor.destroy(),this._adaptor=null}}Ot.extension={type:[_.CanvasPipes],name:"graphics"};class ke{constructor(){this.batches=[],this.batched=!1}destroy(){this.batches.forEach(t=>{Dt.return(t)}),this.batches.length=0}}class Vt{constructor(t,e){this.state=qt.for2d(),this.renderer=t,this._adaptor=e,this.renderer.runners.contextChange.add(this),this._managedGraphics=new vt({renderer:t,type:"renderable",priority:-1,name:"graphics"})}contextChange(){this._adaptor.contextChange(this.renderer)}validateRenderable(t){const e=t.context,s=!!t._gpuData,r=this.renderer.graphicsContext.updateGpuContext(e);return!!(r.isBatchable||s!==r.isBatchable)}addRenderable(t,e){const n=this.renderer.graphicsContext.updateGpuContext(t.context);t.didViewUpdate&&this._rebuild(t),n.isBatchable?this._addToBatcher(t,e):(this.renderer.renderPipes.batch.break(e),e.add(t))}updateRenderable(t){const s=this._getGpuDataForRenderable(t).batches;for(let n=0;n<s.length;n++){const r=s[n];r._batcher.updateElement(r)}}execute(t){if(!t.isRenderable)return;const e=this.renderer,s=t.context;if(!e.graphicsContext.getGpuContext(s).batches.length)return;const r=s.customShader||this._adaptor.shader;this.state.blendMode=t.groupBlendMode;const o=r.resources.localUniforms.uniforms;o.uTransformMatrix=t.groupTransform,o.uRound=e._roundPixels|t._roundPixels,me(t.groupColorAlpha,o.uColor,0),this._adaptor.execute(this,t)}_rebuild(t){const e=this._getGpuDataForRenderable(t),n=this.renderer.graphicsContext.updateGpuContext(t.context);e.destroy(),n.isBatchable&&this._updateBatchesForRenderable(t,e)}_addToBatcher(t,e){const s=this.renderer.renderPipes.batch,n=this._getGpuDataForRenderable(t).batches;for(let r=0;r<n.length;r++){const o=n[r];s.addToBatch(o,e)}}_getGpuDataForRenderable(t){return t._gpuData[this.renderer.uid]||this._initGpuDataForRenderable(t)}_initGpuDataForRenderable(t){const e=new ke;return t._gpuData[this.renderer.uid]=e,this._managedGraphics.add(t),e}_updateBatchesForRenderable(t,e){const s=t.context,r=this.renderer.graphicsContext.getGpuContext(s),o=this.renderer._roundPixels|t._roundPixels;e.batches=r.batches.map(l=>{const i=Dt.get(re);return l.copyTo(i),i.renderable=t,i.roundPixels=o,i})}destroy(){this._managedGraphics.destroy(),this.renderer=null,this._adaptor.destroy(),this._adaptor=null,this.state=null}}Vt.extension={type:[_.WebGLPipes,_.WebGPUPipes],name:"graphics"};z.add(Ot);z.add(Vt);z.add(Me);z.add(ae);class dt extends oe{constructor(t){t instanceof ot&&(t={context:t});const{context:e,roundPixels:s,...n}=t||{};super({label:"Graphics",...n}),this.renderPipeId="graphics",e?this.context=e:(this.context=this._ownedContext=new ot,this.context.autoGarbageCollect=this.autoGarbageCollect),this.didViewUpdate=!0,this.allowChildren=!1,this.roundPixels=s??!1}set context(t){t!==this._context&&(this._context&&(this._context.off("update",this.onViewUpdate,this),this._context.off("unload",this.unload,this)),this._context=t,this._context.on("update",this.onViewUpdate,this),this._context.on("unload",this.unload,this),this.onViewUpdate())}get context(){return this._context}get bounds(){return this._context.bounds}updateBounds(){}containsPoint(t){return this._context.containsPoint(t)}destroy(t){this._ownedContext&&!t?this._ownedContext.destroy(t):(t===!0||(t==null?void 0:t.context)===!0)&&this._context.destroy(t),this._ownedContext=null,this._context=null,super.destroy(t)}_onTouch(t){this._gcLastUsed=t,this._context._gcLastUsed=t}_callContextMethod(t,e){return this.context[t](...e),this}setFillStyle(...t){return this._callContextMethod("setFillStyle",t)}setStrokeStyle(...t){return this._callContextMethod("setStrokeStyle",t)}fill(...t){return this._callContextMethod("fill",t)}stroke(...t){return this._callContextMethod("stroke",t)}texture(...t){return this._callContextMethod("texture",t)}beginPath(){return this._callContextMethod("beginPath",[])}cut(){return this._callContextMethod("cut",[])}arc(...t){return this._callContextMethod("arc",t)}arcTo(...t){return this._callContextMethod("arcTo",t)}arcToSvg(...t){return this._callContextMethod("arcToSvg",t)}bezierCurveTo(...t){return this._callContextMethod("bezierCurveTo",t)}closePath(){return this._callContextMethod("closePath",[])}ellipse(...t){return this._callContextMethod("ellipse",t)}circle(...t){return this._callContextMethod("circle",t)}path(...t){return this._callContextMethod("path",t)}lineTo(...t){return this._callContextMethod("lineTo",t)}moveTo(...t){return this._callContextMethod("moveTo",t)}quadraticCurveTo(...t){return this._callContextMethod("quadraticCurveTo",t)}rect(...t){return this._callContextMethod("rect",t)}roundRect(...t){return this._callContextMethod("roundRect",t)}poly(...t){return this._callContextMethod("poly",t)}regularPoly(...t){return this._callContextMethod("regularPoly",t)}roundPoly(...t){return this._callContextMethod("roundPoly",t)}roundShape(...t){return this._callContextMethod("roundShape",t)}filletRect(...t){return this._callContextMethod("filletRect",t)}chamferRect(...t){return this._callContextMethod("chamferRect",t)}star(...t){return this._callContextMethod("star",t)}svg(...t){return this._callContextMethod("svg",t)}restore(...t){return this._callContextMethod("restore",t)}save(){return this._callContextMethod("save",[])}getTransform(){return this.context.getTransform()}resetTransform(){return this._callContextMethod("resetTransform",[])}rotateTransform(...t){return this._callContextMethod("rotate",t)}scaleTransform(...t){return this._callContextMethod("scale",t)}setTransform(...t){return this._callContextMethod("setTransform",t)}transform(...t){return this._callContextMethod("transform",t)}translateTransform(...t){return this._callContextMethod("translate",t)}clear(){return this._callContextMethod("clear",[])}get fillStyle(){return this._context.fillStyle}set fillStyle(t){this._context.fillStyle=t}get strokeStyle(){return this._context.strokeStyle}set strokeStyle(t){this._context.strokeStyle=t}clone(t=!1){return t?new dt(this._context.clone()):(this._ownedContext=null,new dt(this._context))}lineStyle(t,e,s){E(W,"Graphics#lineStyle is no longer needed. Use Graphics#setStrokeStyle to set the stroke style.");const n={};return t&&(n.width=t),e&&(n.color=e),s&&(n.alpha=s),this.context.strokeStyle=n,this}beginFill(t,e){E(W,"Graphics#beginFill is no longer needed. Use Graphics#fill to fill the shape with the desired style.");const s={};return t!==void 0&&(s.color=t),e!==void 0&&(s.alpha=e),this.context.fillStyle=s,this}endFill(){E(W,"Graphics#endFill is no longer needed. Use Graphics#fill to fill the shape with the desired style."),this.context.fill();const t=this.context.strokeStyle;return(t.width!==ot.defaultStrokeStyle.width||t.color!==ot.defaultStrokeStyle.color||t.alpha!==ot.defaultStrokeStyle.alpha)&&this.context.stroke(),this}drawCircle(...t){return E(W,"Graphics#drawCircle has been renamed to Graphics#circle"),this._callContextMethod("circle",t)}drawEllipse(...t){return E(W,"Graphics#drawEllipse has been renamed to Graphics#ellipse"),this._callContextMethod("ellipse",t)}drawPolygon(...t){return E(W,"Graphics#drawPolygon has been renamed to Graphics#poly"),this._callContextMethod("poly",t)}drawRect(...t){return E(W,"Graphics#drawRect has been renamed to Graphics#rect"),this._callContextMethod("rect",t)}drawRoundedRect(...t){return E(W,"Graphics#drawRoundedRect has been renamed to Graphics#roundRect"),this._callContextMethod("roundRect",t)}drawStar(...t){return E(W,"Graphics#drawStar has been renamed to Graphics#star"),this._callContextMethod("star",t)}}const Tt=class K{static _getPatternRepeat(t,e){const s=t&&t!=="clamp-to-edge",n=e&&e!=="clamp-to-edge";return s&&n?"repeat":s?"repeat-x":n?"repeat-y":"no-repeat"}start(t,e,s){}execute(t,e){var l,i,p,f;const s=e.elements;if(!s||!s.length)return;const n=t.renderer,r=n.canvasContext,o=r.activeContext;for(let y=0;y<s.length;y++){const A=s[y];if(!A.packAsQuad)continue;const g=A,m=g.texture,k=m?T.getCanvasSource(m):null;if(!k)continue;const C=m.source.style,B=r.smoothProperty,$=C.scaleMode!=="nearest";o[B]!==$&&(o[B]=$),r.setBlendMode(e.blendMode);const q=((l=n.globalUniforms.globalUniformData)==null?void 0:l.worldColor)??4294967295,F=g.color,S=(q>>>24&255)/255,v=(F>>>24&255)/255,X=((i=n.filter)==null?void 0:i.alphaMultiplier)??1,et=S*v*X;if(et<=0)continue;o.globalAlpha=et;const st=q&16777215,Q=F&16777215,P=Ft(ct(Q,st)),w=m.frame,R=C.addressModeU??C.addressMode,ut=C.addressModeV??C.addressMode,nt=K._getPatternRepeat(R,ut),O=m.source._resolution??m.source.resolution??1,J=(f=(p=g.renderable)==null?void 0:p.renderGroup)==null?void 0:f.isCachedAsTexture,d=w.x*O,u=w.y*O,x=w.width*O,V=w.height*O,G=g.bounds,M=n.renderTarget.renderTarget.isRoot,U=G.minX,H=G.minY,I=G.maxX-G.minX,D=G.maxY-G.minY,N=m.rotate,c=m.uvs,Y=Math.min(c.x0,c.x1,c.x2,c.x3,c.y0,c.y1,c.y2,c.y3),j=Math.max(c.x0,c.x1,c.x2,c.x3,c.y0,c.y1,c.y2,c.y3),b=nt!=="no-repeat"&&(Y<0||j>1),it=N&&!(!b&&(P!==16777215||N));it?(K._tempPatternMatrix.copyFrom(g.transform),At.matrixAppendRotationInv(K._tempPatternMatrix,N,U,H,I,D),r.setContextTransform(K._tempPatternMatrix,g.roundPixels===1,void 0,J&&M)):r.setContextTransform(g.transform,g.roundPixels===1,void 0,J&&M);const pt=I,ft=D;let rt=it?0:U,at=it?0:H;if(!it&&g.roundPixels===1&&(rt|=0,at|=0),b){let mt=k;const Z=P!==16777215&&!N,tt=w.width<=m.source.width&&w.height<=m.source.height;Z&&tt&&(mt=T.getTintedCanvas({texture:m},P));const xt=o.createPattern(mt,nt);if(!xt)continue;const Pt=pt,Mt=ft;if(Pt===0||Mt===0)continue;const kt=1/Pt,wt=1/Mt,Rt=(c.x1-c.x0)*kt,Gt=(c.y1-c.y0)*kt,Bt=(c.x3-c.x0)*wt,It=(c.y3-c.y0)*wt,ee=c.x0-Rt*rt-Bt*at,se=c.y0-Gt*rt-It*at,gt=m.source.pixelWidth,Ct=m.source.pixelHeight;K._tempPatternMatrix.set(Rt*gt,Gt*Ct,Bt*gt,It*Ct,ee*gt,se*Ct),T.applyPatternTransform(xt,K._tempPatternMatrix),o.fillStyle=xt,o.fillRect(rt,at,pt,ft)}else{const Z=P!==16777215||N?T.getTintedCanvas({texture:m},P):k,tt=Z!==k;o.drawImage(Z,tt?0:d,tt?0:u,tt?Z.width:x,tt?Z.height:V,rt,at,pt,ft)}}}};Tt._tempPatternMatrix=new L;Tt.extension={type:[_.CanvasPipesAdaptor],name:"batch"};let we=Tt;class Nt{constructor(t){this._colorStack=[],this._colorStackIndex=0,this._currentColor=0,this._renderer=t}buildStart(){this._colorStack[0]=15,this._colorStackIndex=1,this._currentColor=15}push(t,e,s){this._renderer.renderPipes.batch.break(s);const n=this._colorStack;n[this._colorStackIndex]=n[this._colorStackIndex-1]&t.mask;const r=this._colorStack[this._colorStackIndex];r!==this._currentColor&&(this._currentColor=r,s.add({renderPipeId:"colorMask",colorMask:r,canBundle:!1})),this._colorStackIndex++}pop(t,e,s){this._renderer.renderPipes.batch.break(s);const n=this._colorStack;this._colorStackIndex--;const r=n[this._colorStackIndex-1];r!==this._currentColor&&(this._currentColor=r,s.add({renderPipeId:"colorMask",colorMask:r,canBundle:!1}))}execute(t){}destroy(){this._renderer=null,this._colorStack=null}}Nt.extension={type:[_.CanvasPipes],name:"colorMask"};function Re(a,t,e,s,n,r){r=Math.max(0,Math.min(r,Math.min(s,n)/2)),a.moveTo(t+r,e),a.lineTo(t+s-r,e),a.quadraticCurveTo(t+s,e,t+s,e+r),a.lineTo(t+s,e+n-r),a.quadraticCurveTo(t+s,e+n,t+s-r,e+n),a.lineTo(t+r,e+n),a.quadraticCurveTo(t,e+n,t,e+n-r),a.lineTo(t,e+r),a.quadraticCurveTo(t,e,t+r,e)}function Yt(a,t){switch(t.type){case"rectangle":{const e=t;a.rect(e.x,e.y,e.width,e.height);break}case"roundedRectangle":{const e=t;Re(a,e.x,e.y,e.width,e.height,e.radius);break}case"circle":{const e=t;a.moveTo(e.x+e.radius,e.y),a.arc(e.x,e.y,e.radius,0,Math.PI*2);break}case"ellipse":{const e=t;a.ellipse?(a.moveTo(e.x+e.halfWidth,e.y),a.ellipse(e.x,e.y,e.halfWidth,e.halfHeight,0,0,Math.PI*2)):(a.save(),a.translate(e.x,e.y),a.scale(e.halfWidth,e.halfHeight),a.moveTo(1,0),a.arc(0,0,1,0,Math.PI*2),a.restore());break}case"triangle":{const e=t;a.moveTo(e.x,e.y),a.lineTo(e.x2,e.y2),a.lineTo(e.x3,e.y3),a.closePath();break}case"polygon":default:{const e=t,s=e.points;if(!(s!=null&&s.length))break;a.moveTo(s[0],s[1]);for(let n=2;n<s.length;n+=2)a.lineTo(s[n],s[n+1]);e.closePath&&a.closePath();break}}}function Ge(a,t,e){const s=[],n=[],r=[],o=Ut[t.type];if(!(o!=null&&o.build(t,s)))return!1;const l=t.closePath??!0;Ht(s,e,!1,l,n,r);for(let i=0;i<r.length;i+=3){const p=r[i]*2,f=r[i+1]*2,y=r[i+2]*2;a.moveTo(n[p],n[p+1]),a.lineTo(n[f],n[f+1]),a.lineTo(n[y],n[y+1]),a.closePath()}return!0}function Be(a,t){if(!(t!=null&&t.length))return!1;for(let e=0;e<t.length;e++){const s=t[e];if(!(s!=null&&s.shape))continue;const n=s.transform,r=n&&!n.isIdentity();r&&(a.save(),a.transform(n.a,n.b,n.c,n.d,n.tx,n.ty)),Yt(a,s.shape),r&&a.restore()}return!0}class jt{constructor(t){this._warnedMaskTypes=new Set,this._canvasMaskStack=[],this._renderer=t}push(t,e,s){this._renderer.renderPipes.batch.break(s),s.add({renderPipeId:"stencilMask",action:"pushMaskBegin",mask:t,inverse:e._maskOptions.inverse,canBundle:!1})}pop(t,e,s){this._renderer.renderPipes.batch.break(s),s.add({renderPipeId:"stencilMask",action:"popMaskEnd",mask:t,inverse:e._maskOptions.inverse,canBundle:!1})}execute(t){var f,y,A;if(t.action!=="pushMaskBegin"&&t.action!=="popMaskEnd")return;const e=this._renderer,s=e.canvasContext,n=s==null?void 0:s.activeContext;if(!n)return;if(t.action==="popMaskEnd"){this._canvasMaskStack.pop()&&n.restore();return}t.inverse&&this._warnOnce("inverse","CanvasRenderer: inverse masks are not supported on Canvas2D; ignoring inverse flag.");const r=t.mask.mask;if(!(r instanceof dt)){this._warnOnce("nonGraphics","CanvasRenderer: only Graphics masks are supported in Canvas2D; skipping mask."),this._canvasMaskStack.push(!1);return}const o=r,l=(f=o.context)==null?void 0:f.instructions;if(!(l!=null&&l.length)){this._canvasMaskStack.push(!1);return}n.save(),s.setContextTransform(o.groupTransform,(e._roundPixels|o._roundPixels)===1),n.beginPath();let i=!1,p=!1;for(let g=0;g<l.length;g++){const m=l[g],k=m.action;if(k!=="fill"&&k!=="stroke")continue;const C=m.data,B=(y=C==null?void 0:C.path)==null?void 0:y.shapePath;if(!((A=B==null?void 0:B.shapePrimitives)!=null&&A.length))continue;const $=k==="stroke",q=B.shapePrimitives;for(let F=0;F<q.length;F++){const S=q[F];if(!(S!=null&&S.shape))continue;const v=S.transform,X=v&&!v.isIdentity();X&&(n.save(),n.transform(v.a,v.b,v.c,v.d,v.tx,v.ty)),$&&C.style?i=Ge(n,S.shape,C.style)||i:(Yt(n,S.shape),p=Be(n,S.holes)||p,i=!0),X&&n.restore()}}if(!i){n.restore(),this._canvasMaskStack.push(!1);return}p?n.clip("evenodd"):n.clip(),this._canvasMaskStack.push(!0)}destroy(){this._renderer=null,this._warnedMaskTypes=null,this._canvasMaskStack=null}_warnOnce(t,e){this._warnedMaskTypes.has(t)||(this._warnedMaskTypes.add(t),ie(e))}}jt.extension={type:[_.CanvasPipes],name:"stencilMask"};const h="source-over";function Ie(){const a=le(),t=Object.create(null);return t.inherit=h,t.none=h,t.normal="source-over",t.add="lighter",t.multiply=a?"multiply":h,t.screen=a?"screen":h,t.overlay=a?"overlay":h,t.darken=a?"darken":h,t.lighten=a?"lighten":h,t["color-dodge"]=a?"color-dodge":h,t["color-burn"]=a?"color-burn":h,t["hard-light"]=a?"hard-light":h,t["soft-light"]=a?"soft-light":h,t.difference=a?"difference":h,t.exclusion=a?"exclusion":h,t.saturation=a?"saturation":h,t.color=a?"color":h,t.luminosity=a?"luminosity":h,t["linear-burn"]=a?"color-burn":h,t["linear-dodge"]=a?"color-dodge":h,t["linear-light"]=a?"hard-light":h,t["pin-light"]=a?"hard-light":h,t["vivid-light"]=a?"hard-light":h,t["hard-mix"]=h,t.negation=a?"difference":h,t["normal-npm"]=t.normal,t["add-npm"]=t.add,t["screen-npm"]=t.screen,t.erase="destination-out",t.subtract=h,t.divide=h,t.min=h,t.max=h,t}const De=new L;class zt{constructor(t){this.activeResolution=1,this.smoothProperty="imageSmoothingEnabled",this.blendModes=Ie(),this._activeBlendMode="normal",this._projTransform=null,this._outerBlend=!1,this._warnedBlendModes=new Set,this._renderer=t}resolutionChange(t){this.activeResolution=t}init(){const t=this._renderer.background.alpha<1;if(this.rootContext=this._renderer.canvas.getContext("2d",{alpha:t}),this.activeContext=this.rootContext,this.activeResolution=this._renderer.resolution,!this.rootContext.imageSmoothingEnabled){const e=this.rootContext;e.webkitImageSmoothingEnabled?this.smoothProperty="webkitImageSmoothingEnabled":e.mozImageSmoothingEnabled?this.smoothProperty="mozImageSmoothingEnabled":e.oImageSmoothingEnabled?this.smoothProperty="oImageSmoothingEnabled":e.msImageSmoothingEnabled&&(this.smoothProperty="msImageSmoothingEnabled")}}setContextTransform(t,e,s,n){var p;const r=n?L.IDENTITY:((p=this._renderer.globalUniforms.globalUniformData)==null?void 0:p.worldTransformMatrix)||L.IDENTITY;let o=De;o.copyFrom(r),o.append(t);const l=this._projTransform,i=this.activeResolution;if(s=s||i,l){const f=L.shared;f.copyFrom(o),f.prepend(l),o=f}e?this.activeContext.setTransform(o.a*s,o.b*s,o.c*s,o.d*s,o.tx*i|0,o.ty*i|0):this.activeContext.setTransform(o.a*s,o.b*s,o.c*s,o.d*s,o.tx*i,o.ty*i)}clear(t,e){const s=this.activeContext,n=this._renderer;if(s.clearRect(0,0,n.width,n.height),t){const r=Et.shared.setValue(t);s.globalAlpha=e??r.alpha,s.fillStyle=r.toHex(),s.fillRect(0,0,n.width,n.height),s.globalAlpha=1}}setBlendMode(t){if(this._activeBlendMode===t)return;this._activeBlendMode=t,this._outerBlend=!1;const e=this.blendModes[t];if(!e){this._warnedBlendModes.has(t)||(console.warn(`CanvasRenderer: blend mode "${t}" is not supported in Canvas2D; falling back to "source-over".`),this._warnedBlendModes.add(t)),this.activeContext.globalCompositeOperation="source-over";return}this.activeContext.globalCompositeOperation=e}destroy(){this.rootContext=null,this.activeContext=null,this._warnedBlendModes.clear()}}zt.extension={type:[_.CanvasSystem],name:"canvasContext"};class $t{constructor(){this.maxTextures=16,this.maxBatchableTextures=16,this.maxUniformBindings=0}init(){}}$t.extension={type:[_.CanvasSystem],name:"limits"};const Ae="#808080",lt=new L,Fe=new L,Ue=new L,_t=new L;function He(a,t,e){a.beginPath();for(let s=0;s<e.length;s+=3){const n=e[s]*2,r=e[s+1]*2,o=e[s+2]*2;a.moveTo(t[n],t[n+1]),a.lineTo(t[r],t[r+1]),a.lineTo(t[o],t[o+1]),a.closePath()}a.fill()}function Ee(a){return`#${(a&16777215).toString(16).padStart(6,"0")}`}function We(a,t,e,s,n,r){r=Math.max(0,Math.min(r,Math.min(s,n)/2)),a.moveTo(t+r,e),a.lineTo(t+s-r,e),a.quadraticCurveTo(t+s,e,t+s,e+r),a.lineTo(t+s,e+n-r),a.quadraticCurveTo(t+s,e+n,t+s-r,e+n),a.lineTo(t+r,e+n),a.quadraticCurveTo(t,e+n,t,e+n-r),a.lineTo(t,e+r),a.quadraticCurveTo(t,e,t+r,e)}function ht(a,t){switch(t.type){case"rectangle":{const e=t;a.rect(e.x,e.y,e.width,e.height);break}case"roundedRectangle":{const e=t;We(a,e.x,e.y,e.width,e.height,e.radius);break}case"circle":{const e=t;a.arc(e.x,e.y,e.radius,0,Math.PI*2);break}case"ellipse":{const e=t;a.ellipse?a.ellipse(e.x,e.y,e.halfWidth,e.halfHeight,0,0,Math.PI*2):(a.save(),a.translate(e.x,e.y),a.scale(e.halfWidth,e.halfHeight),a.arc(0,0,1,0,Math.PI*2),a.restore());break}case"triangle":{const e=t;a.moveTo(e.x,e.y),a.lineTo(e.x2,e.y2),a.lineTo(e.x3,e.y3),a.closePath();break}case"polygon":default:{const e=t,s=e.points;if(!(s!=null&&s.length))break;a.moveTo(s[0],s[1]);for(let n=2;n<s.length;n+=2)a.lineTo(s[n],s[n+1]);e.closePath&&a.closePath();break}}}function Le(a,t){if(!(t!=null&&t.length))return!1;for(let e=0;e<t.length;e++){const s=t[e];if(!(s!=null&&s.shape))continue;const n=s.transform,r=n&&!n.isIdentity();r&&(a.save(),a.transform(n.a,n.b,n.c,n.d,n.tx,n.ty)),ht(a,s.shape),r&&a.restore()}return!0}function qe(a,t,e,s){const n=a.fill;if(n instanceof he){n.buildGradient();const o=n.texture;if(o){const l=T.getTintedPattern(o,t),i=e?_t.copyFrom(e).scale(o.source.pixelWidth,o.source.pixelHeight):_t.copyFrom(n.transform);return s&&!a.textureSpace&&i.append(s),T.applyPatternTransform(l,i),l}}if(n instanceof de){const o=T.getTintedPattern(n.texture,t);return T.applyPatternTransform(o,n.transform,!1),o}const r=a.texture;if(r&&r!==Wt.WHITE){if(!r.source.resource)return Ae;const o=T.getTintedPattern(r,t),l=e?_t.copyFrom(e).scale(r.source.pixelWidth,r.source.pixelHeight):a.matrix;return T.applyPatternTransform(o,l),o}return Ee(t)}class Xt{constructor(){this.shader=null}contextChange(t){}execute(t,e){var $,q,F,S,v,X,et;const s=t.renderer,n=s.canvasContext,r=n.activeContext,o=e.groupTransform,l=(($=s.globalUniforms.globalUniformData)==null?void 0:$.worldColor)??4294967295,i=e.groupColorAlpha,p=(l>>>24&255)/255,f=(i>>>24&255)/255,y=((q=s.filter)==null?void 0:q.alphaMultiplier)??1,A=p*f*y;if(A<=0)return;const g=l&16777215,m=i&16777215,k=Ft(ct(m,g)),C=s._roundPixels|e._roundPixels;r.save(),n.setContextTransform(o,C===1),n.setBlendMode(e.groupBlendMode);const B=e.context.instructions;for(let st=0;st<B.length;st++){const Q=B[st];if(Q.action==="texture"){const d=Q.data,u=d.image,x=u?T.getCanvasSource(u):null;if(!x)continue;const V=d.alpha*A;if(V<=0)continue;const G=ct(d.style,k);r.globalAlpha=V;let M=x;G!==16777215&&(M=T.getTintedCanvas({texture:u},G));const U=u.frame,H=u.source._resolution??u.source.resolution??1;let I=U.x*H,D=U.y*H;const N=U.width*H,c=U.height*H;M!==x&&(I=0,D=0);const Y=d.transform,j=Y&&!Y.isIdentity(),b=u.rotate;j||b?(lt.copyFrom(o),j&<.append(Y),b&&At.matrixAppendRotationInv(lt,b,d.dx,d.dy,d.dw,d.dh),n.setContextTransform(lt,C===1)):n.setContextTransform(o,C===1),r.drawImage(M,I,D,M===x?N:M.width,M===x?c:M.height,b?0:d.dx,b?0:d.dy,d.dw,d.dh),(j||b)&&n.setContextTransform(o,C===1);continue}const P=Q.data,w=(F=P==null?void 0:P.path)==null?void 0:F.shapePath;if(!((S=w==null?void 0:w.shapePrimitives)!=null&&S.length))continue;const R=P.style,ut=ct(R.color,k),nt=R.alpha*A;if(nt<=0)continue;const O=Q.action==="stroke";if(r.globalAlpha=nt,O){const d=R;r.lineWidth=d.width,r.lineCap=d.cap,r.lineJoin=d.join,r.miterLimit=d.miterLimit}const J=w.shapePrimitives;if(!O&&((et=(X=(v=P.hole)==null?void 0:v.shapePath)==null?void 0:X.shapePrimitives)!=null&&et.length)){const d=J[J.length-1];d.holes=P.hole.shapePath.shapePrimitives}for(let d=0;d<J.length;d++){const u=J[d];if(!(u!=null&&u.shape))continue;const x=u.transform,V=x&&!x.isIdentity(),G=R.texture&&R.texture!==Wt.WHITE,M=R.textureSpace==="global"?x:null,U=G?ce(Fe,R,u.shape,M):null,H=V?Ue.copyFrom(o).append(x):o,I=qe(R,ut,U,H);if(V&&(r.save(),r.transform(x.a,x.b,x.c,x.d,x.tx,x.ty)),O){const D=R;if(D.alignment!==.5&&!D.pixelLine){const c=[],Y=[],j=[],b=Ut[u.shape.type];if(b!=null&&b.build(u.shape,c)){const St=u.shape.closePath??!0;Ht(c,D,!1,St,Y,j),r.fillStyle=I,He(r,Y,j)}else r.strokeStyle=I,r.beginPath(),ht(r,u.shape),r.stroke()}else r.strokeStyle=I,r.beginPath(),ht(r,u.shape),r.stroke()}else r.fillStyle=I,r.beginPath(),ht(r,u.shape),Le(r,u.holes)?r.fill("evenodd"):r.fill();V&&r.restore()}}r.restore()}destroy(){this.shader=null}}Xt.extension={type:[_.CanvasPipesAdaptor],name:"graphics"};class Oe{init(t,e){this._renderer=t,this._renderTargetSystem=e}initGpuRenderTarget(t){const e=t.colorTexture,{canvas:s,context:n}=this._ensureCanvas(e);return{canvas:s,context:n,width:s.width,height:s.height}}resizeGpuRenderTarget(t){const e=t.colorTexture,{canvas:s}=this._ensureCanvas(e);s.width=t.pixelWidth,s.height=t.pixelHeight}startRenderPass(t,e,s,n){const r=this._renderTargetSystem.getGpuRenderTarget(t);this._renderer.canvasContext.activeContext=r.context,this._renderer.canvasContext.activeResolution=t.resolution,e&&this.clear(t,e,s,n)}clear(t,e,s,n){const o=this._renderTargetSystem.getGpuRenderTarget(t).context,l=n||{x:0,y:0,width:t.pixelWidth,height:t.pixelHeight};if(o.setTransform(1,0,0,1,0,0),o.clearRect(l.x,l.y,l.width,l.height),s){const i=Et.shared.setValue(s);i.alpha>0&&(o.globalAlpha=i.alpha,o.fillStyle=i.toHex(),o.fillRect(l.x,l.y,l.width,l.height),o.globalAlpha=1)}}finishRenderPass(){}copyToTexture(t,e,s,n,r){const l=this._renderTargetSystem.getGpuRenderTarget(t).canvas,i=e.source,{context:p}=this._ensureCanvas(i),f=(r==null?void 0:r.x)??0,y=(r==null?void 0:r.y)??0;return p.drawImage(l,s.x,s.y,n.width,n.height,f,y,n.width,n.height),i.update(),e}destroyGpuRenderTarget(t){}_ensureCanvas(t){let e=t.resource;(!e||!ue.test(e))&&(e=Lt.get().createCanvas(t.pixelWidth,t.pixelHeight),t.resource=e),(e.width!==t.pixelWidth||e.height!==t.pixelHeight)&&(e.width=t.pixelWidth,e.height=t.pixelHeight);const s=e.getContext("2d");return{canvas:e,context:s}}}class Jt extends xe{constructor(t){super(t),this.adaptor=new Oe,this.adaptor.init(t,this)}}Jt.extension={type:[_.CanvasSystem],name:"renderTarget"};class Kt{constructor(t){}init(){}initSource(t){}generateCanvas(t){const e=Lt.get().createCanvas(),s=e.getContext("2d"),n=T.getCanvasSource(t);if(!n)return e;const r=t.frame,o=t.source._resolution??t.source.resolution??1,l=r.x*o,i=r.y*o,p=r.width*o,f=r.height*o;return e.width=Math.ceil(p),e.height=Math.ceil(f),s.drawImage(n,l,i,p,f,0,0,p,f),e}getPixels(t){const e=this.generateCanvas(t);return{pixels:e.getContext("2d",{willReadFrequently:!0}).getImageData(0,0,e.width,e.height).data,width:e.width,height:e.height}}destroy(){}}Kt.extension={type:[_.CanvasSystem],name:"texture"};const Ve=[...ge,zt,$t,Kt,Jt],Ne=[Ce,_e,ye,ve,be,jt,Nt,Te],Ye=[we,Xt],Qt=[],Zt=[],te=[];z.handleByNamedList(_.CanvasSystem,Qt);z.handleByNamedList(_.CanvasPipes,Zt);z.handleByNamedList(_.CanvasPipesAdaptor,te);z.add(...Ve,...Ne,...Ye);class Xe extends pe{constructor(){const t={name:"canvas",type:fe.CANVAS,systems:Qt,renderPipes:Zt,renderPipeAdaptors:te};super(t)}}export{Xe as CanvasRenderer}; diff --git a/2026/games_submissions/sunshoes/assets/Filter-BiIvpnZm.js b/2026/games_submissions/sunshoes/assets/Filter-BiIvpnZm.js new file mode 100644 index 0000000..127e4e5 --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/Filter-BiIvpnZm.js @@ -0,0 +1 @@ +import{S as b,G as M,a as m}from"./index-DvAPfvr6.js";const F={normal:0,add:1,multiply:2,screen:3,overlay:4,erase:5,"normal-npm":6,"add-npm":7,"screen-npm":8,min:9,max:10},i=0,n=1,d=2,r=3,l=4,o=5,h=class g{constructor(){this.data=0,this.blendMode="normal",this.polygonOffset=0,this.blend=!0,this.depthMask=!0}get blend(){return!!(this.data&1<<i)}set blend(t){!!(this.data&1<<i)!==t&&(this.data^=1<<i)}get offsets(){return!!(this.data&1<<n)}set offsets(t){!!(this.data&1<<n)!==t&&(this.data^=1<<n)}set cullMode(t){if(t==="none"){this.culling=!1;return}this.culling=!0,this.clockwiseFrontFace=t==="front"}get cullMode(){return this.culling?this.clockwiseFrontFace?"front":"back":"none"}get culling(){return!!(this.data&1<<d)}set culling(t){!!(this.data&1<<d)!==t&&(this.data^=1<<d)}get depthTest(){return!!(this.data&1<<r)}set depthTest(t){!!(this.data&1<<r)!==t&&(this.data^=1<<r)}get depthMask(){return!!(this.data&1<<o)}set depthMask(t){!!(this.data&1<<o)!==t&&(this.data^=1<<o)}get clockwiseFrontFace(){return!!(this.data&1<<l)}set clockwiseFrontFace(t){!!(this.data&1<<l)!==t&&(this.data^=1<<l)}get blendMode(){return this._blendMode}set blendMode(t){this.blend=t!=="none",this._blendMode=t,this._blendModeId=F[t]||0}get polygonOffset(){return this._polygonOffset}set polygonOffset(t){this.offsets=!!t,this._polygonOffset=t}toString(){return`[pixi.js/core:State blendMode=${this.blendMode} clockwiseFrontFace=${this.clockwiseFrontFace} culling=${this.culling} depthMask=${this.depthMask} polygonOffset=${this.polygonOffset}]`}static for2d(){const t=new g;return t.depthTest=!1,t.blend=!0,t}};h.default2d=h.for2d();let k=h;const p=class c extends b{constructor(t){t={...c.defaultOptions,...t},super(t),this.enabled=!0,this._state=k.for2d(),this.blendMode=t.blendMode,this.padding=t.padding,typeof t.antialias=="boolean"?this.antialias=t.antialias?"on":"off":this.antialias=t.antialias,this.resolution=t.resolution,this.blendRequired=t.blendRequired,this.clipToViewport=t.clipToViewport,this.addResource("uTexture",0,1),t.blendRequired&&this.addResource("uBackTexture",0,3)}apply(t,e,s,a){t.applyFilter(this,e,s,a)}get blendMode(){return this._state.blendMode}set blendMode(t){this._state.blendMode=t}static from(t){const{gpu:e,gl:s,...a}=t;let f,u;return e&&(f=M.from(e)),s&&(u=m.from(s)),new c({gpuProgram:f,glProgram:u,...a})}};p.defaultOptions={blendMode:"normal",resolution:1,padding:0,antialias:"off",blendRequired:!1,clipToViewport:!0};let y=p;export{y as F,k as S}; diff --git a/2026/games_submissions/sunshoes/assets/RenderTargetSystem-Cp6tD-lP.js b/2026/games_submissions/sunshoes/assets/RenderTargetSystem-Cp6tD-lP.js new file mode 100644 index 0000000..ddb4458 --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/RenderTargetSystem-Cp6tD-lP.js @@ -0,0 +1,184 @@ +import{ag as Ve,ab as oe,N as m,G as Ne,a as je,ah as le,z as l,F as W,A as w,ai as $e,aj as z,ak as T,$ as V,al as de,am as qe,T as f,r as g,a9 as D,an as ue,w as ce,ao as ee,ap as he,aq as pe,ar as fe,as as me,a4 as P,b as Ke,e as E,Z as N,aa as v,R as B,at as Ye,a2 as Je,a7 as Xe,a0 as te,au as re,d as p,t as Ze,Y as O,av as Qe,v as et,aw as tt,ax as rt}from"./index-DvAPfvr6.js";import{F as st,S as nt}from"./Filter-BiIvpnZm.js";var at=`in vec2 vMaskCoord; +in vec2 vTextureCoord; + +uniform sampler2D uTexture; +uniform sampler2D uMaskTexture; + +uniform float uAlpha; +uniform vec4 uMaskClamp; +uniform float uInverse; +uniform float uChannel; + +out vec4 finalColor; + +void main(void) +{ + float clip = step(3.5, + step(uMaskClamp.x, vMaskCoord.x) + + step(uMaskClamp.y, vMaskCoord.y) + + step(vMaskCoord.x, uMaskClamp.z) + + step(vMaskCoord.y, uMaskClamp.w)); + + // TODO look into why this is needed + float npmAlpha = uAlpha; + vec4 original = texture(uTexture, vTextureCoord); + vec4 masky = texture(uMaskTexture, vMaskCoord); + + float a; + if (uChannel == 1.0) { + a = masky.a * npmAlpha * clip; + } else { + float alphaMul = 1.0 - npmAlpha * (1.0 - masky.a); + a = alphaMul * masky.r * npmAlpha * clip; + } + + if (uInverse == 1.0) { + a = 1.0 - a; + } + + finalColor = original * a; +} +`,it=`in vec2 aPosition; + +out vec2 vTextureCoord; +out vec2 vMaskCoord; + + +uniform vec4 uInputSize; +uniform vec4 uOutputFrame; +uniform vec4 uOutputTexture; +uniform mat3 uFilterMatrix; + +vec4 filterVertexPosition( vec2 aPosition ) +{ + vec2 position = aPosition * uOutputFrame.zw + uOutputFrame.xy; + + position.x = position.x * (2.0 / uOutputTexture.x) - 1.0; + position.y = position.y * (2.0*uOutputTexture.z / uOutputTexture.y) - uOutputTexture.z; + + return vec4(position, 0.0, 1.0); +} + +vec2 filterTextureCoord( vec2 aPosition ) +{ + return aPosition * (uOutputFrame.zw * uInputSize.zw); +} + +vec2 getFilterCoord( vec2 aPosition ) +{ + return ( uFilterMatrix * vec3( filterTextureCoord(aPosition), 1.0) ).xy; +} + +void main(void) +{ + gl_Position = filterVertexPosition(aPosition); + vTextureCoord = filterTextureCoord(aPosition); + vMaskCoord = getFilterCoord(aPosition); +} +`,se=`struct GlobalFilterUniforms { + uInputSize:vec4<f32>, + uInputPixel:vec4<f32>, + uInputClamp:vec4<f32>, + uOutputFrame:vec4<f32>, + uGlobalFrame:vec4<f32>, + uOutputTexture:vec4<f32>, +}; + +struct MaskUniforms { + uFilterMatrix:mat3x3<f32>, + uMaskClamp:vec4<f32>, + uAlpha:f32, + uInverse:f32, + uChannel:f32, +}; + +@group(0) @binding(0) var<uniform> gfu: GlobalFilterUniforms; +@group(0) @binding(1) var uTexture: texture_2d<f32>; +@group(0) @binding(2) var uSampler : sampler; + +@group(1) @binding(0) var<uniform> filterUniforms : MaskUniforms; +@group(1) @binding(1) var uMaskTexture: texture_2d<f32>; + +struct VSOutput { + @builtin(position) position: vec4<f32>, + @location(0) uv : vec2<f32>, + @location(1) filterUv : vec2<f32>, +}; + +fn filterVertexPosition(aPosition:vec2<f32>) -> vec4<f32> +{ + var position = aPosition * gfu.uOutputFrame.zw + gfu.uOutputFrame.xy; + + position.x = position.x * (2.0 / gfu.uOutputTexture.x) - 1.0; + position.y = position.y * (2.0*gfu.uOutputTexture.z / gfu.uOutputTexture.y) - gfu.uOutputTexture.z; + + return vec4(position, 0.0, 1.0); +} + +fn filterTextureCoord( aPosition:vec2<f32> ) -> vec2<f32> +{ + return aPosition * (gfu.uOutputFrame.zw * gfu.uInputSize.zw); +} + +fn globalTextureCoord( aPosition:vec2<f32> ) -> vec2<f32> +{ + return (aPosition.xy / gfu.uGlobalFrame.zw) + (gfu.uGlobalFrame.xy / gfu.uGlobalFrame.zw); +} + +fn getFilterCoord(aPosition:vec2<f32> ) -> vec2<f32> +{ + return ( filterUniforms.uFilterMatrix * vec3( filterTextureCoord(aPosition), 1.0) ).xy; +} + +fn getSize() -> vec2<f32> +{ + return gfu.uGlobalFrame.zw; +} + +@vertex +fn mainVertex( + @location(0) aPosition : vec2<f32>, +) -> VSOutput { + return VSOutput( + filterVertexPosition(aPosition), + filterTextureCoord(aPosition), + getFilterCoord(aPosition) + ); +} + +@fragment +fn mainFragment( + @location(0) uv: vec2<f32>, + @location(1) filterUv: vec2<f32>, + @builtin(position) position: vec4<f32> +) -> @location(0) vec4<f32> { + + var maskClamp = filterUniforms.uMaskClamp; + var uAlpha = filterUniforms.uAlpha; + + var clip = step(3.5, + step(maskClamp.x, filterUv.x) + + step(maskClamp.y, filterUv.y) + + step(filterUv.x, maskClamp.z) + + step(filterUv.y, maskClamp.w)); + + var mask = textureSample(uMaskTexture, uSampler, filterUv); + var source = textureSample(uTexture, uSampler, uv); + + var a: f32; + if (filterUniforms.uChannel == 1.0) { + a = mask.a * uAlpha * clip; + } else { + var alphaMul = 1.0 - uAlpha * (1.0 - mask.a); + a = alphaMul * mask.r * uAlpha * clip; + } + + if (filterUniforms.uInverse == 1.0) { + a = 1.0 - a; + } + + return source * a; +} +`;class ot extends st{constructor(e){const{sprite:t,...r}=e,s=new Ve(t.texture),n=new oe({uFilterMatrix:{value:new m,type:"mat3x3<f32>"},uMaskClamp:{value:s.uClampFrame,type:"vec4<f32>"},uAlpha:{value:1,type:"f32"},uInverse:{value:e.inverse?1:0,type:"f32"},uChannel:{value:e.channel==="alpha"?1:0,type:"f32"}}),i=Ne.from({vertex:{source:se,entryPoint:"mainVertex"},fragment:{source:se,entryPoint:"mainFragment"}}),o=je.from({vertex:it,fragment:at,name:"mask-filter"});super({...r,gpuProgram:i,glProgram:o,clipToViewport:!1,resources:{filterUniforms:n,uMaskTexture:t.texture.source}}),this.sprite=t,this._textureMatrix=s}set inverse(e){this.resources.filterUniforms.uniforms.uInverse=e?1:0}get inverse(){return this.resources.filterUniforms.uniforms.uInverse===1}set channel(e){this.resources.filterUniforms.uniforms.uChannel=e==="alpha"?1:0}get channel(){return this.resources.filterUniforms.uniforms.uChannel===1?"alpha":"red"}apply(e,t,r,s){this._textureMatrix.texture=this.sprite.texture,e.calculateSpriteMatrix(this.resources.filterUniforms.uniforms.uFilterMatrix,this.sprite).prepend(this._textureMatrix.mapCoord),this.resources.uMaskTexture=this.sprite.texture.source,e.applyFilter(this,t,r,s)}}function lt(a,e,t){const r=(a>>24&255)/255;e[t++]=(a&255)/255*r,e[t++]=(a>>8&255)/255*r,e[t++]=(a>>16&255)/255*r,e[t++]=r}const j=class ge{constructor(e,t){var r,s;this.state=nt.for2d(),this._batchersByInstructionSet=Object.create(null),this._activeBatches=Object.create(null),this.renderer=e,this._adaptor=t,(s=(r=this._adaptor).init)==null||s.call(r,this)}static getBatcher(e,t){return new this._availableBatchers[e]({maxTextures:t})}buildStart(e){let t=this._batchersByInstructionSet[e.uid];t||(t=this._batchersByInstructionSet[e.uid]=Object.create(null),t.default||(t.default=new le({maxTextures:this.renderer.limits.maxBatchableTextures}))),this._activeBatches=t,this._activeBatch=this._activeBatches.default;for(const r in this._activeBatches)this._activeBatches[r].begin()}addToBatch(e,t){if(this._activeBatch.name!==e.batcherName){this._activeBatch.break(t);let r=this._activeBatches[e.batcherName];r||(r=this._activeBatches[e.batcherName]=ge.getBatcher(e.batcherName,this.renderer.limits.maxBatchableTextures),r.begin()),this._activeBatch=r}this._activeBatch.add(e)}break(e){this._activeBatch.break(e)}buildEnd(e){this._activeBatch.break(e);const t=this._activeBatches;for(const r in t){const s=t[r],n=s.geometry;n.indexBuffer.setDataWithSize(s.indexBuffer,s.indexSize,!0),n.buffers[0].setDataWithSize(s.attributeBuffer.float32View,s.attributeSize,!1)}}upload(e){const t=this._batchersByInstructionSet[e.uid];for(const r in t){const s=t[r],n=s.geometry;s.dirty&&(s.dirty=!1,n.buffers[0].update(s.attributeSize*4))}}execute(e){if(e.action==="startBatch"){const t=e.batcher,r=t.geometry,s=t.shader;this._adaptor.start(this,r,s)}this._adaptor.execute(this,e)}destroy(){this.state=null,this.renderer=null,this._adaptor=null;for(const e in this._activeBatches)this._activeBatches[e].destroy();this._activeBatches=null}};j.extension={type:[l.WebGLPipes,l.WebGPUPipes,l.CanvasPipes],name:"batch"};j._availableBatchers=Object.create(null);let _e=j;W.handleByMap(l.Batcher,_e._availableBatchers);W.add(le);const dt=new z;class ut extends de{constructor(){super(),this.filters=[new ot({sprite:new qe(f.EMPTY),inverse:!1,resolution:"inherit",antialias:"inherit"})]}get sprite(){return this.filters[0].sprite}set sprite(e){this.filters[0].sprite=e}get inverse(){return this.filters[0].inverse}set inverse(e){this.filters[0].inverse=e}get channel(){return this.filters[0].channel}set channel(e){this.filters[0].channel=e}}class xe{constructor(e){this._activeMaskStage=[],this._renderer=e}push(e,t,r){const s=this._renderer;if(s.renderPipes.batch.break(r),r.add({renderPipeId:"alphaMask",action:"pushMaskBegin",mask:e,inverse:t._maskOptions.inverse,canBundle:!1,maskedContainer:t}),e.inverse=t._maskOptions.inverse,e.channel=t._maskOptions.channel??"red",e.renderMaskToTexture){const n=e.mask;n.includeInBuild=!0,n.collectRenderables(r,s,null),n.includeInBuild=!1}s.renderPipes.batch.break(r),r.add({renderPipeId:"alphaMask",action:"pushMaskEnd",mask:e,maskedContainer:t,inverse:t._maskOptions.inverse,canBundle:!1})}pop(e,t,r){this._renderer.renderPipes.batch.break(r),r.add({renderPipeId:"alphaMask",action:"popMaskEnd",mask:e,inverse:t._maskOptions.inverse,canBundle:!1})}execute(e){const t=this._renderer,r=e.mask.renderMaskToTexture;if(e.action==="pushMaskBegin"){const s=w.get(ut);if(s.inverse=e.inverse,s.channel=e.mask.channel,r){e.mask.mask.measurable=!0;const n=$e(e.mask.mask,!0,dt);e.mask.mask.measurable=!1,n.ceil();const i=t.renderTarget.renderTarget.colorTexture.source,o=T.getOptimalTexture(n.width,n.height,i._resolution,i.antialias);t.renderTarget.push(o,!0),t.globalUniforms.push({offset:n,worldColor:4294967295});const d=s.sprite;d.texture=o,d.worldTransform.tx=n.minX,d.worldTransform.ty=n.minY,this._activeMaskStage.push({filterEffect:s,maskedContainer:e.maskedContainer,filterTexture:o})}else s.sprite=e.mask.mask,this._activeMaskStage.push({filterEffect:s,maskedContainer:e.maskedContainer})}else if(e.action==="pushMaskEnd"){const s=this._activeMaskStage[this._activeMaskStage.length-1];r&&(t.type===V.WEBGL&&t.renderTarget.finishRenderPass(),t.renderTarget.pop(),t.globalUniforms.pop()),t.filter.push({renderPipeId:"filter",action:"pushFilter",container:s.maskedContainer,filterEffect:s.filterEffect,canBundle:!1})}else if(e.action==="popMaskEnd"){t.filter.pop();const s=this._activeMaskStage.pop();r&&T.returnTexture(s.filterTexture),w.return(s.filterEffect)}}destroy(){this._renderer=null,this._activeMaskStage=null}}xe.extension={type:[l.WebGLPipes,l.WebGPUPipes,l.CanvasPipes],name:"alphaMask"};class be{constructor(e){this._colorStack=[],this._colorStackIndex=0,this._currentColor=0,this._renderer=e}buildStart(){this._colorStack[0]=15,this._colorStackIndex=1,this._currentColor=15}push(e,t,r){this._renderer.renderPipes.batch.break(r);const n=this._colorStack;n[this._colorStackIndex]=n[this._colorStackIndex-1]&e.mask;const i=this._colorStack[this._colorStackIndex];i!==this._currentColor&&(this._currentColor=i,r.add({renderPipeId:"colorMask",colorMask:i,canBundle:!1})),this._colorStackIndex++}pop(e,t,r){this._renderer.renderPipes.batch.break(r);const n=this._colorStack;this._colorStackIndex--;const i=n[this._colorStackIndex-1];i!==this._currentColor&&(this._currentColor=i,r.add({renderPipeId:"colorMask",colorMask:i,canBundle:!1}))}execute(e){this._renderer.colorMask.setMask(e.colorMask)}destroy(){this._renderer=null,this._colorStack=null}}be.extension={type:[l.WebGLPipes,l.WebGPUPipes],name:"colorMask"};class Te{constructor(e){this._maskStackHash={},this._maskHash=new WeakMap,this._renderer=e}push(e,t,r){var s;const n=e,i=this._renderer;i.renderPipes.batch.break(r),i.renderPipes.blendMode.setBlendMode(n.mask,"none",r),r.add({renderPipeId:"stencilMask",action:"pushMaskBegin",mask:e,inverse:t._maskOptions.inverse,canBundle:!1});const o=n.mask;o.includeInBuild=!0,this._maskHash.has(n)||this._maskHash.set(n,{instructionsStart:0,instructionsLength:0});const d=this._maskHash.get(n);d.instructionsStart=r.instructionSize,o.collectRenderables(r,i,null),o.includeInBuild=!1,i.renderPipes.batch.break(r),r.add({renderPipeId:"stencilMask",action:"pushMaskEnd",mask:e,inverse:t._maskOptions.inverse,canBundle:!1});const h=r.instructionSize-d.instructionsStart-1;d.instructionsLength=h;const c=i.renderTarget.renderTarget.uid;(s=this._maskStackHash)[c]??(s[c]=0)}pop(e,t,r){const s=e,n=this._renderer;n.renderPipes.batch.break(r),n.renderPipes.blendMode.setBlendMode(s.mask,"none",r),r.add({renderPipeId:"stencilMask",action:"popMaskBegin",inverse:t._maskOptions.inverse,canBundle:!1});const i=this._maskHash.get(e);for(let o=0;o<i.instructionsLength;o++)r.instructions[r.instructionSize++]=r.instructions[i.instructionsStart++];r.add({renderPipeId:"stencilMask",action:"popMaskEnd",canBundle:!1})}execute(e){var t;const r=this._renderer,s=r,n=r.renderTarget.renderTarget.uid;let i=(t=this._maskStackHash)[n]??(t[n]=0);e.action==="pushMaskBegin"?(s.renderTarget.ensureDepthStencil(),s.stencil.setStencilMode(g.RENDERING_MASK_ADD,i),i++,s.colorMask.setMask(0)):e.action==="pushMaskEnd"?(e.inverse?s.stencil.setStencilMode(g.INVERSE_MASK_ACTIVE,i):s.stencil.setStencilMode(g.MASK_ACTIVE,i),s.colorMask.setMask(15)):e.action==="popMaskBegin"?(s.colorMask.setMask(0),i!==0?s.stencil.setStencilMode(g.RENDERING_MASK_REMOVE,i):(s.renderTarget.clear(null,D.STENCIL),s.stencil.setStencilMode(g.DISABLED,i)),i--):e.action==="popMaskEnd"&&(e.inverse?s.stencil.setStencilMode(g.INVERSE_MASK_ACTIVE,i):s.stencil.setStencilMode(g.MASK_ACTIVE,i),s.colorMask.setMask(15)),this._maskStackHash[n]=i}destroy(){this._renderer=null,this._maskStackHash=null,this._maskHash=null}}Te.extension={type:[l.WebGLPipes,l.WebGPUPipes],name:"stencilMask"};class ve{constructor(e){this._renderer=e}updateRenderable(){}destroyRenderable(){}validateRenderable(){return!1}addRenderable(e,t){this._renderer.renderPipes.batch.break(t),t.add(e)}execute(e){e.isRenderable&&e.render(this._renderer)}destroy(){this._renderer=null}}ve.extension={type:[l.WebGLPipes,l.WebGPUPipes,l.CanvasPipes],name:"customRender"};function L(a,e){const t=a.instructionSet,r=t.instructions;for(let s=0;s<t.instructionSize;s++){const n=r[s];e[n.renderPipeId].execute(n)}}class ye{constructor(e){this._renderer=e}addRenderGroup(e,t){e.isCachedAsTexture?this._addRenderableCacheAsTexture(e,t):this._addRenderableDirect(e,t)}execute(e){e.isRenderable&&(e.isCachedAsTexture?this._executeCacheAsTexture(e):this._executeDirect(e))}destroy(){this._renderer=null}_addRenderableDirect(e,t){this._renderer.renderPipes.batch.break(t),e._batchableRenderGroup&&(w.return(e._batchableRenderGroup),e._batchableRenderGroup=null),t.add(e)}_addRenderableCacheAsTexture(e,t){const r=e._batchableRenderGroup??(e._batchableRenderGroup=w.get(ue));r.renderable=e.root,r.transform=e.root.relativeGroupTransform,r.texture=e.texture,r.bounds=e._textureBounds,t.add(e),this._renderer.renderPipes.blendMode.pushBlendMode(e,e.root.groupBlendMode,t),this._renderer.renderPipes.batch.addToBatch(r,t),this._renderer.renderPipes.blendMode.popBlendMode(t)}_executeCacheAsTexture(e){if(e.textureNeedsUpdate){e.textureNeedsUpdate=!1;const t=new m().translate(-e._textureBounds.x,-e._textureBounds.y);this._renderer.renderTarget.push(e.texture,!0,null,e.texture.frame),this._renderer.globalUniforms.push({worldTransformMatrix:t,worldColor:4294967295,offset:{x:0,y:0}}),L(e,this._renderer.renderPipes),this._renderer.renderTarget.finishRenderPass(),this._renderer.renderTarget.pop(),this._renderer.globalUniforms.pop()}e._batchableRenderGroup._batcher.updateElement(e._batchableRenderGroup),e._batchableRenderGroup._batcher.geometry.buffers[0].update()}_executeDirect(e){this._renderer.globalUniforms.push({worldTransformMatrix:e.inverseParentTextureTransform,worldColor:e.worldColorAlpha}),L(e,this._renderer.renderPipes),this._renderer.globalUniforms.pop()}}ye.extension={type:[l.WebGLPipes,l.WebGPUPipes,l.CanvasPipes],name:"renderGroup"};class Ce{constructor(e){this._renderer=e}addRenderable(e,t){const r=this._getGpuSprite(e);e.didViewUpdate&&this._updateBatchableSprite(e,r),this._renderer.renderPipes.batch.addToBatch(r,t)}updateRenderable(e){const t=this._getGpuSprite(e);e.didViewUpdate&&this._updateBatchableSprite(e,t),t._batcher.updateElement(t)}validateRenderable(e){const t=this._getGpuSprite(e);return!t._batcher.checkAndUpdateTexture(t,e._texture)}_updateBatchableSprite(e,t){t.bounds=e.visualBounds,t.texture=e._texture}_getGpuSprite(e){return e._gpuData[this._renderer.uid]||this._initGPUSprite(e)}_initGPUSprite(e){const t=new ue;return t.renderable=e,t.transform=e.groupTransform,t.texture=e._texture,t.bounds=e.visualBounds,t.roundPixels=this._renderer._roundPixels|e._roundPixels,e._gpuData[this._renderer.uid]=t,t}destroy(){this._renderer=null}}Ce.extension={type:[l.WebGLPipes,l.WebGPUPipes,l.CanvasPipes],name:"sprite"};const y={};W.handle(l.BlendMode,a=>{if(!a.name)throw new Error("BlendMode extension must have a name property");y[a.name]=a.ref},a=>{delete y[a.name]});class ke{constructor(e){this._blendModeStack=[],this._isAdvanced=!1,this._filterHash=Object.create(null),this._renderer=e,this._renderer.runners.prerender.add(this)}prerender(){this._activeBlendMode="normal",this._isAdvanced=!1}pushBlendMode(e,t,r){this._blendModeStack.push(t),this.setBlendMode(e,t,r)}popBlendMode(e){this._blendModeStack.pop();const t=this._blendModeStack[this._activeBlendMode.length-1]??"normal";this.setBlendMode(null,t,e)}setBlendMode(e,t,r){var n;const s=e instanceof ee;if(this._activeBlendMode===t){this._isAdvanced&&e&&!s&&((n=this._renderableList)==null||n.push(e));return}this._isAdvanced&&this._endAdvancedBlendMode(r),this._activeBlendMode=t,e&&(this._isAdvanced=!!y[t],this._isAdvanced&&this._beginAdvancedBlendMode(e,r))}_beginAdvancedBlendMode(e,t){this._renderer.renderPipes.batch.break(t);const r=this._activeBlendMode;if(!y[r]){ce(`Unable to assign BlendMode: '${r}'. You may want to include: import 'pixi.js/advanced-blend-modes'`);return}const s=this._ensureFilterEffect(r),n=e instanceof ee,i={renderPipeId:"filter",action:"pushFilter",filterEffect:s,renderables:n?null:[e],container:n?e.root:null,canBundle:!1};this._renderableList=i.renderables,t.add(i)}_ensureFilterEffect(e){let t=this._filterHash[e];return t||(t=this._filterHash[e]=new de,t.filters=[new y[e]]),t}_endAdvancedBlendMode(e){this._isAdvanced=!1,this._renderableList=null,this._renderer.renderPipes.batch.break(e),e.add({renderPipeId:"filter",action:"popFilter",canBundle:!1})}buildStart(){this._isAdvanced=!1}buildEnd(e){this._isAdvanced&&this._endAdvancedBlendMode(e)}destroy(){this._renderer=null,this._renderableList=null;for(const e in this._filterHash)this._filterHash[e].destroy();this._filterHash=null}}ke.extension={type:[l.WebGLPipes,l.WebGPUPipes,l.CanvasPipes],name:"blendMode"};function F(a,e){e||(e=0);for(let t=e;t<a.length&&a[t];t++)a[t]=null}const ct=new P,ne=pe|fe|me;function Me(a,e=!1){ht(a);const t=a.childrenToUpdate,r=a.updateTick++;for(const s in t){const n=Number(s),i=t[s],o=i.list,d=i.index;for(let h=0;h<d;h++){const c=o[h];c.parentRenderGroup===a&&c.relativeRenderGroupDepth===n&&Re(c,r,0)}F(o,d),i.index=0}if(e)for(let s=0;s<a.renderGroupChildren.length;s++)Me(a.renderGroupChildren[s],e)}function ht(a){const e=a.root;let t;if(a.renderGroupParent){const r=a.renderGroupParent;a.worldTransform.appendFrom(e.relativeGroupTransform,r.worldTransform),a.worldColor=he(e.groupColor,r.worldColor),t=e.groupAlpha*r.worldAlpha}else a.worldTransform.copyFrom(e.localTransform),a.worldColor=e.localColor,t=e.localAlpha;t=t<0?0:t>1?1:t,a.worldAlpha=t,a.worldColorAlpha=a.worldColor+((t*255|0)<<24)}function Re(a,e,t){if(e===a.updateTick)return;a.updateTick=e,a.didChange=!1;const r=a.localTransform;a.updateLocalTransform();const s=a.parent;if(s&&!s.renderGroup?(t|=a._updateFlags,a.relativeGroupTransform.appendFrom(r,s.relativeGroupTransform),t&ne&&ae(a,s,t)):(t=a._updateFlags,a.relativeGroupTransform.copyFrom(r),t&ne&&ae(a,ct,t)),!a.renderGroup){const n=a.children,i=n.length;for(let h=0;h<i;h++)Re(n[h],e,t);const o=a.parentRenderGroup,d=a;d.renderPipeId&&!o.structureDidChange&&o.updateRenderable(d)}}function ae(a,e,t){if(t&fe){a.groupColor=he(a.localColor,e.groupColor);let r=a.localAlpha*e.groupAlpha;r=r<0?0:r>1?1:r,a.groupAlpha=r,a.groupColorAlpha=a.groupColor+((r*255|0)<<24)}t&me&&(a.groupBlendMode=a.localBlendMode==="inherit"?e.groupBlendMode:a.localBlendMode),t&pe&&(a.globalDisplayStatus=a.localDisplayStatus&e.globalDisplayStatus),a._updateFlags=0}function pt(a,e){const{list:t}=a.childrenRenderablesToUpdate;let r=!1;for(let s=0;s<a.childrenRenderablesToUpdate.index;s++){const n=t[s];if(r=e[n.renderPipeId].validateRenderable(n),r)break}return a.structureDidChange=r,r}const ft=new m;class Se{constructor(e){this._renderer=e}render({container:e,transform:t}){const r=e.parent,s=e.renderGroup.renderGroupParent;e.parent=null,e.renderGroup.renderGroupParent=null;const n=this._renderer,i=ft;t&&(i.copyFrom(e.renderGroup.localTransform),e.renderGroup.localTransform.copyFrom(t));const o=n.renderPipes;this._updateCachedRenderGroups(e.renderGroup,null),this._updateRenderGroups(e.renderGroup),n.globalUniforms.start({worldTransformMatrix:t?e.renderGroup.localTransform:e.renderGroup.worldTransform,worldColor:e.renderGroup.worldColorAlpha}),L(e.renderGroup,o),o.uniformBatch&&o.uniformBatch.renderEnd(),t&&e.renderGroup.localTransform.copyFrom(i),e.parent=r,e.renderGroup.renderGroupParent=s}destroy(){this._renderer=null}_updateCachedRenderGroups(e,t){if(e._parentCacheAsTextureRenderGroup=t,e.isCachedAsTexture){if(!e.textureNeedsUpdate)return;t=e}for(let r=e.renderGroupChildren.length-1;r>=0;r--)this._updateCachedRenderGroups(e.renderGroupChildren[r],t);if(e.invalidateMatrices(),e.isCachedAsTexture){if(e.textureNeedsUpdate){const r=e.root.getLocalBounds(),s=this._renderer,n=e.textureOptions.resolution||s.view.resolution,i=e.textureOptions.antialias??s.view.antialias,o=e.textureOptions.scaleMode??"linear",d=e.texture;r.ceil(),e.texture&&T.returnTexture(e.texture,!0);const h=T.getOptimalTexture(r.width,r.height,n,i);h._source.style=new Ke({scaleMode:o}),e.texture=h,e._textureBounds||(e._textureBounds=new z),e._textureBounds.copyFrom(r),d!==e.texture&&e.renderGroupParent&&(e.renderGroupParent.structureDidChange=!0)}}else e.texture&&(T.returnTexture(e.texture,!0),e.texture=null)}_updateRenderGroups(e){const t=this._renderer,r=t.renderPipes;if(e.runOnRender(t),e.instructionSet.renderPipes=r,e.structureDidChange?F(e.childrenRenderablesToUpdate.list,0):pt(e,r),Me(e),e.structureDidChange?(e.structureDidChange=!1,this._buildInstructions(e,t)):this._updateRenderables(e),e.childrenRenderablesToUpdate.index=0,t.renderPipes.batch.upload(e.instructionSet),!(e.isCachedAsTexture&&!e.textureNeedsUpdate))for(let s=0;s<e.renderGroupChildren.length;s++)this._updateRenderGroups(e.renderGroupChildren[s])}_updateRenderables(e){const{list:t,index:r}=e.childrenRenderablesToUpdate;for(let s=0;s<r;s++){const n=t[s];n.didViewUpdate&&e.updateRenderable(n)}F(t,r)}_buildInstructions(e,t){const r=e.root,s=e.instructionSet;s.reset();const n=t.renderPipes?t:t.batch.renderer,i=n.renderPipes;i.batch.buildStart(s),i.blendMode.buildStart(),i.colorMask.buildStart(),r.sortableChildren&&r.sortChildren(),r.collectRenderablesWithEffects(s,n,null),i.batch.buildEnd(s),i.blendMode.buildEnd(s)}}Se.extension={type:[l.WebGLSystem,l.WebGPUSystem,l.CanvasSystem],name:"renderGroup"};const $=class we{constructor(){this.clearBeforeRender=!0,this._backgroundColor=new E(0),this.color=this._backgroundColor,this.alpha=1}init(e){e={...we.defaultOptions,...e},this.clearBeforeRender=e.clearBeforeRender,this.color=e.background||e.backgroundColor||this._backgroundColor,this.alpha=e.backgroundAlpha,this._backgroundColor.setAlpha(e.backgroundAlpha)}get color(){return this._backgroundColor}set color(e){E.shared.setValue(e).alpha<1&&this._backgroundColor.alpha===1&&ce("Cannot set a transparent background on an opaque canvas. To enable transparency, set backgroundAlpha < 1 when initializing your Application."),this._backgroundColor.setValue(e)}get alpha(){return this._backgroundColor.alpha}set alpha(e){this._backgroundColor.setAlpha(e)}get colorRgba(){return this._backgroundColor.toArray()}destroy(){}};$.extension={type:[l.WebGLSystem,l.WebGPUSystem,l.CanvasSystem],name:"background",priority:0};$.defaultOptions={backgroundAlpha:1,backgroundColor:0,clearBeforeRender:!0};let mt=$;const I={png:"image/png",jpg:"image/jpeg",webp:"image/webp"},q=class Pe{constructor(e){this._renderer=e}_normalizeOptions(e,t={}){return e instanceof P||e instanceof f?{target:e,...t}:{...t,...e}}async image(e){const t=N.get().createImage();return t.src=await this.base64(e),t}async base64(e){e=this._normalizeOptions(e,Pe.defaultImageOptions);const{format:t,quality:r}=e,s=this.canvas(e);if(s.toBlob!==void 0)return new Promise((n,i)=>{s.toBlob(o=>{if(!o){i(new Error("ICanvas.toBlob failed!"));return}const d=new FileReader;d.onload=()=>n(d.result),d.onerror=i,d.readAsDataURL(o)},I[t],r)});if(s.toDataURL!==void 0)return s.toDataURL(I[t],r);if(s.convertToBlob!==void 0){const n=await s.convertToBlob({type:I[t],quality:r});return new Promise((i,o)=>{const d=new FileReader;d.onload=()=>i(d.result),d.onerror=o,d.readAsDataURL(n)})}throw new Error("Extract.base64() requires ICanvas.toDataURL, ICanvas.toBlob, or ICanvas.convertToBlob to be implemented")}canvas(e){e=this._normalizeOptions(e);const t=e.target,r=this._renderer;if(t instanceof f)return r.texture.generateCanvas(t);const s=r.textureGenerator.generateTexture(e),n=r.texture.generateCanvas(s);return s.destroy(!0),n}pixels(e){e=this._normalizeOptions(e);const t=e.target,r=this._renderer,s=t instanceof f?t:r.textureGenerator.generateTexture(e),n=r.texture.getPixels(s);return t instanceof P&&s.destroy(!0),n}texture(e){return e=this._normalizeOptions(e),e.target instanceof f?e.target:this._renderer.textureGenerator.generateTexture(e)}download(e){e=this._normalizeOptions(e);const t=this.canvas(e),r=document.createElement("a");r.download=e.filename??"image.png",r.href=t.toDataURL("image/png"),document.body.appendChild(r),r.click(),document.body.removeChild(r)}log(e){const t=e.width??200;e=this._normalizeOptions(e);const r=this.canvas(e),s=r.toDataURL();console.log(`[Pixi Texture] ${r.width}px ${r.height}px`);const n=["font-size: 1px;",`padding: ${t}px 300px;`,`background: url(${s}) no-repeat;`,"background-size: contain;"].join(" ");console.log("%c ",n)}destroy(){this._renderer=null}};q.extension={type:[l.WebGLSystem,l.WebGPUSystem,l.CanvasSystem],name:"extract"};q.defaultImageOptions={format:"png",quality:1};let gt=q;class K extends f{static create(e){const{dynamic:t,textureOptions:r,...s}=e;return new K({...r,source:new v(s),dynamic:t??!1})}resize(e,t,r){return this.source.resize(e,t,r),this}}const _t=new B,xt=new z,bt=[0,0,0,0];class Be{constructor(e){this._renderer=e}generateTexture(e){var c;e instanceof P&&(e={target:e,frame:void 0,textureSourceOptions:{},resolution:void 0});const t=e.resolution||this._renderer.resolution,r=e.antialias||this._renderer.view.antialias,s=e.target;let n=e.clearColor;n?n=Array.isArray(n)&&n.length===4?n:E.shared.setValue(n).toArray():n=bt;const i=((c=e.frame)==null?void 0:c.copyTo(_t))||Ye(s,xt).rectangle,o=e.defaultAnchor&&{defaultAnchor:e.defaultAnchor};i.width=Math.max(i.width,1/t)|0,i.height=Math.max(i.height,1/t)|0;const d=K.create({...e.textureSourceOptions,width:i.width,height:i.height,resolution:t,antialias:r,textureOptions:o}),h=m.shared.translate(-i.x,-i.y);return this._renderer.render({container:s,transform:h,target:d,clearColor:n}),d.source.updateMipmaps(),d}destroy(){this._renderer=null}}Be.extension={type:[l.WebGLSystem,l.WebGPUSystem,l.CanvasSystem],name:"textureGenerator"};function Tt(a){let e=!1;for(const r in a)if(a[r]==null){e=!0;break}if(!e)return a;const t=Object.create(null);for(const r in a){const s=a[r];s&&(t[r]=s)}return t}function vt(a){let e=0;for(let t=0;t<a.length;t++)a[t]==null?e++:a[t-e]=a[t];return a.length-=e,a}const Y=class Ge{constructor(e){this._managedResources=[],this._managedResourceHashes=[],this._managedCollections=[],this._ready=!1,this._renderer=e}init(e){e={...Ge.defaultOptions,...e},this.maxUnusedTime=e.gcMaxUnusedTime,this._frequency=e.gcFrequency,this.enabled=e.gcActive,this.now=performance.now()}get enabled(){return!!this._handler}set enabled(e){this.enabled!==e&&(e?(this._handler=this._renderer.scheduler.repeat(()=>{this._ready=!0},this._frequency,!1),this._collectionsHandler=this._renderer.scheduler.repeat(()=>{for(const t of this._managedCollections){const{context:r,collection:s,type:n}=t;n==="hash"?r[s]=Tt(r[s]):r[s]=vt(r[s])}},this._frequency)):(this._renderer.scheduler.cancel(this._handler),this._renderer.scheduler.cancel(this._collectionsHandler),this._handler=0,this._collectionsHandler=0))}prerender({container:e}){this.now=performance.now(),e.renderGroup.gcTick=this._renderer.tick++,this._updateInstructionGCTick(e.renderGroup,e.renderGroup.gcTick)}postrender(){!this._ready||!this.enabled||(this.run(),this._ready=!1)}_updateInstructionGCTick(e,t){e.instructionSet.gcTick=t,e.gcTick=t;for(const r of e.renderGroupChildren)this._updateInstructionGCTick(r,t)}addCollection(e,t,r){this._managedCollections.push({context:e,collection:t,type:r})}addResource(e,t){var s,n;if(e._gcLastUsed!==-1){e._gcLastUsed=this.now,(s=e._onTouch)==null||s.call(e,this.now);return}const r=this._managedResources.length;e._gcData={index:r,type:t},e._gcLastUsed=this.now,(n=e._onTouch)==null||n.call(e,this.now),e.once("unload",this.removeResource,this),this._managedResources.push(e)}removeResource(e){const t=e._gcData;if(!t)return;const r=t.index,s=this._managedResources.length-1;if(r!==s){const n=this._managedResources[s];this._managedResources[r]=n,n._gcData.index=r}this._managedResources.length--,e._gcData=null,e._gcLastUsed=-1}addResourceHash(e,t,r,s=0){this._managedResourceHashes.push({context:e,hash:t,type:r,priority:s}),this._managedResourceHashes.sort((n,i)=>n.priority-i.priority)}run(){const e=performance.now(),t=this._managedResourceHashes;for(const s of t)this.runOnHash(s,e);let r=0;for(let s=0;s<this._managedResources.length;s++){const n=this._managedResources[s];r=this.runOnResource(n,e,r)}this._managedResources.length=r}updateRenderableGCTick(e,t){var n,i;const r=e.renderGroup??e.parentRenderGroup,s=((n=r==null?void 0:r.instructionSet)==null?void 0:n.gcTick)??-1;((r==null?void 0:r.gcTick)??0)===s&&(e._gcLastUsed=t,(i=e._onTouch)==null||i.call(e,t))}runOnResource(e,t,r){const s=e._gcData;return s.type==="renderable"&&this.updateRenderableGCTick(e,t),t-e._gcLastUsed<this.maxUnusedTime||!e.autoGarbageCollect?(this._managedResources[r]=e,s.index=r,r++):(e.unload(),e._gcData=null,e._gcLastUsed=-1,e.off("unload",this.removeResource,this)),r}_createHashClone(e,t){const r=Object.create(null);for(const s in e){if(s===t)break;e[s]!==null&&(r[s]=e[s])}return r}runOnHash(e,t){var h;const{context:r,hash:s,type:n}=e,i=r[s];let o=null,d=0;for(const c in i){const u=i[c];if(u===null){d++,d===1e4&&!o&&(o=this._createHashClone(i,c));continue}if(u._gcLastUsed===-1){u._gcLastUsed=t,(h=u._onTouch)==null||h.call(u,t),o&&(o[c]=u);continue}if(n==="renderable"&&this.updateRenderableGCTick(u,t),!(t-u._gcLastUsed<this.maxUnusedTime)&&u.autoGarbageCollect){if(n==="renderable"){const _=u,x=_.renderGroup??_.parentRenderGroup;x&&(x.structureDidChange=!0)}u.unload(),u._gcData=null,u._gcLastUsed=-1,o||(d+1!==1e4?(i[c]=null,d++):o=this._createHashClone(i,c))}else o&&(o[c]=u)}o&&(r[s]=o)}destroy(){this.enabled=!1,this._managedResources.forEach(e=>{e.off("unload",this.removeResource,this)}),this._managedResources.length=0,this._managedResourceHashes.length=0,this._managedCollections.length=0,this._renderer=null}};Y.extension={type:[l.WebGLSystem,l.WebGPUSystem,l.CanvasSystem],name:"gc",priority:0};Y.defaultOptions={gcActive:!0,gcMaxUnusedTime:6e4,gcFrequency:3e4};let yt=Y;class Ue{constructor(e){this._stackIndex=0,this._globalUniformDataStack=[],this._uniformsPool=[],this._activeUniforms=[],this._bindGroupPool=[],this._activeBindGroups=[],this._renderer=e}reset(){this._stackIndex=0;for(let e=0;e<this._activeUniforms.length;e++)this._uniformsPool.push(this._activeUniforms[e]);for(let e=0;e<this._activeBindGroups.length;e++)this._bindGroupPool.push(this._activeBindGroups[e]);this._activeUniforms.length=0,this._activeBindGroups.length=0}start(e){this.reset(),this.push(e)}bind({size:e,projectionMatrix:t,worldTransformMatrix:r,worldColor:s,offset:n}){const i=this._renderer.renderTarget.renderTarget,o=this._stackIndex?this._globalUniformDataStack[this._stackIndex-1]:{worldTransformMatrix:new m,worldColor:4294967295,offset:new Je},d={projectionMatrix:t||this._renderer.renderTarget.projectionMatrix,resolution:e||i.size,worldTransformMatrix:r||o.worldTransformMatrix,worldColor:s||o.worldColor,offset:n||o.offset,bindGroup:null},h=this._uniformsPool.pop()||this._createUniforms();this._activeUniforms.push(h);const c=h.uniforms;c.uProjectionMatrix=d.projectionMatrix,c.uResolution=d.resolution,c.uWorldTransformMatrix.copyFrom(d.worldTransformMatrix),c.uWorldTransformMatrix.tx-=d.offset.x,c.uWorldTransformMatrix.ty-=d.offset.y,lt(d.worldColor,c.uWorldColorAlpha,0),h.update();let u;this._renderer.renderPipes.uniformBatch?u=this._renderer.renderPipes.uniformBatch.getUniformBindGroup(h,!1):(u=this._bindGroupPool.pop()||new Xe,this._activeBindGroups.push(u),u.setResource(h,0)),d.bindGroup=u,this._currentGlobalUniformData=d}push(e){this.bind(e),this._globalUniformDataStack[this._stackIndex++]=this._currentGlobalUniformData}pop(){this._currentGlobalUniformData=this._globalUniformDataStack[--this._stackIndex-1],this._renderer.type===V.WEBGL&&this._currentGlobalUniformData.bindGroup.resources[0].update()}get bindGroup(){return this._currentGlobalUniformData.bindGroup}get globalUniformData(){return this._currentGlobalUniformData}get uniformGroup(){return this._currentGlobalUniformData.bindGroup.resources[0]}_createUniforms(){return new oe({uProjectionMatrix:{value:new m,type:"mat3x3<f32>"},uWorldTransformMatrix:{value:new m,type:"mat3x3<f32>"},uWorldColorAlpha:{value:new Float32Array(4),type:"vec4<f32>"},uResolution:{value:[0,0],type:"vec2<f32>"}},{isStatic:!0})}destroy(){this._renderer=null,this._globalUniformDataStack.length=0,this._uniformsPool.length=0,this._activeUniforms.length=0,this._bindGroupPool.length=0,this._activeBindGroups.length=0,this._currentGlobalUniformData=null}}Ue.extension={type:[l.WebGLSystem,l.WebGPUSystem,l.CanvasSystem],name:"globalUniforms"};let Ct=1;class Ae{constructor(){this._tasks=[],this._offset=0}init(){te.system.add(this._update,this)}repeat(e,t,r=!0){const s=Ct++;let n=0;return r&&(this._offset+=1e3,n=this._offset),this._tasks.push({func:e,duration:t,start:performance.now(),offset:n,last:performance.now(),repeat:!0,id:s}),s}cancel(e){for(let t=0;t<this._tasks.length;t++)if(this._tasks[t].id===e){this._tasks.splice(t,1);return}}_update(){const e=performance.now();for(let t=0;t<this._tasks.length;t++){const r=this._tasks[t];if(e-r.offset-r.last>=r.duration){const s=e-r.start;r.func(s),r.last=e}}}destroy(){te.system.remove(this._update,this),this._tasks.length=0}}Ae.extension={type:[l.WebGLSystem,l.WebGPUSystem,l.CanvasSystem],name:"scheduler",priority:0};let ie=!1;function kt(a){if(!ie){if(N.get().getNavigator().userAgent.toLowerCase().indexOf("chrome")>-1){const e=[`%c %c %c %c %c PixiJS %c v${re} (${a}) http://www.pixijs.com/ + +`,"background: #E72264; padding:5px 0;","background: #6CA2EA; padding:5px 0;","background: #B5D33D; padding:5px 0;","background: #FED23F; padding:5px 0;","color: #FFFFFF; background: #E72264; padding:5px 0;","color: #E72264; background: #FFFFFF; padding:5px 0;"];globalThis.console.log(...e)}else globalThis.console&&globalThis.console.log(`PixiJS ${re} - ${a} - http://www.pixijs.com/`);ie=!0}}class J{constructor(e){this._renderer=e}init(e){if(e.hello){let t=this._renderer.name;this._renderer.type===V.WEBGL&&(t+=` ${this._renderer.context.webGLVersion}`),kt(t)}}}J.extension={type:[l.WebGLSystem,l.WebGPUSystem,l.CanvasSystem],name:"hello",priority:-2};J.defaultOptions={hello:!1};const X=class Ie{constructor(e){this._renderer=e}init(e){e={...Ie.defaultOptions,...e},this.maxUnusedTime=e.renderableGCMaxUnusedTime}get enabled(){return p("8.15.0","RenderableGCSystem.enabled is deprecated, please use the GCSystem.enabled instead."),this._renderer.gc.enabled}set enabled(e){p("8.15.0","RenderableGCSystem.enabled is deprecated, please use the GCSystem.enabled instead."),this._renderer.gc.enabled=e}addManagedHash(e,t){p("8.15.0","RenderableGCSystem.addManagedHash is deprecated, please use the GCSystem.addCollection instead."),this._renderer.gc.addCollection(e,t,"hash")}addManagedArray(e,t){p("8.15.0","RenderableGCSystem.addManagedArray is deprecated, please use the GCSystem.addCollection instead."),this._renderer.gc.addCollection(e,t,"array")}addRenderable(e){p("8.15.0","RenderableGCSystem.addRenderable is deprecated, please use the GCSystem instead."),this._renderer.gc.addResource(e,"renderable")}run(){p("8.15.0","RenderableGCSystem.run is deprecated, please use the GCSystem instead."),this._renderer.gc.run()}destroy(){this._renderer=null}};X.extension={type:[l.WebGLSystem,l.WebGPUSystem,l.CanvasSystem],name:"renderableGC",priority:0};X.defaultOptions={renderableGCActive:!0,renderableGCMaxUnusedTime:6e4,renderableGCFrequency:3e4};let Mt=X;const Z=class S{get count(){return this._renderer.tick}get checkCount(){return this._checkCount}set checkCount(e){p("8.15.0","TextureGCSystem.run is deprecated, please use the GCSystem instead."),this._checkCount=e}get maxIdle(){return this._renderer.gc.maxUnusedTime/1e3*60}set maxIdle(e){p("8.15.0","TextureGCSystem.run is deprecated, please use the GCSystem instead."),this._renderer.gc.maxUnusedTime=e/60*1e3}get checkCountMax(){return Math.floor(this._renderer.gc._frequency/1e3)}set checkCountMax(e){p("8.15.0","TextureGCSystem.run is deprecated, please use the GCSystem instead.")}get active(){return this._renderer.gc.enabled}set active(e){p("8.15.0","TextureGCSystem.run is deprecated, please use the GCSystem instead."),this._renderer.gc.enabled=e}constructor(e){this._renderer=e,this._checkCount=0}init(e){e.textureGCActive!==S.defaultOptions.textureGCActive&&(this.active=e.textureGCActive),e.textureGCMaxIdle!==S.defaultOptions.textureGCMaxIdle&&(this.maxIdle=e.textureGCMaxIdle),e.textureGCCheckCountMax!==S.defaultOptions.textureGCCheckCountMax&&(this.checkCountMax=e.textureGCCheckCountMax)}run(){p("8.15.0","TextureGCSystem.run is deprecated, please use the GCSystem instead."),this._renderer.gc.run()}destroy(){this._renderer=null}};Z.extension={type:[l.WebGLSystem,l.WebGPUSystem],name:"textureGC"};Z.defaultOptions={textureGCActive:!0,textureGCAMaxIdle:null,textureGCMaxIdle:3600,textureGCCheckCountMax:600};let Rt=Z;const De=class Ee{constructor(e={}){if(this.uid=Ze("renderTarget"),this.colorTextures=[],this.dirtyId=0,this.isRoot=!1,this._size=new Float32Array(2),this._managedColorTextures=!1,e={...Ee.defaultOptions,...e},this.stencil=e.stencil,this.depth=e.depth,this.isRoot=e.isRoot,typeof e.colorTextures=="number"){this._managedColorTextures=!0;for(let t=0;t<e.colorTextures;t++)this.colorTextures.push(new v({width:e.width,height:e.height,resolution:e.resolution,antialias:e.antialias}))}else{this.colorTextures=[...e.colorTextures.map(r=>r.source)];const t=this.colorTexture.source;this.resize(t.width,t.height,t._resolution)}this.colorTexture.source.on("resize",this.onSourceResize,this),(e.depthStencilTexture||this.stencil)&&(e.depthStencilTexture instanceof f||e.depthStencilTexture instanceof v?this.depthStencilTexture=e.depthStencilTexture.source:this.ensureDepthStencilTexture())}get size(){const e=this._size;return e[0]=this.pixelWidth,e[1]=this.pixelHeight,e}get width(){return this.colorTexture.source.width}get height(){return this.colorTexture.source.height}get pixelWidth(){return this.colorTexture.source.pixelWidth}get pixelHeight(){return this.colorTexture.source.pixelHeight}get resolution(){return this.colorTexture.source._resolution}get colorTexture(){return this.colorTextures[0]}onSourceResize(e){this.resize(e.width,e.height,e._resolution,!0)}ensureDepthStencilTexture(){this.depthStencilTexture||(this.depthStencilTexture=new v({width:this.width,height:this.height,resolution:this.resolution,format:"depth24plus-stencil8",autoGenerateMipmaps:!1,antialias:!1,mipLevelCount:1}))}resize(e,t,r=this.resolution,s=!1){this.dirtyId++,this.colorTextures.forEach((n,i)=>{s&&i===0||n.source.resize(e,t,r)}),this.depthStencilTexture&&this.depthStencilTexture.source.resize(e,t,r)}destroy(){this.colorTexture.source.off("resize",this.onSourceResize,this),this._managedColorTextures&&this.colorTextures.forEach(e=>{e.destroy()}),this.depthStencilTexture&&(this.depthStencilTexture.destroy(),delete this.depthStencilTexture)}};De.defaultOptions={width:0,height:0,resolution:1,colorTextures:1,stencil:!1,depth:!1,antialias:!1,isRoot:!1};let H=De;const b=new Map;Qe.register(b);function Oe(a,e){if(!b.has(a)){const t=new f({source:new O({resource:a,...e})}),r=()=>{b.get(a)===t&&b.delete(a)};t.once("destroy",r),t.source.once("destroy",r),b.set(a,t)}return b.get(a)}const Q=class Le{get autoDensity(){return this.texture.source.autoDensity}set autoDensity(e){this.texture.source.autoDensity=e}get resolution(){return this.texture.source._resolution}set resolution(e){this.texture.source.resize(this.texture.source.width,this.texture.source.height,e)}init(e){e={...Le.defaultOptions,...e},e.view&&(p(et,"ViewSystem.view has been renamed to ViewSystem.canvas"),e.canvas=e.view),this.screen=new B(0,0,e.width,e.height),this.canvas=e.canvas||N.get().createCanvas(),this.antialias=!!e.antialias,this.texture=Oe(this.canvas,e),this.renderTarget=new H({colorTextures:[this.texture],depth:!!e.depth,isRoot:!0}),this.texture.source.transparent=e.backgroundAlpha<1,this.resolution=e.resolution}resize(e,t,r){this.texture.source.resize(e,t,r),this.screen.width=this.texture.frame.width,this.screen.height=this.texture.frame.height}destroy(e=!1){(typeof e=="boolean"?e:!!(e!=null&&e.removeView))&&this.canvas.parentNode&&this.canvas.parentNode.removeChild(this.canvas),this.texture.destroy()}};Q.extension={type:[l.WebGLSystem,l.WebGPUSystem,l.CanvasSystem],name:"view",priority:0};Q.defaultOptions={width:800,height:600,autoDensity:!1,antialias:!1};let St=Q;const Ut=[mt,Ue,J,St,Se,yt,Rt,Be,gt,tt,Mt,Ae],At=[ke,_e,Ce,ye,xe,Te,be,ve];function wt(a,e,t,r,s,n){const i=n?1:-1;return a.identity(),a.a=1/r*2,a.d=i*(1/s*2),a.tx=-1-e*a.a,a.ty=-i-t*a.d,a}function Pt(a){const e=a.colorTexture.source.resource;return globalThis.HTMLCanvasElement&&e instanceof HTMLCanvasElement&&document.body.contains(e)}class It{constructor(e){this.rootViewPort=new B,this.viewport=new B,this.mipLevel=0,this.layer=0,this.onRenderTargetChange=new rt("onRenderTargetChange"),this.projectionMatrix=new m,this.defaultClearColor=[0,0,0,0],this._renderSurfaceToRenderTargetHash=new Map,this._gpuRenderTargetHash=Object.create(null),this._renderTargetStack=[],this._renderer=e,e.gc.addCollection(this,"_gpuRenderTargetHash","hash")}finishRenderPass(){this.adaptor.finishRenderPass(this.renderTarget)}renderStart({target:e,clear:t,clearColor:r,frame:s,mipLevel:n,layer:i}){var o,d;this._renderTargetStack.length=0,this.push(e,t,r,s,n??0,i??0),this.rootViewPort.copyFrom(this.viewport),this.rootRenderTarget=this.renderTarget,this.renderingToScreen=Pt(this.rootRenderTarget),(d=(o=this.adaptor).prerender)==null||d.call(o,this.rootRenderTarget)}postrender(){var e,t;(t=(e=this.adaptor).postrender)==null||t.call(e,this.rootRenderTarget)}bind(e,t=!0,r,s,n=0,i=0){const o=this.getRenderTarget(e),d=this.renderTarget!==o;this.renderTarget=o,this.renderSurface=e;const h=this.getGpuRenderTarget(o);(o.pixelWidth!==h.width||o.pixelHeight!==h.height)&&(this.adaptor.resizeGpuRenderTarget(o),h.width=o.pixelWidth,h.height=o.pixelHeight);const c=o.colorTexture,u=this.viewport,G=c.arrayLayerCount||1;if((i|0)!==i&&(i|=0),i<0||i>=G)throw new Error(`[RenderTargetSystem] layer ${i} is out of bounds (arrayLayerCount=${G}).`);this.mipLevel=n|0,this.layer=i|0;const _=Math.max(c.pixelWidth>>n,1),x=Math.max(c.pixelHeight>>n,1);if(!s&&e instanceof f&&(s=e.frame),s){const C=c._resolution,k=1<<Math.max(n|0,0),Fe=s.x*C+.5|0,He=s.y*C+.5|0,We=s.width*C+.5|0,ze=s.height*C+.5|0;let M=Math.floor(Fe/k),R=Math.floor(He/k),U=Math.ceil(We/k),A=Math.ceil(ze/k);M=Math.min(Math.max(M,0),_-1),R=Math.min(Math.max(R,0),x-1),U=Math.min(Math.max(U,1),_-M),A=Math.min(Math.max(A,1),x-R),u.x=M,u.y=R,u.width=U,u.height=A}else u.x=0,u.y=0,u.width=_,u.height=x;return wt(this.projectionMatrix,0,0,u.width/c.resolution,u.height/c.resolution,!o.isRoot),this.adaptor.startRenderPass(o,t,r,u,n,i),d&&this.onRenderTargetChange.emit(o),o}clear(e,t=D.ALL,r,s=this.mipLevel,n=this.layer){t&&(e&&(e=this.getRenderTarget(e)),this.adaptor.clear(e||this.renderTarget,t,r,this.viewport,s,n))}contextChange(){this._gpuRenderTargetHash=Object.create(null)}push(e,t=D.ALL,r,s,n=0,i=0){const o=this.bind(e,t,r,s,n,i);return this._renderTargetStack.push({renderTarget:o,frame:s,mipLevel:n,layer:i}),o}pop(){this._renderTargetStack.pop();const e=this._renderTargetStack[this._renderTargetStack.length-1];this.bind(e.renderTarget,!1,null,e.frame,e.mipLevel,e.layer)}getRenderTarget(e){return e.isTexture&&(e=e.source),this._renderSurfaceToRenderTargetHash.get(e)??this._initRenderTarget(e)}copyToTexture(e,t,r,s,n){r.x<0&&(s.width+=r.x,n.x-=r.x,r.x=0),r.y<0&&(s.height+=r.y,n.y-=r.y,r.y=0);const{pixelWidth:i,pixelHeight:o}=e;return s.width=Math.min(s.width,i-r.x),s.height=Math.min(s.height,o-r.y),this.adaptor.copyToTexture(e,t,r,s,n)}ensureDepthStencil(){this.renderTarget.stencil||(this.renderTarget.stencil=!0,this.adaptor.startRenderPass(this.renderTarget,!1,null,this.viewport,0,this.layer))}destroy(){this._renderer=null,this._renderSurfaceToRenderTargetHash.forEach((e,t)=>{e!==t&&e.destroy()}),this._renderSurfaceToRenderTargetHash.clear(),this._gpuRenderTargetHash=Object.create(null)}_initRenderTarget(e){let t=null;return O.test(e)&&(e=Oe(e).source),e instanceof H?t=e:e instanceof v&&(t=new H({colorTextures:[e]}),e.source instanceof O&&(t.isRoot=!0),e.once("destroy",()=>{t.destroy(),this._renderSurfaceToRenderTargetHash.delete(e);const r=this._gpuRenderTargetHash[t.uid];r&&(this._gpuRenderTargetHash[t.uid]=null,this.adaptor.destroyGpuRenderTarget(r))})),this._renderSurfaceToRenderTargetHash.set(e,t),t}getGpuRenderTarget(e){return this._gpuRenderTargetHash[e.uid]||(this._gpuRenderTargetHash[e.uid]=this.adaptor.initGpuRenderTarget(e))}resetState(){this.renderTarget=null,this.renderSurface=null}}export{xe as A,ke as B,ve as C,It as R,Ut as S,_e as a,Ce as b,lt as c,ye as d,At as e}; diff --git a/2026/games_submissions/sunshoes/assets/WebGLRenderer-CdpFaPwH.js b/2026/games_submissions/sunshoes/assets/WebGLRenderer-CdpFaPwH.js new file mode 100644 index 0000000..870b422 --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/WebGLRenderer-CdpFaPwH.js @@ -0,0 +1,156 @@ +import{Z as R,z as d,x as F,s as B,w as p,q,a as Ne,S as P,T as S,ay as De,aa as Z,az as Ie,r as T,R as X,Y as y,a9 as C,ab as O,F as g,N as J,aA as Q,aB as Ge,aC as ee,aD as Ue,aE as Fe,_ as Pe,$ as Oe}from"./index-DvAPfvr6.js";import{e as Me,G as Le,c as we,b as He,U as Ve,B as te,d as N,f as re,g as Xe}from"./BufferResource-BZpoqTVb.js";import{S as M}from"./Filter-BiIvpnZm.js";import{R as ke,S as We,e as je}from"./RenderTargetSystem-Cp6tD-lP.js";function Ke(){const{userAgent:t}=R.get().getNavigator();return/^((?!chrome|android).)*safari/i.test(t)}class ne{constructor(){this._tempState=M.for2d(),this._didUploadHash={}}init(e){e.renderer.runners.contextChange.add(this)}contextChange(){this._didUploadHash={}}start(e,r,n){const s=e.renderer,i=this._didUploadHash[n.uid];s.shader.bind(n,i),i||(this._didUploadHash[n.uid]=!0),s.shader.updateUniformGroup(s.globalUniforms.uniformGroup),s.geometry.bind(r,n.glProgram)}execute(e,r){const n=e.renderer;this._tempState.blendMode=r.blendMode,n.state.set(this._tempState);const s=r.textures.textures;for(let i=0;i<r.textures.count;i++)n.texture.bind(s[i],i);n.geometry.draw(r.topology,r.size,r.start)}}ne.extension={type:[d.WebGLPipesAdaptor],name:"batch"};var A=(t=>(t[t.ELEMENT_ARRAY_BUFFER=34963]="ELEMENT_ARRAY_BUFFER",t[t.ARRAY_BUFFER=34962]="ARRAY_BUFFER",t[t.UNIFORM_BUFFER=35345]="UNIFORM_BUFFER",t))(A||{});class $e{constructor(e,r){this._lastBindBaseLocation=-1,this._lastBindCallId=-1,this.buffer=e||null,this.updateID=-1,this.byteLength=-1,this.type=r}destroy(){this.buffer=null,this.updateID=-1,this.byteLength=-1,this.type=-1,this._lastBindBaseLocation=-1,this._lastBindCallId=-1}}class se{constructor(e){this._boundBufferBases=Object.create(null),this._minBaseLocation=0,this._nextBindBaseIndex=this._minBaseLocation,this._bindCallId=0,this._renderer=e,this._managedBuffers=new F({renderer:e,type:"resource",onUnload:this.onBufferUnload.bind(this),name:"glBuffer"})}destroy(){this._managedBuffers.destroy(),this._renderer=null,this._gl=null,this._boundBufferBases={}}contextChange(){this._gl=this._renderer.gl,this.destroyAll(!0),this._maxBindings=this._renderer.limits.maxUniformBindings}getGlBuffer(e){return e._gcLastUsed=this._renderer.gc.now,e._gpuData[this._renderer.uid]||this.createGLBuffer(e)}bind(e){const{_gl:r}=this,n=this.getGlBuffer(e);r.bindBuffer(n.type,n.buffer)}bindBufferBase(e,r){const{_gl:n}=this;this._boundBufferBases[r]!==e&&(this._boundBufferBases[r]=e,e._lastBindBaseLocation=r,n.bindBufferBase(n.UNIFORM_BUFFER,r,e.buffer))}nextBindBase(e){this._bindCallId++,this._minBaseLocation=0,e&&(this._boundBufferBases[0]=null,this._minBaseLocation=1,this._nextBindBaseIndex<1&&(this._nextBindBaseIndex=1))}freeLocationForBufferBase(e){let r=this.getLastBindBaseLocation(e);if(r>=this._minBaseLocation)return e._lastBindCallId=this._bindCallId,r;let n=0,s=this._nextBindBaseIndex;for(;n<2;){s>=this._maxBindings&&(s=this._minBaseLocation,n++);const i=this._boundBufferBases[s];if(i&&i._lastBindCallId===this._bindCallId){s++;continue}break}return r=s,this._nextBindBaseIndex=s+1,n>=2?-1:(e._lastBindCallId=this._bindCallId,this._boundBufferBases[r]=null,r)}getLastBindBaseLocation(e){const r=e._lastBindBaseLocation;return this._boundBufferBases[r]===e?r:-1}bindBufferRange(e,r,n,s){const{_gl:i}=this;n||(n=0),r||(r=0),this._boundBufferBases[r]=null,i.bindBufferRange(i.UNIFORM_BUFFER,r||0,e.buffer,n*256,s||256)}updateBuffer(e){const{_gl:r}=this,n=this.getGlBuffer(e);if(e._updateID===n.updateID)return n;n.updateID=e._updateID,r.bindBuffer(n.type,n.buffer);const s=e.data,i=e.descriptor.usage&B.STATIC?r.STATIC_DRAW:r.DYNAMIC_DRAW;return s?n.byteLength>=s.byteLength?r.bufferSubData(n.type,0,s,0,e._updateSize/s.BYTES_PER_ELEMENT):(n.byteLength=s.byteLength,r.bufferData(n.type,s,i)):(n.byteLength=e.descriptor.size,r.bufferData(n.type,n.byteLength,i)),n}destroyAll(e=!1){this._managedBuffers.removeAll(e)}onBufferUnload(e,r=!1){const n=e._gpuData[this._renderer.uid];n&&(r||this._gl.deleteBuffer(n.buffer))}createGLBuffer(e){const{_gl:r}=this;let n=A.ARRAY_BUFFER;e.descriptor.usage&B.INDEX?n=A.ELEMENT_ARRAY_BUFFER:e.descriptor.usage&B.UNIFORM&&(n=A.UNIFORM_BUFFER);const s=new $e(r.createBuffer(),n);return e._gpuData[this._renderer.uid]=s,this._managedBuffers.add(e),s}resetState(){this._boundBufferBases=Object.create(null)}}se.extension={type:[d.WebGLSystem],name:"buffer"};const L=class ie{constructor(e){this.supports={uint32Indices:!0,uniformBufferObject:!0,vertexArrayObject:!0,srgbTextures:!0,nonPowOf2wrapping:!0,msaa:!0,nonPowOf2mipmaps:!0},this._renderer=e,this.extensions=Object.create(null),this.handleContextLost=this.handleContextLost.bind(this),this.handleContextRestored=this.handleContextRestored.bind(this)}get isLost(){return!this.gl||this.gl.isContextLost()}contextChange(e){this.gl=e,this._renderer.gl=e}init(e){e={...ie.defaultOptions,...e};let r=this.multiView=e.multiView;if(e.context&&r&&(p("Renderer created with both a context and multiview enabled. Disabling multiView as both cannot work together."),r=!1),r?this.canvas=R.get().createCanvas(this._renderer.canvas.width,this._renderer.canvas.height):this.canvas=this._renderer.view.canvas,e.context)this.initFromContext(e.context);else{const n=this._renderer.background.alpha<1,s=e.premultipliedAlpha??!0,i=e.antialias&&!this._renderer.backBuffer.useBackBuffer;this.createContext(e.preferWebGLVersion,{alpha:n,premultipliedAlpha:s,antialias:i,stencil:!0,preserveDrawingBuffer:e.preserveDrawingBuffer,powerPreference:e.powerPreference??"default"})}}ensureCanvasSize(e){if(!this.multiView){e!==this.canvas&&p("multiView is disabled, but targetCanvas is not the main canvas");return}const{canvas:r}=this;(r.width<e.width||r.height<e.height)&&(r.width=Math.max(e.width,e.width),r.height=Math.max(e.height,e.height))}initFromContext(e){this.gl=e,this.webGLVersion=e instanceof R.get().getWebGLRenderingContext()?1:2,this.getExtensions(),this.validateContext(e),this._renderer.runners.contextChange.emit(e);const r=this._renderer.view.canvas;r.addEventListener("webglcontextlost",this.handleContextLost,!1),r.addEventListener("webglcontextrestored",this.handleContextRestored,!1)}createContext(e,r){let n;const s=this.canvas;if(e===2&&(n=s.getContext("webgl2",r)),!n&&(n=s.getContext("webgl",r),!n))throw new Error("This browser does not support WebGL. Try using the canvas renderer");this.gl=n,this.initFromContext(this.gl)}getExtensions(){const{gl:e}=this,r={anisotropicFiltering:e.getExtension("EXT_texture_filter_anisotropic"),floatTextureLinear:e.getExtension("OES_texture_float_linear"),s3tc:e.getExtension("WEBGL_compressed_texture_s3tc"),s3tc_sRGB:e.getExtension("WEBGL_compressed_texture_s3tc_srgb"),etc:e.getExtension("WEBGL_compressed_texture_etc"),etc1:e.getExtension("WEBGL_compressed_texture_etc1"),pvrtc:e.getExtension("WEBGL_compressed_texture_pvrtc")||e.getExtension("WEBKIT_WEBGL_compressed_texture_pvrtc"),atc:e.getExtension("WEBGL_compressed_texture_atc"),astc:e.getExtension("WEBGL_compressed_texture_astc"),bptc:e.getExtension("EXT_texture_compression_bptc"),rgtc:e.getExtension("EXT_texture_compression_rgtc"),loseContext:e.getExtension("WEBGL_lose_context")};if(this.webGLVersion===1)this.extensions={...r,drawBuffers:e.getExtension("WEBGL_draw_buffers"),depthTexture:e.getExtension("WEBGL_depth_texture"),vertexArrayObject:e.getExtension("OES_vertex_array_object")||e.getExtension("MOZ_OES_vertex_array_object")||e.getExtension("WEBKIT_OES_vertex_array_object"),uint32ElementIndex:e.getExtension("OES_element_index_uint"),floatTexture:e.getExtension("OES_texture_float"),floatTextureLinear:e.getExtension("OES_texture_float_linear"),textureHalfFloat:e.getExtension("OES_texture_half_float"),textureHalfFloatLinear:e.getExtension("OES_texture_half_float_linear"),vertexAttribDivisorANGLE:e.getExtension("ANGLE_instanced_arrays"),srgb:e.getExtension("EXT_sRGB")};else{this.extensions={...r,colorBufferFloat:e.getExtension("EXT_color_buffer_float")};const n=e.getExtension("WEBGL_provoking_vertex");n&&n.provokingVertexWEBGL(n.FIRST_VERTEX_CONVENTION_WEBGL)}}handleContextLost(e){e.preventDefault(),this._contextLossForced&&(this._contextLossForced=!1,setTimeout(()=>{var r;this.gl.isContextLost()&&((r=this.extensions.loseContext)==null||r.restoreContext())},0))}handleContextRestored(){this.getExtensions(),this._renderer.runners.contextChange.emit(this.gl)}destroy(){var r;const e=this._renderer.view.canvas;this._renderer=null,e.removeEventListener("webglcontextlost",this.handleContextLost),e.removeEventListener("webglcontextrestored",this.handleContextRestored),this.gl.useProgram(null),(r=this.extensions.loseContext)==null||r.loseContext()}forceContextLoss(){var e;(e=this.extensions.loseContext)==null||e.loseContext(),this._contextLossForced=!0}validateContext(e){const r=e.getContextAttributes();r&&!r.stencil&&p("Provided WebGL context does not have a stencil buffer, masks may not render correctly");const n=this.supports,s=this.webGLVersion===2,i=this.extensions;n.uint32Indices=s||!!i.uint32ElementIndex,n.uniformBufferObject=s,n.vertexArrayObject=s||!!i.vertexArrayObject,n.srgbTextures=s||!!i.srgb,n.nonPowOf2wrapping=s,n.nonPowOf2mipmaps=s,n.msaa=s,n.uint32Indices||p("Provided WebGL context does not support 32 index buffer, large scenes may not render correctly")}};L.extension={type:[d.WebGLSystem],name:"context"};L.defaultOptions={context:null,premultipliedAlpha:!0,preserveDrawingBuffer:!1,powerPreference:void 0,preferWebGLVersion:2,multiView:!1};let Ye=L;var G=(t=>(t[t.RGBA=6408]="RGBA",t[t.RGB=6407]="RGB",t[t.RG=33319]="RG",t[t.RED=6403]="RED",t[t.RGBA_INTEGER=36249]="RGBA_INTEGER",t[t.RGB_INTEGER=36248]="RGB_INTEGER",t[t.RG_INTEGER=33320]="RG_INTEGER",t[t.RED_INTEGER=36244]="RED_INTEGER",t[t.ALPHA=6406]="ALPHA",t[t.LUMINANCE=6409]="LUMINANCE",t[t.LUMINANCE_ALPHA=6410]="LUMINANCE_ALPHA",t[t.DEPTH_COMPONENT=6402]="DEPTH_COMPONENT",t[t.DEPTH_STENCIL=34041]="DEPTH_STENCIL",t))(G||{}),w=(t=>(t[t.TEXTURE_2D=3553]="TEXTURE_2D",t[t.TEXTURE_CUBE_MAP=34067]="TEXTURE_CUBE_MAP",t[t.TEXTURE_2D_ARRAY=35866]="TEXTURE_2D_ARRAY",t[t.TEXTURE_CUBE_MAP_POSITIVE_X=34069]="TEXTURE_CUBE_MAP_POSITIVE_X",t[t.TEXTURE_CUBE_MAP_NEGATIVE_X=34070]="TEXTURE_CUBE_MAP_NEGATIVE_X",t[t.TEXTURE_CUBE_MAP_POSITIVE_Y=34071]="TEXTURE_CUBE_MAP_POSITIVE_Y",t[t.TEXTURE_CUBE_MAP_NEGATIVE_Y=34072]="TEXTURE_CUBE_MAP_NEGATIVE_Y",t[t.TEXTURE_CUBE_MAP_POSITIVE_Z=34073]="TEXTURE_CUBE_MAP_POSITIVE_Z",t[t.TEXTURE_CUBE_MAP_NEGATIVE_Z=34074]="TEXTURE_CUBE_MAP_NEGATIVE_Z",t))(w||{}),h=(t=>(t[t.UNSIGNED_BYTE=5121]="UNSIGNED_BYTE",t[t.UNSIGNED_SHORT=5123]="UNSIGNED_SHORT",t[t.UNSIGNED_SHORT_5_6_5=33635]="UNSIGNED_SHORT_5_6_5",t[t.UNSIGNED_SHORT_4_4_4_4=32819]="UNSIGNED_SHORT_4_4_4_4",t[t.UNSIGNED_SHORT_5_5_5_1=32820]="UNSIGNED_SHORT_5_5_5_1",t[t.UNSIGNED_INT=5125]="UNSIGNED_INT",t[t.UNSIGNED_INT_10F_11F_11F_REV=35899]="UNSIGNED_INT_10F_11F_11F_REV",t[t.UNSIGNED_INT_2_10_10_10_REV=33640]="UNSIGNED_INT_2_10_10_10_REV",t[t.UNSIGNED_INT_24_8=34042]="UNSIGNED_INT_24_8",t[t.UNSIGNED_INT_5_9_9_9_REV=35902]="UNSIGNED_INT_5_9_9_9_REV",t[t.BYTE=5120]="BYTE",t[t.SHORT=5122]="SHORT",t[t.INT=5124]="INT",t[t.FLOAT=5126]="FLOAT",t[t.FLOAT_32_UNSIGNED_INT_24_8_REV=36269]="FLOAT_32_UNSIGNED_INT_24_8_REV",t[t.HALF_FLOAT=36193]="HALF_FLOAT",t))(h||{});const k={uint8x2:h.UNSIGNED_BYTE,uint8x4:h.UNSIGNED_BYTE,sint8x2:h.BYTE,sint8x4:h.BYTE,unorm8x2:h.UNSIGNED_BYTE,unorm8x4:h.UNSIGNED_BYTE,snorm8x2:h.BYTE,snorm8x4:h.BYTE,uint16x2:h.UNSIGNED_SHORT,uint16x4:h.UNSIGNED_SHORT,sint16x2:h.SHORT,sint16x4:h.SHORT,unorm16x2:h.UNSIGNED_SHORT,unorm16x4:h.UNSIGNED_SHORT,snorm16x2:h.SHORT,snorm16x4:h.SHORT,float16x2:h.HALF_FLOAT,float16x4:h.HALF_FLOAT,float32:h.FLOAT,float32x2:h.FLOAT,float32x3:h.FLOAT,float32x4:h.FLOAT,uint32:h.UNSIGNED_INT,uint32x2:h.UNSIGNED_INT,uint32x3:h.UNSIGNED_INT,uint32x4:h.UNSIGNED_INT,sint32:h.INT,sint32x2:h.INT,sint32x3:h.INT,sint32x4:h.INT};function ze(t){return k[t]??k.float32}const qe={"point-list":0,"line-list":1,"line-strip":3,"triangle-list":4,"triangle-strip":5};class Ze{constructor(){this.vaoCache=Object.create(null)}destroy(){this.vaoCache=Object.create(null)}}class ae{constructor(e){this._renderer=e,this._activeGeometry=null,this._activeVao=null,this.hasVao=!0,this.hasInstance=!0,this._managedGeometries=new F({renderer:e,type:"resource",onUnload:this.onGeometryUnload.bind(this),name:"glGeometry"})}contextChange(){const e=this.gl=this._renderer.gl;if(!this._renderer.context.supports.vertexArrayObject)throw new Error("[PixiJS] Vertex Array Objects are not supported on this device");this.destroyAll(!0);const r=this._renderer.context.extensions.vertexArrayObject;r&&(e.createVertexArray=()=>r.createVertexArrayOES(),e.bindVertexArray=s=>r.bindVertexArrayOES(s),e.deleteVertexArray=s=>r.deleteVertexArrayOES(s));const n=this._renderer.context.extensions.vertexAttribDivisorANGLE;n&&(e.drawArraysInstanced=(s,i,a,o)=>{n.drawArraysInstancedANGLE(s,i,a,o)},e.drawElementsInstanced=(s,i,a,o,c)=>{n.drawElementsInstancedANGLE(s,i,a,o,c)},e.vertexAttribDivisor=(s,i)=>n.vertexAttribDivisorANGLE(s,i)),this._activeGeometry=null,this._activeVao=null}bind(e,r){const n=this.gl;this._activeGeometry=e;const s=this.getVao(e,r);this._activeVao!==s&&(this._activeVao=s,n.bindVertexArray(s)),this.updateBuffers()}resetState(){this.unbind()}updateBuffers(){const e=this._activeGeometry,r=this._renderer.buffer;for(let n=0;n<e.buffers.length;n++){const s=e.buffers[n];r.updateBuffer(s)}e._gcLastUsed=this._renderer.gc.now}checkCompatibility(e,r){const n=e.attributes,s=r._attributeData;for(const i in s)if(!n[i])throw new Error(`shader and geometry incompatible, geometry missing the "${i}" attribute`)}getSignature(e,r){const n=e.attributes,s=r._attributeData,i=["g",e.uid];for(const a in n)s[a]&&i.push(a,s[a].location);return i.join("-")}getVao(e,r){var n;return((n=e._gpuData[this._renderer.uid])==null?void 0:n.vaoCache[r._key])||this.initGeometryVao(e,r)}initGeometryVao(e,r,n=!0){const s=this._renderer.gl,i=this._renderer.buffer;this._renderer.shader._getProgramData(r),this.checkCompatibility(e,r);const a=this.getSignature(e,r);let o=e._gpuData[this._renderer.uid];o||(o=new Ze,e._gpuData[this._renderer.uid]=o,this._managedGeometries.add(e));const c=o.vaoCache;let u=c[a];if(u)return c[r._key]=u,u;Me(e,r._attributeData);const _=e.buffers;u=s.createVertexArray(),s.bindVertexArray(u);for(let f=0;f<_.length;f++){const l=_[f];i.bind(l)}return this.activateVao(e,r),c[r._key]=u,c[a]=u,s.bindVertexArray(null),u}onGeometryUnload(e,r=!1){const n=e._gpuData[this._renderer.uid];if(!n)return;const s=n.vaoCache;if(!r)for(const i in s)this._activeVao!==s[i]&&this.resetState(),this.gl.deleteVertexArray(s[i])}destroyAll(e=!1){this._managedGeometries.removeAll(e)}activateVao(e,r){var o;const n=this._renderer.gl,s=this._renderer.buffer,i=e.attributes;e.indexBuffer&&s.bind(e.indexBuffer);let a=null;for(const c in i){const u=i[c],_=u.buffer,f=s.getGlBuffer(_),l=r._attributeData[c];if(l){a!==f&&(s.bind(_),a=f);const m=l.location;n.enableVertexAttribArray(m);const b=q(u.format),E=ze(u.format);if(((o=l.format)==null?void 0:o.substring(1,4))==="int"?n.vertexAttribIPointer(m,b.size,E,u.stride,u.offset):n.vertexAttribPointer(m,b.size,E,b.normalised,u.stride,u.offset),u.instance)if(this.hasInstance){const Ce=u.divisor??1;n.vertexAttribDivisor(m,Ce)}else throw new Error("geometry error, GPU Instancing is not supported on this device")}}}draw(e,r,n,s){const{gl:i}=this._renderer,a=this._activeGeometry,o=qe[e||a.topology];if(s??(s=a.instanceCount),a.indexBuffer){const c=a.indexBuffer.data.BYTES_PER_ELEMENT,u=c===2?i.UNSIGNED_SHORT:i.UNSIGNED_INT;s!==1?i.drawElementsInstanced(o,r||a.indexBuffer.data.length,u,(n||0)*c,s):i.drawElements(o,r||a.indexBuffer.data.length,u,(n||0)*c)}else s!==1?i.drawArraysInstanced(o,n||0,r||a.getSize(),s):i.drawArrays(o,n||0,r||a.getSize());return this}unbind(){this.gl.bindVertexArray(null),this._activeVao=null,this._activeGeometry=null}destroy(){this._managedGeometries.destroy(),this._renderer=null,this.gl=null,this._activeVao=null,this._activeGeometry=null}}ae.extension={type:[d.WebGLSystem],name:"geometry"};const Je=new De({attributes:{aPosition:[-1,-1,3,-1,-1,3]}}),H=class oe{constructor(e){this.useBackBuffer=!1,this._useBackBufferThisRender=!1,this._renderer=e}init(e={}){const{useBackBuffer:r,antialias:n}={...oe.defaultOptions,...e};this.useBackBuffer=r,this._antialias=n,this._renderer.context.supports.msaa||(p("antialiasing, is not supported on when using the back buffer"),this._antialias=!1),this._state=M.for2d();const s=new Ne({vertex:` + attribute vec2 aPosition; + out vec2 vUv; + + void main() { + gl_Position = vec4(aPosition, 0.0, 1.0); + + vUv = (aPosition + 1.0) / 2.0; + + // flip dem UVs + vUv.y = 1.0 - vUv.y; + }`,fragment:` + in vec2 vUv; + out vec4 finalColor; + + uniform sampler2D uTexture; + + void main() { + finalColor = texture(uTexture, vUv); + }`,name:"big-triangle"});this._bigTriangleShader=new P({glProgram:s,resources:{uTexture:S.WHITE.source}})}renderStart(e){const r=this._renderer.renderTarget.getRenderTarget(e.target);if(this._useBackBufferThisRender=this.useBackBuffer&&!!r.isRoot,this._useBackBufferThisRender){const n=this._renderer.renderTarget.getRenderTarget(e.target);this._targetTexture=n.colorTexture,e.target=this._getBackBufferTexture(n.colorTexture)}}renderEnd(){this._presentBackBuffer()}_presentBackBuffer(){const e=this._renderer;e.renderTarget.finishRenderPass(),this._useBackBufferThisRender&&(e.renderTarget.bind(this._targetTexture,!1),this._bigTriangleShader.resources.uTexture=this._backBufferTexture.source,e.encoder.draw({geometry:Je,shader:this._bigTriangleShader,state:this._state}))}_getBackBufferTexture(e){return this._backBufferTexture=this._backBufferTexture||new S({source:new Z({width:e.width,height:e.height,resolution:e._resolution,antialias:this._antialias})}),this._backBufferTexture.source.resize(e.width,e.height,e._resolution),this._backBufferTexture}destroy(){this._backBufferTexture&&(this._backBufferTexture.destroy(),this._backBufferTexture=null)}};H.extension={type:[d.WebGLSystem],name:"backBuffer",priority:1};H.defaultOptions={useBackBuffer:!1};let Qe=H;class ce{constructor(e){this._colorMaskCache=15,this._renderer=e}setMask(e){this._colorMaskCache!==e&&(this._colorMaskCache=e,this._renderer.gl.colorMask(!!(e&8),!!(e&4),!!(e&2),!!(e&1)))}}ce.extension={type:[d.WebGLSystem],name:"colorMask"};class ue{constructor(e){this.commandFinished=Promise.resolve(),this._renderer=e}setGeometry(e,r){this._renderer.geometry.bind(e,r.glProgram)}finishRenderPass(){}draw(e){const r=this._renderer,{geometry:n,shader:s,state:i,skipSync:a,topology:o,size:c,start:u,instanceCount:_}=e;r.shader.bind(s,a),r.geometry.bind(n,r.shader._activeProgram),i&&r.state.set(i),r.geometry.draw(o,c,u,_??n.instanceCount)}destroy(){this._renderer=null}}ue.extension={type:[d.WebGLSystem],name:"encoder"};class _e{constructor(e){this._renderer=e}contextChange(){const e=this._renderer.gl;this.maxTextures=e.getParameter(e.MAX_TEXTURE_IMAGE_UNITS),this.maxBatchableTextures=Ie(this.maxTextures,e);const r=this._renderer.context.webGLVersion===2;this.maxUniformBindings=r?e.getParameter(e.MAX_UNIFORM_BUFFER_BINDINGS):0}destroy(){}}_e.extension={type:[d.WebGLSystem],name:"limits"};class et{constructor(){this.width=-1,this.height=-1,this.msaa=!1,this._attachedMipLevel=0,this._attachedLayer=0,this.msaaRenderBuffer=[]}}class fe{constructor(e){this._stencilCache={enabled:!1,stencilReference:0,stencilMode:T.NONE},this._renderTargetStencilState=Object.create(null),e.renderTarget.onRenderTargetChange.add(this)}contextChange(e){this._gl=e,this._comparisonFuncMapping={always:e.ALWAYS,never:e.NEVER,equal:e.EQUAL,"not-equal":e.NOTEQUAL,less:e.LESS,"less-equal":e.LEQUAL,greater:e.GREATER,"greater-equal":e.GEQUAL},this._stencilOpsMapping={keep:e.KEEP,zero:e.ZERO,replace:e.REPLACE,invert:e.INVERT,"increment-clamp":e.INCR,"decrement-clamp":e.DECR,"increment-wrap":e.INCR_WRAP,"decrement-wrap":e.DECR_WRAP},this.resetState()}onRenderTargetChange(e){if(this._activeRenderTarget===e)return;this._activeRenderTarget=e;let r=this._renderTargetStencilState[e.uid];r||(r=this._renderTargetStencilState[e.uid]={stencilMode:T.DISABLED,stencilReference:0}),this.setStencilMode(r.stencilMode,r.stencilReference)}resetState(){this._stencilCache.enabled=!1,this._stencilCache.stencilMode=T.NONE,this._stencilCache.stencilReference=0}setStencilMode(e,r){const n=this._renderTargetStencilState[this._activeRenderTarget.uid],s=this._gl,i=Le[e],a=this._stencilCache;if(n.stencilMode=e,n.stencilReference=r,e===T.DISABLED){this._stencilCache.enabled&&(this._stencilCache.enabled=!1,s.disable(s.STENCIL_TEST));return}this._stencilCache.enabled||(this._stencilCache.enabled=!0,s.enable(s.STENCIL_TEST)),(e!==a.stencilMode||a.stencilReference!==r)&&(a.stencilMode=e,a.stencilReference=r,s.stencilFunc(this._comparisonFuncMapping[i.stencilBack.compare],r,255),s.stencilOp(s.KEEP,s.KEEP,this._stencilOpsMapping[i.stencilBack.passOp]))}}fe.extension={type:[d.WebGLSystem],name:"stencil"};const le={f32:4,i32:4,"vec2<f32>":8,"vec3<f32>":12,"vec4<f32>":16,"vec2<i32>":8,"vec3<i32>":12,"vec4<i32>":16,"mat2x2<f32>":32,"mat3x3<f32>":48,"mat4x4<f32>":64};function tt(t){const e=t.map(i=>({data:i,offset:0,size:0})),r=16;let n=0,s=0;for(let i=0;i<e.length;i++){const a=e[i];if(n=le[a.data.type],!n)throw new Error(`Unknown type ${a.data.type}`);a.data.size>1&&(n=Math.max(n,r)*a.data.size);const o=n===12?16:n;a.size=n;const c=s%r;c>0&&r-c<o?s+=(r-c)%16:s+=(n-c%n)%n,a.offset=s,s+=n}return s=Math.ceil(s/16)*16,{uboElements:e,size:s}}function rt(t,e){const r=Math.max(le[t.data.type]/16,1),n=t.data.value.length/t.data.size,s=(4-n%4)%4,i=t.data.type.indexOf("i32")>=0?"dataInt32":"data";return` + v = uv.${t.data.name}; + offset += ${e}; + + arrayOffset = offset; + + t = 0; + + for(var i=0; i < ${t.data.size*r}; i++) + { + for(var j = 0; j < ${n}; j++) + { + ${i}[arrayOffset++] = v[t++]; + } + ${s!==0?`arrayOffset += ${s};`:""} + } + `}function nt(t){return we(t,"uboStd40",rt,He)}class he extends Ve{constructor(){super({createUboElements:tt,generateUboSync:nt})}}he.extension={type:[d.WebGLSystem],name:"ubo"};class st{constructor(){this._clearColorCache=[0,0,0,0],this._viewPortCache=new X}init(e,r){this._renderer=e,this._renderTargetSystem=r,e.runners.contextChange.add(this)}contextChange(){this._clearColorCache=[0,0,0,0],this._viewPortCache=new X;const e=this._renderer.gl;this._drawBuffersCache=[];for(let r=1;r<=16;r++)this._drawBuffersCache[r]=Array.from({length:r},(n,s)=>e.COLOR_ATTACHMENT0+s)}copyToTexture(e,r,n,s,i){const a=this._renderTargetSystem,o=this._renderer,c=a.getGpuRenderTarget(e),u=o.gl;return this.finishRenderPass(e),u.bindFramebuffer(u.FRAMEBUFFER,c.resolveTargetFramebuffer),o.texture.bind(r,0),u.copyTexSubImage2D(u.TEXTURE_2D,0,i.x,i.y,n.x,n.y,s.width,s.height),r}startRenderPass(e,r=!0,n,s,i=0,a=0){const o=this._renderTargetSystem,c=e.colorTexture,u=o.getGpuRenderTarget(e);if(a!==0&&this._renderer.context.webGLVersion<2)throw new Error("[RenderTargetSystem] Rendering to array layers requires WebGL2.");if(i>0){if(u.msaa)throw new Error("[RenderTargetSystem] Rendering to mip levels is not supported with MSAA render targets.");if(this._renderer.context.webGLVersion<2)throw new Error("[RenderTargetSystem] Rendering to mip levels requires WebGL2.")}let _=s.y;e.isRoot&&(_=c.pixelHeight-s.height-s.y),e.colorTextures.forEach(m=>{this._renderer.texture.unbind(m)});const f=this._renderer.gl;f.bindFramebuffer(f.FRAMEBUFFER,u.framebuffer),!e.isRoot&&(u._attachedMipLevel!==i||u._attachedLayer!==a)&&(e.colorTextures.forEach((m,b)=>{const E=this._renderer.texture.getGlSource(m);if(E.target===f.TEXTURE_2D){if(a!==0)throw new Error("[RenderTargetSystem] layer must be 0 when rendering to 2D textures in WebGL.");f.framebufferTexture2D(f.FRAMEBUFFER,f.COLOR_ATTACHMENT0+b,f.TEXTURE_2D,E.texture,i)}else if(E.target===f.TEXTURE_2D_ARRAY){if(this._renderer.context.webGLVersion<2)throw new Error("[RenderTargetSystem] Rendering to 2D array textures requires WebGL2.");f.framebufferTextureLayer(f.FRAMEBUFFER,f.COLOR_ATTACHMENT0+b,E.texture,i,a)}else if(E.target===f.TEXTURE_CUBE_MAP){if(a<0||a>5)throw new Error("[RenderTargetSystem] Cube map layer must be between 0 and 5.");f.framebufferTexture2D(f.FRAMEBUFFER,f.COLOR_ATTACHMENT0+b,f.TEXTURE_CUBE_MAP_POSITIVE_X+a,E.texture,i)}else throw new Error("[RenderTargetSystem] Unsupported texture target for render-to-layer in WebGL.")}),u._attachedMipLevel=i,u._attachedLayer=a),e.colorTextures.length>1&&this._setDrawBuffers(e,f);const l=this._viewPortCache;(l.x!==s.x||l.y!==_||l.width!==s.width||l.height!==s.height)&&(l.x=s.x,l.y=_,l.width=s.width,l.height=s.height,f.viewport(s.x,_,s.width,s.height)),!u.depthStencilRenderBuffer&&(e.stencil||e.depth)&&this._initStencil(u),this.clear(e,r,n)}finishRenderPass(e){const n=this._renderTargetSystem.getGpuRenderTarget(e);if(!n.msaa)return;const s=this._renderer.gl;s.bindFramebuffer(s.FRAMEBUFFER,n.resolveTargetFramebuffer),s.bindFramebuffer(s.READ_FRAMEBUFFER,n.framebuffer),s.blitFramebuffer(0,0,n.width,n.height,0,0,n.width,n.height,s.COLOR_BUFFER_BIT,s.NEAREST),s.bindFramebuffer(s.FRAMEBUFFER,n.framebuffer)}initGpuRenderTarget(e){const n=this._renderer.gl,s=new et;return s._attachedMipLevel=0,s._attachedLayer=0,e.colorTexture instanceof y?(this._renderer.context.ensureCanvasSize(e.colorTexture.resource),s.framebuffer=null,s):(this._initColor(e,s),n.bindFramebuffer(n.FRAMEBUFFER,null),s)}destroyGpuRenderTarget(e){const r=this._renderer.gl;e.framebuffer&&(r.deleteFramebuffer(e.framebuffer),e.framebuffer=null),e.resolveTargetFramebuffer&&(r.deleteFramebuffer(e.resolveTargetFramebuffer),e.resolveTargetFramebuffer=null),e.depthStencilRenderBuffer&&(r.deleteRenderbuffer(e.depthStencilRenderBuffer),e.depthStencilRenderBuffer=null),e.msaaRenderBuffer.forEach(n=>{r.deleteRenderbuffer(n)}),e.msaaRenderBuffer=null}clear(e,r,n,s,i=0,a=0){if(!r)return;if(a!==0)throw new Error("[RenderTargetSystem] Clearing array layers is not supported in WebGL renderer.");const o=this._renderTargetSystem;typeof r=="boolean"&&(r=r?C.ALL:C.NONE);const c=this._renderer.gl;if(r&C.COLOR){n??(n=o.defaultClearColor);const u=this._clearColorCache,_=n;(u[0]!==_[0]||u[1]!==_[1]||u[2]!==_[2]||u[3]!==_[3])&&(u[0]=_[0],u[1]=_[1],u[2]=_[2],u[3]=_[3],c.clearColor(_[0],_[1],_[2],_[3]))}c.clear(r)}resizeGpuRenderTarget(e){if(e.isRoot)return;const n=this._renderTargetSystem.getGpuRenderTarget(e);this._resizeColor(e,n),(e.stencil||e.depth)&&this._resizeStencil(n)}_initColor(e,r){const n=this._renderer,s=n.gl,i=s.createFramebuffer();if(r.resolveTargetFramebuffer=i,s.bindFramebuffer(s.FRAMEBUFFER,i),r.width=e.colorTexture.source.pixelWidth,r.height=e.colorTexture.source.pixelHeight,e.colorTextures.forEach((o,c)=>{const u=o.source;u.antialias&&(n.context.supports.msaa?r.msaa=!0:p("[RenderTexture] Antialiasing on textures is not supported in WebGL1")),n.texture.bindSource(u,0);const _=n.texture.getGlSource(u),f=_.texture;if(_.target===s.TEXTURE_2D)s.framebufferTexture2D(s.FRAMEBUFFER,s.COLOR_ATTACHMENT0+c,s.TEXTURE_2D,f,0);else if(_.target===s.TEXTURE_2D_ARRAY){if(n.context.webGLVersion<2)throw new Error("[RenderTargetSystem] TEXTURE_2D_ARRAY requires WebGL2.");s.framebufferTextureLayer(s.FRAMEBUFFER,s.COLOR_ATTACHMENT0+c,f,0,0)}else if(_.target===s.TEXTURE_CUBE_MAP)s.framebufferTexture2D(s.FRAMEBUFFER,s.COLOR_ATTACHMENT0+c,s.TEXTURE_CUBE_MAP_POSITIVE_X,f,0);else throw new Error("[RenderTargetSystem] Unsupported texture target for framebuffer attachment.")}),r.msaa){const o=s.createFramebuffer();r.framebuffer=o,s.bindFramebuffer(s.FRAMEBUFFER,o),e.colorTextures.forEach((c,u)=>{const _=s.createRenderbuffer();r.msaaRenderBuffer[u]=_})}else r.framebuffer=i;this._resizeColor(e,r)}_resizeColor(e,r){const n=e.colorTexture.source;if(r.width=n.pixelWidth,r.height=n.pixelHeight,r._attachedMipLevel=0,r._attachedLayer=0,e.colorTextures.forEach((s,i)=>{i!==0&&s.source.resize(n.width,n.height,n._resolution)}),r.msaa){const s=this._renderer,i=s.gl,a=r.framebuffer;i.bindFramebuffer(i.FRAMEBUFFER,a),e.colorTextures.forEach((o,c)=>{const u=o.source;s.texture.bindSource(u,0);const f=s.texture.getGlSource(u).internalFormat,l=r.msaaRenderBuffer[c];i.bindRenderbuffer(i.RENDERBUFFER,l),i.renderbufferStorageMultisample(i.RENDERBUFFER,4,f,u.pixelWidth,u.pixelHeight),i.framebufferRenderbuffer(i.FRAMEBUFFER,i.COLOR_ATTACHMENT0+c,i.RENDERBUFFER,l)})}}_initStencil(e){if(e.framebuffer===null)return;const r=this._renderer.gl,n=r.createRenderbuffer();e.depthStencilRenderBuffer=n,r.bindRenderbuffer(r.RENDERBUFFER,n),r.framebufferRenderbuffer(r.FRAMEBUFFER,r.DEPTH_STENCIL_ATTACHMENT,r.RENDERBUFFER,n),this._resizeStencil(e)}_resizeStencil(e){const r=this._renderer.gl;r.bindRenderbuffer(r.RENDERBUFFER,e.depthStencilRenderBuffer),e.msaa?r.renderbufferStorageMultisample(r.RENDERBUFFER,4,r.DEPTH24_STENCIL8,e.width,e.height):r.renderbufferStorage(r.RENDERBUFFER,this._renderer.context.webGLVersion===2?r.DEPTH24_STENCIL8:r.DEPTH_STENCIL,e.width,e.height)}prerender(e){const r=e.colorTexture.resource;this._renderer.context.multiView&&y.test(r)&&this._renderer.context.ensureCanvasSize(r)}postrender(e){if(this._renderer.context.multiView&&y.test(e.colorTexture.resource)){const r=this._renderer.context.canvas,n=e.colorTexture;n.context2D.drawImage(r,0,n.pixelHeight-r.height)}}_setDrawBuffers(e,r){const n=e.colorTextures.length,s=this._drawBuffersCache[n];if(this._renderer.context.webGLVersion===1){const i=this._renderer.context.extensions.drawBuffers;i?i.drawBuffersWEBGL(s):p("[RenderTexture] This WebGL1 context does not support rendering to multiple targets")}else r.drawBuffers(s)}}class de extends ke{constructor(e){super(e),this.adaptor=new st,this.adaptor.init(e,this)}}de.extension={type:[d.WebGLSystem],name:"renderTarget"};function it(t,e){const r=[],n=[` + var g = s.groups; + var sS = r.shader; + var p = s.glProgram; + var ugS = r.uniformGroup; + var resources; + `];let s=!1,i=0;const a=e._getProgramData(t.glProgram);for(const c in t.groups){const u=t.groups[c];r.push(` + resources = g[${c}].resources; + `);for(const _ in u.resources){const f=u.resources[_];if(f instanceof O)if(f.ubo){const l=t._uniformBindMap[c][Number(_)];r.push(` + sS.bindUniformBlock( + resources[${_}], + '${l}', + ${t.glProgram._uniformBlockData[l].index} + ); + `)}else r.push(` + ugS.updateUniformGroup(resources[${_}], p, sD); + `);else if(f instanceof te){const l=t._uniformBindMap[c][Number(_)];r.push(` + sS.bindUniformBlock( + resources[${_}], + '${l}', + ${t.glProgram._uniformBlockData[l].index} + ); + `)}else if(f instanceof Z){const l=t._uniformBindMap[c][_],m=a.uniformData[l];m&&(s||(s=!0,n.push(` + var tS = r.texture; + `)),e._gl.uniform1i(m.location,i),r.push(` + tS.bind(resources[${_}], ${i}); + `),i++)}}}const o=[...n,...r].join(` +`);return new Function("r","s","sD",o)}class at{constructor(e,r){this.program=e,this.uniformData=r,this.uniformGroups={},this.uniformDirtyGroups={},this.uniformBlockBindings={}}destroy(){this.uniformData=null,this.uniformGroups=null,this.uniformDirtyGroups=null,this.uniformBlockBindings=null,this.program=null}}function W(t,e,r){const n=t.createShader(e);return t.shaderSource(n,r),t.compileShader(n),n}function D(t){const e=new Array(t);for(let r=0;r<e.length;r++)e[r]=!1;return e}function me(t,e){switch(t){case"float":return 0;case"vec2":return new Float32Array(2*e);case"vec3":return new Float32Array(3*e);case"vec4":return new Float32Array(4*e);case"int":case"uint":case"sampler2D":case"sampler2DArray":return 0;case"ivec2":return new Int32Array(2*e);case"ivec3":return new Int32Array(3*e);case"ivec4":return new Int32Array(4*e);case"uvec2":return new Uint32Array(2*e);case"uvec3":return new Uint32Array(3*e);case"uvec4":return new Uint32Array(4*e);case"bool":return!1;case"bvec2":return D(2*e);case"bvec3":return D(3*e);case"bvec4":return D(4*e);case"mat2":return new Float32Array([1,0,0,1]);case"mat3":return new Float32Array([1,0,0,0,1,0,0,0,1]);case"mat4":return new Float32Array([1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1])}return null}let x=null;const j={FLOAT:"float",FLOAT_VEC2:"vec2",FLOAT_VEC3:"vec3",FLOAT_VEC4:"vec4",INT:"int",INT_VEC2:"ivec2",INT_VEC3:"ivec3",INT_VEC4:"ivec4",UNSIGNED_INT:"uint",UNSIGNED_INT_VEC2:"uvec2",UNSIGNED_INT_VEC3:"uvec3",UNSIGNED_INT_VEC4:"uvec4",BOOL:"bool",BOOL_VEC2:"bvec2",BOOL_VEC3:"bvec3",BOOL_VEC4:"bvec4",FLOAT_MAT2:"mat2",FLOAT_MAT3:"mat3",FLOAT_MAT4:"mat4",SAMPLER_2D:"sampler2D",INT_SAMPLER_2D:"sampler2D",UNSIGNED_INT_SAMPLER_2D:"sampler2D",SAMPLER_CUBE:"samplerCube",INT_SAMPLER_CUBE:"samplerCube",UNSIGNED_INT_SAMPLER_CUBE:"samplerCube",SAMPLER_2D_ARRAY:"sampler2DArray",INT_SAMPLER_2D_ARRAY:"sampler2DArray",UNSIGNED_INT_SAMPLER_2D_ARRAY:"sampler2DArray"},ot={float:"float32",vec2:"float32x2",vec3:"float32x3",vec4:"float32x4",int:"sint32",ivec2:"sint32x2",ivec3:"sint32x3",ivec4:"sint32x4",uint:"uint32",uvec2:"uint32x2",uvec3:"uint32x3",uvec4:"uint32x4",bool:"uint32",bvec2:"uint32x2",bvec3:"uint32x3",bvec4:"uint32x4"};function Ee(t,e){if(!x){const r=Object.keys(j);x={};for(let n=0;n<r.length;++n){const s=r[n];x[t[s]]=j[s]}}return x[e]}function ct(t,e){const r=Ee(t,e);return ot[r]||"float32"}function ut(t,e,r=!1){const n={},s=e.getProgramParameter(t,e.ACTIVE_ATTRIBUTES);for(let a=0;a<s;a++){const o=e.getActiveAttrib(t,a);if(o.name.startsWith("gl_"))continue;const c=ct(e,o.type);n[o.name]={location:0,format:c,stride:q(c).stride,offset:0,instance:!1,start:0}}const i=Object.keys(n);if(r){i.sort((a,o)=>a>o?1:-1);for(let a=0;a<i.length;a++)n[i[a]].location=a,e.bindAttribLocation(t,a,i[a]);e.linkProgram(t)}else for(let a=0;a<i.length;a++)n[i[a]].location=e.getAttribLocation(t,i[a]);return n}function _t(t,e){if(!e.ACTIVE_UNIFORM_BLOCKS)return{};const r={},n=e.getProgramParameter(t,e.ACTIVE_UNIFORM_BLOCKS);for(let s=0;s<n;s++){const i=e.getActiveUniformBlockName(t,s),a=e.getUniformBlockIndex(t,i),o=e.getActiveUniformBlockParameter(t,s,e.UNIFORM_BLOCK_DATA_SIZE);r[i]={name:i,index:a,size:o}}return r}function ft(t,e){const r={},n=e.getProgramParameter(t,e.ACTIVE_UNIFORMS);for(let s=0;s<n;s++){const i=e.getActiveUniform(t,s),a=i.name.replace(/\[.*?\]$/,""),o=!!i.name.match(/\[.*?\]$/),c=Ee(e,i.type);r[a]={name:a,index:s,type:c,size:i.size,isArray:o,value:me(c,i.size)}}return r}function K(t,e){const r=t.getShaderSource(e);if(r===null){console.error("PixiJS Error: Could not retrieve shader source (WebGL context may be lost).");return}const n=r.split(` +`).map((_,f)=>`${f}: ${_}`),s=t.getShaderInfoLog(e)??"",i=s.split(` +`),a={},o=i.map(_=>parseFloat(_.replace(/^ERROR\: 0\:([\d]+)\:.*$/,"$1"))).filter(_=>_&&!a[_]?(a[_]=!0,!0):!1),c=[""];o.forEach(_=>{n[_-1]=`%c${n[_-1]}%c`,c.push("background: #FF0000; color:#FFFFFF; font-size: 10px","font-size: 10px")});const u=n.join(` +`);c[0]=u,console.error(s),console.groupCollapsed("click to view full shader code"),console.warn(...c),console.groupEnd()}function lt(t,e,r,n){t.getProgramParameter(e,t.LINK_STATUS)||(t.getShaderParameter(r,t.COMPILE_STATUS)||K(t,r),t.getShaderParameter(n,t.COMPILE_STATUS)||K(t,n),console.error("PixiJS Error: Could not initialize shader."),t.getProgramInfoLog(e)!==""&&console.warn("PixiJS Warning: gl.getProgramInfoLog()",t.getProgramInfoLog(e)))}function ht(t,e){const r=W(t,t.VERTEX_SHADER,e.vertex),n=W(t,t.FRAGMENT_SHADER,e.fragment),s=t.createProgram();t.attachShader(s,r),t.attachShader(s,n);const i=e.transformFeedbackVaryings;i&&(typeof t.transformFeedbackVaryings!="function"?p("TransformFeedback is not supported but TransformFeedbackVaryings are given."):t.transformFeedbackVaryings(s,i.names,i.bufferMode==="separate"?t.SEPARATE_ATTRIBS:t.INTERLEAVED_ATTRIBS)),t.linkProgram(s),t.getProgramParameter(s,t.LINK_STATUS)||lt(t,s,r,n),e._attributeData=ut(s,t,!/^[ \t]*#[ \t]*version[ \t]+300[ \t]+es[ \t]*$/m.test(e.vertex)),e._uniformData=ft(s,t),e._uniformBlockData=_t(s,t),t.deleteShader(r),t.deleteShader(n);const a={};for(const c in e._uniformData){const u=e._uniformData[c];a[c]={location:t.getUniformLocation(s,c),value:me(u.type,u.size)}}return new at(s,a)}const v={textureCount:0,blockIndex:0};class be{constructor(e){this._activeProgram=null,this._programDataHash=Object.create(null),this._shaderSyncFunctions=Object.create(null),this._renderer=e}contextChange(e){this._gl=e,this._programDataHash=Object.create(null),this._shaderSyncFunctions=Object.create(null),this._activeProgram=null}bind(e,r){if(this._setProgram(e.glProgram),r)return;v.textureCount=0,v.blockIndex=0;let n=this._shaderSyncFunctions[e.glProgram._key];n||(n=this._shaderSyncFunctions[e.glProgram._key]=this._generateShaderSync(e,this)),this._renderer.buffer.nextBindBase(!!e.glProgram.transformFeedbackVaryings),n(this._renderer,e,v)}updateUniformGroup(e){this._renderer.uniformGroup.updateUniformGroup(e,this._activeProgram,v)}bindUniformBlock(e,r,n=0){const s=this._renderer.buffer,i=this._getProgramData(this._activeProgram),a=e._bufferResource;a||this._renderer.ubo.updateUniformGroup(e);const o=e.buffer,c=s.updateBuffer(o),u=s.freeLocationForBufferBase(c);if(a){const{offset:f,size:l}=e;f===0&&l===o.data.byteLength?s.bindBufferBase(c,u):s.bindBufferRange(c,u,f)}else s.getLastBindBaseLocation(c)!==u&&s.bindBufferBase(c,u);const _=this._activeProgram._uniformBlockData[r].index;i.uniformBlockBindings[n]!==u&&(i.uniformBlockBindings[n]=u,this._renderer.gl.uniformBlockBinding(i.program,_,u))}_setProgram(e){if(this._activeProgram===e)return;this._activeProgram=e;const r=this._getProgramData(e);this._gl.useProgram(r.program)}_getProgramData(e){return this._programDataHash[e._key]||this._createProgramData(e)}_createProgramData(e){const r=e._key;return this._programDataHash[r]=ht(this._gl,e),this._programDataHash[r]}destroy(){for(const e of Object.keys(this._programDataHash))this._programDataHash[e].destroy();this._programDataHash=null,this._shaderSyncFunctions=null,this._activeProgram=null,this._renderer=null,this._gl=null}_generateShaderSync(e,r){return it(e,r)}resetState(){this._activeProgram=null}}be.extension={type:[d.WebGLSystem],name:"shader"};const dt={f32:`if (cv !== v) { + cu.value = v; + gl.uniform1f(location, v); + }`,"vec2<f32>":`if (cv[0] !== v[0] || cv[1] !== v[1]) { + cv[0] = v[0]; + cv[1] = v[1]; + gl.uniform2f(location, v[0], v[1]); + }`,"vec3<f32>":`if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2]) { + cv[0] = v[0]; + cv[1] = v[1]; + cv[2] = v[2]; + gl.uniform3f(location, v[0], v[1], v[2]); + }`,"vec4<f32>":`if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2] || cv[3] !== v[3]) { + cv[0] = v[0]; + cv[1] = v[1]; + cv[2] = v[2]; + cv[3] = v[3]; + gl.uniform4f(location, v[0], v[1], v[2], v[3]); + }`,i32:`if (cv !== v) { + cu.value = v; + gl.uniform1i(location, v); + }`,"vec2<i32>":`if (cv[0] !== v[0] || cv[1] !== v[1]) { + cv[0] = v[0]; + cv[1] = v[1]; + gl.uniform2i(location, v[0], v[1]); + }`,"vec3<i32>":`if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2]) { + cv[0] = v[0]; + cv[1] = v[1]; + cv[2] = v[2]; + gl.uniform3i(location, v[0], v[1], v[2]); + }`,"vec4<i32>":`if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2] || cv[3] !== v[3]) { + cv[0] = v[0]; + cv[1] = v[1]; + cv[2] = v[2]; + cv[3] = v[3]; + gl.uniform4i(location, v[0], v[1], v[2], v[3]); + }`,u32:`if (cv !== v) { + cu.value = v; + gl.uniform1ui(location, v); + }`,"vec2<u32>":`if (cv[0] !== v[0] || cv[1] !== v[1]) { + cv[0] = v[0]; + cv[1] = v[1]; + gl.uniform2ui(location, v[0], v[1]); + }`,"vec3<u32>":`if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2]) { + cv[0] = v[0]; + cv[1] = v[1]; + cv[2] = v[2]; + gl.uniform3ui(location, v[0], v[1], v[2]); + }`,"vec4<u32>":`if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2] || cv[3] !== v[3]) { + cv[0] = v[0]; + cv[1] = v[1]; + cv[2] = v[2]; + cv[3] = v[3]; + gl.uniform4ui(location, v[0], v[1], v[2], v[3]); + }`,bool:`if (cv !== v) { + cu.value = v; + gl.uniform1i(location, v); + }`,"vec2<bool>":`if (cv[0] !== v[0] || cv[1] !== v[1]) { + cv[0] = v[0]; + cv[1] = v[1]; + gl.uniform2i(location, v[0], v[1]); + }`,"vec3<bool>":`if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2]) { + cv[0] = v[0]; + cv[1] = v[1]; + cv[2] = v[2]; + gl.uniform3i(location, v[0], v[1], v[2]); + }`,"vec4<bool>":`if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2] || cv[3] !== v[3]) { + cv[0] = v[0]; + cv[1] = v[1]; + cv[2] = v[2]; + cv[3] = v[3]; + gl.uniform4i(location, v[0], v[1], v[2], v[3]); + }`,"mat2x2<f32>":"gl.uniformMatrix2fv(location, false, v);","mat3x3<f32>":"gl.uniformMatrix3fv(location, false, v);","mat4x4<f32>":"gl.uniformMatrix4fv(location, false, v);"},mt={f32:"gl.uniform1fv(location, v);","vec2<f32>":"gl.uniform2fv(location, v);","vec3<f32>":"gl.uniform3fv(location, v);","vec4<f32>":"gl.uniform4fv(location, v);","mat2x2<f32>":"gl.uniformMatrix2fv(location, false, v);","mat3x3<f32>":"gl.uniformMatrix3fv(location, false, v);","mat4x4<f32>":"gl.uniformMatrix4fv(location, false, v);",i32:"gl.uniform1iv(location, v);","vec2<i32>":"gl.uniform2iv(location, v);","vec3<i32>":"gl.uniform3iv(location, v);","vec4<i32>":"gl.uniform4iv(location, v);",u32:"gl.uniform1iv(location, v);","vec2<u32>":"gl.uniform2iv(location, v);","vec3<u32>":"gl.uniform3iv(location, v);","vec4<u32>":"gl.uniform4iv(location, v);",bool:"gl.uniform1iv(location, v);","vec2<bool>":"gl.uniform2iv(location, v);","vec3<bool>":"gl.uniform3iv(location, v);","vec4<bool>":"gl.uniform4iv(location, v);"};function Et(t,e){const r=[` + var v = null; + var cv = null; + var cu = null; + var t = 0; + var gl = renderer.gl; + var name = null; + `];for(const n in t.uniforms){if(!e[n]){t.uniforms[n]instanceof O?t.uniforms[n].ubo?r.push(` + renderer.shader.bindUniformBlock(uv.${n}, "${n}"); + `):r.push(` + renderer.shader.updateUniformGroup(uv.${n}); + `):t.uniforms[n]instanceof te&&r.push(` + renderer.shader.bindBufferResource(uv.${n}, "${n}"); + `);continue}const s=t.uniformStructures[n];let i=!1;for(let a=0;a<N.length;a++){const o=N[a];if(s.type===o.type&&o.test(s)){r.push(`name = "${n}";`,N[a].uniform),i=!0;break}}if(!i){const o=(s.size===1?dt:mt)[s.type].replace("location",`ud["${n}"].location`);r.push(` + cu = ud["${n}"]; + cv = cu.value; + v = uv["${n}"]; + ${o};`)}}return new Function("ud","uv","renderer","syncData",r.join(` +`))}class pe{constructor(e){this._cache={},this._uniformGroupSyncHash={},this._renderer=e,this.gl=null,this._cache={}}contextChange(e){this.gl=e}updateUniformGroup(e,r,n){const s=this._renderer.shader._getProgramData(r);(!e.isStatic||e._dirtyId!==s.uniformDirtyGroups[e.uid])&&(s.uniformDirtyGroups[e.uid]=e._dirtyId,this._getUniformSyncFunction(e,r)(s.uniformData,e.uniforms,this._renderer,n))}_getUniformSyncFunction(e,r){var n;return((n=this._uniformGroupSyncHash[e._signature])==null?void 0:n[r._key])||this._createUniformSyncFunction(e,r)}_createUniformSyncFunction(e,r){const n=this._uniformGroupSyncHash[e._signature]||(this._uniformGroupSyncHash[e._signature]={}),s=this._getSignature(e,r._uniformData,"u");return this._cache[s]||(this._cache[s]=this._generateUniformsSync(e,r._uniformData)),n[r._key]=this._cache[s],n[r._key]}_generateUniformsSync(e,r){return Et(e,r)}_getSignature(e,r,n){const s=e.uniforms,i=[`${n}-`];for(const a in s)i.push(a),r[a]&&i.push(r[a].type);return i.join("-")}destroy(){this._renderer=null,this._cache=null}}pe.extension={type:[d.WebGLSystem],name:"uniformGroup"};function bt(t){const e={};if(e.normal=[t.ONE,t.ONE_MINUS_SRC_ALPHA],e.add=[t.ONE,t.ONE],e.multiply=[t.DST_COLOR,t.ONE_MINUS_SRC_ALPHA,t.ONE,t.ONE_MINUS_SRC_ALPHA],e.screen=[t.ONE,t.ONE_MINUS_SRC_COLOR,t.ONE,t.ONE_MINUS_SRC_ALPHA],e.none=[0,0],e["normal-npm"]=[t.SRC_ALPHA,t.ONE_MINUS_SRC_ALPHA,t.ONE,t.ONE_MINUS_SRC_ALPHA],e["add-npm"]=[t.SRC_ALPHA,t.ONE,t.ONE,t.ONE],e["screen-npm"]=[t.SRC_ALPHA,t.ONE_MINUS_SRC_COLOR,t.ONE,t.ONE_MINUS_SRC_ALPHA],e.erase=[t.ZERO,t.ONE_MINUS_SRC_ALPHA],!(t instanceof R.get().getWebGLRenderingContext()))e.min=[t.ONE,t.ONE,t.ONE,t.ONE,t.MIN,t.MIN],e.max=[t.ONE,t.ONE,t.ONE,t.ONE,t.MAX,t.MAX];else{const n=t.getExtension("EXT_blend_minmax");n&&(e.min=[t.ONE,t.ONE,t.ONE,t.ONE,n.MIN_EXT,n.MIN_EXT],e.max=[t.ONE,t.ONE,t.ONE,t.ONE,n.MAX_EXT,n.MAX_EXT])}return e}const pt=0,St=1,Rt=2,gt=3,Tt=4,xt=5,Se=class U{constructor(e){this._invertFrontFace=!1,this.gl=null,this.stateId=0,this.polygonOffset=0,this.blendMode="none",this._blendEq=!1,this.map=[],this.map[pt]=this.setBlend,this.map[St]=this.setOffset,this.map[Rt]=this.setCullFace,this.map[gt]=this.setDepthTest,this.map[Tt]=this.setFrontFace,this.map[xt]=this.setDepthMask,this.checks=[],this.defaultState=M.for2d(),e.renderTarget.onRenderTargetChange.add(this)}onRenderTargetChange(e){this._invertFrontFace=!e.isRoot,this._cullFace?this.setFrontFace(this._frontFace):this._frontFaceDirty=!0}contextChange(e){this.gl=e,this.blendModesMap=bt(e),this.resetState()}set(e){if(e||(e=this.defaultState),this.stateId!==e.data){let r=this.stateId^e.data,n=0;for(;r;)r&1&&this.map[n].call(this,!!(e.data&1<<n)),r>>=1,n++;this.stateId=e.data}for(let r=0;r<this.checks.length;r++)this.checks[r](this,e)}forceState(e){e||(e=this.defaultState);for(let r=0;r<this.map.length;r++)this.map[r].call(this,!!(e.data&1<<r));for(let r=0;r<this.checks.length;r++)this.checks[r](this,e);this.stateId=e.data}setBlend(e){this._updateCheck(U._checkBlendMode,e),this.gl[e?"enable":"disable"](this.gl.BLEND)}setOffset(e){this._updateCheck(U._checkPolygonOffset,e),this.gl[e?"enable":"disable"](this.gl.POLYGON_OFFSET_FILL)}setDepthTest(e){this.gl[e?"enable":"disable"](this.gl.DEPTH_TEST)}setDepthMask(e){this.gl.depthMask(e)}setCullFace(e){this._cullFace=e,this.gl[e?"enable":"disable"](this.gl.CULL_FACE),this._cullFace&&this._frontFaceDirty&&this.setFrontFace(this._frontFace)}setFrontFace(e){this._frontFace=e,this._frontFaceDirty=!1;const r=this._invertFrontFace?!e:e;this._glFrontFace!==r&&(this._glFrontFace=r,this.gl.frontFace(this.gl[r?"CW":"CCW"]))}setBlendMode(e){if(this.blendModesMap[e]||(e="normal"),e===this.blendMode)return;this.blendMode=e;const r=this.blendModesMap[e],n=this.gl;r.length===2?n.blendFunc(r[0],r[1]):n.blendFuncSeparate(r[0],r[1],r[2],r[3]),r.length===6?(this._blendEq=!0,n.blendEquationSeparate(r[4],r[5])):this._blendEq&&(this._blendEq=!1,n.blendEquationSeparate(n.FUNC_ADD,n.FUNC_ADD))}setPolygonOffset(e,r){this.gl.polygonOffset(e,r)}resetState(){this._glFrontFace=!1,this._frontFace=!1,this._cullFace=!1,this._frontFaceDirty=!1,this._invertFrontFace=!1,this.gl.frontFace(this.gl.CCW),this.gl.pixelStorei(this.gl.UNPACK_FLIP_Y_WEBGL,!1),this.forceState(this.defaultState),this._blendEq=!0,this.blendMode="",this.setBlendMode("normal")}_updateCheck(e,r){const n=this.checks.indexOf(e);r&&n===-1?this.checks.push(e):!r&&n!==-1&&this.checks.splice(n,1)}static _checkBlendMode(e,r){e.setBlendMode(r.blendMode)}static _checkPolygonOffset(e,r){e.setPolygonOffset(1,r.polygonOffset)}destroy(){this.gl=null,this.checks.length=0}};Se.extension={type:[d.WebGLSystem],name:"state"};let vt=Se;class At{constructor(e){this.target=w.TEXTURE_2D,this._layerInitMask=0,this.texture=e,this.width=-1,this.height=-1,this.type=h.UNSIGNED_BYTE,this.internalFormat=G.RGBA,this.format=G.RGBA,this.samplerType=0}destroy(){}}const Bt={id:"buffer",upload(t,e,r,n,s,i=!1){const a=s||e.target;!i&&e.width===t.width&&e.height===t.height?r.texSubImage2D(a,0,0,0,t.width,t.height,e.format,e.type,t.resource):r.texImage2D(a,0,e.internalFormat,t.width,t.height,0,e.format,e.type,t.resource),e.width=t.width,e.height=t.height}},yt={"bc1-rgba-unorm":!0,"bc1-rgba-unorm-srgb":!0,"bc2-rgba-unorm":!0,"bc2-rgba-unorm-srgb":!0,"bc3-rgba-unorm":!0,"bc3-rgba-unorm-srgb":!0,"bc4-r-unorm":!0,"bc4-r-snorm":!0,"bc5-rg-unorm":!0,"bc5-rg-snorm":!0,"bc6h-rgb-ufloat":!0,"bc6h-rgb-float":!0,"bc7-rgba-unorm":!0,"bc7-rgba-unorm-srgb":!0,"etc2-rgb8unorm":!0,"etc2-rgb8unorm-srgb":!0,"etc2-rgb8a1unorm":!0,"etc2-rgb8a1unorm-srgb":!0,"etc2-rgba8unorm":!0,"etc2-rgba8unorm-srgb":!0,"eac-r11unorm":!0,"eac-r11snorm":!0,"eac-rg11unorm":!0,"eac-rg11snorm":!0,"astc-4x4-unorm":!0,"astc-4x4-unorm-srgb":!0,"astc-5x4-unorm":!0,"astc-5x4-unorm-srgb":!0,"astc-5x5-unorm":!0,"astc-5x5-unorm-srgb":!0,"astc-6x5-unorm":!0,"astc-6x5-unorm-srgb":!0,"astc-6x6-unorm":!0,"astc-6x6-unorm-srgb":!0,"astc-8x5-unorm":!0,"astc-8x5-unorm-srgb":!0,"astc-8x6-unorm":!0,"astc-8x6-unorm-srgb":!0,"astc-8x8-unorm":!0,"astc-8x8-unorm-srgb":!0,"astc-10x5-unorm":!0,"astc-10x5-unorm-srgb":!0,"astc-10x6-unorm":!0,"astc-10x6-unorm-srgb":!0,"astc-10x8-unorm":!0,"astc-10x8-unorm-srgb":!0,"astc-10x10-unorm":!0,"astc-10x10-unorm-srgb":!0,"astc-12x10-unorm":!0,"astc-12x10-unorm-srgb":!0,"astc-12x12-unorm":!0,"astc-12x12-unorm-srgb":!0},Ct={id:"compressed",upload(t,e,r,n,s,i){const a=s??e.target;r.pixelStorei(r.UNPACK_ALIGNMENT,4);let o=t.pixelWidth,c=t.pixelHeight;const u=!!yt[t.format];for(let _=0;_<t.resource.length;_++){const f=t.resource[_];u?r.compressedTexImage2D(a,_,e.internalFormat,o,c,0,f):r.texImage2D(a,_,e.internalFormat,o,c,0,e.format,e.type,f),o=Math.max(o>>1,1),c=Math.max(c>>1,1)}}},$=["right","left","top","bottom","front","back"];function Nt(t){return{id:"cube",upload(e,r,n,s){const i=e.faces;for(let a=0;a<$.length;a++){const o=$[a],c=i[o];(t[c.uploadMethodId]||t.image).upload(c,r,n,s,w.TEXTURE_CUBE_MAP_POSITIVE_X+a,(r._layerInitMask&1<<a)===0),r._layerInitMask|=1<<a}r.width=e.pixelWidth,r.height=e.pixelHeight}}}const Re={id:"image",upload(t,e,r,n,s,i=!1){const a=s||e.target,o=t.pixelWidth,c=t.pixelHeight,u=t.resourceWidth,_=t.resourceHeight,f=n===2,l=i||e.width!==o||e.height!==c,m=u>=o&&_>=c,b=t.resource;(f?Dt:It)(r,a,e,o,c,u,_,b,l,m),e.width=o,e.height=c}};function Dt(t,e,r,n,s,i,a,o,c,u){if(!u){c&&t.texImage2D(e,0,r.internalFormat,n,s,0,r.format,r.type,null),t.texSubImage2D(e,0,0,0,i,a,r.format,r.type,o);return}if(!c){t.texSubImage2D(e,0,0,0,r.format,r.type,o);return}t.texImage2D(e,0,r.internalFormat,n,s,0,r.format,r.type,o)}function It(t,e,r,n,s,i,a,o,c,u){if(!u){c&&t.texImage2D(e,0,r.internalFormat,n,s,0,r.format,r.type,null),t.texSubImage2D(e,0,0,0,r.format,r.type,o);return}if(!c){t.texSubImage2D(e,0,0,0,r.format,r.type,o);return}t.texImage2D(e,0,r.internalFormat,r.format,r.type,o)}const Gt=Ke(),Ut={id:"video",upload(t,e,r,n,s,i=Gt){if(!t.isValid){const a=s??e.target;r.texImage2D(a,0,e.internalFormat,1,1,0,e.format,e.type,null);return}Re.upload(t,e,r,n,s,i)}},Y={linear:9729,nearest:9728},Ft={linear:{linear:9987,nearest:9985},nearest:{linear:9986,nearest:9984}},I={"clamp-to-edge":33071,repeat:10497,"mirror-repeat":33648},Pt={never:512,less:513,equal:514,"less-equal":515,greater:516,"not-equal":517,"greater-equal":518,always:519};function z(t,e,r,n,s,i,a,o){const c=i;if(!o||t.addressModeU!=="repeat"||t.addressModeV!=="repeat"||t.addressModeW!=="repeat"){const u=I[a?"clamp-to-edge":t.addressModeU],_=I[a?"clamp-to-edge":t.addressModeV],f=I[a?"clamp-to-edge":t.addressModeW];e[s](c,e.TEXTURE_WRAP_S,u),e[s](c,e.TEXTURE_WRAP_T,_),e.TEXTURE_WRAP_R&&e[s](c,e.TEXTURE_WRAP_R,f)}if((!o||t.magFilter!=="linear")&&e[s](c,e.TEXTURE_MAG_FILTER,Y[t.magFilter]),r){if(!o||t.mipmapFilter!=="linear"){const u=Ft[t.minFilter][t.mipmapFilter];e[s](c,e.TEXTURE_MIN_FILTER,u)}}else e[s](c,e.TEXTURE_MIN_FILTER,Y[t.minFilter]);if(n&&t.maxAnisotropy>1){const u=Math.min(t.maxAnisotropy,e.getParameter(n.MAX_TEXTURE_MAX_ANISOTROPY_EXT));e[s](c,n.TEXTURE_MAX_ANISOTROPY_EXT,u)}t.compare&&e[s](c,e.TEXTURE_COMPARE_FUNC,Pt[t.compare])}function Ot(t){return{r8unorm:t.RED,r8snorm:t.RED,r8uint:t.RED,r8sint:t.RED,r16uint:t.RED,r16sint:t.RED,r16float:t.RED,rg8unorm:t.RG,rg8snorm:t.RG,rg8uint:t.RG,rg8sint:t.RG,r32uint:t.RED,r32sint:t.RED,r32float:t.RED,rg16uint:t.RG,rg16sint:t.RG,rg16float:t.RG,rgba8unorm:t.RGBA,"rgba8unorm-srgb":t.RGBA,rgba8snorm:t.RGBA,rgba8uint:t.RGBA,rgba8sint:t.RGBA,bgra8unorm:t.RGBA,"bgra8unorm-srgb":t.RGBA,rgb9e5ufloat:t.RGB,rgb10a2unorm:t.RGBA,rg11b10ufloat:t.RGB,rg32uint:t.RG,rg32sint:t.RG,rg32float:t.RG,rgba16uint:t.RGBA,rgba16sint:t.RGBA,rgba16float:t.RGBA,rgba32uint:t.RGBA,rgba32sint:t.RGBA,rgba32float:t.RGBA,stencil8:t.STENCIL_INDEX8,depth16unorm:t.DEPTH_COMPONENT,depth24plus:t.DEPTH_COMPONENT,"depth24plus-stencil8":t.DEPTH_STENCIL,depth32float:t.DEPTH_COMPONENT,"depth32float-stencil8":t.DEPTH_STENCIL}}function Mt(t,e){let r={},n=t.RGBA;return t instanceof R.get().getWebGLRenderingContext()?e.srgb&&(r={"rgba8unorm-srgb":e.srgb.SRGB8_ALPHA8_EXT,"bgra8unorm-srgb":e.srgb.SRGB8_ALPHA8_EXT}):(r={"rgba8unorm-srgb":t.SRGB8_ALPHA8,"bgra8unorm-srgb":t.SRGB8_ALPHA8},n=t.RGBA8),{r8unorm:t.R8,r8snorm:t.R8_SNORM,r8uint:t.R8UI,r8sint:t.R8I,r16uint:t.R16UI,r16sint:t.R16I,r16float:t.R16F,rg8unorm:t.RG8,rg8snorm:t.RG8_SNORM,rg8uint:t.RG8UI,rg8sint:t.RG8I,r32uint:t.R32UI,r32sint:t.R32I,r32float:t.R32F,rg16uint:t.RG16UI,rg16sint:t.RG16I,rg16float:t.RG16F,rgba8unorm:t.RGBA,...r,rgba8snorm:t.RGBA8_SNORM,rgba8uint:t.RGBA8UI,rgba8sint:t.RGBA8I,bgra8unorm:n,rgb9e5ufloat:t.RGB9_E5,rgb10a2unorm:t.RGB10_A2,rg11b10ufloat:t.R11F_G11F_B10F,rg32uint:t.RG32UI,rg32sint:t.RG32I,rg32float:t.RG32F,rgba16uint:t.RGBA16UI,rgba16sint:t.RGBA16I,rgba16float:t.RGBA16F,rgba32uint:t.RGBA32UI,rgba32sint:t.RGBA32I,rgba32float:t.RGBA32F,stencil8:t.STENCIL_INDEX8,depth16unorm:t.DEPTH_COMPONENT16,depth24plus:t.DEPTH_COMPONENT24,"depth24plus-stencil8":t.DEPTH24_STENCIL8,depth32float:t.DEPTH_COMPONENT32F,"depth32float-stencil8":t.DEPTH32F_STENCIL8,...e.s3tc?{"bc1-rgba-unorm":e.s3tc.COMPRESSED_RGBA_S3TC_DXT1_EXT,"bc2-rgba-unorm":e.s3tc.COMPRESSED_RGBA_S3TC_DXT3_EXT,"bc3-rgba-unorm":e.s3tc.COMPRESSED_RGBA_S3TC_DXT5_EXT}:{},...e.s3tc_sRGB?{"bc1-rgba-unorm-srgb":e.s3tc_sRGB.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT,"bc2-rgba-unorm-srgb":e.s3tc_sRGB.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT,"bc3-rgba-unorm-srgb":e.s3tc_sRGB.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT}:{},...e.rgtc?{"bc4-r-unorm":e.rgtc.COMPRESSED_RED_RGTC1_EXT,"bc4-r-snorm":e.rgtc.COMPRESSED_SIGNED_RED_RGTC1_EXT,"bc5-rg-unorm":e.rgtc.COMPRESSED_RED_GREEN_RGTC2_EXT,"bc5-rg-snorm":e.rgtc.COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT}:{},...e.bptc?{"bc6h-rgb-float":e.bptc.COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT,"bc6h-rgb-ufloat":e.bptc.COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT,"bc7-rgba-unorm":e.bptc.COMPRESSED_RGBA_BPTC_UNORM_EXT,"bc7-rgba-unorm-srgb":e.bptc.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT}:{},...e.etc?{"etc2-rgb8unorm":e.etc.COMPRESSED_RGB8_ETC2,"etc2-rgb8unorm-srgb":e.etc.COMPRESSED_SRGB8_ETC2,"etc2-rgb8a1unorm":e.etc.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2,"etc2-rgb8a1unorm-srgb":e.etc.COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2,"etc2-rgba8unorm":e.etc.COMPRESSED_RGBA8_ETC2_EAC,"etc2-rgba8unorm-srgb":e.etc.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC,"eac-r11unorm":e.etc.COMPRESSED_R11_EAC,"eac-rg11unorm":e.etc.COMPRESSED_SIGNED_RG11_EAC}:{},...e.astc?{"astc-4x4-unorm":e.astc.COMPRESSED_RGBA_ASTC_4x4_KHR,"astc-4x4-unorm-srgb":e.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR,"astc-5x4-unorm":e.astc.COMPRESSED_RGBA_ASTC_5x4_KHR,"astc-5x4-unorm-srgb":e.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR,"astc-5x5-unorm":e.astc.COMPRESSED_RGBA_ASTC_5x5_KHR,"astc-5x5-unorm-srgb":e.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR,"astc-6x5-unorm":e.astc.COMPRESSED_RGBA_ASTC_6x5_KHR,"astc-6x5-unorm-srgb":e.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR,"astc-6x6-unorm":e.astc.COMPRESSED_RGBA_ASTC_6x6_KHR,"astc-6x6-unorm-srgb":e.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR,"astc-8x5-unorm":e.astc.COMPRESSED_RGBA_ASTC_8x5_KHR,"astc-8x5-unorm-srgb":e.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR,"astc-8x6-unorm":e.astc.COMPRESSED_RGBA_ASTC_8x6_KHR,"astc-8x6-unorm-srgb":e.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR,"astc-8x8-unorm":e.astc.COMPRESSED_RGBA_ASTC_8x8_KHR,"astc-8x8-unorm-srgb":e.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR,"astc-10x5-unorm":e.astc.COMPRESSED_RGBA_ASTC_10x5_KHR,"astc-10x5-unorm-srgb":e.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR,"astc-10x6-unorm":e.astc.COMPRESSED_RGBA_ASTC_10x6_KHR,"astc-10x6-unorm-srgb":e.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR,"astc-10x8-unorm":e.astc.COMPRESSED_RGBA_ASTC_10x8_KHR,"astc-10x8-unorm-srgb":e.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR,"astc-10x10-unorm":e.astc.COMPRESSED_RGBA_ASTC_10x10_KHR,"astc-10x10-unorm-srgb":e.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR,"astc-12x10-unorm":e.astc.COMPRESSED_RGBA_ASTC_12x10_KHR,"astc-12x10-unorm-srgb":e.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR,"astc-12x12-unorm":e.astc.COMPRESSED_RGBA_ASTC_12x12_KHR,"astc-12x12-unorm-srgb":e.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR}:{}}}function Lt(t){return{r8unorm:t.UNSIGNED_BYTE,r8snorm:t.BYTE,r8uint:t.UNSIGNED_BYTE,r8sint:t.BYTE,r16uint:t.UNSIGNED_SHORT,r16sint:t.SHORT,r16float:t.HALF_FLOAT,rg8unorm:t.UNSIGNED_BYTE,rg8snorm:t.BYTE,rg8uint:t.UNSIGNED_BYTE,rg8sint:t.BYTE,r32uint:t.UNSIGNED_INT,r32sint:t.INT,r32float:t.FLOAT,rg16uint:t.UNSIGNED_SHORT,rg16sint:t.SHORT,rg16float:t.HALF_FLOAT,rgba8unorm:t.UNSIGNED_BYTE,"rgba8unorm-srgb":t.UNSIGNED_BYTE,rgba8snorm:t.BYTE,rgba8uint:t.UNSIGNED_BYTE,rgba8sint:t.BYTE,bgra8unorm:t.UNSIGNED_BYTE,"bgra8unorm-srgb":t.UNSIGNED_BYTE,rgb9e5ufloat:t.UNSIGNED_INT_5_9_9_9_REV,rgb10a2unorm:t.UNSIGNED_INT_2_10_10_10_REV,rg11b10ufloat:t.UNSIGNED_INT_10F_11F_11F_REV,rg32uint:t.UNSIGNED_INT,rg32sint:t.INT,rg32float:t.FLOAT,rgba16uint:t.UNSIGNED_SHORT,rgba16sint:t.SHORT,rgba16float:t.HALF_FLOAT,rgba32uint:t.UNSIGNED_INT,rgba32sint:t.INT,rgba32float:t.FLOAT,stencil8:t.UNSIGNED_BYTE,depth16unorm:t.UNSIGNED_SHORT,depth24plus:t.UNSIGNED_INT,"depth24plus-stencil8":t.UNSIGNED_INT_24_8,depth32float:t.FLOAT,"depth32float-stencil8":t.FLOAT_32_UNSIGNED_INT_24_8_REV}}function wt(t){return{"2d":t.TEXTURE_2D,cube:t.TEXTURE_CUBE_MAP,"1d":null,"3d":(t==null?void 0:t.TEXTURE_3D)||null,"2d-array":(t==null?void 0:t.TEXTURE_2D_ARRAY)||null,"cube-array":(t==null?void 0:t.TEXTURE_CUBE_MAP_ARRAY)||null}}const Ht=4,V=class ge{constructor(e){this._glSamplers=Object.create(null),this._boundTextures=[],this._activeTextureLocation=-1,this._boundSamplers=Object.create(null),this._premultiplyAlpha=!1,this._useSeparateSamplers=!1,this._renderer=e,this._managedTextures=new F({renderer:e,type:"resource",onUnload:this.onSourceUnload.bind(this),name:"glTexture"});const r={image:Re,buffer:Bt,video:Ut,compressed:Ct,...ge.uploadExtensions};this._uploads={...r,cube:Nt(r)}}get managedTextures(){return Object.values(this._managedTextures.items)}contextChange(e){this._gl=e,this._mapFormatToInternalFormat||(this._mapFormatToInternalFormat=Mt(e,this._renderer.context.extensions),this._mapFormatToType=Lt(e),this._mapFormatToFormat=Ot(e),this._mapViewDimensionToGlTarget=wt(e)),this._managedTextures.removeAll(!0),this._glSamplers=Object.create(null),this._boundSamplers=Object.create(null),this._premultiplyAlpha=!1;for(let r=0;r<16;r++)this.bind(S.EMPTY,r)}initSource(e){this.bind(e)}bind(e,r=0){const n=e.source;e?(this.bindSource(n,r),this._useSeparateSamplers&&this._bindSampler(n.style,r)):(this.bindSource(null,r),this._useSeparateSamplers&&this._bindSampler(null,r))}bindSource(e,r=0){const n=this._gl;if(e._gcLastUsed=this._renderer.gc.now,this._boundTextures[r]!==e){this._boundTextures[r]=e,this._activateLocation(r),e||(e=S.EMPTY.source);const s=this.getGlSource(e);n.bindTexture(s.target,s.texture)}}_bindSampler(e,r=0){const n=this._gl;if(!e){this._boundSamplers[r]=null,n.bindSampler(r,null);return}const s=this._getGlSampler(e);this._boundSamplers[r]!==s&&(this._boundSamplers[r]=s,n.bindSampler(r,s))}unbind(e){const r=e.source,n=this._boundTextures,s=this._gl;for(let i=0;i<n.length;i++)if(n[i]===r){this._activateLocation(i);const a=this.getGlSource(r);s.bindTexture(a.target,null),n[i]=null}}_activateLocation(e){this._activeTextureLocation!==e&&(this._activeTextureLocation=e,this._gl.activeTexture(this._gl.TEXTURE0+e))}_initSource(e){const r=this._gl,n=new At(r.createTexture());if(n.type=this._mapFormatToType[e.format],n.internalFormat=this._mapFormatToInternalFormat[e.format],n.format=this._mapFormatToFormat[e.format],n.target=this._mapViewDimensionToGlTarget[e.viewDimension],n.target===null)throw new Error(`Unsupported view dimension: ${e.viewDimension} with this webgl version: ${this._renderer.context.webGLVersion}`);if(e.uploadMethodId==="cube"&&(n.target=r.TEXTURE_CUBE_MAP),e.autoGenerateMipmaps&&(this._renderer.context.supports.nonPowOf2mipmaps||e.isPowerOfTwo)){const i=Math.max(e.width,e.height);e.mipLevelCount=Math.floor(Math.log2(i))+1}return e._gpuData[this._renderer.uid]=n,this._managedTextures.add(e)&&(e.on("update",this.onSourceUpdate,this),e.on("resize",this.onSourceUpdate,this),e.on("styleChange",this.onStyleChange,this),e.on("updateMipmaps",this.onUpdateMipmaps,this)),this.onSourceUpdate(e),this.updateStyle(e,!1),n}onStyleChange(e){this.updateStyle(e,!1)}updateStyle(e,r){const n=this._gl,s=this.getGlSource(e);n.bindTexture(s.target,s.texture),this._boundTextures[this._activeTextureLocation]=e,z(e.style,n,e.mipLevelCount>1,this._renderer.context.extensions.anisotropicFiltering,"texParameteri",s.target,!this._renderer.context.supports.nonPowOf2wrapping&&!e.isPowerOfTwo,r)}onSourceUnload(e,r=!1){const n=e._gpuData[this._renderer.uid];n&&(r||(this.unbind(e),this._gl.deleteTexture(n.texture)),e.off("update",this.onSourceUpdate,this),e.off("resize",this.onSourceUpdate,this),e.off("styleChange",this.onStyleChange,this),e.off("updateMipmaps",this.onUpdateMipmaps,this))}onSourceUpdate(e){const r=this._gl,n=this.getGlSource(e);r.bindTexture(n.target,n.texture),this._boundTextures[this._activeTextureLocation]=e;const s=e.alphaMode==="premultiply-alpha-on-upload";if(this._premultiplyAlpha!==s&&(this._premultiplyAlpha=s,r.pixelStorei(r.UNPACK_PREMULTIPLY_ALPHA_WEBGL,s)),this._uploads[e.uploadMethodId])this._uploads[e.uploadMethodId].upload(e,n,r,this._renderer.context.webGLVersion);else if(n.target===r.TEXTURE_2D)this._initEmptyTexture2D(n,e);else if(n.target===r.TEXTURE_2D_ARRAY)this._initEmptyTexture2DArray(n,e);else if(n.target===r.TEXTURE_CUBE_MAP)this._initEmptyTextureCube(n,e);else throw new Error("[GlTextureSystem] Unsupported texture target for empty allocation.");this._applyMipRange(n,e),e.autoGenerateMipmaps&&e.mipLevelCount>1&&this.onUpdateMipmaps(e,!1)}onUpdateMipmaps(e,r=!0){r&&this.bindSource(e,0);const n=this.getGlSource(e);this._gl.generateMipmap(n.target)}_initEmptyTexture2D(e,r){const n=this._gl;n.texImage2D(n.TEXTURE_2D,0,e.internalFormat,r.pixelWidth,r.pixelHeight,0,e.format,e.type,null);let s=Math.max(r.pixelWidth>>1,1),i=Math.max(r.pixelHeight>>1,1);for(let a=1;a<r.mipLevelCount;a++)n.texImage2D(n.TEXTURE_2D,a,e.internalFormat,s,i,0,e.format,e.type,null),s=Math.max(s>>1,1),i=Math.max(i>>1,1)}_initEmptyTexture2DArray(e,r){if(this._renderer.context.webGLVersion!==2)throw new Error("[GlTextureSystem] TEXTURE_2D_ARRAY requires WebGL2.");const n=this._gl,s=Math.max(r.arrayLayerCount|0,1);n.texImage3D(n.TEXTURE_2D_ARRAY,0,e.internalFormat,r.pixelWidth,r.pixelHeight,s,0,e.format,e.type,null);let i=Math.max(r.pixelWidth>>1,1),a=Math.max(r.pixelHeight>>1,1);for(let o=1;o<r.mipLevelCount;o++)n.texImage3D(n.TEXTURE_2D_ARRAY,o,e.internalFormat,i,a,s,0,e.format,e.type,null),i=Math.max(i>>1,1),a=Math.max(a>>1,1)}_initEmptyTextureCube(e,r){const n=this._gl,s=6;for(let o=0;o<s;o++)n.texImage2D(n.TEXTURE_CUBE_MAP_POSITIVE_X+o,0,e.internalFormat,r.pixelWidth,r.pixelHeight,0,e.format,e.type,null);let i=Math.max(r.pixelWidth>>1,1),a=Math.max(r.pixelHeight>>1,1);for(let o=1;o<r.mipLevelCount;o++){for(let c=0;c<s;c++)n.texImage2D(n.TEXTURE_CUBE_MAP_POSITIVE_X+c,o,e.internalFormat,i,a,0,e.format,e.type,null);i=Math.max(i>>1,1),a=Math.max(a>>1,1)}}_applyMipRange(e,r){if(this._renderer.context.webGLVersion!==2||r.mipLevelCount<=1)return;const n=this._gl,s=Math.max((r.mipLevelCount|0)-1,0);n.texParameteri(e.target,n.TEXTURE_BASE_LEVEL,0),n.texParameteri(e.target,n.TEXTURE_MAX_LEVEL,s)}_initSampler(e){const r=this._gl,n=this._gl.createSampler();return this._glSamplers[e._resourceId]=n,z(e,r,this._boundTextures[this._activeTextureLocation].mipLevelCount>1,this._renderer.context.extensions.anisotropicFiltering,"samplerParameteri",n,!1,!0),this._glSamplers[e._resourceId]}_getGlSampler(e){return this._glSamplers[e._resourceId]||this._initSampler(e)}getGlSource(e){return e._gcLastUsed=this._renderer.gc.now,e._gpuData[this._renderer.uid]||this._initSource(e)}generateCanvas(e){const{pixels:r,width:n,height:s}=this.getPixels(e),i=R.get().createCanvas();i.width=n,i.height=s;const a=i.getContext("2d");if(a){const o=a.createImageData(n,s);o.data.set(r),a.putImageData(o,0,0)}return i}getPixels(e){const r=e.source.resolution,n=e.frame,s=Math.max(Math.round(n.width*r),1),i=Math.max(Math.round(n.height*r),1),a=new Uint8Array(Ht*s*i),o=this._renderer,c=o.renderTarget.getRenderTarget(e),u=o.renderTarget.getGpuRenderTarget(c),_=o.gl;return _.bindFramebuffer(_.FRAMEBUFFER,u.resolveTargetFramebuffer),_.readPixels(Math.round(n.x*r),Math.round(n.y*r),s,i,_.RGBA,_.UNSIGNED_BYTE,a),{pixels:new Uint8ClampedArray(a.buffer),width:s,height:i}}destroy(){this._managedTextures.destroy(),this._glSamplers=null,this._boundTextures=null,this._boundSamplers=null,this._mapFormatToInternalFormat=null,this._mapFormatToType=null,this._mapFormatToFormat=null,this._uploads=null,this._renderer=null}resetState(){this._activeTextureLocation=-1,this._boundTextures.fill(S.EMPTY.source),this._boundSamplers=Object.create(null);const e=this._gl;this._premultiplyAlpha=!1,e.pixelStorei(e.UNPACK_PREMULTIPLY_ALPHA_WEBGL,this._premultiplyAlpha)}};V.extension={type:[d.WebGLSystem],name:"texture"};V.uploadExtensions=Object.create(null);let Te=V;g.handleByMap(d.TextureUploaderWebGL,Te.uploadExtensions);class xe{contextChange(e){const r=new O({uColor:{value:new Float32Array([1,1,1,1]),type:"vec4<f32>"},uTransformMatrix:{value:new J,type:"mat3x3<f32>"},uRound:{value:0,type:"f32"}}),n=e.limits.maxBatchableTextures,s=Q({name:"graphics",bits:[Ge,Ue(n),re,ee]});this.shader=new P({glProgram:s,resources:{localUniforms:r,batchSamplers:Fe(n)}})}execute(e,r){const n=r.context,s=n.customShader||this.shader,i=e.renderer,a=i.graphicsContext,{batcher:o,instructions:c}=a.getContextRenderData(n);s.groups[0]=i.globalUniforms.bindGroup,i.state.set(e.state),i.shader.bind(s),i.geometry.bind(o.geometry,s.glProgram);const u=c.instructions;for(let _=0;_<c.instructionSize;_++){const f=u[_];if(f.size){for(let l=0;l<f.textures.count;l++)i.texture.bind(f.textures.textures[l],l);i.geometry.draw(f.topology,f.size,f.start)}}}destroy(){this.shader.destroy(!0),this.shader=null}}xe.extension={type:[d.WebGLPipesAdaptor],name:"graphics"};class ve{init(){const e=Q({name:"mesh",bits:[re,Xe,ee]});this._shader=new P({glProgram:e,resources:{uTexture:S.EMPTY.source,textureUniforms:{uTextureMatrix:{type:"mat3x3<f32>",value:new J}}}})}execute(e,r){const n=e.renderer;let s=r._shader;if(s){if(!s.glProgram){p("Mesh shader has no glProgram",r.shader);return}}else{s=this._shader;const i=r.texture,a=i.source;s.resources.uTexture=a,s.resources.uSampler=a.style,s.resources.textureUniforms.uniforms.uTextureMatrix=i.textureMatrix.mapCoord}s.groups[100]=n.globalUniforms.bindGroup,s.groups[101]=e.localUniformsBindGroup,n.encoder.draw({geometry:r._geometry,shader:s,state:r.state})}destroy(){this._shader.destroy(!0),this._shader=null}}ve.extension={type:[d.WebGLPipesAdaptor],name:"mesh"};const Vt=[...We,he,Qe,Ye,_e,se,Te,de,ae,pe,be,ue,vt,fe,ce],Xt=[...je],kt=[ne,ve,xe],Ae=[],Be=[],ye=[];g.handleByNamedList(d.WebGLSystem,Ae);g.handleByNamedList(d.WebGLPipes,Be);g.handleByNamedList(d.WebGLPipesAdaptor,ye);g.add(...Vt,...Xt,...kt);class Yt extends Pe{constructor(){const e={name:"webgl",type:Oe.WEBGL,systems:Ae,renderPipes:Be,renderPipeAdaptors:ye};super(e)}}export{Yt as WebGLRenderer}; diff --git a/2026/games_submissions/sunshoes/assets/WebGPURenderer-Ddwua8JA.js b/2026/games_submissions/sunshoes/assets/WebGPURenderer-Ddwua8JA.js new file mode 100644 index 0000000..2247c5a --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/WebGPURenderer-Ddwua8JA.js @@ -0,0 +1,41 @@ +import{a5 as D,z as l,x as k,t as le,a6 as fe,Z as T,r as C,s as B,B as ge,a7 as z,a8 as R,w as v,a9 as y,Y as me,aa as _e,ab as F,c as E,F as G,N as O,ac as I,ad as be,ae as W,af as xe,S as H,T as A,_ as ye,$ as Ge}from"./index-DvAPfvr6.js";import{c as Pe,u as Se,U as Te,B as Be,G as Ce,e as ve,l as Ue,a as Me,t as we}from"./BufferResource-BZpoqTVb.js";import{S as N}from"./Filter-BiIvpnZm.js";import{R as Re,S as Ee,e as Ae}from"./RenderTargetSystem-Cp6tD-lP.js";const P=N.for2d();class V{start(e,t,r){const s=e.renderer,i=s.encoder,n=r.gpuProgram;this._shader=r,this._geometry=t,i.setGeometry(t,n),P.blendMode="normal",s.pipeline.getPipeline(t,n,P);const a=s.globalUniforms.bindGroup;i.resetBindGroup(1),i.setBindGroup(0,a,n)}execute(e,t){const r=this._shader.gpuProgram,s=e.renderer,i=s.encoder;if(!t.bindGroup){const u=t.textures;t.bindGroup=D(u.textures,u.count,s.limits.maxBatchableTextures)}P.blendMode=t.blendMode;const n=s.bindGroup.getBindGroup(t.bindGroup,r,1),a=s.pipeline.getPipeline(this._geometry,r,P,t.topology);t.bindGroup._touch(s.gc.now,s.tick),i.setPipeline(a),i.renderPassEncoder.setBindGroup(1,n),i.renderPassEncoder.drawIndexed(t.size,1,t.start)}}V.extension={type:[l.WebGPUPipesAdaptor],name:"batch"};class j{constructor(e){this._hash=Object.create(null),this._renderer=e}contextChange(e){this._gpu=e}getBindGroup(e,t,r){return e._updateKey(),this._hash[e._key]||this._createBindGroup(e,t,r)}_createBindGroup(e,t,r){const s=this._gpu.device,i=t.layout[r],n=[],a=this._renderer;for(const f in i){const h=e.resources[f]??e.resources[i[f]];let p;if(h._resourceType==="uniformGroup"){const d=h;a.ubo.updateUniformGroup(d);const m=d.buffer;p={buffer:a.buffer.getGPUBuffer(m),offset:0,size:m.descriptor.size}}else if(h._resourceType==="buffer"){const d=h;p={buffer:a.buffer.getGPUBuffer(d),offset:0,size:d.descriptor.size}}else if(h._resourceType==="bufferResource"){const d=h;p={buffer:a.buffer.getGPUBuffer(d.buffer),offset:d.offset,size:d.size}}else if(h._resourceType==="textureSampler"){const d=h;p=a.texture.getGpuSampler(d)}else if(h._resourceType==="textureSource"){const d=h;p=a.texture.getTextureView(d)}n.push({binding:i[f],resource:p})}const u=a.shader.getProgramData(t).bindGroups[r],c=s.createBindGroup({layout:u,entries:n});return this._hash[e._key]=c,c}destroy(){this._hash=null,this._renderer=null}}j.extension={type:[l.WebGPUSystem],name:"bindGroup"};class Le{constructor(e){this.gpuBuffer=e}destroy(){this.gpuBuffer.destroy(),this.gpuBuffer=null}}class K{constructor(e){this._renderer=e,this._managedBuffers=new k({renderer:e,type:"resource",onUnload:this.onBufferUnload.bind(this),name:"gpuBuffer"})}contextChange(e){this._gpu=e}getGPUBuffer(e){var t;return e._gcLastUsed=this._renderer.gc.now,((t=e._gpuData[this._renderer.uid])==null?void 0:t.gpuBuffer)||this.createGPUBuffer(e)}updateBuffer(e){const t=this.getGPUBuffer(e),r=e.data;return e._updateID&&r&&(e._updateID=0,this._gpu.device.queue.writeBuffer(t,0,r.buffer,0,(e._updateSize||r.byteLength)+3&-4)),t}destroyAll(){this._managedBuffers.removeAll()}onBufferUnload(e){e.off("update",this.updateBuffer,this),e.off("change",this.onBufferChange,this)}createGPUBuffer(e){const t=this._gpu.device.createBuffer(e.descriptor);return e._updateID=0,e._resourceId=le("resource"),e.data&&(fe(e.data.buffer,t.getMappedRange(),e.data.byteOffset,e.data.byteLength),t.unmap()),e._gpuData[this._renderer.uid]=new Le(t),this._managedBuffers.add(e)&&(e.on("update",this.updateBuffer,this),e.on("change",this.onBufferChange,this)),t}onBufferChange(e){this._managedBuffers.remove(e),e._updateID=0,this.createGPUBuffer(e)}destroy(){this._managedBuffers.destroy(),this._renderer=null,this._gpu=null}}K.extension={type:[l.WebGPUSystem],name:"buffer"};class De{constructor({minUniformOffsetAlignment:e}){this._minUniformOffsetAlignment=256,this.byteIndex=0,this._minUniformOffsetAlignment=e,this.data=new Float32Array(65535)}clear(){this.byteIndex=0}addEmptyGroup(e){if(e>this._minUniformOffsetAlignment/4)throw new Error(`UniformBufferBatch: array is too large: ${e*4}`);const t=this.byteIndex;let r=t+e*4;if(r=Math.ceil(r/this._minUniformOffsetAlignment)*this._minUniformOffsetAlignment,r>this.data.length*4)throw new Error("UniformBufferBatch: ubo batch got too big");return this.byteIndex=r,t}addGroup(e){const t=this.addEmptyGroup(e.length);for(let r=0;r<e.length;r++)this.data[t/4+r]=e[r];return t}destroy(){this.data=null}}class q{constructor(e){this._colorMaskCache=15,this._renderer=e}setMask(e){this._colorMaskCache!==e&&(this._colorMaskCache=e,this._renderer.pipeline.setColorMask(e))}destroy(){this._renderer=null,this._colorMaskCache=null}}q.extension={type:[l.WebGPUSystem],name:"colorMask"};class U{constructor(e){this._renderer=e}async init(e){return this._initPromise?this._initPromise:(this._initPromise=(e.gpu?Promise.resolve(e.gpu):this._createDeviceAndAdaptor(e)).then(t=>{this.gpu=t,this.extensions={transientAttachment:typeof GPUTextureUsage.TRANSIENT_ATTACHMENT=="number"},this._renderer.runners.contextChange.emit(this.gpu)}),this._initPromise)}contextChange(e){this._renderer.gpu=e}async _createDeviceAndAdaptor(e){const t=await T.get().getNavigator().gpu.requestAdapter({powerPreference:e.powerPreference,forceFallbackAdapter:e.forceFallbackAdapter}),r=["texture-compression-bc","texture-compression-astc","texture-compression-etc2"].filter(i=>t.features.has(i)),s=await t.requestDevice({requiredFeatures:r});return{adapter:t,device:s}}destroy(){this.gpu=null,this.extensions=null,this._renderer=null}}U.extension={type:[l.WebGPUSystem],name:"device"};U.defaultOptions={powerPreference:void 0,forceFallbackAdapter:!1};class Y{constructor(e){this._boundBindGroup=Object.create(null),this._boundVertexBuffer=Object.create(null),this._renderer=e}renderStart(){this.commandFinished=new Promise(e=>{this._resolveCommandFinished=e}),this.commandEncoder=this._renderer.gpu.device.createCommandEncoder()}beginRenderPass(e){this.endRenderPass(),this._clearCache(),this.renderPassEncoder=this.commandEncoder.beginRenderPass(e.descriptor)}endRenderPass(){this.renderPassEncoder&&this.renderPassEncoder.end(),this.renderPassEncoder=null}setViewport(e){this.renderPassEncoder.setViewport(e.x,e.y,e.width,e.height,0,1)}setPipelineFromGeometryProgramAndState(e,t,r,s){const i=this._renderer.pipeline.getPipeline(e,t,r,s);this.setPipeline(i)}setPipeline(e){this._boundPipeline!==e&&(this._boundPipeline=e,this.renderPassEncoder.setPipeline(e))}_setVertexBuffer(e,t){this._boundVertexBuffer[e]!==t&&(this._boundVertexBuffer[e]=t,this.renderPassEncoder.setVertexBuffer(e,this._renderer.buffer.updateBuffer(t)))}_setIndexBuffer(e){if(this._boundIndexBuffer===e)return;this._boundIndexBuffer=e;const t=e.data.BYTES_PER_ELEMENT===2?"uint16":"uint32";this.renderPassEncoder.setIndexBuffer(this._renderer.buffer.updateBuffer(e),t)}resetBindGroup(e){this._boundBindGroup[e]=null}setBindGroup(e,t,r){if(this._boundBindGroup[e]===t)return;this._boundBindGroup[e]=t,t._touch(this._renderer.gc.now,this._renderer.tick);const s=this._renderer.bindGroup.getBindGroup(t,r,e);this.renderPassEncoder.setBindGroup(e,s)}setGeometry(e,t){const r=this._renderer.pipeline.getBufferNamesToBind(e,t);for(const s in r)this._setVertexBuffer(parseInt(s,10),e.attributes[r[s]].buffer);e.indexBuffer&&this._setIndexBuffer(e.indexBuffer)}_setShaderBindGroups(e,t){for(const r in e.groups){const s=e.groups[r];t||this._syncBindGroup(s),this.setBindGroup(r,s,e.gpuProgram)}}_syncBindGroup(e){for(const t in e.resources){const r=e.resources[t];r.isUniformGroup&&this._renderer.ubo.updateUniformGroup(r)}}draw(e){const{geometry:t,shader:r,state:s,topology:i,size:n,start:a,instanceCount:u,skipSync:c}=e;this.setPipelineFromGeometryProgramAndState(t,r.gpuProgram,s,i),this.setGeometry(t,r.gpuProgram),this._setShaderBindGroups(r,c),t.indexBuffer?this.renderPassEncoder.drawIndexed(n||t.indexBuffer.data.length,u??t.instanceCount,a||0):this.renderPassEncoder.draw(n||t.getSize(),u??t.instanceCount,a||0)}finishRenderPass(){this.renderPassEncoder&&(this.renderPassEncoder.end(),this.renderPassEncoder=null)}postrender(){this.finishRenderPass(),this._gpu.device.queue.submit([this.commandEncoder.finish()]),this._resolveCommandFinished(),this.commandEncoder=null}restoreRenderPass(){const e=this._renderer.renderTarget.adaptor.getDescriptor(this._renderer.renderTarget.renderTarget,!1,[0,0,0,1],this._renderer.renderTarget.mipLevel,this._renderer.renderTarget.layer);this.renderPassEncoder=this.commandEncoder.beginRenderPass(e);const t=this._boundPipeline,r={...this._boundVertexBuffer},s=this._boundIndexBuffer,i={...this._boundBindGroup};this._clearCache();const n=this._renderer.renderTarget.viewport;this.renderPassEncoder.setViewport(n.x,n.y,n.width,n.height,0,1),this.setPipeline(t);for(const a in r)this._setVertexBuffer(a,r[a]);for(const a in i)this.setBindGroup(a,i[a],null);this._setIndexBuffer(s)}_clearCache(){for(let e=0;e<16;e++)this._boundBindGroup[e]=null,this._boundVertexBuffer[e]=null;this._boundIndexBuffer=null,this._boundPipeline=null}destroy(){this._renderer=null,this._gpu=null,this._boundBindGroup=null,this._boundVertexBuffer=null,this._boundIndexBuffer=null,this._boundPipeline=null}contextChange(e){this._gpu=e}}Y.extension={type:[l.WebGPUSystem],name:"encoder",priority:1};class ${constructor(e){this._renderer=e}contextChange(){this.maxTextures=this._renderer.device.gpu.device.limits.maxSampledTexturesPerShaderStage,this.maxBatchableTextures=this.maxTextures}destroy(){}}$.extension={type:[l.WebGPUSystem],name:"limits"};class X{constructor(e){this._renderTargetStencilState=Object.create(null),this._renderer=e,e.renderTarget.onRenderTargetChange.add(this)}onRenderTargetChange(e){let t=this._renderTargetStencilState[e.uid];t||(t=this._renderTargetStencilState[e.uid]={stencilMode:C.DISABLED,stencilReference:0}),this._activeRenderTarget=e,this.setStencilMode(t.stencilMode,t.stencilReference)}setStencilMode(e,t){const r=this._renderTargetStencilState[this._activeRenderTarget.uid];r.stencilMode=e,r.stencilReference=t;const s=this._renderer;s.pipeline.setStencilMode(e),s.encoder.renderPassEncoder.setStencilReference(t)}destroy(){this._renderer.renderTarget.onRenderTargetChange.remove(this),this._renderer=null,this._activeRenderTarget=null,this._renderTargetStencilState=null}}X.extension={type:[l.WebGPUSystem],name:"stencil"};const S={i32:{align:4,size:4},u32:{align:4,size:4},f32:{align:4,size:4},f16:{align:2,size:2},"vec2<i32>":{align:8,size:8},"vec2<u32>":{align:8,size:8},"vec2<f32>":{align:8,size:8},"vec2<f16>":{align:4,size:4},"vec3<i32>":{align:16,size:12},"vec3<u32>":{align:16,size:12},"vec3<f32>":{align:16,size:12},"vec3<f16>":{align:8,size:6},"vec4<i32>":{align:16,size:16},"vec4<u32>":{align:16,size:16},"vec4<f32>":{align:16,size:16},"vec4<f16>":{align:8,size:8},"mat2x2<f32>":{align:8,size:16},"mat2x2<f16>":{align:4,size:8},"mat3x2<f32>":{align:8,size:24},"mat3x2<f16>":{align:4,size:12},"mat4x2<f32>":{align:8,size:32},"mat4x2<f16>":{align:4,size:16},"mat2x3<f32>":{align:16,size:32},"mat2x3<f16>":{align:8,size:16},"mat3x3<f32>":{align:16,size:48},"mat3x3<f16>":{align:8,size:24},"mat4x3<f32>":{align:16,size:64},"mat4x3<f16>":{align:8,size:32},"mat2x4<f32>":{align:16,size:32},"mat2x4<f16>":{align:8,size:16},"mat3x4<f32>":{align:16,size:48},"mat3x4<f16>":{align:8,size:24},"mat4x4<f32>":{align:16,size:64},"mat4x4<f16>":{align:8,size:32}};function ke(o){const e=o.map(r=>({data:r,offset:0,size:0}));let t=0;for(let r=0;r<e.length;r++){const s=e[r];let i=S[s.data.type].size;const n=S[s.data.type].align;if(!S[s.data.type])throw new Error(`[Pixi.js] WebGPU UniformBuffer: Unknown type ${s.data.type}`);s.data.size>1&&(i=Math.max(i,n)*s.data.size),t=Math.ceil(t/n)*n,s.size=i,s.offset=t,t+=i}return t=Math.ceil(t/16)*16,{uboElements:e,size:t}}function ze(o,e){const{size:t,align:r}=S[o.data.type],s=(r-t)/4,i=o.data.type.indexOf("i32")>=0?"dataInt32":"data";return` + v = uv.${o.data.name}; + ${e!==0?`offset += ${e};`:""} + + arrayOffset = offset; + + t = 0; + + for(var i=0; i < ${o.data.size*(t/4)}; i++) + { + for(var j = 0; j < ${t/4}; j++) + { + ${i}[arrayOffset++] = v[t++]; + } + ${s!==0?`arrayOffset += ${s};`:""} + } + `}function Fe(o){return Pe(o,"uboWgsl",ze,Se)}class Z extends Te{constructor(){super({createUboElements:ke,generateUboSync:Fe})}}Z.extension={type:[l.WebGPUSystem],name:"ubo"};const b=128;class J{constructor(e){this._bindGroupHash=Object.create(null),this._buffers=[],this._bindGroups=[],this._bufferResources=[],this._renderer=e,this._batchBuffer=new De({minUniformOffsetAlignment:b});const t=256/b;for(let r=0;r<t;r++){let s=B.UNIFORM|B.COPY_DST;r===0&&(s|=B.COPY_SRC),this._buffers.push(new ge({data:this._batchBuffer.data,usage:s}))}}renderEnd(){this._uploadBindGroups(),this._resetBindGroups()}_resetBindGroups(){this._bindGroupHash=Object.create(null),this._batchBuffer.clear()}getUniformBindGroup(e,t){if(!t&&this._bindGroupHash[e.uid])return this._bindGroupHash[e.uid];this._renderer.ubo.ensureUniformGroup(e);const r=e.buffer.data,s=this._batchBuffer.addEmptyGroup(r.length);return this._renderer.ubo.syncUniformGroup(e,this._batchBuffer.data,s/4),this._bindGroupHash[e.uid]=this._getBindGroup(s/b),this._bindGroupHash[e.uid]}getUboResource(e){this._renderer.ubo.updateUniformGroup(e);const t=e.buffer.data,r=this._batchBuffer.addGroup(t);return this._getBufferResource(r/b)}getArrayBindGroup(e){const t=this._batchBuffer.addGroup(e);return this._getBindGroup(t/b)}getArrayBufferResource(e){const r=this._batchBuffer.addGroup(e)/b;return this._getBufferResource(r)}_getBufferResource(e){if(!this._bufferResources[e]){const t=this._buffers[e%2];this._bufferResources[e]=new Be({buffer:t,offset:(e/2|0)*256,size:b})}return this._bufferResources[e]}_getBindGroup(e){if(!this._bindGroups[e]){const t=new z({0:this._getBufferResource(e)});this._bindGroups[e]=t}return this._bindGroups[e]}_uploadBindGroups(){const e=this._renderer.buffer,t=this._buffers[0];t.update(this._batchBuffer.byteIndex),e.updateBuffer(t);const r=this._renderer.gpu.device.createCommandEncoder();for(let s=1;s<this._buffers.length;s++){const i=this._buffers[s];r.copyBufferToBuffer(e.getGPUBuffer(t),b,e.getGPUBuffer(i),0,this._batchBuffer.byteIndex)}this._renderer.gpu.device.queue.submit([r.finish()])}destroy(){var e;for(let t=0;t<this._bindGroups.length;t++)(e=this._bindGroups[t])==null||e.destroy();this._bindGroups=null,this._bindGroupHash=null;for(let t=0;t<this._buffers.length;t++)this._buffers[t].destroy();this._buffers=null;for(let t=0;t<this._bufferResources.length;t++)this._bufferResources[t].destroy();this._bufferResources=null,this._batchBuffer.destroy(),this._renderer=null}}J.extension={type:[l.WebGPUPipes],name:"uniformBatch"};const Oe={"point-list":0,"line-list":1,"line-strip":2,"triangle-list":3,"triangle-strip":4};function Ie(o,e,t,r,s){return o<<24|e<<16|t<<10|r<<5|s}function We(o,e,t,r,s){return t<<8|o<<5|r<<3|s<<1|e}class Q{constructor(e){this._moduleCache=Object.create(null),this._bufferLayoutsCache=Object.create(null),this._bindingNamesCache=Object.create(null),this._pipeCache=Object.create(null),this._pipeStateCaches=Object.create(null),this._colorMask=15,this._multisampleCount=1,this._colorTargetCount=1,this._renderer=e}contextChange(e){this._gpu=e,this.setStencilMode(C.DISABLED),this._updatePipeHash()}setMultisampleCount(e){this._multisampleCount!==e&&(this._multisampleCount=e,this._updatePipeHash())}setRenderTarget(e){this._multisampleCount=e.msaaSamples,this._depthStencilAttachment=e.descriptor.depthStencilAttachment?1:0,this._colorTargetCount=e.colorTargetCount,this._updatePipeHash()}setColorMask(e){this._colorMask!==e&&(this._colorMask=e,this._updatePipeHash())}setStencilMode(e){this._stencilMode!==e&&(this._stencilMode=e,this._stencilState=Ce[e],this._updatePipeHash())}setPipeline(e,t,r,s){const i=this.getPipeline(e,t,r);s.setPipeline(i)}getPipeline(e,t,r,s){e._layoutKey||(ve(e,t.attributeData),this._generateBufferKey(e)),s||(s=e.topology);const i=Ie(e._layoutKey,t._layoutKey,r.data,r._blendModeId,Oe[s]);return this._pipeCache[i]?this._pipeCache[i]:(this._pipeCache[i]=this._createPipeline(e,t,r,s),this._pipeCache[i])}_createPipeline(e,t,r,s){const i=this._gpu.device,n=this._createVertexBufferLayouts(e,t),a=this._renderer.state.getColorTargets(r,this._colorTargetCount),u=this._stencilMode===C.RENDERING_MASK_ADD?0:this._colorMask;for(let p=0;p<a.length;p++)a[p].writeMask=u;const c=this._renderer.shader.getProgramData(t).pipeline,f={vertex:{module:this._getModule(t.vertex.source),entryPoint:t.vertex.entryPoint,buffers:n},fragment:{module:this._getModule(t.fragment.source),entryPoint:t.fragment.entryPoint,targets:a},primitive:{topology:s,cullMode:r.cullMode},layout:c,multisample:{count:this._multisampleCount},label:"PIXI Pipeline"};return this._depthStencilAttachment&&(f.depthStencil={...this._stencilState,format:"depth24plus-stencil8",depthWriteEnabled:r.depthTest,depthCompare:r.depthTest?"less":"always"}),i.createRenderPipeline(f)}_getModule(e){return this._moduleCache[e]||this._createModule(e)}_createModule(e){const t=this._gpu.device;return this._moduleCache[e]=t.createShaderModule({code:e}),this._moduleCache[e]}_generateBufferKey(e){const t=[];let r=0;const s=Object.keys(e.attributes).sort();for(let n=0;n<s.length;n++){const a=e.attributes[s[n]];t[r++]=a.offset,t[r++]=a.format,t[r++]=a.stride,t[r++]=a.instance}const i=t.join("|");return e._layoutKey=R(i,"geometry"),e._layoutKey}_generateAttributeLocationsKey(e){const t=[];let r=0;const s=Object.keys(e.attributeData).sort();for(let n=0;n<s.length;n++){const a=e.attributeData[s[n]];t[r++]=a.location}const i=t.join("|");return e._attributeLocationsKey=R(i,"programAttributes"),e._attributeLocationsKey}getBufferNamesToBind(e,t){const r=e._layoutKey<<16|t._attributeLocationsKey;if(this._bindingNamesCache[r])return this._bindingNamesCache[r];const s=this._createVertexBufferLayouts(e,t),i=Object.create(null),n=t.attributeData;for(let a=0;a<s.length;a++){const c=Object.values(s[a].attributes)[0].shaderLocation;for(const f in n)if(n[f].location===c){i[a]=f;break}}return this._bindingNamesCache[r]=i,i}_createVertexBufferLayouts(e,t){t._attributeLocationsKey||this._generateAttributeLocationsKey(t);const r=e._layoutKey<<16|t._attributeLocationsKey;if(this._bufferLayoutsCache[r])return this._bufferLayoutsCache[r];const s=[];return e.buffers.forEach(i=>{const n={arrayStride:0,stepMode:"vertex",attributes:[]},a=n.attributes;for(const u in t.attributeData){const c=e.attributes[u];(c.divisor??1)!==1&&v(`Attribute ${u} has an invalid divisor value of '${c.divisor}'. WebGPU only supports a divisor value of 1`),c.buffer===i&&(n.arrayStride=c.stride,n.stepMode=c.instance?"instance":"vertex",a.push({shaderLocation:t.attributeData[u].location,offset:c.offset,format:c.format}))}a.length&&s.push(n)}),this._bufferLayoutsCache[r]=s,s}_updatePipeHash(){const e=We(this._stencilMode,this._multisampleCount,this._colorMask,this._depthStencilAttachment,this._colorTargetCount);this._pipeStateCaches[e]||(this._pipeStateCaches[e]=Object.create(null)),this._pipeCache=this._pipeStateCaches[e]}destroy(){this._renderer=null,this._bufferLayoutsCache=null}}Q.extension={type:[l.WebGPUSystem],name:"pipeline"};class He{constructor(){this.contexts=[],this.msaaTextures=[],this.msaaSamples=1}}class Ne{init(e,t){this._renderer=e,this._renderTargetSystem=t}copyToTexture(e,t,r,s,i){const n=this._renderer,a=this._getGpuColorTexture(e),u=n.texture.getGpuSource(t.source);return n.encoder.commandEncoder.copyTextureToTexture({texture:a,origin:r},{texture:u,origin:i},s),t}startRenderPass(e,t=!0,r,s,i=0,n=0){var f,h;const u=this._renderTargetSystem.getGpuRenderTarget(e);if(n!==0&&((f=u.msaaTextures)!=null&&f.length))throw new Error("[RenderTargetSystem] Rendering to array layers is not supported with MSAA render targets.");if(i>0&&((h=u.msaaTextures)!=null&&h.length))throw new Error("[RenderTargetSystem] Rendering to mip levels is not supported with MSAA render targets.");const c=this.getDescriptor(e,t,r,i,n);u.descriptor=c,this._renderer.pipeline.setRenderTarget(u),this._renderer.encoder.beginRenderPass(u),this._renderer.encoder.setViewport(s)}finishRenderPass(){this._renderer.encoder.endRenderPass()}_getGpuColorTexture(e){const t=this._renderTargetSystem.getGpuRenderTarget(e);return t.contexts[0]?t.contexts[0].getCurrentTexture():this._renderer.texture.getGpuSource(e.colorTextures[0].source)}getDescriptor(e,t,r,s=0,i=0){var h;typeof t=="boolean"&&(t=t?y.ALL:y.NONE);const n=this._renderTargetSystem,a=n.getGpuRenderTarget(e),u=e.colorTextures.map((p,d)=>{const m=a.contexts[d];let g,x;if(m){if(i!==0)throw new Error("[RenderTargetSystem] Rendering to array layers is not supported for canvas targets.");g=m.getCurrentTexture().createView()}else g=this._renderer.texture.getGpuSource(p).createView({dimension:"2d",baseMipLevel:s,mipLevelCount:1,baseArrayLayer:i,arrayLayerCount:1});let w=!1;a.msaaTextures[d]&&(x=g,g=this._renderer.texture.getTextureView(a.msaaTextures[d]),w=a.msaaTextures[d].transient);const pe=t&y.COLOR?"clear":"load";return r??(r=n.defaultClearColor),{view:g,resolveTarget:x,clearValue:r,storeOp:w?"discard":"store",loadOp:pe}});let c;if((e.stencil||e.depth)&&!e.depthStencilTexture&&(e.ensureDepthStencilTexture(),e.depthStencilTexture.source.sampleCount=a.msaa?4:1,e.depthStencilTexture.source.transient=!!((h=a.msaaTextures[0])!=null&&h.transient)),e.depthStencilTexture){const p=t&y.STENCIL?"clear":"load",d=t&y.DEPTH?"clear":"load",m=e.depthStencilTexture.source.transient?"discard":"store";c={view:this._renderer.texture.getGpuSource(e.depthStencilTexture.source).createView({dimension:"2d",baseMipLevel:s,mipLevelCount:1,baseArrayLayer:i,arrayLayerCount:1}),stencilStoreOp:m,stencilLoadOp:p,depthClearValue:1,depthLoadOp:d,depthStoreOp:m}}return{colorAttachments:u,depthStencilAttachment:c}}clear(e,t=!0,r,s,i=0,n=0){if(!t)return;const{gpu:a,encoder:u}=this._renderer,c=a.device;if(u.commandEncoder===null){const h=c.createCommandEncoder(),p=this.getDescriptor(e,t,r,i,n),d=h.beginRenderPass(p);d.setViewport(s.x,s.y,s.width,s.height,0,1),d.end();const m=h.finish();c.queue.submit([m])}else this.startRenderPass(e,t,r,s,i,n)}initGpuRenderTarget(e){var r;e.isRoot=!0;const t=new He;return t.colorTargetCount=e.colorTextures.length,e.colorTextures.forEach((s,i)=>{if(s instanceof me){const n=s.resource.getContext("webgpu"),a=s.transparent?"premultiplied":"opaque";try{n.configure({device:this._renderer.gpu.device,usage:GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_DST|GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.COPY_SRC,format:"bgra8unorm",alphaMode:a})}catch(u){console.error(u)}t.contexts[i]=n}if(t.msaa=s.source.antialias,s.source.antialias){const n=new _e({width:0,height:0,sampleCount:4,transient:s.source.transient,arrayLayerCount:s.source.arrayLayerCount});t.msaaTextures[i]=n}}),t.msaa&&(t.msaaSamples=4,e.depthStencilTexture&&(e.depthStencilTexture.source.sampleCount=4,e.depthStencilTexture.source.transient=!!((r=t.msaaTextures[0])!=null&&r.transient))),t}destroyGpuRenderTarget(e){e.contexts.forEach(t=>{t.unconfigure()}),e.msaaTextures.forEach(t=>{t.destroy()}),e.msaaTextures.length=0,e.contexts.length=0}ensureDepthStencilTexture(e){const t=this._renderTargetSystem.getGpuRenderTarget(e);e.depthStencilTexture&&t.msaa&&(e.depthStencilTexture.source.sampleCount=4)}resizeGpuRenderTarget(e){const t=this._renderTargetSystem.getGpuRenderTarget(e);t.width=e.width,t.height=e.height,t.msaa&&e.colorTextures.forEach((r,s)=>{const i=t.msaaTextures[s];i==null||i.resize(r.source.width,r.source.height,r.source._resolution)})}}class ee extends Re{constructor(e){super(e),this.adaptor=new Ne,this.adaptor.init(e,this)}}ee.extension={type:[l.WebGPUSystem],name:"renderTarget"};class te{constructor(){this._gpuProgramData=Object.create(null)}contextChange(e){this._gpu=e}getProgramData(e){return this._gpuProgramData[e._layoutKey]||this._createGPUProgramData(e)}_createGPUProgramData(e){const t=this._gpu.device,r=e.gpuLayout.map(i=>t.createBindGroupLayout({entries:i})),s={bindGroupLayouts:r};return this._gpuProgramData[e._layoutKey]={bindGroups:r,pipeline:t.createPipelineLayout(s)},this._gpuProgramData[e._layoutKey]}destroy(){this._gpu=null,this._gpuProgramData=null}}te.extension={type:[l.WebGPUSystem],name:"shader"};const _={};_.normal={alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}};_.add={alpha:{srcFactor:"src-alpha",dstFactor:"one-minus-src-alpha",operation:"add"},color:{srcFactor:"one",dstFactor:"one",operation:"add"}};_.multiply={alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},color:{srcFactor:"dst",dstFactor:"one-minus-src-alpha",operation:"add"}};_.screen={alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},color:{srcFactor:"one",dstFactor:"one-minus-src",operation:"add"}};_.overlay={alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},color:{srcFactor:"one",dstFactor:"one-minus-src",operation:"add"}};_.none={alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},color:{srcFactor:"zero",dstFactor:"zero",operation:"add"}};_["normal-npm"]={alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},color:{srcFactor:"src-alpha",dstFactor:"one-minus-src-alpha",operation:"add"}};_["add-npm"]={alpha:{srcFactor:"one",dstFactor:"one",operation:"add"},color:{srcFactor:"src-alpha",dstFactor:"one",operation:"add"}};_["screen-npm"]={alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},color:{srcFactor:"src-alpha",dstFactor:"one-minus-src",operation:"add"}};_.erase={alpha:{srcFactor:"zero",dstFactor:"one-minus-src-alpha",operation:"add"},color:{srcFactor:"zero",dstFactor:"one-minus-src",operation:"add"}};_.min={alpha:{srcFactor:"one",dstFactor:"one",operation:"min"},color:{srcFactor:"one",dstFactor:"one",operation:"min"}};_.max={alpha:{srcFactor:"one",dstFactor:"one",operation:"max"},color:{srcFactor:"one",dstFactor:"one",operation:"max"}};class re{constructor(){this.defaultState=new N,this.defaultState.blend=!0}contextChange(e){this.gpu=e}getColorTargets(e,t){const r=_[e.blendMode]||_.normal,s=[],i={format:"bgra8unorm",writeMask:0,blend:r};for(let n=0;n<t;n++)s[n]=i;return s}destroy(){this.gpu=null}}re.extension={type:[l.WebGPUSystem],name:"state"};const Ve={type:"image",upload(o,e,t,r=0){const s=o.resource,i=(o.pixelWidth|0)*(o.pixelHeight|0),n=s.byteLength/i;t.device.queue.writeTexture({texture:e,origin:{x:0,y:0,z:r}},s,{offset:0,rowsPerImage:o.pixelHeight,bytesPerRow:o.pixelWidth*n},{width:o.pixelWidth,height:o.pixelHeight,depthOrArrayLayers:1})}},se={"bc1-rgba-unorm":{blockBytes:8,blockWidth:4,blockHeight:4},"bc2-rgba-unorm":{blockBytes:16,blockWidth:4,blockHeight:4},"bc3-rgba-unorm":{blockBytes:16,blockWidth:4,blockHeight:4},"bc7-rgba-unorm":{blockBytes:16,blockWidth:4,blockHeight:4},"etc1-rgb-unorm":{blockBytes:8,blockWidth:4,blockHeight:4},"etc2-rgba8unorm":{blockBytes:16,blockWidth:4,blockHeight:4},"astc-4x4-unorm":{blockBytes:16,blockWidth:4,blockHeight:4}},je={blockBytes:4,blockWidth:1,blockHeight:1},Ke={type:"compressed",upload(o,e,t,r=0){let s=o.pixelWidth,i=o.pixelHeight;const n=se[o.format]||je;for(let a=0;a<o.resource.length;a++){const u=o.resource[a],c=Math.ceil(s/n.blockWidth)*n.blockBytes;t.device.queue.writeTexture({texture:e,mipLevel:a,origin:{x:0,y:0,z:r}},u,{offset:0,bytesPerRow:c},{width:Math.ceil(s/n.blockWidth)*n.blockWidth,height:Math.ceil(i/n.blockHeight)*n.blockHeight,depthOrArrayLayers:1}),s=Math.max(s>>1,1),i=Math.max(i>>1,1)}}},L=["right","left","top","bottom","front","back"];function qe(o){return{type:"cube",upload(e,t,r){const s=e.faces;for(let i=0;i<L.length;i++){const n=L[i],a=s[n];(o[a.uploadMethodId]||o.image).upload(a,t,r,i)}}}}const ie={type:"image",upload(o,e,t,r=0){const s=o.resource;if(!s)return;if(globalThis.HTMLImageElement&&s instanceof HTMLImageElement){const u=T.get().createCanvas(s.width,s.height);u.getContext("2d").drawImage(s,0,0,s.width,s.height),o.resource=u,v("ImageSource: Image element passed, converting to canvas and replacing resource.")}const i=Math.min(e.width,o.resourceWidth||o.pixelWidth),n=Math.min(e.height,o.resourceHeight||o.pixelHeight),a=o.alphaMode==="premultiply-alpha-on-upload";t.device.queue.copyExternalImageToTexture({source:s},{texture:e,origin:{x:0,y:0,z:r},premultipliedAlpha:a},{width:i,height:n})}},Ye={type:"video",upload(o,e,t,r){ie.upload(o,e,t,r)}};class $e{constructor(e){this.device=e,this.sampler=e.createSampler({minFilter:"linear"}),this.pipelines={}}_getMipmapPipeline(e){let t=this.pipelines[e];return t||(this.mipmapShaderModule||(this.mipmapShaderModule=this.device.createShaderModule({code:` + var<private> pos : array<vec2<f32>, 3> = array<vec2<f32>, 3>( + vec2<f32>(-1.0, -1.0), vec2<f32>(-1.0, 3.0), vec2<f32>(3.0, -1.0)); + + struct VertexOutput { + @builtin(position) position : vec4<f32>, + @location(0) texCoord : vec2<f32>, + }; + + @vertex + fn vertexMain(@builtin(vertex_index) vertexIndex : u32) -> VertexOutput { + var output : VertexOutput; + output.texCoord = pos[vertexIndex] * vec2<f32>(0.5, -0.5) + vec2<f32>(0.5); + output.position = vec4<f32>(pos[vertexIndex], 0.0, 1.0); + return output; + } + + @group(0) @binding(0) var imgSampler : sampler; + @group(0) @binding(1) var img : texture_2d<f32>; + + @fragment + fn fragmentMain(@location(0) texCoord : vec2<f32>) -> @location(0) vec4<f32> { + return textureSample(img, imgSampler, texCoord); + } + `})),t=this.device.createRenderPipeline({layout:"auto",vertex:{module:this.mipmapShaderModule,entryPoint:"vertexMain"},fragment:{module:this.mipmapShaderModule,entryPoint:"fragmentMain",targets:[{format:e}]}}),this.pipelines[e]=t),t}generateMipmap(e){const t=this._getMipmapPipeline(e.format);if(e.dimension==="3d"||e.dimension==="1d")throw new Error("Generating mipmaps for non-2d textures is currently unsupported!");let r=e;const s=e.depthOrArrayLayers||1,i=e.usage&GPUTextureUsage.RENDER_ATTACHMENT;if(!i){const u={size:{width:Math.ceil(e.width/2),height:Math.ceil(e.height/2),depthOrArrayLayers:s},format:e.format,usage:GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_SRC|GPUTextureUsage.RENDER_ATTACHMENT,mipLevelCount:e.mipLevelCount-1};r=this.device.createTexture(u)}const n=this.device.createCommandEncoder({}),a=t.getBindGroupLayout(0);for(let u=0;u<s;++u){let c=e.createView({baseMipLevel:0,mipLevelCount:1,dimension:"2d",baseArrayLayer:u,arrayLayerCount:1}),f=i?1:0;for(let h=1;h<e.mipLevelCount;++h){const p=r.createView({baseMipLevel:f++,mipLevelCount:1,dimension:"2d",baseArrayLayer:u,arrayLayerCount:1}),d=n.beginRenderPass({colorAttachments:[{view:p,storeOp:"store",loadOp:"clear",clearValue:{r:0,g:0,b:0,a:0}}]}),m=this.device.createBindGroup({layout:a,entries:[{binding:0,resource:this.sampler},{binding:1,resource:c}]});d.setPipeline(t),d.setBindGroup(0,m),d.draw(3,1,0,0),d.end(),c=p}}if(!i){const u={width:Math.ceil(e.width/2),height:Math.ceil(e.height/2),depthOrArrayLayers:s};for(let c=1;c<e.mipLevelCount;++c)n.copyTextureToTexture({texture:r,mipLevel:c-1},{texture:e,mipLevel:c},u),u.width=Math.ceil(u.width/2),u.height=Math.ceil(u.height/2)}return this.device.queue.submit([n.finish()]),i||r.destroy(),e}}class Xe{constructor(e){this.textureView=null,this.gpuTexture=e}destroy(){this.gpuTexture.destroy(),this.textureView=null,this.gpuTexture=null}}const M=class ne{constructor(e){this._gpuSamplers=Object.create(null),this._bindGroupHash=Object.create(null),this._renderer=e,e.gc.addCollection(this,"_bindGroupHash","hash"),this._managedTextures=new k({renderer:e,type:"resource",onUnload:this.onSourceUnload.bind(this),name:"gpuTextureSource"});const t={image:ie,buffer:Ve,video:Ye,compressed:Ke,...ne.uploadExtensions};this._uploads={...t,cube:qe(t)}}get managedTextures(){return Object.values(this._managedTextures.items)}contextChange(e){this._gpu=e}initSource(e){var t;return((t=e._gpuData[this._renderer.uid])==null?void 0:t.gpuTexture)||this._initSource(e)}_initSource(e){if(e.autoGenerateMipmaps){const c=Math.max(e.pixelWidth,e.pixelHeight);e.mipLevelCount=Math.floor(Math.log2(c))+1}let t;e.sampleCount>1?(t=GPUTextureUsage.RENDER_ATTACHMENT,e.transient&&this._renderer.device.extensions.transientAttachment&&(t|=GPUTextureUsage.TRANSIENT_ATTACHMENT)):(t=GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_DST,e.uploadMethodId!=="compressed"&&(t|=GPUTextureUsage.RENDER_ATTACHMENT,t|=GPUTextureUsage.COPY_SRC));const r=se[e.format]||{blockWidth:1,blockHeight:1},s=Math.ceil(e.pixelWidth/r.blockWidth)*r.blockWidth,i=Math.ceil(e.pixelHeight/r.blockHeight)*r.blockHeight,n={label:e.label,size:{width:s,height:i,depthOrArrayLayers:e.arrayLayerCount},format:e.format,sampleCount:e.sampleCount,mipLevelCount:e.mipLevelCount,dimension:e.dimension,usage:t},a=this._gpu.device.createTexture(n);return e._gpuData[this._renderer.uid]=new Xe(a),this._managedTextures.add(e)&&(e.on("update",this.onSourceUpdate,this),e.on("resize",this.onSourceResize,this),e.on("updateMipmaps",this.onUpdateMipmaps,this)),this.onSourceUpdate(e),a}onSourceUpdate(e){const t=this.getGpuSource(e);t&&(this._uploads[e.uploadMethodId]&&this._uploads[e.uploadMethodId].upload(e,t,this._gpu),e.autoGenerateMipmaps&&e.mipLevelCount>1&&this.onUpdateMipmaps(e))}onUpdateMipmaps(e){this._mipmapGenerator||(this._mipmapGenerator=new $e(this._gpu.device));const t=this.getGpuSource(e);this._mipmapGenerator.generateMipmap(t)}onSourceUnload(e){e.off("update",this.onSourceUpdate,this),e.off("resize",this.onSourceResize,this),e.off("updateMipmaps",this.onUpdateMipmaps,this)}onSourceResize(e){e._gcLastUsed=this._renderer.gc.now;const t=e._gpuData[this._renderer.uid],r=t==null?void 0:t.gpuTexture;r?(r.width!==e.pixelWidth||r.height!==e.pixelHeight)&&(t.destroy(),this._bindGroupHash[e.uid]=null,e._gpuData[this._renderer.uid]=null,this.initSource(e)):this.initSource(e)}_initSampler(e){return this._gpuSamplers[e._resourceId]=this._gpu.device.createSampler(e),this._gpuSamplers[e._resourceId]}getGpuSampler(e){return this._gpuSamplers[e._resourceId]||this._initSampler(e)}getGpuSource(e){var t;return e._gcLastUsed=this._renderer.gc.now,((t=e._gpuData[this._renderer.uid])==null?void 0:t.gpuTexture)||this.initSource(e)}getTextureBindGroup(e){return this._bindGroupHash[e.uid]||this._createTextureBindGroup(e)}_createTextureBindGroup(e){const t=e.source;return this._bindGroupHash[e.uid]=new z({0:t,1:t.style,2:new F({uTextureMatrix:{type:"mat3x3<f32>",value:e.textureMatrix.mapCoord}})}),this._bindGroupHash[e.uid]}getTextureView(e){const t=e.source;t._gcLastUsed=this._renderer.gc.now;let r=t._gpuData[this._renderer.uid];return r||(this.initSource(t),r=t._gpuData[this._renderer.uid]),r.textureView||(r.textureView=r.gpuTexture.createView({dimension:t.viewDimension})),r.textureView}generateCanvas(e){const t=this._renderer,r=t.gpu.device.createCommandEncoder(),s=T.get().createCanvas();s.width=e.source.pixelWidth,s.height=e.source.pixelHeight;const i=s.getContext("webgpu");return i.configure({device:t.gpu.device,usage:GPUTextureUsage.COPY_DST|GPUTextureUsage.COPY_SRC,format:T.get().getNavigator().gpu.getPreferredCanvasFormat(),alphaMode:"premultiplied"}),r.copyTextureToTexture({texture:t.texture.getGpuSource(e.source),origin:{x:0,y:0}},{texture:i.getCurrentTexture()},{width:s.width,height:s.height}),t.gpu.device.queue.submit([r.finish()]),s}getPixels(e){const t=this.generateCanvas(e),r=E.getOptimalCanvasAndContext(t.width,t.height),s=r.context;s.drawImage(t,0,0);const{width:i,height:n}=t,a=s.getImageData(0,0,i,n),u=new Uint8ClampedArray(a.data.buffer);return E.returnCanvasAndContext(r),{pixels:u,width:i,height:n}}destroy(){this._managedTextures.destroy();for(const e of Object.keys(this._bindGroupHash)){const t=Number(e),r=this._bindGroupHash[t];r==null||r.destroy()}this._renderer=null,this._gpu=null,this._mipmapGenerator=null,this._gpuSamplers=null,this._bindGroupHash=null}};M.extension={type:[l.WebGPUSystem],name:"texture"};M.uploadExtensions=Object.create(null);let ae=M;G.handleByMap(l.TextureUploaderWebGPU,ae.uploadExtensions);class oe{constructor(){this._maxTextures=0}contextChange(e){const t=new F({uTransformMatrix:{value:new O,type:"mat3x3<f32>"},uColor:{value:new Float32Array([1,1,1,1]),type:"vec4<f32>"},uRound:{value:0,type:"f32"}});this._maxTextures=e.limits.maxBatchableTextures;const r=I({name:"graphics",bits:[be,xe(this._maxTextures),Ue,W]});this.shader=new H({gpuProgram:r,resources:{localUniforms:t}})}execute(e,t){const r=t.context,s=r.customShader||this.shader,i=e.renderer,n=i.graphicsContext,{batcher:a,instructions:u}=n.getContextRenderData(r),c=i.encoder;c.setGeometry(a.geometry,s.gpuProgram);const f=i.globalUniforms.bindGroup;c.setBindGroup(0,f,s.gpuProgram);const h=i.renderPipes.uniformBatch.getUniformBindGroup(s.resources.localUniforms,!0);c.setBindGroup(2,h,s.gpuProgram);const p=u.instructions;let d=null;for(let m=0;m<u.instructionSize;m++){const g=p[m];if(g.topology!==d&&(d=g.topology,c.setPipelineFromGeometryProgramAndState(a.geometry,s.gpuProgram,e.state,g.topology)),s.groups[1]=g.bindGroup,!g.gpuBindGroup){const x=g.textures;g.bindGroup=D(x.textures,x.count,this._maxTextures),g.gpuBindGroup=i.bindGroup.getBindGroup(g.bindGroup,s.gpuProgram,1)}c.setBindGroup(1,g.bindGroup,s.gpuProgram),c.renderPassEncoder.drawIndexed(g.size,1,g.start)}}destroy(){this.shader.destroy(!0),this.shader=null}}oe.extension={type:[l.WebGPUPipesAdaptor],name:"graphics"};class ue{init(){const e=I({name:"mesh",bits:[Me,we,W]});this._shader=new H({gpuProgram:e,resources:{uTexture:A.EMPTY._source,uSampler:A.EMPTY._source.style,textureUniforms:{uTextureMatrix:{type:"mat3x3<f32>",value:new O}}}})}execute(e,t){const r=e.renderer;let s=t._shader;if(!s)s=this._shader,s.groups[2]=r.texture.getTextureBindGroup(t.texture);else if(!s.gpuProgram){v("Mesh shader has no gpuProgram",t.shader);return}const i=s.gpuProgram;if(i.autoAssignGlobalUniforms&&(s.groups[0]=r.globalUniforms.bindGroup),i.autoAssignLocalUniforms){const n=e.localUniforms;s.groups[1]=r.renderPipes.uniformBatch.getUniformBindGroup(n,!0)}r.encoder.draw({geometry:t._geometry,shader:s,state:t.state})}destroy(){this._shader.destroy(!0),this._shader=null}}ue.extension={type:[l.WebGPUPipesAdaptor],name:"mesh"};const Ze=[...Ee,Z,Y,U,$,K,ae,ee,te,re,Q,q,X,j],Je=[...Ae,J],Qe=[V,ue,oe],ce=[],de=[],he=[];G.handleByNamedList(l.WebGPUSystem,ce);G.handleByNamedList(l.WebGPUPipes,de);G.handleByNamedList(l.WebGPUPipesAdaptor,he);G.add(...Ze,...Je,...Qe);class at extends ye{constructor(){const e={name:"webgpu",type:Ge.WEBGPU,systems:ce,renderPipes:de,renderPipeAdaptors:he};super(e)}}export{at as WebGPURenderer}; diff --git a/2026/games_submissions/sunshoes/assets/animations/explosion.json b/2026/games_submissions/sunshoes/assets/animations/explosion.json new file mode 100644 index 0000000..55a2776 --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/animations/explosion.json @@ -0,0 +1,43 @@ +{ + "frames": { + "explosion-0": { + "frame": { "x": 0, "y": 0, "w": 32, "h": 32 }, + "sourceSize": { "w": 32, "h": 32 }, + "spriteSourceSize": { "x": 0, "y": 0, "w": 32, "h": 32 } + }, + "explosion-1": { + "frame": { "x": 32, "y": 0, "w": 32, "h": 32 }, + "sourceSize": { "w": 32, "h": 32 }, + "spriteSourceSize": { "x": 0, "y": 0, "w": 32, "h": 32 } + }, + "explosion-2": { + "frame": { "x": 64, "y": 0, "w": 32, "h": 32 }, + "sourceSize": { "w": 32, "h": 32 }, + "spriteSourceSize": { "x": 0, "y": 0, "w": 32, "h": 32 } + }, + "explosion-3": { + "frame": { "x": 96, "y": 0, "w": 32, "h": 32 }, + "sourceSize": { "w": 32, "h": 32 }, + "spriteSourceSize": { "x": 0, "y": 0, "w": 32, "h": 32 } + }, + "explosion-4": { + "frame": { "x": 128, "y": 0, "w": 32, "h": 32 }, + "sourceSize": { "w": 32, "h": 32 }, + "spriteSourceSize": { "x": 0, "y": 0, "w": 32, "h": 32 } + }, + "explosion-5": { + "frame": { "x": 160, "y": 0, "w": 32, "h": 32 }, + "sourceSize": { "w": 32, "h": 32 }, + "spriteSourceSize": { "x": 0, "y": 0, "w": 32, "h": 32 } + } + }, + "meta": { + "image": "/explosion.png", + "format": "RGBA8888", + "size": { "w": 192, "h": 32 }, + "scale": 1 + }, + "animations": { + "explosion": ["explosion-0", "explosion-1", "explosion-2", "explosion-3", "explosion-4", "explosion-5"] + } +} diff --git a/2026/games_submissions/sunshoes/assets/animations/explosion.png b/2026/games_submissions/sunshoes/assets/animations/explosion.png Binary files differnew file mode 100644 index 0000000..1244e21 --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/animations/explosion.png diff --git a/2026/games_submissions/sunshoes/assets/browserAll-1STCoqOQ.js b/2026/games_submissions/sunshoes/assets/browserAll-1STCoqOQ.js new file mode 100644 index 0000000..26fbd19 --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/browserAll-1STCoqOQ.js @@ -0,0 +1,14 @@ +import{a0 as A,a1 as Z,a2 as g,a3 as te,z as b,E as ie,w as y,F as w,a4 as V}from"./index-DvAPfvr6.js";import"./webworkerAll-3Ebn88U3.js";import"./Filter-BiIvpnZm.js";class q{constructor(e){this._lastTransform="",this._observer=null,this._tickerAttached=!1,this.updateTranslation=()=>{if(!this._canvas)return;const t=this._canvas.getBoundingClientRect(),i=this._canvas.width,s=this._canvas.height,n=t.width/i*this._renderer.resolution,o=t.height/s*this._renderer.resolution,r=t.left,h=t.top,d=`translate(${r}px, ${h}px) scale(${n}, ${o})`;d!==this._lastTransform&&(this._domElement.style.transform=d,this._lastTransform=d)},this._domElement=e.domElement,this._renderer=e.renderer,!(globalThis.OffscreenCanvas&&this._renderer.canvas instanceof OffscreenCanvas)&&(this._canvas=this._renderer.canvas,this._attachObserver())}get canvas(){return this._canvas}ensureAttached(){!this._domElement.parentNode&&this._canvas.parentNode&&(this._canvas.parentNode.appendChild(this._domElement),this.updateTranslation())}_attachObserver(){"ResizeObserver"in globalThis?(this._observer&&(this._observer.disconnect(),this._observer=null),this._observer=new ResizeObserver(e=>{for(const t of e){if(t.target!==this._canvas)continue;const i=this.canvas.width,s=this.canvas.height,n=t.contentRect.width/i*this._renderer.resolution,o=t.contentRect.height/s*this._renderer.resolution;(this._lastScaleX!==n||this._lastScaleY!==o)&&(this.updateTranslation(),this._lastScaleX=n,this._lastScaleY=o)}}),this._observer.observe(this._canvas)):this._tickerAttached||A.shared.add(this.updateTranslation,this,Z.HIGH)}destroy(){this._observer?(this._observer.disconnect(),this._observer=null):this._tickerAttached&&A.shared.remove(this.updateTranslation),this._domElement=null,this._renderer=null,this._canvas=null,this._tickerAttached=!1,this._lastTransform="",this._lastScaleX=null,this._lastScaleY=null}}class O{constructor(e){this.bubbles=!0,this.cancelBubble=!0,this.cancelable=!1,this.composed=!1,this.defaultPrevented=!1,this.eventPhase=O.prototype.NONE,this.propagationStopped=!1,this.propagationImmediatelyStopped=!1,this.layer=new g,this.page=new g,this.NONE=0,this.CAPTURING_PHASE=1,this.AT_TARGET=2,this.BUBBLING_PHASE=3,this.manager=e}get layerX(){return this.layer.x}get layerY(){return this.layer.y}get pageX(){return this.page.x}get pageY(){return this.page.y}get data(){return this}composedPath(){return this.manager&&(!this.path||this.path[this.path.length-1]!==this.target)&&(this.path=this.target?this.manager.propagationPath(this.target):[]),this.path}initEvent(e,t,i){throw new Error("initEvent() is a legacy DOM API. It is not implemented in the Federated Events API.")}initUIEvent(e,t,i,s,n){throw new Error("initUIEvent() is a legacy DOM API. It is not implemented in the Federated Events API.")}preventDefault(){this.nativeEvent instanceof Event&&this.nativeEvent.cancelable&&this.nativeEvent.preventDefault(),this.defaultPrevented=!0}stopImmediatePropagation(){this.propagationImmediatelyStopped=!0}stopPropagation(){this.propagationStopped=!0}}var I=/iPhone/i,B=/iPod/i,C=/iPad/i,U=/\biOS-universal(?:.+)Mac\b/i,k=/\bAndroid(?:.+)Mobile\b/i,R=/Android/i,E=/(?:SD4930UR|\bSilk(?:.+)Mobile\b)/i,M=/Silk/i,m=/Windows Phone/i,X=/\bWindows(?:.+)ARM\b/i,K=/BlackBerry/i,Y=/BB10/i,H=/Opera Mini/i,F=/\b(CriOS|Chrome)(?:.+)Mobile/i,N=/Mobile(?:.+)Firefox\b/i,$=function(a){return typeof a<"u"&&a.platform==="MacIntel"&&typeof a.maxTouchPoints=="number"&&a.maxTouchPoints>1&&typeof MSStream>"u"};function se(a){return function(e){return e.test(a)}}function G(a){var e={userAgent:"",platform:"",maxTouchPoints:0};!a&&typeof navigator<"u"?e={userAgent:navigator.userAgent,platform:navigator.platform,maxTouchPoints:navigator.maxTouchPoints||0}:typeof a=="string"?e.userAgent=a:a&&a.userAgent&&(e={userAgent:a.userAgent,platform:a.platform,maxTouchPoints:a.maxTouchPoints||0});var t=e.userAgent,i=t.split("[FBAN");typeof i[1]<"u"&&(t=i[0]),i=t.split("Twitter"),typeof i[1]<"u"&&(t=i[0]);var s=se(t),n={apple:{phone:s(I)&&!s(m),ipod:s(B),tablet:!s(I)&&(s(C)||$(e))&&!s(m),universal:s(U),device:(s(I)||s(B)||s(C)||s(U)||$(e))&&!s(m)},amazon:{phone:s(E),tablet:!s(E)&&s(M),device:s(E)||s(M)},android:{phone:!s(m)&&s(E)||!s(m)&&s(k),tablet:!s(m)&&!s(E)&&!s(k)&&(s(M)||s(R)),device:!s(m)&&(s(E)||s(M)||s(k)||s(R))||s(/\bokhttp\b/i)},windows:{phone:s(m),tablet:s(X),device:s(m)||s(X)},other:{blackberry:s(K),blackberry10:s(Y),opera:s(H),firefox:s(N),chrome:s(F),device:s(K)||s(Y)||s(H)||s(N)||s(F)},any:!1,phone:!1,tablet:!1};return n.any=n.apple.device||n.android.device||n.windows.device||n.other.device,n.phone=n.apple.phone||n.android.phone||n.windows.phone,n.tablet=n.apple.tablet||n.android.tablet||n.windows.tablet,n}const ne=G.default??G,oe=ne(globalThis.navigator),re=9,W=100,ae=0,le=0,j=2,z=1,he=-1e3,ce=-1e3,de=2,L=class J{constructor(e,t=oe){this._mobileInfo=t,this.debug=!1,this._activateOnTab=!0,this._deactivateOnMouseMove=!0,this._isActive=!1,this._isMobileAccessibility=!1,this._div=null,this._pools={},this._renderId=0,this._children=[],this._androidUpdateCount=0,this._androidUpdateFrequency=500,this._isRunningTests=!1,this._boundOnKeyDown=this._onKeyDown.bind(this),this._boundOnMouseMove=this._onMouseMove.bind(this),this._hookDiv=null,(t.tablet||t.phone)&&this._createTouchHook(),this._renderer=e}get isActive(){return this._isActive}get isMobileAccessibility(){return this._isMobileAccessibility}get hookDiv(){return this._hookDiv}get div(){return this._div}_createTouchHook(){const e=document.createElement("button");e.style.width=`${z}px`,e.style.height=`${z}px`,e.style.position="absolute",e.style.top=`${he}px`,e.style.left=`${ce}px`,e.style.zIndex=de.toString(),e.style.backgroundColor="#FF0000",e.title="select to enable accessibility for this content",e.addEventListener("focus",()=>{this._isMobileAccessibility=!0,this._activate(),this._destroyTouchHook()}),document.body.appendChild(e),this._hookDiv=e}_destroyTouchHook(){this._hookDiv&&(document.body.removeChild(this._hookDiv),this._hookDiv=null)}_activate(){if(this._isActive)return;this._isActive=!0,this._div||(this._div=document.createElement("div"),this._div.style.position="absolute",this._div.style.top=`${ae}px`,this._div.style.left=`${le}px`,this._div.style.pointerEvents="none",this._div.style.zIndex=j.toString(),this._canvasObserver=new q({domElement:this._div,renderer:this._renderer})),this._activateOnTab&&globalThis.addEventListener("keydown",this._boundOnKeyDown,!1),this._deactivateOnMouseMove&&globalThis.document.addEventListener("mousemove",this._boundOnMouseMove,!0);const e=this._renderer.view.canvas;if(e.parentNode)this._canvasObserver.ensureAttached(),this._initAccessibilitySetup();else{const t=new MutationObserver(()=>{e.parentNode&&(t.disconnect(),this._canvasObserver.ensureAttached(),this._initAccessibilitySetup())});t.observe(document.body,{childList:!0,subtree:!0})}}_initAccessibilitySetup(){this._renderer.runners.postrender.add(this),this._renderer.lastObjectRendered&&this._updateAccessibleObjects(this._renderer.lastObjectRendered)}_deactivate(){var e,t;if(!(!this._isActive||this._isMobileAccessibility)){this._isActive=!1,globalThis.document.removeEventListener("mousemove",this._boundOnMouseMove,!0),this._activateOnTab&&globalThis.addEventListener("keydown",this._boundOnKeyDown,!1),this._renderer.runners.postrender.remove(this);for(const i of this._children)(e=i._accessibleDiv)!=null&&e.parentNode&&(i._accessibleDiv.parentNode.removeChild(i._accessibleDiv),i._accessibleDiv=null),i._accessibleActive=!1;for(const i in this._pools)this._pools[i].forEach(n=>{n.parentNode&&n.parentNode.removeChild(n)}),delete this._pools[i];(t=this._div)!=null&&t.parentNode&&this._div.parentNode.removeChild(this._div),this._pools={},this._children=[]}}_updateAccessibleObjects(e){if(!e.visible||!e.accessibleChildren)return;e.accessible&&(e._accessibleActive||this._addChild(e),e._renderId=this._renderId);const t=e.children;if(t)for(let i=0;i<t.length;i++)this._updateAccessibleObjects(t[i])}init(e){const i={accessibilityOptions:{...J.defaultOptions,...(e==null?void 0:e.accessibilityOptions)||{}}};this.debug=i.accessibilityOptions.debug,this._activateOnTab=i.accessibilityOptions.activateOnTab,this._deactivateOnMouseMove=i.accessibilityOptions.deactivateOnMouseMove,i.accessibilityOptions.enabledByDefault&&this._activate(),this._renderer.runners.postrender.remove(this)}postrender(){const e=performance.now();if(this._mobileInfo.android.device&&e<this._androidUpdateCount||(this._androidUpdateCount=e+this._androidUpdateFrequency,(!this._renderer.renderingToScreen||!this._renderer.view.canvas)&&!this._isRunningTests))return;const t=new Set;if(this._renderer.lastObjectRendered){this._updateAccessibleObjects(this._renderer.lastObjectRendered);for(const i of this._children)i._renderId===this._renderId&&t.add(this._children.indexOf(i))}for(let i=this._children.length-1;i>=0;i--){const s=this._children[i];t.has(i)||(s._accessibleDiv&&s._accessibleDiv.parentNode&&(s._accessibleDiv.parentNode.removeChild(s._accessibleDiv),this._getPool(s.accessibleType).push(s._accessibleDiv),s._accessibleDiv=null),s._accessibleActive=!1,te(this._children,i,1))}this._renderer.renderingToScreen&&this._canvasObserver.ensureAttached();for(let i=0;i<this._children.length;i++){const s=this._children[i];if(!s._accessibleActive||!s._accessibleDiv)continue;const n=s._accessibleDiv,o=s.hitArea||s.getBounds().rectangle;if(s.hitArea){const r=s.worldTransform;n.style.left=`${r.tx+o.x*r.a}px`,n.style.top=`${r.ty+o.y*r.d}px`,n.style.width=`${o.width*r.a}px`,n.style.height=`${o.height*r.d}px`}else this._capHitArea(o),n.style.left=`${o.x}px`,n.style.top=`${o.y}px`,n.style.width=`${o.width}px`,n.style.height=`${o.height}px`}this._renderId++}_updateDebugHTML(e){e.innerHTML=`type: ${e.type}</br> title : ${e.title}</br> tabIndex: ${e.tabIndex}`}_capHitArea(e){e.x<0&&(e.width+=e.x,e.x=0),e.y<0&&(e.height+=e.y,e.y=0);const{width:t,height:i}=this._renderer;e.x+e.width>t&&(e.width=t-e.x),e.y+e.height>i&&(e.height=i-e.y)}_addChild(e){let i=this._getPool(e.accessibleType).pop();i?(i.innerHTML="",i.removeAttribute("title"),i.removeAttribute("aria-label"),i.tabIndex=0):(e.accessibleType==="button"?i=document.createElement("button"):(i=document.createElement(e.accessibleType),i.style.cssText=` + color: transparent; + pointer-events: none; + padding: 0; + margin: 0; + border: 0; + outline: 0; + background: transparent; + box-sizing: border-box; + user-select: none; + -webkit-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + `,e.accessibleText&&(i.innerText=e.accessibleText)),i.style.width=`${W}px`,i.style.height=`${W}px`,i.style.backgroundColor=this.debug?"rgba(255,255,255,0.5)":"transparent",i.style.position="absolute",i.style.zIndex=j.toString(),i.style.borderStyle="none",navigator.userAgent.toLowerCase().includes("chrome")?i.setAttribute("aria-live","off"):i.setAttribute("aria-live","polite"),navigator.userAgent.match(/rv:.*Gecko\//)?i.setAttribute("aria-relevant","additions"):i.setAttribute("aria-relevant","text"),i.addEventListener("click",this._onClick.bind(this)),i.addEventListener("focus",this._onFocus.bind(this)),i.addEventListener("focusout",this._onFocusOut.bind(this))),i.style.pointerEvents=e.accessiblePointerEvents,i.type=e.accessibleType,e.accessibleTitle&&e.accessibleTitle!==null?i.title=e.accessibleTitle:(!e.accessibleHint||e.accessibleHint===null)&&(i.title=`container ${e.tabIndex}`),e.accessibleHint&&e.accessibleHint!==null&&i.setAttribute("aria-label",e.accessibleHint),e.interactive?i.tabIndex=e.tabIndex:i.tabIndex=0,this.debug&&this._updateDebugHTML(i),e._accessibleActive=!0,e._accessibleDiv=i,i.container=e,this._children.push(e),this._div.appendChild(e._accessibleDiv)}_dispatchEvent(e,t){const{container:i}=e.target,s=this._renderer.events.rootBoundary,n=Object.assign(new O(s),{target:i});s.rootTarget=this._renderer.lastObjectRendered,t.forEach(o=>s.dispatchEvent(n,o))}_onClick(e){this._dispatchEvent(e,["click","pointertap","tap"])}_onFocus(e){e.target.getAttribute("aria-live")||e.target.setAttribute("aria-live","assertive"),this._dispatchEvent(e,["mouseover"])}_onFocusOut(e){e.target.getAttribute("aria-live")||e.target.setAttribute("aria-live","polite"),this._dispatchEvent(e,["mouseout"])}_onKeyDown(e){e.keyCode!==re||!this._activateOnTab||this._activate()}_onMouseMove(e){e.movementX===0&&e.movementY===0||this._deactivate()}destroy(){var e;this._deactivate(),this._destroyTouchHook(),(e=this._canvasObserver)==null||e.destroy(),this._canvasObserver=null,this._div=null,this._pools=null,this._children=null,this._renderer=null,this._hookDiv=null,globalThis.removeEventListener("keydown",this._boundOnKeyDown),this._boundOnKeyDown=null,globalThis.document.removeEventListener("mousemove",this._boundOnMouseMove,!0),this._boundOnMouseMove=null}setAccessibilityEnabled(e){e?this._activate():this._deactivate()}_getPool(e){return this._pools[e]||(this._pools[e]=[]),this._pools[e]}};L.extension={type:[b.WebGLSystem,b.WebGPUSystem],name:"accessibility"};L.defaultOptions={enabledByDefault:!1,debug:!1,activateOnTab:!0,deactivateOnMouseMove:!0};let ue=L;const pe={accessible:!1,accessibleTitle:null,accessibleHint:null,tabIndex:0,accessibleType:"button",accessibleText:null,accessiblePointerEvents:"auto",accessibleChildren:!0,_accessibleActive:!1,_accessibleDiv:null,_renderId:-1};class Q{constructor(e){this._attachedDomElements=[],this._renderer=e,this._renderer.runners.postrender.add(this),this._renderer.runners.init.add(this),this._domElement=document.createElement("div"),this._domElement.style.position="absolute",this._domElement.style.top="0",this._domElement.style.left="0",this._domElement.style.pointerEvents="none",this._domElement.style.zIndex="1000"}init(){this._canvasObserver=new q({domElement:this._domElement,renderer:this._renderer})}addRenderable(e,t){this._attachedDomElements.includes(e)||this._attachedDomElements.push(e)}updateRenderable(e){}validateRenderable(e){return!0}postrender(){const e=this._attachedDomElements;if(e.length===0){this._domElement.remove();return}this._canvasObserver.ensureAttached();for(let t=0;t<e.length;t++){const i=e[t],s=i.element;if(!i.parent||i.globalDisplayStatus<7)s==null||s.remove(),e.splice(t,1),t--;else{this._domElement.contains(s)||(s.style.position="absolute",s.style.pointerEvents="auto",this._domElement.appendChild(s));const n=i.worldTransform,o=i._anchor,r=i.width*o.x,h=i.height*o.y;s.style.transformOrigin=`${r}px ${h}px`,s.style.transform=`matrix(${n.a}, ${n.b}, ${n.c}, ${n.d}, ${n.tx-r}, ${n.ty-h})`,s.style.opacity=i.groupAlpha.toString()}}}destroy(){var e;this._renderer.runners.postrender.remove(this);for(let t=0;t<this._attachedDomElements.length;t++)(e=this._attachedDomElements[t].element)==null||e.remove();this._attachedDomElements.length=0,this._domElement.remove(),this._canvasObserver.destroy(),this._renderer=null}}Q.extension={type:[b.WebGLPipes,b.WebGPUPipes,b.CanvasPipes],name:"dom"};class ve{constructor(){this.interactionFrequency=10,this._deltaTime=0,this._didMove=!1,this._tickerAdded=!1,this._pauseUpdate=!0}init(e){this.removeTickerListener(),this.events=e,this.interactionFrequency=10,this._deltaTime=0,this._didMove=!1,this._tickerAdded=!1,this._pauseUpdate=!0}get pauseUpdate(){return this._pauseUpdate}set pauseUpdate(e){this._pauseUpdate=e}addTickerListener(){this._tickerAdded||!this.domElement||(A.system.add(this._tickerUpdate,this,Z.INTERACTION),this._tickerAdded=!0)}removeTickerListener(){this._tickerAdded&&(A.system.remove(this._tickerUpdate,this),this._tickerAdded=!1)}pointerMoved(){this._didMove=!0}_update(){if(!this.domElement||this._pauseUpdate)return;if(this._didMove){this._didMove=!1;return}const e=this.events._rootPointerEvent;this.events.supportsTouchEvents&&e.pointerType==="touch"||globalThis.document.dispatchEvent(this.events.supportsPointerEvents?new PointerEvent("pointermove",{clientX:e.clientX,clientY:e.clientY,pointerType:e.pointerType,pointerId:e.pointerId}):new MouseEvent("mousemove",{clientX:e.clientX,clientY:e.clientY}))}_tickerUpdate(e){this._deltaTime+=e.deltaTime,!(this._deltaTime<this.interactionFrequency)&&(this._deltaTime=0,this._update())}destroy(){this.removeTickerListener(),this.events=null,this.domElement=null,this._deltaTime=0,this._didMove=!1,this._tickerAdded=!1,this._pauseUpdate=!0}}const _=new ve;class D extends O{constructor(){super(...arguments),this.client=new g,this.movement=new g,this.offset=new g,this.global=new g,this.screen=new g}get clientX(){return this.client.x}get clientY(){return this.client.y}get x(){return this.clientX}get y(){return this.clientY}get movementX(){return this.movement.x}get movementY(){return this.movement.y}get offsetX(){return this.offset.x}get offsetY(){return this.offset.y}get globalX(){return this.global.x}get globalY(){return this.global.y}get screenX(){return this.screen.x}get screenY(){return this.screen.y}getLocalPosition(e,t,i){return e.worldTransform.applyInverse(i||this.global,t)}getModifierState(e){return"getModifierState"in this.nativeEvent&&this.nativeEvent.getModifierState(e)}initMouseEvent(e,t,i,s,n,o,r,h,d,p,u,l,v,c,Ee){throw new Error("Method not implemented.")}}class f extends D{constructor(){super(...arguments),this.width=0,this.height=0,this.isPrimary=!1}getCoalescedEvents(){return this.type==="pointermove"||this.type==="mousemove"||this.type==="touchmove"?[this]:[]}getPredictedEvents(){throw new Error("getPredictedEvents is not supported!")}}class T extends D{constructor(){super(...arguments),this.DOM_DELTA_PIXEL=0,this.DOM_DELTA_LINE=1,this.DOM_DELTA_PAGE=2}}T.DOM_DELTA_PIXEL=0;T.DOM_DELTA_LINE=1;T.DOM_DELTA_PAGE=2;const fe=2048,me=new g,P=new g;class _e{constructor(e){this.dispatch=new ie,this.moveOnAll=!1,this.enableGlobalMoveEvents=!0,this.mappingState={trackingData:{}},this.eventPool=new Map,this._allInteractiveElements=[],this._hitElements=[],this._isPointerMoveEvent=!1,this.rootTarget=e,this.hitPruneFn=this.hitPruneFn.bind(this),this.hitTestFn=this.hitTestFn.bind(this),this.mapPointerDown=this.mapPointerDown.bind(this),this.mapPointerMove=this.mapPointerMove.bind(this),this.mapPointerOut=this.mapPointerOut.bind(this),this.mapPointerOver=this.mapPointerOver.bind(this),this.mapPointerUp=this.mapPointerUp.bind(this),this.mapPointerUpOutside=this.mapPointerUpOutside.bind(this),this.mapWheel=this.mapWheel.bind(this),this.mappingTable={},this.addEventMapping("pointerdown",this.mapPointerDown),this.addEventMapping("pointermove",this.mapPointerMove),this.addEventMapping("pointerout",this.mapPointerOut),this.addEventMapping("pointerleave",this.mapPointerOut),this.addEventMapping("pointerover",this.mapPointerOver),this.addEventMapping("pointerup",this.mapPointerUp),this.addEventMapping("pointerupoutside",this.mapPointerUpOutside),this.addEventMapping("wheel",this.mapWheel)}addEventMapping(e,t){this.mappingTable[e]||(this.mappingTable[e]=[]),this.mappingTable[e].push({fn:t,priority:0}),this.mappingTable[e].sort((i,s)=>i.priority-s.priority)}dispatchEvent(e,t){e.propagationStopped=!1,e.propagationImmediatelyStopped=!1,this.propagate(e,t),this.dispatch.emit(t||e.type,e)}mapEvent(e){if(!this.rootTarget)return;const t=this.mappingTable[e.type];if(t)for(let i=0,s=t.length;i<s;i++)t[i].fn(e);else y(`[EventBoundary]: Event mapping not defined for ${e.type}`)}hitTest(e,t){_.pauseUpdate=!0;const s=this._isPointerMoveEvent&&this.enableGlobalMoveEvents?"hitTestMoveRecursive":"hitTestRecursive",n=this[s](this.rootTarget,this.rootTarget.eventMode,me.set(e,t),this.hitTestFn,this.hitPruneFn);return n&&n[0]}propagate(e,t){if(!e.target)return;const i=e.composedPath();e.eventPhase=e.CAPTURING_PHASE;for(let s=0,n=i.length-1;s<n;s++)if(e.currentTarget=i[s],this.notifyTarget(e,t),e.propagationStopped||e.propagationImmediatelyStopped)return;if(e.eventPhase=e.AT_TARGET,e.currentTarget=e.target,this.notifyTarget(e,t),!(e.propagationStopped||e.propagationImmediatelyStopped)){e.eventPhase=e.BUBBLING_PHASE;for(let s=i.length-2;s>=0;s--)if(e.currentTarget=i[s],this.notifyTarget(e,t),e.propagationStopped||e.propagationImmediatelyStopped)return}}all(e,t,i=this._allInteractiveElements){if(i.length===0)return;e.eventPhase=e.BUBBLING_PHASE;const s=Array.isArray(t)?t:[t];for(let n=i.length-1;n>=0;n--)s.forEach(o=>{e.currentTarget=i[n],this.notifyTarget(e,o)})}propagationPath(e){const t=[e];for(let i=0;i<fe&&e!==this.rootTarget&&e.parent;i++){if(!e.parent)throw new Error("Cannot find propagation path to disconnected target");t.push(e.parent),e=e.parent}return t.reverse(),t}hitTestMoveRecursive(e,t,i,s,n,o=!1){let r=!1;if(this._interactivePrune(e))return null;if((e.eventMode==="dynamic"||t==="dynamic")&&(_.pauseUpdate=!1),e.interactiveChildren&&e.children){const p=e.children;for(let u=p.length-1;u>=0;u--){const l=p[u],v=this.hitTestMoveRecursive(l,this._isInteractive(t)?t:l.eventMode,i,s,n,o||n(e,i));if(v){if(v.length>0&&!v[v.length-1].parent)continue;const c=e.isInteractive();(v.length>0||c)&&(c&&this._allInteractiveElements.push(e),v.push(e)),this._hitElements.length===0&&(this._hitElements=v),r=!0}}}const h=this._isInteractive(t),d=e.isInteractive();return d&&d&&this._allInteractiveElements.push(e),o||this._hitElements.length>0?null:r?this._hitElements:h&&!n(e,i)&&s(e,i)?d?[e]:[]:null}hitTestRecursive(e,t,i,s,n){if(this._interactivePrune(e)||n(e,i))return null;if((e.eventMode==="dynamic"||t==="dynamic")&&(_.pauseUpdate=!1),e.interactiveChildren&&e.children){const h=e.children,d=i;for(let p=h.length-1;p>=0;p--){const u=h[p],l=this.hitTestRecursive(u,this._isInteractive(t)?t:u.eventMode,d,s,n);if(l){if(l.length>0&&!l[l.length-1].parent)continue;const v=e.isInteractive();return(l.length>0||v)&&l.push(e),l}}}const o=this._isInteractive(t),r=e.isInteractive();return o&&s(e,i)?r?[e]:[]:null}_isInteractive(e){return e==="static"||e==="dynamic"}_interactivePrune(e){return!e||!e.visible||!e.renderable||!e.measurable||e.eventMode==="none"||e.eventMode==="passive"&&!e.interactiveChildren}hitPruneFn(e,t){if(e.hitArea&&(e.worldTransform.applyInverse(t,P),!e.hitArea.contains(P.x,P.y)))return!0;if(e.effects&&e.effects.length)for(let i=0;i<e.effects.length;i++){const s=e.effects[i];if(s.containsPoint&&!s.containsPoint(t,this.hitTestFn))return!0}return!1}hitTestFn(e,t){return e.hitArea?!0:e!=null&&e.containsPoint?(e.worldTransform.applyInverse(t,P),e.containsPoint(P)):!1}notifyTarget(e,t){var n,o;if(!e.currentTarget.isInteractive())return;t??(t=e.type);const i=`on${t}`;(o=(n=e.currentTarget)[i])==null||o.call(n,e);const s=e.eventPhase===e.CAPTURING_PHASE||e.eventPhase===e.AT_TARGET?`${t}capture`:t;this._notifyListeners(e,s),e.eventPhase===e.AT_TARGET&&this._notifyListeners(e,t)}mapPointerDown(e){if(!(e instanceof f)){y("EventBoundary cannot map a non-pointer event as a pointer event");return}const t=this.createPointerEvent(e);if(this.dispatchEvent(t,"pointerdown"),t.pointerType==="touch")this.dispatchEvent(t,"touchstart");else if(t.pointerType==="mouse"||t.pointerType==="pen"){const s=t.button===2;this.dispatchEvent(t,s?"rightdown":"mousedown")}const i=this.trackingData(e.pointerId);i.pressTargetsByButton[e.button]=t.composedPath(),this.freeEvent(t)}mapPointerMove(e){var h,d;if(!(e instanceof f)){y("EventBoundary cannot map a non-pointer event as a pointer event");return}this._allInteractiveElements.length=0,this._hitElements.length=0,this._isPointerMoveEvent=!0;const t=this.createPointerEvent(e);this._isPointerMoveEvent=!1;const i=t.pointerType==="mouse"||t.pointerType==="pen",s=this.trackingData(e.pointerId),n=this.findMountedTarget(s.overTargets);if(((h=s.overTargets)==null?void 0:h.length)>0&&n!==t.target){const p=e.type==="mousemove"?"mouseout":"pointerout",u=this.createPointerEvent(e,p,n);if(this.dispatchEvent(u,"pointerout"),i&&this.dispatchEvent(u,"mouseout"),!t.composedPath().includes(n)){const l=this.createPointerEvent(e,"pointerleave",n);for(l.eventPhase=l.AT_TARGET;l.target&&!t.composedPath().includes(l.target);)l.currentTarget=l.target,this.notifyTarget(l),i&&this.notifyTarget(l,"mouseleave"),l.target=l.target.parent;this.freeEvent(l)}this.freeEvent(u)}if(n!==t.target){const p=e.type==="mousemove"?"mouseover":"pointerover",u=this.clonePointerEvent(t,p);this.dispatchEvent(u,"pointerover"),i&&this.dispatchEvent(u,"mouseover");let l=n==null?void 0:n.parent;for(;l&&l!==this.rootTarget.parent&&l!==t.target;)l=l.parent;if(!l||l===this.rootTarget.parent){const c=this.clonePointerEvent(t,"pointerenter");for(c.eventPhase=c.AT_TARGET;c.target&&c.target!==n&&c.target!==this.rootTarget.parent;)c.currentTarget=c.target,this.notifyTarget(c),i&&this.notifyTarget(c,"mouseenter"),c.target=c.target.parent;this.freeEvent(c)}this.freeEvent(u)}const o=[],r=this.enableGlobalMoveEvents??!0;this.moveOnAll?o.push("pointermove"):this.dispatchEvent(t,"pointermove"),r&&o.push("globalpointermove"),t.pointerType==="touch"&&(this.moveOnAll?o.splice(1,0,"touchmove"):this.dispatchEvent(t,"touchmove"),r&&o.push("globaltouchmove")),i&&(this.moveOnAll?o.splice(1,0,"mousemove"):this.dispatchEvent(t,"mousemove"),r&&o.push("globalmousemove"),this.cursor=(d=t.target)==null?void 0:d.cursor),o.length>0&&this.all(t,o),this._allInteractiveElements.length=0,this._hitElements.length=0,s.overTargets=t.composedPath(),this.freeEvent(t)}mapPointerOver(e){var o;if(!(e instanceof f)){y("EventBoundary cannot map a non-pointer event as a pointer event");return}const t=this.trackingData(e.pointerId),i=this.createPointerEvent(e),s=i.pointerType==="mouse"||i.pointerType==="pen";this.dispatchEvent(i,"pointerover"),s&&this.dispatchEvent(i,"mouseover"),i.pointerType==="mouse"&&(this.cursor=(o=i.target)==null?void 0:o.cursor);const n=this.clonePointerEvent(i,"pointerenter");for(n.eventPhase=n.AT_TARGET;n.target&&n.target!==this.rootTarget.parent;)n.currentTarget=n.target,this.notifyTarget(n),s&&this.notifyTarget(n,"mouseenter"),n.target=n.target.parent;t.overTargets=i.composedPath(),this.freeEvent(i),this.freeEvent(n)}mapPointerOut(e){if(!(e instanceof f)){y("EventBoundary cannot map a non-pointer event as a pointer event");return}const t=this.trackingData(e.pointerId);if(t.overTargets){const i=e.pointerType==="mouse"||e.pointerType==="pen",s=this.findMountedTarget(t.overTargets),n=this.createPointerEvent(e,"pointerout",s);this.dispatchEvent(n),i&&this.dispatchEvent(n,"mouseout");const o=this.createPointerEvent(e,"pointerleave",s);for(o.eventPhase=o.AT_TARGET;o.target&&o.target!==this.rootTarget.parent;)o.currentTarget=o.target,this.notifyTarget(o),i&&this.notifyTarget(o,"mouseleave"),o.target=o.target.parent;t.overTargets=null,this.freeEvent(n),this.freeEvent(o)}this.cursor=null}mapPointerUp(e){if(!(e instanceof f)){y("EventBoundary cannot map a non-pointer event as a pointer event");return}const t=performance.now(),i=this.createPointerEvent(e);if(this.dispatchEvent(i,"pointerup"),i.pointerType==="touch")this.dispatchEvent(i,"touchend");else if(i.pointerType==="mouse"||i.pointerType==="pen"){const r=i.button===2;this.dispatchEvent(i,r?"rightup":"mouseup")}const s=this.trackingData(e.pointerId),n=this.findMountedTarget(s.pressTargetsByButton[e.button]);let o=n;if(n&&!i.composedPath().includes(n)){let r=n;for(;r&&!i.composedPath().includes(r);){if(i.currentTarget=r,this.notifyTarget(i,"pointerupoutside"),i.pointerType==="touch")this.notifyTarget(i,"touchendoutside");else if(i.pointerType==="mouse"||i.pointerType==="pen"){const h=i.button===2;this.notifyTarget(i,h?"rightupoutside":"mouseupoutside")}r=r.parent}delete s.pressTargetsByButton[e.button],o=r}if(o){const r=this.clonePointerEvent(i,"click");r.target=o,r.path=null,s.clicksByButton[e.button]||(s.clicksByButton[e.button]={clickCount:0,target:r.target,timeStamp:t});const h=s.clicksByButton[e.button];if(h.target===r.target&&t-h.timeStamp<200?++h.clickCount:h.clickCount=1,h.target=r.target,h.timeStamp=t,r.detail=h.clickCount,r.pointerType==="mouse"){const d=r.button===2;this.dispatchEvent(r,d?"rightclick":"click")}else r.pointerType==="touch"&&this.dispatchEvent(r,"tap");this.dispatchEvent(r,"pointertap"),this.freeEvent(r)}this.freeEvent(i)}mapPointerUpOutside(e){if(!(e instanceof f)){y("EventBoundary cannot map a non-pointer event as a pointer event");return}const t=this.trackingData(e.pointerId),i=this.findMountedTarget(t.pressTargetsByButton[e.button]),s=this.createPointerEvent(e);if(i){let n=i;for(;n;)s.currentTarget=n,this.notifyTarget(s,"pointerupoutside"),s.pointerType==="touch"?this.notifyTarget(s,"touchendoutside"):(s.pointerType==="mouse"||s.pointerType==="pen")&&this.notifyTarget(s,s.button===2?"rightupoutside":"mouseupoutside"),n=n.parent;delete t.pressTargetsByButton[e.button]}this.freeEvent(s)}mapWheel(e){if(!(e instanceof T)){y("EventBoundary cannot map a non-wheel event as a wheel event");return}const t=this.createWheelEvent(e);this.dispatchEvent(t),this.freeEvent(t)}findMountedTarget(e){if(!e)return null;let t=e[0];for(let i=1;i<e.length&&e[i].parent===t;i++)t=e[i];return t}createPointerEvent(e,t,i){const s=this.allocateEvent(f);return this.copyPointerData(e,s),this.copyMouseData(e,s),this.copyData(e,s),s.nativeEvent=e.nativeEvent,s.originalEvent=e,s.target=i??this.hitTest(s.global.x,s.global.y)??this._hitElements[0],typeof t=="string"&&(s.type=t),s}createWheelEvent(e){const t=this.allocateEvent(T);return this.copyWheelData(e,t),this.copyMouseData(e,t),this.copyData(e,t),t.nativeEvent=e.nativeEvent,t.originalEvent=e,t.target=this.hitTest(t.global.x,t.global.y),t}clonePointerEvent(e,t){const i=this.allocateEvent(f);return i.nativeEvent=e.nativeEvent,i.originalEvent=e.originalEvent,this.copyPointerData(e,i),this.copyMouseData(e,i),this.copyData(e,i),i.target=e.target,i.path=e.composedPath().slice(),i.type=t??i.type,i}copyWheelData(e,t){t.deltaMode=e.deltaMode,t.deltaX=e.deltaX,t.deltaY=e.deltaY,t.deltaZ=e.deltaZ}copyPointerData(e,t){e instanceof f&&t instanceof f&&(t.pointerId=e.pointerId,t.width=e.width,t.height=e.height,t.isPrimary=e.isPrimary,t.pointerType=e.pointerType,t.pressure=e.pressure,t.tangentialPressure=e.tangentialPressure,t.tiltX=e.tiltX,t.tiltY=e.tiltY,t.twist=e.twist)}copyMouseData(e,t){e instanceof D&&t instanceof D&&(t.altKey=e.altKey,t.button=e.button,t.buttons=e.buttons,t.client.copyFrom(e.client),t.ctrlKey=e.ctrlKey,t.metaKey=e.metaKey,t.movement.copyFrom(e.movement),t.screen.copyFrom(e.screen),t.shiftKey=e.shiftKey,t.global.copyFrom(e.global))}copyData(e,t){t.isTrusted=e.isTrusted,t.srcElement=e.srcElement,t.timeStamp=performance.now(),t.type=e.type,t.detail=e.detail,t.view=e.view,t.which=e.which,t.layer.copyFrom(e.layer),t.page.copyFrom(e.page)}trackingData(e){return this.mappingState.trackingData[e]||(this.mappingState.trackingData[e]={pressTargetsByButton:{},clicksByButton:{},overTarget:null}),this.mappingState.trackingData[e]}allocateEvent(e){this.eventPool.has(e)||this.eventPool.set(e,[]);const t=this.eventPool.get(e).pop()||new e(this);return t.eventPhase=t.NONE,t.currentTarget=null,t.defaultPrevented=!1,t.path=null,t.target=null,t}freeEvent(e){if(e.manager!==this)throw new Error("It is illegal to free an event not managed by this EventBoundary!");const t=e.constructor;this.eventPool.has(t)||this.eventPool.set(t,[]),this.eventPool.get(t).push(e)}_notifyListeners(e,t){const i=e.currentTarget._events[t];if(i)if("fn"in i)i.once&&e.currentTarget.removeListener(t,i.fn,void 0,!0),i.fn.call(i.context,e);else for(let s=0,n=i.length;s<n&&!e.propagationImmediatelyStopped;s++)i[s].once&&e.currentTarget.removeListener(t,i[s].fn,void 0,!0),i[s].fn.call(i[s].context,e)}}const ge=1,ye={touchstart:"pointerdown",touchend:"pointerup",touchendoutside:"pointerupoutside",touchmove:"pointermove",touchcancel:"pointercancel"},S=class x{constructor(e){this.supportsTouchEvents="ontouchstart"in globalThis,this.supportsPointerEvents=!!globalThis.PointerEvent,this.domElement=null,this.resolution=1,this.renderer=e,this.rootBoundary=new _e(null),_.init(this),this.autoPreventDefault=!0,this._eventsAdded=!1,this._rootPointerEvent=new f(null),this._rootWheelEvent=new T(null),this.cursorStyles={default:"inherit",pointer:"pointer"},this.features=new Proxy({...x.defaultEventFeatures},{set:(t,i,s)=>(i==="globalMove"&&(this.rootBoundary.enableGlobalMoveEvents=s),t[i]=s,!0)}),this._onPointerDown=this._onPointerDown.bind(this),this._onPointerMove=this._onPointerMove.bind(this),this._onPointerUp=this._onPointerUp.bind(this),this._onPointerOverOut=this._onPointerOverOut.bind(this),this.onWheel=this.onWheel.bind(this)}static get defaultEventMode(){return this._defaultEventMode}init(e){const{canvas:t,resolution:i}=this.renderer;this.setTargetElement(t),this.resolution=i,x._defaultEventMode=e.eventMode??"passive",Object.assign(this.features,e.eventFeatures??{}),this.rootBoundary.enableGlobalMoveEvents=this.features.globalMove}resolutionChange(e){this.resolution=e}destroy(){_.destroy(),this.setTargetElement(null),this.renderer=null,this._currentCursor=null}setCursor(e){e||(e="default");let t=!0;if(globalThis.OffscreenCanvas&&this.domElement instanceof OffscreenCanvas&&(t=!1),this._currentCursor===e)return;this._currentCursor=e;const i=this.cursorStyles[e];if(i)switch(typeof i){case"string":t&&(this.domElement.style.cursor=i);break;case"function":i(e);break;case"object":t&&Object.assign(this.domElement.style,i);break}else t&&typeof e=="string"&&!Object.prototype.hasOwnProperty.call(this.cursorStyles,e)&&(this.domElement.style.cursor=e)}get pointer(){return this._rootPointerEvent}_onPointerDown(e){if(!this.features.click)return;this.rootBoundary.rootTarget=this.renderer.lastObjectRendered;const t=this._normalizeToPointerData(e);this.autoPreventDefault&&t[0].isNormalized&&(e.cancelable||!("cancelable"in e))&&e.preventDefault();for(let i=0,s=t.length;i<s;i++){const n=t[i],o=this._bootstrapEvent(this._rootPointerEvent,n);this.rootBoundary.mapEvent(o)}this.setCursor(this.rootBoundary.cursor)}_onPointerMove(e){if(!this.features.move)return;this.rootBoundary.rootTarget=this.renderer.lastObjectRendered,_.pointerMoved();const t=this._normalizeToPointerData(e);for(let i=0,s=t.length;i<s;i++){const n=this._bootstrapEvent(this._rootPointerEvent,t[i]);this.rootBoundary.mapEvent(n)}this.setCursor(this.rootBoundary.cursor)}_onPointerUp(e){if(!this.features.click)return;this.rootBoundary.rootTarget=this.renderer.lastObjectRendered;let t=e.target;e.composedPath&&e.composedPath().length>0&&(t=e.composedPath()[0]);const i=t!==this.domElement?"outside":"",s=this._normalizeToPointerData(e);for(let n=0,o=s.length;n<o;n++){const r=this._bootstrapEvent(this._rootPointerEvent,s[n]);r.type+=i,this.rootBoundary.mapEvent(r)}this.setCursor(this.rootBoundary.cursor)}_onPointerOverOut(e){if(!this.features.click)return;this.rootBoundary.rootTarget=this.renderer.lastObjectRendered;const t=this._normalizeToPointerData(e);for(let i=0,s=t.length;i<s;i++){const n=this._bootstrapEvent(this._rootPointerEvent,t[i]);this.rootBoundary.mapEvent(n)}this.setCursor(this.rootBoundary.cursor)}onWheel(e){if(!this.features.wheel)return;const t=this.normalizeWheelEvent(e);this.rootBoundary.rootTarget=this.renderer.lastObjectRendered,this.rootBoundary.mapEvent(t)}setTargetElement(e){this._removeEvents(),this.domElement=e,_.domElement=e,this._addEvents()}_addEvents(){if(this._eventsAdded||!this.domElement)return;_.addTickerListener();const e=this.domElement.style;e&&(globalThis.navigator.msPointerEnabled?(e.msContentZooming="none",e.msTouchAction="none"):this.supportsPointerEvents&&(e.touchAction="none")),this.supportsPointerEvents?(globalThis.document.addEventListener("pointermove",this._onPointerMove,!0),this.domElement.addEventListener("pointerdown",this._onPointerDown,!0),this.domElement.addEventListener("pointerleave",this._onPointerOverOut,!0),this.domElement.addEventListener("pointerover",this._onPointerOverOut,!0),globalThis.addEventListener("pointerup",this._onPointerUp,!0)):(globalThis.document.addEventListener("mousemove",this._onPointerMove,!0),this.domElement.addEventListener("mousedown",this._onPointerDown,!0),this.domElement.addEventListener("mouseout",this._onPointerOverOut,!0),this.domElement.addEventListener("mouseover",this._onPointerOverOut,!0),globalThis.addEventListener("mouseup",this._onPointerUp,!0),this.supportsTouchEvents&&(this.domElement.addEventListener("touchstart",this._onPointerDown,!0),this.domElement.addEventListener("touchend",this._onPointerUp,!0),this.domElement.addEventListener("touchmove",this._onPointerMove,!0))),this.domElement.addEventListener("wheel",this.onWheel,{passive:!0,capture:!0}),this._eventsAdded=!0}_removeEvents(){if(!this._eventsAdded||!this.domElement)return;_.removeTickerListener();const e=this.domElement.style;e&&(globalThis.navigator.msPointerEnabled?(e.msContentZooming="",e.msTouchAction=""):this.supportsPointerEvents&&(e.touchAction="")),this.supportsPointerEvents?(globalThis.document.removeEventListener("pointermove",this._onPointerMove,!0),this.domElement.removeEventListener("pointerdown",this._onPointerDown,!0),this.domElement.removeEventListener("pointerleave",this._onPointerOverOut,!0),this.domElement.removeEventListener("pointerover",this._onPointerOverOut,!0),globalThis.removeEventListener("pointerup",this._onPointerUp,!0)):(globalThis.document.removeEventListener("mousemove",this._onPointerMove,!0),this.domElement.removeEventListener("mousedown",this._onPointerDown,!0),this.domElement.removeEventListener("mouseout",this._onPointerOverOut,!0),this.domElement.removeEventListener("mouseover",this._onPointerOverOut,!0),globalThis.removeEventListener("mouseup",this._onPointerUp,!0),this.supportsTouchEvents&&(this.domElement.removeEventListener("touchstart",this._onPointerDown,!0),this.domElement.removeEventListener("touchend",this._onPointerUp,!0),this.domElement.removeEventListener("touchmove",this._onPointerMove,!0))),this.domElement.removeEventListener("wheel",this.onWheel,!0),this.domElement=null,this._eventsAdded=!1}mapPositionToPoint(e,t,i){const s=this.domElement.isConnected?this.domElement.getBoundingClientRect():{width:this.domElement.width,height:this.domElement.height,left:0,top:0},n=1/this.resolution;e.x=(t-s.left)*(this.domElement.width/s.width)*n,e.y=(i-s.top)*(this.domElement.height/s.height)*n}_normalizeToPointerData(e){const t=[];if(this.supportsTouchEvents&&e instanceof TouchEvent)for(let i=0,s=e.changedTouches.length;i<s;i++){const n=e.changedTouches[i];typeof n.button>"u"&&(n.button=0),typeof n.buttons>"u"&&(n.buttons=1),typeof n.isPrimary>"u"&&(n.isPrimary=e.touches.length===1&&e.type==="touchstart"),typeof n.width>"u"&&(n.width=n.radiusX||1),typeof n.height>"u"&&(n.height=n.radiusY||1),typeof n.tiltX>"u"&&(n.tiltX=0),typeof n.tiltY>"u"&&(n.tiltY=0),typeof n.pointerType>"u"&&(n.pointerType="touch"),typeof n.pointerId>"u"&&(n.pointerId=n.identifier||0),typeof n.pressure>"u"&&(n.pressure=n.force||.5),typeof n.twist>"u"&&(n.twist=0),typeof n.tangentialPressure>"u"&&(n.tangentialPressure=0),typeof n.layerX>"u"&&(n.layerX=n.offsetX=n.clientX),typeof n.layerY>"u"&&(n.layerY=n.offsetY=n.clientY),n.isNormalized=!0,n.type=e.type,n.altKey??(n.altKey=e.altKey),n.ctrlKey??(n.ctrlKey=e.ctrlKey),n.metaKey??(n.metaKey=e.metaKey),n.shiftKey??(n.shiftKey=e.shiftKey),t.push(n)}else if(!globalThis.MouseEvent||e instanceof MouseEvent&&(!this.supportsPointerEvents||!(e instanceof globalThis.PointerEvent))){const i=e;typeof i.isPrimary>"u"&&(i.isPrimary=!0),typeof i.width>"u"&&(i.width=1),typeof i.height>"u"&&(i.height=1),typeof i.tiltX>"u"&&(i.tiltX=0),typeof i.tiltY>"u"&&(i.tiltY=0),typeof i.pointerType>"u"&&(i.pointerType="mouse"),typeof i.pointerId>"u"&&(i.pointerId=ge),typeof i.pressure>"u"&&(i.pressure=.5),typeof i.twist>"u"&&(i.twist=0),typeof i.tangentialPressure>"u"&&(i.tangentialPressure=0),i.isNormalized=!0,t.push(i)}else t.push(e);return t}normalizeWheelEvent(e){const t=this._rootWheelEvent;return this._transferMouseData(t,e),t.deltaX=e.deltaX,t.deltaY=e.deltaY,t.deltaZ=e.deltaZ,t.deltaMode=e.deltaMode,this.mapPositionToPoint(t.screen,e.clientX,e.clientY),t.global.copyFrom(t.screen),t.offset.copyFrom(t.screen),t.nativeEvent=e,t.type=e.type,t}_bootstrapEvent(e,t){return e.originalEvent=null,e.nativeEvent=t,e.pointerId=t.pointerId,e.width=t.width,e.height=t.height,e.isPrimary=t.isPrimary,e.pointerType=t.pointerType,e.pressure=t.pressure,e.tangentialPressure=t.tangentialPressure,e.tiltX=t.tiltX,e.tiltY=t.tiltY,e.twist=t.twist,this._transferMouseData(e,t),this.mapPositionToPoint(e.screen,t.clientX,t.clientY),e.global.copyFrom(e.screen),e.offset.copyFrom(e.screen),e.isTrusted=t.isTrusted,e.type==="pointerleave"&&(e.type="pointerout"),e.type.startsWith("mouse")&&(e.type=e.type.replace("mouse","pointer")),e.type.startsWith("touch")&&(e.type=ye[e.type]||e.type),e}_transferMouseData(e,t){e.isTrusted=t.isTrusted,e.srcElement=t.srcElement,e.timeStamp=performance.now(),e.type=t.type,e.altKey=t.altKey,e.button=t.button,e.buttons=t.buttons,e.client.x=t.clientX,e.client.y=t.clientY,e.ctrlKey=t.ctrlKey,e.metaKey=t.metaKey,e.movement.x=t.movementX,e.movement.y=t.movementY,e.page.x=t.pageX,e.page.y=t.pageY,e.relatedTarget=null,e.shiftKey=t.shiftKey}};S.extension={name:"events",type:[b.WebGLSystem,b.CanvasSystem,b.WebGPUSystem],priority:-1};S.defaultEventFeatures={move:!0,globalMove:!0,click:!0,wheel:!0};let ee=S;const be={onclick:null,onmousedown:null,onmouseenter:null,onmouseleave:null,onmousemove:null,onglobalmousemove:null,onmouseout:null,onmouseover:null,onmouseup:null,onmouseupoutside:null,onpointercancel:null,onpointerdown:null,onpointerenter:null,onpointerleave:null,onpointermove:null,onglobalpointermove:null,onpointerout:null,onpointerover:null,onpointertap:null,onpointerup:null,onpointerupoutside:null,onrightclick:null,onrightdown:null,onrightup:null,onrightupoutside:null,ontap:null,ontouchcancel:null,ontouchend:null,ontouchendoutside:null,ontouchmove:null,onglobaltouchmove:null,ontouchstart:null,onwheel:null,get interactive(){return this.eventMode==="dynamic"||this.eventMode==="static"},set interactive(a){this.eventMode=a?"static":"passive"},_internalEventMode:void 0,get eventMode(){return this._internalEventMode??ee.defaultEventMode},set eventMode(a){this._internalEventMode=a},isInteractive(){return this.eventMode==="static"||this.eventMode==="dynamic"},interactiveChildren:!0,hitArea:null,addEventListener(a,e,t){const i=typeof t=="boolean"&&t||typeof t=="object"&&t.capture,s=typeof t=="object"?t.signal:void 0,n=typeof t=="object"?t.once===!0:!1,o=typeof e=="function"?void 0:e;a=i?`${a}capture`:a;const r=typeof e=="function"?e:e.handleEvent,h=this;s&&s.addEventListener("abort",()=>{h.off(a,r,o)}),n?h.once(a,r,o):h.on(a,r,o)},removeEventListener(a,e,t){const i=typeof t=="boolean"&&t||typeof t=="object"&&t.capture,s=typeof e=="function"?void 0:e;a=i?`${a}capture`:a,e=typeof e=="function"?e:e.handleEvent,this.off(a,e,s)},dispatchEvent(a){if(!(a instanceof O))throw new Error("Container cannot propagate events outside of the Federated Events API");return a.defaultPrevented=!1,a.path=null,a.target=this,a.manager.dispatchEvent(a),!a.defaultPrevented}};w.add(ue);w.mixin(V,pe);w.add(Q);w.add(ee);w.mixin(V,be); diff --git a/2026/games_submissions/sunshoes/assets/bunny.png b/2026/games_submissions/sunshoes/assets/bunny.png Binary files differnew file mode 100644 index 0000000..79c3167 --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/bunny.png diff --git a/2026/games_submissions/sunshoes/assets/index-DvAPfvr6.js b/2026/games_submissions/sunshoes/assets/index-DvAPfvr6.js new file mode 100644 index 0000000..4694962 --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/index-DvAPfvr6.js @@ -0,0 +1,300 @@ +const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["games/sunshoes/assets/browserAll-1STCoqOQ.js","games/sunshoes/assets/webworkerAll-3Ebn88U3.js","games/sunshoes/assets/Filter-BiIvpnZm.js","games/sunshoes/assets/WebGPURenderer-Ddwua8JA.js","games/sunshoes/assets/BufferResource-BZpoqTVb.js","games/sunshoes/assets/RenderTargetSystem-Cp6tD-lP.js","games/sunshoes/assets/WebGLRenderer-CdpFaPwH.js","games/sunshoes/assets/CanvasRenderer-Yf_04ykh.js"])))=>i.map(i=>d[i]); +var ra=Object.defineProperty;var na=(s,t,e)=>t in s?ra(s,t,{enumerable:!0,configurable:!0,writable:!0,value:e}):s[t]=e;var G=(s,t,e)=>na(s,typeof t!="symbol"?t+"":t,e);(function(){const t=document.createElement("link").relList;if(t&&t.supports&&t.supports("modulepreload"))return;for(const r of document.querySelectorAll('link[rel="modulepreload"]'))i(r);new MutationObserver(r=>{for(const n of r)if(n.type==="childList")for(const o of n.addedNodes)o.tagName==="LINK"&&o.rel==="modulepreload"&&i(o)}).observe(document,{childList:!0,subtree:!0});function e(r){const n={};return r.integrity&&(n.integrity=r.integrity),r.referrerPolicy&&(n.referrerPolicy=r.referrerPolicy),r.crossOrigin==="use-credentials"?n.credentials="include":r.crossOrigin==="anonymous"?n.credentials="omit":n.credentials="same-origin",n}function i(r){if(r.ep)return;r.ep=!0;const n=e(r);fetch(r.href,n)}})();const oa="modulepreload",aa=function(s){return"/"+s},ji={},pe=function(t,e,i){let r=Promise.resolve();if(e&&e.length>0){let o=function(l){return Promise.all(l.map(c=>Promise.resolve(c).then(u=>({status:"fulfilled",value:u}),u=>({status:"rejected",reason:u}))))};document.getElementsByTagName("link");const a=document.querySelector("meta[property=csp-nonce]"),h=(a==null?void 0:a.nonce)||(a==null?void 0:a.getAttribute("nonce"));r=o(e.map(l=>{if(l=aa(l),l in ji)return;ji[l]=!0;const c=l.endsWith(".css"),u=c?'[rel="stylesheet"]':"";if(document.querySelector(`link[href="${l}"]${u}`))return;const f=document.createElement("link");if(f.rel=c?"stylesheet":oa,c||(f.as="script"),f.crossOrigin="",f.href=l,h&&f.setAttribute("nonce",h),document.head.appendChild(f),c)return new Promise((d,p)=>{f.addEventListener("load",d),f.addEventListener("error",()=>p(new Error(`Unable to preload CSS for ${l}`)))})}))}function n(o){const a=new Event("vite:preloadError",{cancelable:!0});if(a.payload=o,window.dispatchEvent(a),!a.defaultPrevented)throw o}return r.then(o=>{for(const a of o||[])a.status==="rejected"&&n(a.reason);return t().catch(n)})};var I=(s=>(s.Application="application",s.WebGLPipes="webgl-pipes",s.WebGLPipesAdaptor="webgl-pipes-adaptor",s.WebGLSystem="webgl-system",s.WebGPUPipes="webgpu-pipes",s.WebGPUPipesAdaptor="webgpu-pipes-adaptor",s.WebGPUSystem="webgpu-system",s.CanvasSystem="canvas-system",s.CanvasPipesAdaptor="canvas-pipes-adaptor",s.CanvasPipes="canvas-pipes",s.Asset="asset",s.LoadParser="load-parser",s.ResolveParser="resolve-parser",s.CacheParser="cache-parser",s.DetectionParser="detection-parser",s.MaskEffect="mask-effect",s.BlendMode="blend-mode",s.TextureSource="texture-source",s.TextureUploaderWebGL="texture-uploader-webgl",s.TextureUploaderWebGPU="texture-uploader-webgpu",s.Environment="environment",s.ShapeBuilder="shape-builder",s.Batcher="batcher",s))(I||{});const ni=s=>{if(typeof s=="function"||typeof s=="object"&&s.extension){if(!s.extension)throw new Error("Extension class must have an extension object");s={...typeof s.extension!="object"?{type:s.extension}:s.extension,ref:s}}if(typeof s=="object")s={...s};else throw new Error("Invalid extension type");return typeof s.type=="string"&&(s.type=[s.type]),s},Je=(s,t)=>ni(s).priority??t,K={_addHandlers:{},_removeHandlers:{},_queue:{},remove(...s){return s.map(ni).forEach(t=>{t.type.forEach(e=>{var i,r;return(r=(i=this._removeHandlers)[e])==null?void 0:r.call(i,t)})}),this},add(...s){return s.map(ni).forEach(t=>{t.type.forEach(e=>{var n,o;const i=this._addHandlers,r=this._queue;i[e]?(o=i[e])==null||o.call(i,t):(r[e]=r[e]||[],(n=r[e])==null||n.push(t))})}),this},handle(s,t,e){var o;const i=this._addHandlers,r=this._removeHandlers;if(i[s]||r[s])throw new Error(`Extension type ${s} already has a handler`);i[s]=t,r[s]=e;const n=this._queue;return n[s]&&((o=n[s])==null||o.forEach(a=>t(a)),delete n[s]),this},handleByMap(s,t){return this.handle(s,e=>{e.name&&(t[e.name]=e.ref)},e=>{e.name&&delete t[e.name]})},handleByNamedList(s,t,e=-1){return this.handle(s,i=>{t.findIndex(n=>n.name===i.name)>=0||(t.push({name:i.name,value:i.ref}),t.sort((n,o)=>Je(o.value,e)-Je(n.value,e)))},i=>{const r=t.findIndex(n=>n.name===i.name);r!==-1&&t.splice(r,1)})},handleByList(s,t,e=-1){return this.handle(s,i=>{t.includes(i.ref)||(t.push(i.ref),t.sort((r,n)=>Je(n,e)-Je(r,e)))},i=>{const r=t.indexOf(i.ref);r!==-1&&t.splice(r,1)})},mixin(s,...t){for(const e of t)Object.defineProperties(s.prototype,Object.getOwnPropertyDescriptors(e))}},ha={extension:{type:I.Environment,name:"browser",priority:-1},test:()=>!0,load:async()=>{await pe(()=>import("./browserAll-1STCoqOQ.js"),__vite__mapDeps([0,1,2]))}},la={extension:{type:I.Environment,name:"webworker",priority:0},test:()=>typeof self<"u"&&self.WorkerGlobalScope!==void 0,load:async()=>{await pe(()=>import("./webworkerAll-3Ebn88U3.js"),__vite__mapDeps([1,2]))}};class ot{constructor(t,e,i){this._x=e||0,this._y=i||0,this._observer=t}clone(t){return new ot(t??this._observer,this._x,this._y)}set(t=0,e=t){return(this._x!==t||this._y!==e)&&(this._x=t,this._y=e,this._observer._onUpdate(this)),this}copyFrom(t){return(this._x!==t.x||this._y!==t.y)&&(this._x=t.x,this._y=t.y,this._observer._onUpdate(this)),this}copyTo(t){return t.set(this._x,this._y),t}equals(t){return t.x===this._x&&t.y===this._y}toString(){return`[pixi.js/math:ObservablePoint x=${this._x} y=${this._y} scope=${this._observer}]`}get x(){return this._x}set x(t){this._x!==t&&(this._x=t,this._observer._onUpdate(this))}get y(){return this._y}set y(t){this._y!==t&&(this._y=t,this._observer._onUpdate(this))}}function ca(s){return s&&s.__esModule&&Object.prototype.hasOwnProperty.call(s,"default")?s.default:s}var Ls={exports:{}},Yi;function ua(){return Yi||(Yi=1,(function(s){var t=Object.prototype.hasOwnProperty,e="~";function i(){}Object.create&&(i.prototype=Object.create(null),new i().__proto__||(e=!1));function r(h,l,c){this.fn=h,this.context=l,this.once=c||!1}function n(h,l,c,u,f){if(typeof c!="function")throw new TypeError("The listener must be a function");var d=new r(c,u||h,f),p=e?e+l:l;return h._events[p]?h._events[p].fn?h._events[p]=[h._events[p],d]:h._events[p].push(d):(h._events[p]=d,h._eventsCount++),h}function o(h,l){--h._eventsCount===0?h._events=new i:delete h._events[l]}function a(){this._events=new i,this._eventsCount=0}a.prototype.eventNames=function(){var l=[],c,u;if(this._eventsCount===0)return l;for(u in c=this._events)t.call(c,u)&&l.push(e?u.slice(1):u);return Object.getOwnPropertySymbols?l.concat(Object.getOwnPropertySymbols(c)):l},a.prototype.listeners=function(l){var c=e?e+l:l,u=this._events[c];if(!u)return[];if(u.fn)return[u.fn];for(var f=0,d=u.length,p=new Array(d);f<d;f++)p[f]=u[f].fn;return p},a.prototype.listenerCount=function(l){var c=e?e+l:l,u=this._events[c];return u?u.fn?1:u.length:0},a.prototype.emit=function(l,c,u,f,d,p){var g=e?e+l:l;if(!this._events[g])return!1;var m=this._events[g],_=arguments.length,y,x;if(m.fn){switch(m.once&&this.removeListener(l,m.fn,void 0,!0),_){case 1:return m.fn.call(m.context),!0;case 2:return m.fn.call(m.context,c),!0;case 3:return m.fn.call(m.context,c,u),!0;case 4:return m.fn.call(m.context,c,u,f),!0;case 5:return m.fn.call(m.context,c,u,f,d),!0;case 6:return m.fn.call(m.context,c,u,f,d,p),!0}for(x=1,y=new Array(_-1);x<_;x++)y[x-1]=arguments[x];m.fn.apply(m.context,y)}else{var w=m.length,v;for(x=0;x<w;x++)switch(m[x].once&&this.removeListener(l,m[x].fn,void 0,!0),_){case 1:m[x].fn.call(m[x].context);break;case 2:m[x].fn.call(m[x].context,c);break;case 3:m[x].fn.call(m[x].context,c,u);break;case 4:m[x].fn.call(m[x].context,c,u,f);break;default:if(!y)for(v=1,y=new Array(_-1);v<_;v++)y[v-1]=arguments[v];m[x].fn.apply(m[x].context,y)}}return!0},a.prototype.on=function(l,c,u){return n(this,l,c,u,!1)},a.prototype.once=function(l,c,u){return n(this,l,c,u,!0)},a.prototype.removeListener=function(l,c,u,f){var d=e?e+l:l;if(!this._events[d])return this;if(!c)return o(this,d),this;var p=this._events[d];if(p.fn)p.fn===c&&(!f||p.once)&&(!u||p.context===u)&&o(this,d);else{for(var g=0,m=[],_=p.length;g<_;g++)(p[g].fn!==c||f&&!p[g].once||u&&p[g].context!==u)&&m.push(p[g]);m.length?this._events[d]=m.length===1?m[0]:m:o(this,d)}return this},a.prototype.removeAllListeners=function(l){var c;return l?(c=e?e+l:l,this._events[c]&&o(this,c)):(this._events=new i,this._eventsCount=0),this},a.prototype.off=a.prototype.removeListener,a.prototype.addListener=a.prototype.on,a.prefixed=e,a.EventEmitter=a,s.exports=a})(Ls)),Ls.exports}var da=ua();const ft=ca(da),fa=Math.PI*2,pa=180/Math.PI,ma=Math.PI/180;class lt{constructor(t=0,e=0){this.x=0,this.y=0,this.x=t,this.y=e}clone(){return new lt(this.x,this.y)}copyFrom(t){return this.set(t.x,t.y),this}copyTo(t){return t.set(this.x,this.y),t}equals(t){return t.x===this.x&&t.y===this.y}set(t=0,e=t){return this.x=t,this.y=e,this}toString(){return`[pixi.js/math:Point x=${this.x} y=${this.y}]`}static get shared(){return Bs.x=0,Bs.y=0,Bs}}const Bs=new lt;class W{constructor(t=1,e=0,i=0,r=1,n=0,o=0){this.array=null,this.a=t,this.b=e,this.c=i,this.d=r,this.tx=n,this.ty=o}fromArray(t){this.a=t[0],this.b=t[1],this.c=t[3],this.d=t[4],this.tx=t[2],this.ty=t[5]}set(t,e,i,r,n,o){return this.a=t,this.b=e,this.c=i,this.d=r,this.tx=n,this.ty=o,this}toArray(t,e){this.array||(this.array=new Float32Array(9));const i=e||this.array;return t?(i[0]=this.a,i[1]=this.b,i[2]=0,i[3]=this.c,i[4]=this.d,i[5]=0,i[6]=this.tx,i[7]=this.ty,i[8]=1):(i[0]=this.a,i[1]=this.c,i[2]=this.tx,i[3]=this.b,i[4]=this.d,i[5]=this.ty,i[6]=0,i[7]=0,i[8]=1),i}apply(t,e){e=e||new lt;const i=t.x,r=t.y;return e.x=this.a*i+this.c*r+this.tx,e.y=this.b*i+this.d*r+this.ty,e}applyInverse(t,e){e=e||new lt;const i=this.a,r=this.b,n=this.c,o=this.d,a=this.tx,h=this.ty,l=1/(i*o+n*-r),c=t.x,u=t.y;return e.x=o*l*c+-n*l*u+(h*n-a*o)*l,e.y=i*l*u+-r*l*c+(-h*i+a*r)*l,e}translate(t,e){return this.tx+=t,this.ty+=e,this}scale(t,e){return this.a*=t,this.d*=e,this.c*=t,this.b*=e,this.tx*=t,this.ty*=e,this}rotate(t){const e=Math.cos(t),i=Math.sin(t),r=this.a,n=this.c,o=this.tx;return this.a=r*e-this.b*i,this.b=r*i+this.b*e,this.c=n*e-this.d*i,this.d=n*i+this.d*e,this.tx=o*e-this.ty*i,this.ty=o*i+this.ty*e,this}append(t){const e=this.a,i=this.b,r=this.c,n=this.d;return this.a=t.a*e+t.b*r,this.b=t.a*i+t.b*n,this.c=t.c*e+t.d*r,this.d=t.c*i+t.d*n,this.tx=t.tx*e+t.ty*r+this.tx,this.ty=t.tx*i+t.ty*n+this.ty,this}appendFrom(t,e){const i=t.a,r=t.b,n=t.c,o=t.d,a=t.tx,h=t.ty,l=e.a,c=e.b,u=e.c,f=e.d;return this.a=i*l+r*u,this.b=i*c+r*f,this.c=n*l+o*u,this.d=n*c+o*f,this.tx=a*l+h*u+e.tx,this.ty=a*c+h*f+e.ty,this}setTransform(t,e,i,r,n,o,a,h,l){return this.a=Math.cos(a+l)*n,this.b=Math.sin(a+l)*n,this.c=-Math.sin(a-h)*o,this.d=Math.cos(a-h)*o,this.tx=t-(i*this.a+r*this.c),this.ty=e-(i*this.b+r*this.d),this}prepend(t){const e=this.tx;if(t.a!==1||t.b!==0||t.c!==0||t.d!==1){const i=this.a,r=this.c;this.a=i*t.a+this.b*t.c,this.b=i*t.b+this.b*t.d,this.c=r*t.a+this.d*t.c,this.d=r*t.b+this.d*t.d}return this.tx=e*t.a+this.ty*t.c+t.tx,this.ty=e*t.b+this.ty*t.d+t.ty,this}decompose(t){const e=this.a,i=this.b,r=this.c,n=this.d,o=t.pivot,a=-Math.atan2(-r,n),h=Math.atan2(i,e),l=Math.abs(a+h);return l<1e-5||Math.abs(fa-l)<1e-5?(t.rotation=h,t.skew.x=t.skew.y=0):(t.rotation=0,t.skew.x=a,t.skew.y=h),t.scale.x=Math.sqrt(e*e+i*i),t.scale.y=Math.sqrt(r*r+n*n),t.position.x=this.tx+(o.x*e+o.y*r),t.position.y=this.ty+(o.x*i+o.y*n),t}invert(){const t=this.a,e=this.b,i=this.c,r=this.d,n=this.tx,o=t*r-e*i;return this.a=r/o,this.b=-e/o,this.c=-i/o,this.d=t/o,this.tx=(i*this.ty-r*n)/o,this.ty=-(t*this.ty-e*n)/o,this}isIdentity(){return this.a===1&&this.b===0&&this.c===0&&this.d===1&&this.tx===0&&this.ty===0}identity(){return this.a=1,this.b=0,this.c=0,this.d=1,this.tx=0,this.ty=0,this}clone(){const t=new W;return t.a=this.a,t.b=this.b,t.c=this.c,t.d=this.d,t.tx=this.tx,t.ty=this.ty,t}copyTo(t){return t.a=this.a,t.b=this.b,t.c=this.c,t.d=this.d,t.tx=this.tx,t.ty=this.ty,t}copyFrom(t){return this.a=t.a,this.b=t.b,this.c=t.c,this.d=t.d,this.tx=t.tx,this.ty=t.ty,this}equals(t){return t.a===this.a&&t.b===this.b&&t.c===this.c&&t.d===this.d&&t.tx===this.tx&&t.ty===this.ty}toString(){return`[pixi.js:Matrix a=${this.a} b=${this.b} c=${this.c} d=${this.d} tx=${this.tx} ty=${this.ty}]`}static get IDENTITY(){return _a.identity()}static get shared(){return ga.identity()}}const ga=new W,_a=new W,qt=[1,1,0,-1,-1,-1,0,1,1,1,0,-1,-1,-1,0,1],Kt=[0,1,1,1,0,-1,-1,-1,0,1,1,1,0,-1,-1,-1],Qt=[0,-1,-1,-1,0,1,1,1,0,1,1,1,0,-1,-1,-1],Zt=[1,1,0,-1,-1,-1,0,1,-1,-1,0,1,1,1,0,-1],oi=[],mn=[],ts=Math.sign;function ya(){for(let s=0;s<16;s++){const t=[];oi.push(t);for(let e=0;e<16;e++){const i=ts(qt[s]*qt[e]+Qt[s]*Kt[e]),r=ts(Kt[s]*qt[e]+Zt[s]*Kt[e]),n=ts(qt[s]*Qt[e]+Qt[s]*Zt[e]),o=ts(Kt[s]*Qt[e]+Zt[s]*Zt[e]);for(let a=0;a<16;a++)if(qt[a]===i&&Kt[a]===r&&Qt[a]===n&&Zt[a]===o){t.push(a);break}}}for(let s=0;s<16;s++){const t=new W;t.set(qt[s],Kt[s],Qt[s],Zt[s],0,0),mn.push(t)}}ya();const O={E:0,SE:1,S:2,SW:3,W:4,NW:5,N:6,NE:7,MIRROR_VERTICAL:8,MAIN_DIAGONAL:10,MIRROR_HORIZONTAL:12,REVERSE_DIAGONAL:14,uX:s=>qt[s],uY:s=>Kt[s],vX:s=>Qt[s],vY:s=>Zt[s],inv:s=>s&8?s&15:-s&7,add:(s,t)=>oi[s][t],sub:(s,t)=>oi[s][O.inv(t)],rotate180:s=>s^4,isVertical:s=>(s&3)===2,byDirection:(s,t)=>Math.abs(s)*2<=Math.abs(t)?t>=0?O.S:O.N:Math.abs(t)*2<=Math.abs(s)?s>0?O.E:O.W:t>0?s>0?O.SE:O.SW:s>0?O.NE:O.NW,matrixAppendRotationInv:(s,t,e=0,i=0,r=0,n=0)=>{const o=mn[O.inv(t)],a=o.a,h=o.b,l=o.c,c=o.d,u=e-Math.min(0,a*r,l*n,a*r+l*n),f=i-Math.min(0,h*r,c*n,h*r+c*n),d=s.a,p=s.b,g=s.c,m=s.d;s.a=a*d+h*g,s.b=a*p+h*m,s.c=l*d+c*g,s.d=l*p+c*m,s.tx=u*d+f*g+s.tx,s.ty=u*p+f*m+s.ty},transformRectCoords:(s,t,e,i)=>{const{x:r,y:n,width:o,height:a}=s,{x:h,y:l,width:c,height:u}=t;return e===O.E?(i.set(r+h,n+l,o,a),i):e===O.S?i.set(c-n-a+h,r+l,a,o):e===O.W?i.set(c-r-o+h,u-n-a+l,o,a):e===O.N?i.set(n+h,u-r-o+l,a,o):i.set(r+h,n+l,o,a)}},es=[new lt,new lt,new lt,new lt];class tt{constructor(t=0,e=0,i=0,r=0){this.type="rectangle",this.x=Number(t),this.y=Number(e),this.width=Number(i),this.height=Number(r)}get left(){return this.x}get right(){return this.x+this.width}get top(){return this.y}get bottom(){return this.y+this.height}isEmpty(){return this.left===this.right||this.top===this.bottom}static get EMPTY(){return new tt(0,0,0,0)}clone(){return new tt(this.x,this.y,this.width,this.height)}copyFromBounds(t){return this.x=t.minX,this.y=t.minY,this.width=t.maxX-t.minX,this.height=t.maxY-t.minY,this}copyFrom(t){return this.x=t.x,this.y=t.y,this.width=t.width,this.height=t.height,this}copyTo(t){return t.copyFrom(this),t}contains(t,e){return this.width<=0||this.height<=0?!1:t>=this.x&&t<this.x+this.width&&e>=this.y&&e<this.y+this.height}strokeContains(t,e,i,r=.5){const{width:n,height:o}=this;if(n<=0||o<=0)return!1;const a=this.x,h=this.y,l=i*(1-r),c=i-l,u=a-l,f=a+n+l,d=h-l,p=h+o+l,g=a+c,m=a+n-c,_=h+c,y=h+o-c;return t>=u&&t<=f&&e>=d&&e<=p&&!(t>g&&t<m&&e>_&&e<y)}intersects(t,e){if(!e){const k=this.x<t.x?t.x:this.x;if((this.right>t.right?t.right:this.right)<=k)return!1;const S=this.y<t.y?t.y:this.y;return(this.bottom>t.bottom?t.bottom:this.bottom)>S}const i=this.left,r=this.right,n=this.top,o=this.bottom;if(r<=i||o<=n)return!1;const a=es[0].set(t.left,t.top),h=es[1].set(t.left,t.bottom),l=es[2].set(t.right,t.top),c=es[3].set(t.right,t.bottom);if(l.x<=a.x||h.y<=a.y)return!1;const u=Math.sign(e.a*e.d-e.b*e.c);if(u===0||(e.apply(a,a),e.apply(h,h),e.apply(l,l),e.apply(c,c),Math.max(a.x,h.x,l.x,c.x)<=i||Math.min(a.x,h.x,l.x,c.x)>=r||Math.max(a.y,h.y,l.y,c.y)<=n||Math.min(a.y,h.y,l.y,c.y)>=o))return!1;const f=u*(h.y-a.y),d=u*(a.x-h.x),p=f*i+d*n,g=f*r+d*n,m=f*i+d*o,_=f*r+d*o;if(Math.max(p,g,m,_)<=f*a.x+d*a.y||Math.min(p,g,m,_)>=f*c.x+d*c.y)return!1;const y=u*(a.y-l.y),x=u*(l.x-a.x),w=y*i+x*n,v=y*r+x*n,b=y*i+x*o,A=y*r+x*o;return!(Math.max(w,v,b,A)<=y*a.x+x*a.y||Math.min(w,v,b,A)>=y*c.x+x*c.y)}pad(t=0,e=t){return this.x-=t,this.y-=e,this.width+=t*2,this.height+=e*2,this}fit(t){const e=Math.max(this.x,t.x),i=Math.min(this.x+this.width,t.x+t.width),r=Math.max(this.y,t.y),n=Math.min(this.y+this.height,t.y+t.height);return this.x=e,this.width=Math.max(i-e,0),this.y=r,this.height=Math.max(n-r,0),this}ceil(t=1,e=.001){const i=Math.ceil((this.x+this.width-e)*t)/t,r=Math.ceil((this.y+this.height-e)*t)/t;return this.x=Math.floor((this.x+e)*t)/t,this.y=Math.floor((this.y+e)*t)/t,this.width=i-this.x,this.height=r-this.y,this}scale(t,e=t){return this.x*=t,this.y*=e,this.width*=t,this.height*=e,this}enlarge(t){const e=Math.min(this.x,t.x),i=Math.max(this.x+this.width,t.x+t.width),r=Math.min(this.y,t.y),n=Math.max(this.y+this.height,t.y+t.height);return this.x=e,this.width=i-e,this.y=r,this.height=n-r,this}getBounds(t){return t||(t=new tt),t.copyFrom(this),t}containsRect(t){if(this.width<=0||this.height<=0)return!1;const e=t.x,i=t.y,r=t.x+t.width,n=t.y+t.height;return e>=this.x&&e<this.x+this.width&&i>=this.y&&i<this.y+this.height&&r>=this.x&&r<this.x+this.width&&n>=this.y&&n<this.y+this.height}set(t,e,i,r){return this.x=t,this.y=e,this.width=i,this.height=r,this}toString(){return`[pixi.js/math:Rectangle x=${this.x} y=${this.y} width=${this.width} height=${this.height}]`}}const Fs={default:-1};function J(s="default"){return Fs[s]===void 0&&(Fs[s]=-1),++Fs[s]}const Xi=new Set,_t="8.0.0",xa="8.3.4",ue={quiet:!1,noColor:!1},X=((s,t,e=3)=>{if(ue.quiet||Xi.has(t))return;let i=new Error().stack;const r=`${t} +Deprecated since v${s}`,n=typeof console.groupCollapsed=="function"&&!ue.noColor;typeof i>"u"?console.warn("PixiJS Deprecation Warning: ",r):(i=i.split(` +`).splice(e).join(` +`),n?(console.groupCollapsed("%cPixiJS Deprecation Warning: %c%s","color:#614108;background:#fffbe6","font-weight:normal;color:#614108;background:#fffbe6",r),console.warn(i),console.groupEnd()):(console.warn("PixiJS Deprecation Warning: ",r),console.warn(i))),Xi.add(t)});Object.defineProperties(X,{quiet:{get:()=>ue.quiet,set:s=>{ue.quiet=s},enumerable:!0,configurable:!1},noColor:{get:()=>ue.noColor,set:s=>{ue.noColor=s},enumerable:!0,configurable:!1}});const gn=()=>{};function _e(s){return s+=s===0?1:0,--s,s|=s>>>1,s|=s>>>2,s|=s>>>4,s|=s>>>8,s|=s>>>16,s+1}function qi(s){return!(s&s-1)&&!!s}function _n(s){const t={};for(const e in s)s[e]!==void 0&&(t[e]=s[e]);return t}const Ki=Object.create(null);function ba(s){const t=Ki[s];return t===void 0&&(Ki[s]=J("resource")),t}const yn=class xn extends ft{constructor(t={}){super(),this._resourceType="textureSampler",this._touched=0,this._maxAnisotropy=1,this.destroyed=!1,t={...xn.defaultOptions,...t},this.addressMode=t.addressMode,this.addressModeU=t.addressModeU??this.addressModeU,this.addressModeV=t.addressModeV??this.addressModeV,this.addressModeW=t.addressModeW??this.addressModeW,this.scaleMode=t.scaleMode,this.magFilter=t.magFilter??this.magFilter,this.minFilter=t.minFilter??this.minFilter,this.mipmapFilter=t.mipmapFilter??this.mipmapFilter,this.lodMinClamp=t.lodMinClamp,this.lodMaxClamp=t.lodMaxClamp,this.compare=t.compare,this.maxAnisotropy=t.maxAnisotropy??1}set addressMode(t){this.addressModeU=t,this.addressModeV=t,this.addressModeW=t}get addressMode(){return this.addressModeU}set wrapMode(t){X(_t,"TextureStyle.wrapMode is now TextureStyle.addressMode"),this.addressMode=t}get wrapMode(){return this.addressMode}set scaleMode(t){this.magFilter=t,this.minFilter=t,this.mipmapFilter=t}get scaleMode(){return this.magFilter}set maxAnisotropy(t){this._maxAnisotropy=Math.min(t,16),this._maxAnisotropy>1&&(this.scaleMode="linear")}get maxAnisotropy(){return this._maxAnisotropy}get _resourceId(){return this._sharedResourceId||this._generateResourceId()}update(){this._sharedResourceId=null,this.emit("change",this)}_generateResourceId(){const t=`${this.addressModeU}-${this.addressModeV}-${this.addressModeW}-${this.magFilter}-${this.minFilter}-${this.mipmapFilter}-${this.lodMinClamp}-${this.lodMaxClamp}-${this.compare}-${this._maxAnisotropy}`;return this._sharedResourceId=ba(t),this._resourceId}destroy(){this.destroyed=!0,this.emit("destroy",this),this.emit("change",this),this.removeAllListeners()}};yn.defaultOptions={addressMode:"clamp-to-edge",scaleMode:"linear"};let ye=yn;const bn=class wn extends ft{constructor(t={}){super(),this.options=t,this._gpuData=Object.create(null),this._gcLastUsed=-1,this.uid=J("textureSource"),this._resourceType="textureSource",this._resourceId=J("resource"),this.uploadMethodId="unknown",this._resolution=1,this.pixelWidth=1,this.pixelHeight=1,this.width=1,this.height=1,this.sampleCount=1,this.mipLevelCount=1,this.autoGenerateMipmaps=!1,this.format="rgba8unorm",this.dimension="2d",this.viewDimension="2d",this.arrayLayerCount=1,this.antialias=!1,this.transient=!1,this._touched=0,this._batchTick=-1,this._textureBindLocation=-1,t={...wn.defaultOptions,...t},this.label=t.label??"",this.resource=t.resource,this.autoGarbageCollect=t.autoGarbageCollect,this._resolution=t.resolution,t.width?this.pixelWidth=t.width*this._resolution:this.pixelWidth=this.resource?this.resourceWidth??1:1,t.height?this.pixelHeight=t.height*this._resolution:this.pixelHeight=this.resource?this.resourceHeight??1:1,this.width=this.pixelWidth/this._resolution,this.height=this.pixelHeight/this._resolution,this.format=t.format,this.dimension=t.dimensions,this.viewDimension=t.viewDimension??t.dimensions,this.arrayLayerCount=t.arrayLayerCount,this.mipLevelCount=t.mipLevelCount,this.autoGenerateMipmaps=t.autoGenerateMipmaps,this.sampleCount=t.sampleCount,this.antialias=t.antialias,this.transient=t.transient??!1,this.alphaMode=t.alphaMode,this.style=new ye(_n(t)),this.destroyed=!1,this._refreshPOT()}get source(){return this}get style(){return this._style}set style(t){var e,i;this.style!==t&&((e=this._style)==null||e.off("change",this._onStyleChange,this),this._style=t,(i=this._style)==null||i.on("change",this._onStyleChange,this),this._onStyleChange())}set maxAnisotropy(t){this._style.maxAnisotropy=t}get maxAnisotropy(){return this._style.maxAnisotropy}get addressMode(){return this._style.addressMode}set addressMode(t){this._style.addressMode=t}get repeatMode(){return this._style.addressMode}set repeatMode(t){this._style.addressMode=t}get magFilter(){return this._style.magFilter}set magFilter(t){this._style.magFilter=t}get minFilter(){return this._style.minFilter}set minFilter(t){this._style.minFilter=t}get mipmapFilter(){return this._style.mipmapFilter}set mipmapFilter(t){this._style.mipmapFilter=t}get lodMinClamp(){return this._style.lodMinClamp}set lodMinClamp(t){this._style.lodMinClamp=t}get lodMaxClamp(){return this._style.lodMaxClamp}set lodMaxClamp(t){this._style.lodMaxClamp=t}_onStyleChange(){this.emit("styleChange",this)}update(){if(this.resource){const t=this._resolution;if(this.resize(this.resourceWidth/t,this.resourceHeight/t))return}this.emit("update",this)}destroy(){this.destroyed=!0,this.unload(),this.emit("destroy",this),this._style&&(this._style.destroy(),this._style=null),this.uploadMethodId=null,this.resource=null,this.removeAllListeners()}unload(){var t,e;this._resourceId=J("resource"),this.emit("change",this),this.emit("unload",this);for(const i in this._gpuData)(e=(t=this._gpuData[i])==null?void 0:t.destroy)==null||e.call(t);this._gpuData=Object.create(null)}get resourceWidth(){const{resource:t}=this;return t.naturalWidth||t.videoWidth||t.displayWidth||t.width}get resourceHeight(){const{resource:t}=this;return t.naturalHeight||t.videoHeight||t.displayHeight||t.height}get resolution(){return this._resolution}set resolution(t){this._resolution!==t&&(this._resolution=t,this.width=this.pixelWidth/t,this.height=this.pixelHeight/t)}resize(t,e,i){i||(i=this._resolution),t||(t=this.width),e||(e=this.height);const r=Math.round(t*i),n=Math.round(e*i);return this.width=r/i,this.height=n/i,this._resolution=i,this.pixelWidth===r&&this.pixelHeight===n?!1:(this._refreshPOT(),this.pixelWidth=r,this.pixelHeight=n,this.emit("resize",this),this._resourceId=J("resource"),this.emit("change",this),!0)}updateMipmaps(){this.autoGenerateMipmaps&&this.mipLevelCount>1&&this.emit("updateMipmaps",this)}set wrapMode(t){this._style.wrapMode=t}get wrapMode(){return this._style.wrapMode}set scaleMode(t){this._style.scaleMode=t}get scaleMode(){return this._style.scaleMode}_refreshPOT(){this.isPowerOfTwo=qi(this.pixelWidth)&&qi(this.pixelHeight)}static test(t){throw new Error("Unimplemented")}};bn.defaultOptions={resolution:1,format:"bgra8unorm",alphaMode:"premultiply-alpha-on-upload",dimensions:"2d",viewDimension:"2d",arrayLayerCount:1,mipLevelCount:1,autoGenerateMipmaps:!1,sampleCount:1,antialias:!1,autoGarbageCollect:!1};let St=bn;class Ri extends St{constructor(t){const e=t.resource||new Float32Array(t.width*t.height*4);let i=t.format;i||(e instanceof Float32Array?i="rgba32float":e instanceof Int32Array||e instanceof Uint32Array?i="rgba32uint":e instanceof Int16Array||e instanceof Uint16Array?i="rgba16uint":(e instanceof Int8Array,i="bgra8unorm")),super({...t,resource:e,format:i}),this.uploadMethodId="buffer"}static test(t){return t instanceof Int8Array||t instanceof Uint8Array||t instanceof Uint8ClampedArray||t instanceof Int16Array||t instanceof Uint16Array||t instanceof Int32Array||t instanceof Uint32Array||t instanceof Float32Array}}Ri.extension=I.TextureSource;const Qi=new W;class wa{constructor(t,e){this.mapCoord=new W,this.uClampFrame=new Float32Array(4),this.uClampOffset=new Float32Array(2),this._updateID=0,this.clampOffset=0,typeof e>"u"?this.clampMargin=t.width<10?0:.5:this.clampMargin=e,this.isSimple=!1,this.texture=t}get texture(){return this._texture}set texture(t){var e;this._texture!==t&&((e=this._texture)==null||e.removeListener("update",this.update,this),this._texture=t,this._texture.addListener("update",this.update,this)),this.update()}multiplyUvs(t,e){e===void 0&&(e=t);const i=this.mapCoord;for(let r=0;r<t.length;r+=2){const n=t[r],o=t[r+1];e[r]=n*i.a+o*i.c+i.tx,e[r+1]=n*i.b+o*i.d+i.ty}return e}update(){const t=this._texture;this._updateID++;const e=t.uvs;this.mapCoord.set(e.x1-e.x0,e.y1-e.y0,e.x3-e.x0,e.y3-e.y0,e.x0,e.y0);const i=t.orig,r=t.trim;r&&(Qi.set(i.width/r.width,0,0,i.height/r.height,-r.x/r.width,-r.y/r.height),this.mapCoord.append(Qi));const n=t.source,o=this.uClampFrame,a=this.clampMargin/n._resolution,h=this.clampOffset/n._resolution;return o[0]=(t.frame.x+a+h)/n.width,o[1]=(t.frame.y+a+h)/n.height,o[2]=(t.frame.x+t.frame.width-a+h)/n.width,o[3]=(t.frame.y+t.frame.height-a+h)/n.height,this.uClampOffset[0]=this.clampOffset/n.pixelWidth,this.uClampOffset[1]=this.clampOffset/n.pixelHeight,this.isSimple=t.frame.width===n.width&&t.frame.height===n.height&&t.rotate===0,!0}}class U extends ft{constructor({source:t,label:e,frame:i,orig:r,trim:n,defaultAnchor:o,defaultBorders:a,rotate:h,dynamic:l}={}){if(super(),this.uid=J("texture"),this.uvs={x0:0,y0:0,x1:0,y1:0,x2:0,y2:0,x3:0,y3:0},this.frame=new tt,this.noFrame=!1,this.dynamic=!1,this.isTexture=!0,this.label=e,this.source=(t==null?void 0:t.source)??new St,this.noFrame=!i,i)this.frame.copyFrom(i);else{const{width:c,height:u}=this._source;this.frame.width=c,this.frame.height=u}this.orig=r||this.frame,this.trim=n,this.rotate=h??0,this.defaultAnchor=o,this.defaultBorders=a,this.destroyed=!1,this.dynamic=l||!1,this.updateUvs()}set source(t){this._source&&this._source.off("resize",this.update,this),this._source=t,t.on("resize",this.update,this),this.emit("update",this)}get source(){return this._source}get textureMatrix(){return this._textureMatrix||(this._textureMatrix=new wa(this)),this._textureMatrix}get width(){return this.orig.width}get height(){return this.orig.height}updateUvs(){const{uvs:t,frame:e}=this,{width:i,height:r}=this._source,n=e.x/i,o=e.y/r,a=e.width/i,h=e.height/r;let l=this.rotate;if(l){const c=a/2,u=h/2,f=n+c,d=o+u;l=O.add(l,O.NW),t.x0=f+c*O.uX(l),t.y0=d+u*O.uY(l),l=O.add(l,2),t.x1=f+c*O.uX(l),t.y1=d+u*O.uY(l),l=O.add(l,2),t.x2=f+c*O.uX(l),t.y2=d+u*O.uY(l),l=O.add(l,2),t.x3=f+c*O.uX(l),t.y3=d+u*O.uY(l)}else t.x0=n,t.y0=o,t.x1=n+a,t.y1=o,t.x2=n+a,t.y2=o+h,t.x3=n,t.y3=o+h}destroy(t=!1){this._source&&(this._source.off("resize",this.update,this),t&&(this._source.destroy(),this._source=null)),this._textureMatrix=null,this.destroyed=!0,this.emit("destroy",this),this.removeAllListeners()}update(){this.noFrame&&(this.frame.width=this._source.width,this.frame.height=this._source.height),this.updateUvs(),this.emit("update",this)}get baseTexture(){return X(_t,"Texture.baseTexture is now Texture.source"),this._source}}U.EMPTY=new U({label:"EMPTY",source:new St({label:"EMPTY"})});U.EMPTY.destroy=gn;U.WHITE=new U({source:new Ri({resource:new Uint8Array([255,255,255,255]),width:1,height:1,alphaMode:"premultiply-alpha-on-upload",label:"WHITE"}),label:"WHITE"});U.WHITE.destroy=gn;function vn(s,t,e){const{width:i,height:r}=e.orig,n=e.trim;if(n){const o=n.width,a=n.height;s.minX=n.x-t._x*i,s.maxX=s.minX+o,s.minY=n.y-t._y*r,s.maxY=s.minY+a}else s.minX=-t._x*i,s.maxX=s.minX+i,s.minY=-t._y*r,s.maxY=s.minY+r}const Zi=new W;class vt{constructor(t=1/0,e=1/0,i=-1/0,r=-1/0){this.minX=1/0,this.minY=1/0,this.maxX=-1/0,this.maxY=-1/0,this.matrix=Zi,this.minX=t,this.minY=e,this.maxX=i,this.maxY=r}isEmpty(){return this.minX>this.maxX||this.minY>this.maxY}get rectangle(){this._rectangle||(this._rectangle=new tt);const t=this._rectangle;return this.minX>this.maxX||this.minY>this.maxY?(t.x=0,t.y=0,t.width=0,t.height=0):t.copyFromBounds(this),t}clear(){return this.minX=1/0,this.minY=1/0,this.maxX=-1/0,this.maxY=-1/0,this.matrix=Zi,this}set(t,e,i,r){this.minX=t,this.minY=e,this.maxX=i,this.maxY=r}addFrame(t,e,i,r,n){n||(n=this.matrix);const o=n.a,a=n.b,h=n.c,l=n.d,c=n.tx,u=n.ty;let f=this.minX,d=this.minY,p=this.maxX,g=this.maxY,m=o*t+h*e+c,_=a*t+l*e+u;m<f&&(f=m),_<d&&(d=_),m>p&&(p=m),_>g&&(g=_),m=o*i+h*e+c,_=a*i+l*e+u,m<f&&(f=m),_<d&&(d=_),m>p&&(p=m),_>g&&(g=_),m=o*t+h*r+c,_=a*t+l*r+u,m<f&&(f=m),_<d&&(d=_),m>p&&(p=m),_>g&&(g=_),m=o*i+h*r+c,_=a*i+l*r+u,m<f&&(f=m),_<d&&(d=_),m>p&&(p=m),_>g&&(g=_),this.minX=f,this.minY=d,this.maxX=p,this.maxY=g}addRect(t,e){this.addFrame(t.x,t.y,t.x+t.width,t.y+t.height,e)}addBounds(t,e){this.addFrame(t.minX,t.minY,t.maxX,t.maxY,e)}addBoundsMask(t){this.minX=this.minX>t.minX?this.minX:t.minX,this.minY=this.minY>t.minY?this.minY:t.minY,this.maxX=this.maxX<t.maxX?this.maxX:t.maxX,this.maxY=this.maxY<t.maxY?this.maxY:t.maxY}applyMatrix(t){const e=this.minX,i=this.minY,r=this.maxX,n=this.maxY,{a:o,b:a,c:h,d:l,tx:c,ty:u}=t;let f=o*e+h*i+c,d=a*e+l*i+u;this.minX=f,this.minY=d,this.maxX=f,this.maxY=d,f=o*r+h*i+c,d=a*r+l*i+u,this.minX=f<this.minX?f:this.minX,this.minY=d<this.minY?d:this.minY,this.maxX=f>this.maxX?f:this.maxX,this.maxY=d>this.maxY?d:this.maxY,f=o*e+h*n+c,d=a*e+l*n+u,this.minX=f<this.minX?f:this.minX,this.minY=d<this.minY?d:this.minY,this.maxX=f>this.maxX?f:this.maxX,this.maxY=d>this.maxY?d:this.maxY,f=o*r+h*n+c,d=a*r+l*n+u,this.minX=f<this.minX?f:this.minX,this.minY=d<this.minY?d:this.minY,this.maxX=f>this.maxX?f:this.maxX,this.maxY=d>this.maxY?d:this.maxY}fit(t){return this.minX<t.left&&(this.minX=t.left),this.maxX>t.right&&(this.maxX=t.right),this.minY<t.top&&(this.minY=t.top),this.maxY>t.bottom&&(this.maxY=t.bottom),this}fitBounds(t,e,i,r){return this.minX<t&&(this.minX=t),this.maxX>e&&(this.maxX=e),this.minY<i&&(this.minY=i),this.maxY>r&&(this.maxY=r),this}pad(t,e=t){return this.minX-=t,this.maxX+=t,this.minY-=e,this.maxY+=e,this}ceil(){return this.minX=Math.floor(this.minX),this.minY=Math.floor(this.minY),this.maxX=Math.ceil(this.maxX),this.maxY=Math.ceil(this.maxY),this}clone(){return new vt(this.minX,this.minY,this.maxX,this.maxY)}scale(t,e=t){return this.minX*=t,this.minY*=e,this.maxX*=t,this.maxY*=e,this}get x(){return this.minX}set x(t){const e=this.maxX-this.minX;this.minX=t,this.maxX=t+e}get y(){return this.minY}set y(t){const e=this.maxY-this.minY;this.minY=t,this.maxY=t+e}get width(){return this.maxX-this.minX}set width(t){this.maxX=this.minX+t}get height(){return this.maxY-this.minY}set height(t){this.maxY=this.minY+t}get left(){return this.minX}get right(){return this.maxX}get top(){return this.minY}get bottom(){return this.maxY}get isPositive(){return this.maxX-this.minX>0&&this.maxY-this.minY>0}get isValid(){return this.minX+this.minY!==1/0}addVertexData(t,e,i,r){let n=this.minX,o=this.minY,a=this.maxX,h=this.maxY;r||(r=this.matrix);const l=r.a,c=r.b,u=r.c,f=r.d,d=r.tx,p=r.ty;for(let g=e;g<i;g+=2){const m=t[g],_=t[g+1],y=l*m+u*_+d,x=c*m+f*_+p;n=y<n?y:n,o=x<o?x:o,a=y>a?y:a,h=x>h?x:h}this.minX=n,this.minY=o,this.maxX=a,this.maxY=h}containsPoint(t,e){return this.minX<=t&&this.minY<=e&&this.maxX>=t&&this.maxY>=e}toString(){return`[pixi.js:Bounds minX=${this.minX} minY=${this.minY} maxX=${this.maxX} maxY=${this.maxY} width=${this.width} height=${this.height}]`}copyFrom(t){return this.minX=t.minX,this.minY=t.minY,this.maxX=t.maxX,this.maxY=t.maxY,this}}var va={grad:.9,turn:360,rad:360/(2*Math.PI)},Et=function(s){return typeof s=="string"?s.length>0:typeof s=="number"},rt=function(s,t,e){return t===void 0&&(t=0),e===void 0&&(e=Math.pow(10,t)),Math.round(e*s)/e+0},bt=function(s,t,e){return t===void 0&&(t=0),e===void 0&&(e=1),s>e?e:s>t?s:t},An=function(s){return(s=isFinite(s)?s%360:0)>0?s:s+360},Ji=function(s){return{r:bt(s.r,0,255),g:bt(s.g,0,255),b:bt(s.b,0,255),a:bt(s.a)}},Gs=function(s){return{r:rt(s.r),g:rt(s.g),b:rt(s.b),a:rt(s.a,3)}},Aa=/^#([0-9a-f]{3,8})$/i,ss=function(s){var t=s.toString(16);return t.length<2?"0"+t:t},Sn=function(s){var t=s.r,e=s.g,i=s.b,r=s.a,n=Math.max(t,e,i),o=n-Math.min(t,e,i),a=o?n===t?(e-i)/o:n===e?2+(i-t)/o:4+(t-e)/o:0;return{h:60*(a<0?a+6:a),s:n?o/n*100:0,v:n/255*100,a:r}},Cn=function(s){var t=s.h,e=s.s,i=s.v,r=s.a;t=t/360*6,e/=100,i/=100;var n=Math.floor(t),o=i*(1-e),a=i*(1-(t-n)*e),h=i*(1-(1-t+n)*e),l=n%6;return{r:255*[i,a,o,o,h,i][l],g:255*[h,i,i,a,o,o][l],b:255*[o,o,h,i,i,a][l],a:r}},tr=function(s){return{h:An(s.h),s:bt(s.s,0,100),l:bt(s.l,0,100),a:bt(s.a)}},er=function(s){return{h:rt(s.h),s:rt(s.s),l:rt(s.l),a:rt(s.a,3)}},sr=function(s){return Cn((e=(t=s).s,{h:t.h,s:(e*=((i=t.l)<50?i:100-i)/100)>0?2*e/(i+e)*100:0,v:i+e,a:t.a}));var t,e,i},Ge=function(s){return{h:(t=Sn(s)).h,s:(r=(200-(e=t.s))*(i=t.v)/100)>0&&r<200?e*i/100/(r<=100?r:200-r)*100:0,l:r/2,a:t.a};var t,e,i,r},Sa=/^hsla?\(\s*([+-]?\d*\.?\d+)(deg|rad|grad|turn)?\s*,\s*([+-]?\d*\.?\d+)%\s*,\s*([+-]?\d*\.?\d+)%\s*(?:,\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i,Ca=/^hsla?\(\s*([+-]?\d*\.?\d+)(deg|rad|grad|turn)?\s+([+-]?\d*\.?\d+)%\s+([+-]?\d*\.?\d+)%\s*(?:\/\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i,Ta=/^rgba?\(\s*([+-]?\d*\.?\d+)(%)?\s*,\s*([+-]?\d*\.?\d+)(%)?\s*,\s*([+-]?\d*\.?\d+)(%)?\s*(?:,\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i,Pa=/^rgba?\(\s*([+-]?\d*\.?\d+)(%)?\s+([+-]?\d*\.?\d+)(%)?\s+([+-]?\d*\.?\d+)(%)?\s*(?:\/\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i,ai={string:[[function(s){var t=Aa.exec(s);return t?(s=t[1]).length<=4?{r:parseInt(s[0]+s[0],16),g:parseInt(s[1]+s[1],16),b:parseInt(s[2]+s[2],16),a:s.length===4?rt(parseInt(s[3]+s[3],16)/255,2):1}:s.length===6||s.length===8?{r:parseInt(s.substr(0,2),16),g:parseInt(s.substr(2,2),16),b:parseInt(s.substr(4,2),16),a:s.length===8?rt(parseInt(s.substr(6,2),16)/255,2):1}:null:null},"hex"],[function(s){var t=Ta.exec(s)||Pa.exec(s);return t?t[2]!==t[4]||t[4]!==t[6]?null:Ji({r:Number(t[1])/(t[2]?100/255:1),g:Number(t[3])/(t[4]?100/255:1),b:Number(t[5])/(t[6]?100/255:1),a:t[7]===void 0?1:Number(t[7])/(t[8]?100:1)}):null},"rgb"],[function(s){var t=Sa.exec(s)||Ca.exec(s);if(!t)return null;var e,i,r=tr({h:(e=t[1],i=t[2],i===void 0&&(i="deg"),Number(e)*(va[i]||1)),s:Number(t[3]),l:Number(t[4]),a:t[5]===void 0?1:Number(t[5])/(t[6]?100:1)});return sr(r)},"hsl"]],object:[[function(s){var t=s.r,e=s.g,i=s.b,r=s.a,n=r===void 0?1:r;return Et(t)&&Et(e)&&Et(i)?Ji({r:Number(t),g:Number(e),b:Number(i),a:Number(n)}):null},"rgb"],[function(s){var t=s.h,e=s.s,i=s.l,r=s.a,n=r===void 0?1:r;if(!Et(t)||!Et(e)||!Et(i))return null;var o=tr({h:Number(t),s:Number(e),l:Number(i),a:Number(n)});return sr(o)},"hsl"],[function(s){var t=s.h,e=s.s,i=s.v,r=s.a,n=r===void 0?1:r;if(!Et(t)||!Et(e)||!Et(i))return null;var o=(function(a){return{h:An(a.h),s:bt(a.s,0,100),v:bt(a.v,0,100),a:bt(a.a)}})({h:Number(t),s:Number(e),v:Number(i),a:Number(n)});return Cn(o)},"hsv"]]},ir=function(s,t){for(var e=0;e<t.length;e++){var i=t[e][0](s);if(i)return[i,t[e][1]]}return[null,void 0]},Ma=function(s){return typeof s=="string"?ir(s.trim(),ai.string):typeof s=="object"&&s!==null?ir(s,ai.object):[null,void 0]},Ds=function(s,t){var e=Ge(s);return{h:e.h,s:bt(e.s+100*t,0,100),l:e.l,a:e.a}},Os=function(s){return(299*s.r+587*s.g+114*s.b)/1e3/255},rr=function(s,t){var e=Ge(s);return{h:e.h,s:e.s,l:bt(e.l+100*t,0,100),a:e.a}},hi=(function(){function s(t){this.parsed=Ma(t)[0],this.rgba=this.parsed||{r:0,g:0,b:0,a:1}}return s.prototype.isValid=function(){return this.parsed!==null},s.prototype.brightness=function(){return rt(Os(this.rgba),2)},s.prototype.isDark=function(){return Os(this.rgba)<.5},s.prototype.isLight=function(){return Os(this.rgba)>=.5},s.prototype.toHex=function(){return t=Gs(this.rgba),e=t.r,i=t.g,r=t.b,o=(n=t.a)<1?ss(rt(255*n)):"","#"+ss(e)+ss(i)+ss(r)+o;var t,e,i,r,n,o},s.prototype.toRgb=function(){return Gs(this.rgba)},s.prototype.toRgbString=function(){return t=Gs(this.rgba),e=t.r,i=t.g,r=t.b,(n=t.a)<1?"rgba("+e+", "+i+", "+r+", "+n+")":"rgb("+e+", "+i+", "+r+")";var t,e,i,r,n},s.prototype.toHsl=function(){return er(Ge(this.rgba))},s.prototype.toHslString=function(){return t=er(Ge(this.rgba)),e=t.h,i=t.s,r=t.l,(n=t.a)<1?"hsla("+e+", "+i+"%, "+r+"%, "+n+")":"hsl("+e+", "+i+"%, "+r+"%)";var t,e,i,r,n},s.prototype.toHsv=function(){return t=Sn(this.rgba),{h:rt(t.h),s:rt(t.s),v:rt(t.v),a:rt(t.a,3)};var t},s.prototype.invert=function(){return Pt({r:255-(t=this.rgba).r,g:255-t.g,b:255-t.b,a:t.a});var t},s.prototype.saturate=function(t){return t===void 0&&(t=.1),Pt(Ds(this.rgba,t))},s.prototype.desaturate=function(t){return t===void 0&&(t=.1),Pt(Ds(this.rgba,-t))},s.prototype.grayscale=function(){return Pt(Ds(this.rgba,-1))},s.prototype.lighten=function(t){return t===void 0&&(t=.1),Pt(rr(this.rgba,t))},s.prototype.darken=function(t){return t===void 0&&(t=.1),Pt(rr(this.rgba,-t))},s.prototype.rotate=function(t){return t===void 0&&(t=15),this.hue(this.hue()+t)},s.prototype.alpha=function(t){return typeof t=="number"?Pt({r:(e=this.rgba).r,g:e.g,b:e.b,a:t}):rt(this.rgba.a,3);var e},s.prototype.hue=function(t){var e=Ge(this.rgba);return typeof t=="number"?Pt({h:t,s:e.s,l:e.l,a:e.a}):rt(e.h)},s.prototype.isEqual=function(t){return this.toHex()===Pt(t).toHex()},s})(),Pt=function(s){return s instanceof hi?s:new hi(s)},nr=[],ka=function(s){s.forEach(function(t){nr.indexOf(t)<0&&(t(hi,ai),nr.push(t))})};function Ea(s,t){var e={white:"#ffffff",bisque:"#ffe4c4",blue:"#0000ff",cadetblue:"#5f9ea0",chartreuse:"#7fff00",chocolate:"#d2691e",coral:"#ff7f50",antiquewhite:"#faebd7",aqua:"#00ffff",azure:"#f0ffff",whitesmoke:"#f5f5f5",papayawhip:"#ffefd5",plum:"#dda0dd",blanchedalmond:"#ffebcd",black:"#000000",gold:"#ffd700",goldenrod:"#daa520",gainsboro:"#dcdcdc",cornsilk:"#fff8dc",cornflowerblue:"#6495ed",burlywood:"#deb887",aquamarine:"#7fffd4",beige:"#f5f5dc",crimson:"#dc143c",cyan:"#00ffff",darkblue:"#00008b",darkcyan:"#008b8b",darkgoldenrod:"#b8860b",darkkhaki:"#bdb76b",darkgray:"#a9a9a9",darkgreen:"#006400",darkgrey:"#a9a9a9",peachpuff:"#ffdab9",darkmagenta:"#8b008b",darkred:"#8b0000",darkorchid:"#9932cc",darkorange:"#ff8c00",darkslateblue:"#483d8b",gray:"#808080",darkslategray:"#2f4f4f",darkslategrey:"#2f4f4f",deeppink:"#ff1493",deepskyblue:"#00bfff",wheat:"#f5deb3",firebrick:"#b22222",floralwhite:"#fffaf0",ghostwhite:"#f8f8ff",darkviolet:"#9400d3",magenta:"#ff00ff",green:"#008000",dodgerblue:"#1e90ff",grey:"#808080",honeydew:"#f0fff0",hotpink:"#ff69b4",blueviolet:"#8a2be2",forestgreen:"#228b22",lawngreen:"#7cfc00",indianred:"#cd5c5c",indigo:"#4b0082",fuchsia:"#ff00ff",brown:"#a52a2a",maroon:"#800000",mediumblue:"#0000cd",lightcoral:"#f08080",darkturquoise:"#00ced1",lightcyan:"#e0ffff",ivory:"#fffff0",lightyellow:"#ffffe0",lightsalmon:"#ffa07a",lightseagreen:"#20b2aa",linen:"#faf0e6",mediumaquamarine:"#66cdaa",lemonchiffon:"#fffacd",lime:"#00ff00",khaki:"#f0e68c",mediumseagreen:"#3cb371",limegreen:"#32cd32",mediumspringgreen:"#00fa9a",lightskyblue:"#87cefa",lightblue:"#add8e6",midnightblue:"#191970",lightpink:"#ffb6c1",mistyrose:"#ffe4e1",moccasin:"#ffe4b5",mintcream:"#f5fffa",lightslategray:"#778899",lightslategrey:"#778899",navajowhite:"#ffdead",navy:"#000080",mediumvioletred:"#c71585",powderblue:"#b0e0e6",palegoldenrod:"#eee8aa",oldlace:"#fdf5e6",paleturquoise:"#afeeee",mediumturquoise:"#48d1cc",mediumorchid:"#ba55d3",rebeccapurple:"#663399",lightsteelblue:"#b0c4de",mediumslateblue:"#7b68ee",thistle:"#d8bfd8",tan:"#d2b48c",orchid:"#da70d6",mediumpurple:"#9370db",purple:"#800080",pink:"#ffc0cb",skyblue:"#87ceeb",springgreen:"#00ff7f",palegreen:"#98fb98",red:"#ff0000",yellow:"#ffff00",slateblue:"#6a5acd",lavenderblush:"#fff0f5",peru:"#cd853f",palevioletred:"#db7093",violet:"#ee82ee",teal:"#008080",slategray:"#708090",slategrey:"#708090",aliceblue:"#f0f8ff",darkseagreen:"#8fbc8f",darkolivegreen:"#556b2f",greenyellow:"#adff2f",seagreen:"#2e8b57",seashell:"#fff5ee",tomato:"#ff6347",silver:"#c0c0c0",sienna:"#a0522d",lavender:"#e6e6fa",lightgreen:"#90ee90",orange:"#ffa500",orangered:"#ff4500",steelblue:"#4682b4",royalblue:"#4169e1",turquoise:"#40e0d0",yellowgreen:"#9acd32",salmon:"#fa8072",saddlebrown:"#8b4513",sandybrown:"#f4a460",rosybrown:"#bc8f8f",darksalmon:"#e9967a",lightgoldenrodyellow:"#fafad2",snow:"#fffafa",lightgrey:"#d3d3d3",lightgray:"#d3d3d3",dimgray:"#696969",dimgrey:"#696969",olivedrab:"#6b8e23",olive:"#808000"},i={};for(var r in e)i[e[r]]=r;var n={};s.prototype.toName=function(o){if(!(this.rgba.a||this.rgba.r||this.rgba.g||this.rgba.b))return"transparent";var a,h,l=i[this.toHex()];if(l)return l;if(o!=null&&o.closest){var c=this.toRgb(),u=1/0,f="black";if(!n.length)for(var d in e)n[d]=new s(e[d]).toRgb();for(var p in e){var g=(a=c,h=n[p],Math.pow(a.r-h.r,2)+Math.pow(a.g-h.g,2)+Math.pow(a.b-h.b,2));g<u&&(u=g,f=p)}return f}},t.string.push([function(o){var a=o.toLowerCase(),h=a==="transparent"?"#0000":e[a];return h?new s(h).toRgb():null},"name"])}ka([Ea]);const xe=class Be{constructor(t=16777215){this._value=null,this._components=new Float32Array(4),this._components.fill(1),this._int=16777215,this.value=t}get red(){return this._components[0]}get green(){return this._components[1]}get blue(){return this._components[2]}get alpha(){return this._components[3]}setValue(t){return this.value=t,this}set value(t){if(t instanceof Be)this._value=this._cloneSource(t._value),this._int=t._int,this._components.set(t._components);else{if(t===null)throw new Error("Cannot set Color#value to null");(this._value===null||!this._isSourceEqual(this._value,t))&&(this._value=this._cloneSource(t),this._normalize(this._value))}}get value(){return this._value}_cloneSource(t){return typeof t=="string"||typeof t=="number"||t instanceof Number||t===null?t:Array.isArray(t)||ArrayBuffer.isView(t)?t.slice(0):typeof t=="object"&&t!==null?{...t}:t}_isSourceEqual(t,e){const i=typeof t;if(i!==typeof e)return!1;if(i==="number"||i==="string"||t instanceof Number)return t===e;if(Array.isArray(t)&&Array.isArray(e)||ArrayBuffer.isView(t)&&ArrayBuffer.isView(e))return t.length!==e.length?!1:t.every((n,o)=>n===e[o]);if(t!==null&&e!==null){const n=Object.keys(t),o=Object.keys(e);return n.length!==o.length?!1:n.every(a=>t[a]===e[a])}return t===e}toRgba(){const[t,e,i,r]=this._components;return{r:t,g:e,b:i,a:r}}toRgb(){const[t,e,i]=this._components;return{r:t,g:e,b:i}}toRgbaString(){const[t,e,i]=this.toUint8RgbArray();return`rgba(${t},${e},${i},${this.alpha})`}toUint8RgbArray(t){const[e,i,r]=this._components;return this._arrayRgb||(this._arrayRgb=[]),t||(t=this._arrayRgb),t[0]=Math.round(e*255),t[1]=Math.round(i*255),t[2]=Math.round(r*255),t}toArray(t){this._arrayRgba||(this._arrayRgba=[]),t||(t=this._arrayRgba);const[e,i,r,n]=this._components;return t[0]=e,t[1]=i,t[2]=r,t[3]=n,t}toRgbArray(t){this._arrayRgb||(this._arrayRgb=[]),t||(t=this._arrayRgb);const[e,i,r]=this._components;return t[0]=e,t[1]=i,t[2]=r,t}toNumber(){return this._int}toBgrNumber(){const[t,e,i]=this.toUint8RgbArray();return(i<<16)+(e<<8)+t}toLittleEndianNumber(){const t=this._int;return(t>>16)+(t&65280)+((t&255)<<16)}multiply(t){const[e,i,r,n]=Be._temp.setValue(t)._components;return this._components[0]*=e,this._components[1]*=i,this._components[2]*=r,this._components[3]*=n,this._refreshInt(),this._value=null,this}premultiply(t,e=!0){return e&&(this._components[0]*=t,this._components[1]*=t,this._components[2]*=t),this._components[3]=t,this._refreshInt(),this._value=null,this}toPremultiplied(t,e=!0){if(t===1)return(255<<24)+this._int;if(t===0)return e?0:this._int;let i=this._int>>16&255,r=this._int>>8&255,n=this._int&255;return e&&(i=i*t+.5|0,r=r*t+.5|0,n=n*t+.5|0),(t*255<<24)+(i<<16)+(r<<8)+n}toHex(){const t=this._int.toString(16);return`#${"000000".substring(0,6-t.length)+t}`}toHexa(){const e=Math.round(this._components[3]*255).toString(16);return this.toHex()+"00".substring(0,2-e.length)+e}setAlpha(t){return this._components[3]=this._clamp(t),this._value=null,this}_normalize(t){let e,i,r,n;if((typeof t=="number"||t instanceof Number)&&t>=0&&t<=16777215){const o=t;e=(o>>16&255)/255,i=(o>>8&255)/255,r=(o&255)/255,n=1}else if((Array.isArray(t)||t instanceof Float32Array)&&t.length>=3&&t.length<=4)t=this._clamp(t),[e,i,r,n=1]=t;else if((t instanceof Uint8Array||t instanceof Uint8ClampedArray)&&t.length>=3&&t.length<=4)t=this._clamp(t,0,255),[e,i,r,n=255]=t,e/=255,i/=255,r/=255,n/=255;else if(typeof t=="string"||typeof t=="object"){if(typeof t=="string"){const a=Be.HEX_PATTERN.exec(t);a&&(t=`#${a[2]}`)}const o=Pt(t);o.isValid()&&({r:e,g:i,b:r,a:n}=o.rgba,e/=255,i/=255,r/=255)}if(e!==void 0)this._components[0]=e,this._components[1]=i,this._components[2]=r,this._components[3]=n,this._refreshInt();else throw new Error(`Unable to convert color ${t}`)}_refreshInt(){this._clamp(this._components);const[t,e,i]=this._components;this._int=(t*255<<16)+(e*255<<8)+(i*255|0)}_clamp(t,e=0,i=1){return typeof t=="number"?Math.min(Math.max(t,e),i):(t.forEach((r,n)=>{t[n]=Math.min(Math.max(r,e),i)}),t)}static isColorLike(t){return typeof t=="number"||typeof t=="string"||t instanceof Number||t instanceof Be||Array.isArray(t)||t instanceof Uint8Array||t instanceof Uint8ClampedArray||t instanceof Float32Array||t.r!==void 0&&t.g!==void 0&&t.b!==void 0||t.r!==void 0&&t.g!==void 0&&t.b!==void 0&&t.a!==void 0||t.h!==void 0&&t.s!==void 0&&t.l!==void 0||t.h!==void 0&&t.s!==void 0&&t.l!==void 0&&t.a!==void 0||t.h!==void 0&&t.s!==void 0&&t.v!==void 0||t.h!==void 0&&t.s!==void 0&&t.v!==void 0&&t.a!==void 0}};xe.shared=new xe;xe._temp=new xe;xe.HEX_PATTERN=/^(#|0x)?(([a-f0-9]{3}){1,2}([a-f0-9]{2})?)$/i;let q=xe;const Ia={cullArea:null,cullable:!1,cullableChildren:!0};let Ws=0;const or=500;function Y(...s){Ws!==or&&(Ws++,Ws===or?console.warn("PixiJS Warning: too many warnings, no more warnings will be reported to the console by PixiJS."):console.warn("PixiJS Warning: ",...s))}const Qe={_registeredResources:new Set,register(s){this._registeredResources.add(s)},unregister(s){this._registeredResources.delete(s)},release(){this._registeredResources.forEach(s=>s.clear())},get registeredCount(){return this._registeredResources.size},isRegistered(s){return this._registeredResources.has(s)},reset(){this._registeredResources.clear()}};class Ra{constructor(t,e){this._pool=[],this._count=0,this._index=0,this._classType=t,e&&this.prepopulate(e)}prepopulate(t){for(let e=0;e<t;e++)this._pool[this._index++]=new this._classType;this._count+=t}get(t){var i;let e;return this._index>0?e=this._pool[--this._index]:(e=new this._classType,this._count++),(i=e.init)==null||i.call(e,t),e}return(t){var e;(e=t.reset)==null||e.call(t),this._pool[this._index++]=t}get totalSize(){return this._count}get totalFree(){return this._index}get totalUsed(){return this._count-this._index}clear(){if(this._pool.length>0&&this._pool[0].destroy)for(let t=0;t<this._index;t++)this._pool[t].destroy();this._pool.length=0,this._count=0,this._index=0}}class La{constructor(){this._poolsByClass=new Map}prepopulate(t,e){this.getPool(t).prepopulate(e)}get(t,e){return this.getPool(t).get(e)}return(t){this.getPool(t.constructor).return(t)}getPool(t){return this._poolsByClass.has(t)||this._poolsByClass.set(t,new Ra(t)),this._poolsByClass.get(t)}stats(){const t={};return this._poolsByClass.forEach(e=>{const i=t[e._classType.name]?e._classType.name+e._classType.ID:e._classType.name;t[i]={free:e.totalFree,used:e.totalUsed,size:e.totalSize}}),t}clear(){this._poolsByClass.forEach(t=>t.clear()),this._poolsByClass.clear()}}const At=new La;Qe.register(At);const Ba={get isCachedAsTexture(){var s;return!!((s=this.renderGroup)!=null&&s.isCachedAsTexture)},cacheAsTexture(s){typeof s=="boolean"&&s===!1?this.disableRenderGroup():(this.enableRenderGroup(),this.renderGroup.enableCacheAsTexture(s===!0?{}:s))},updateCacheTexture(){var s;(s=this.renderGroup)==null||s.updateCacheTexture()},get cacheAsBitmap(){return this.isCachedAsTexture},set cacheAsBitmap(s){X("v8.6.0","cacheAsBitmap is deprecated, use cacheAsTexture instead."),this.cacheAsTexture(s)}};function Fa(s,t,e){const i=s.length;let r;if(t>=i||e===0)return;e=t+e>i?i-t:e;const n=i-e;for(r=t;r<n;++r)s[r]=s[r+e];s.length=n}const Ga={allowChildren:!0,removeChildren(s=0,t){var n;const e=t??this.children.length,i=e-s,r=[];if(i>0&&i<=e){for(let a=e-1;a>=s;a--){const h=this.children[a];h&&(r.push(h),h.parent=null)}Fa(this.children,s,e);const o=this.renderGroup||this.parentRenderGroup;o&&o.removeChildren(r);for(let a=0;a<r.length;++a){const h=r[a];(n=h.parentRenderLayer)==null||n.detach(h),this.emit("childRemoved",h,this,a),r[a].emit("removed",this)}return r.length>0&&this._didViewChangeTick++,r}else if(i===0&&this.children.length===0)return r;throw new RangeError("removeChildren: numeric values are outside the acceptable range.")},removeChildAt(s){const t=this.getChildAt(s);return this.removeChild(t)},getChildAt(s){if(s<0||s>=this.children.length)throw new Error(`getChildAt: Index (${s}) does not exist.`);return this.children[s]},setChildIndex(s,t){if(t<0||t>=this.children.length)throw new Error(`The index ${t} supplied is out of bounds ${this.children.length}`);this.getChildIndex(s),this.addChildAt(s,t)},getChildIndex(s){const t=this.children.indexOf(s);if(t===-1)throw new Error("The supplied Container must be a child of the caller");return t},addChildAt(s,t){this.allowChildren||X(_t,"addChildAt: Only Containers will be allowed to add children in v8.0.0");const{children:e}=this;if(t<0||t>e.length)throw new Error(`${s}addChildAt: The index ${t} supplied is out of bounds ${e.length}`);const i=s.parent===this;if(s.parent){const n=s.parent.children.indexOf(s);if(i){if(n===t)return s;s.parent.children.splice(n,1)}else s.removeFromParent()}t===e.length?e.push(s):e.splice(t,0,s),s.parent=this,s.didChange=!0,s._updateFlags=15;const r=this.renderGroup||this.parentRenderGroup;return r&&r.addChild(s),this.sortableChildren&&(this.sortDirty=!0),i||(this.emit("childAdded",s,this,t),s.emit("added",this)),s},swapChildren(s,t){if(s===t)return;const e=this.getChildIndex(s),i=this.getChildIndex(t);this.children[e]=t,this.children[i]=s;const r=this.renderGroup||this.parentRenderGroup;r&&(r.structureDidChange=!0),this._didContainerChangeTick++},removeFromParent(){var s;(s=this.parent)==null||s.removeChild(this)},reparentChild(...s){return s.length===1?this.reparentChildAt(s[0],this.children.length):(s.forEach(t=>this.reparentChildAt(t,this.children.length)),s[0])},reparentChildAt(s,t){if(s.parent===this)return this.setChildIndex(s,t),s;const e=s.worldTransform.clone();s.removeFromParent(),this.addChildAt(s,t);const i=this.worldTransform.clone();return i.invert(),e.prepend(i),s.setFromMatrix(e),s},replaceChild(s,t){s.updateLocalTransform(),this.addChildAt(t,this.getChildIndex(s)),t.setFromMatrix(s.localTransform),t.updateLocalTransform(),this.removeChild(s)}},Da={collectRenderables(s,t,e){this.parentRenderLayer&&this.parentRenderLayer!==e||this.globalDisplayStatus<7||!this.includeInBuild||(this.sortableChildren&&this.sortChildren(),this.isSimple?this.collectRenderablesSimple(s,t,e):this.renderGroup?t.renderPipes.renderGroup.addRenderGroup(this.renderGroup,s):this.collectRenderablesWithEffects(s,t,e))},collectRenderablesSimple(s,t,e){const i=this.children,r=i.length;for(let n=0;n<r;n++)i[n].collectRenderables(s,t,e)},collectRenderablesWithEffects(s,t,e){const{renderPipes:i}=t;for(let r=0;r<this.effects.length;r++){const n=this.effects[r];i[n.pipe].push(n,this,s)}this.collectRenderablesSimple(s,t,e);for(let r=this.effects.length-1;r>=0;r--){const n=this.effects[r];i[n.pipe].pop(n,this,s)}}};class ar{constructor(){this.pipe="filter",this.priority=1}destroy(){for(let t=0;t<this.filters.length;t++)this.filters[t].destroy();this.filters=null,this.filterArea=null}}class Oa{constructor(){this._effectClasses=[],this._tests=[],this._initialized=!1}init(){this._initialized||(this._initialized=!0,this._effectClasses.forEach(t=>{this.add({test:t.test,maskClass:t})}))}add(t){this._tests.push(t)}getMaskEffect(t){this._initialized||this.init();for(let e=0;e<this._tests.length;e++){const i=this._tests[e];if(i.test(t))return At.get(i.maskClass,t)}return t}returnMaskEffect(t){At.return(t)}}const li=new Oa;K.handleByList(I.MaskEffect,li._effectClasses);const Wa={_maskEffect:null,_maskOptions:{inverse:!1,channel:"red"},_filterEffect:null,effects:[],_markStructureAsChanged(){const s=this.renderGroup||this.parentRenderGroup;s&&(s.structureDidChange=!0)},addEffect(s){this.effects.indexOf(s)===-1&&(this.effects.push(s),this.effects.sort((e,i)=>e.priority-i.priority),this._markStructureAsChanged(),this._updateIsSimple())},removeEffect(s){const t=this.effects.indexOf(s);t!==-1&&(this.effects.splice(t,1),this._markStructureAsChanged(),this._updateIsSimple())},set mask(s){const t=this._maskEffect;(t==null?void 0:t.mask)!==s&&(t&&(this.removeEffect(t),li.returnMaskEffect(t),this._maskEffect=null),s!=null&&(this._maskEffect=li.getMaskEffect(s),this.addEffect(this._maskEffect)))},get mask(){var s;return(s=this._maskEffect)==null?void 0:s.mask},setMask(s){this._maskOptions={...this._maskOptions,...s},s.mask&&(this.mask=s.mask),this._markStructureAsChanged()},set filters(s){var n;!Array.isArray(s)&&s&&(s=[s]);const t=this._filterEffect||(this._filterEffect=new ar);s=s;const e=(s==null?void 0:s.length)>0,i=((n=t.filters)==null?void 0:n.length)>0,r=e!==i;s=Array.isArray(s)?s.slice(0):s,t.filters=Object.freeze(s),r&&(e?this.addEffect(t):(this.removeEffect(t),t.filters=s??null))},get filters(){var s;return(s=this._filterEffect)==null?void 0:s.filters},set filterArea(s){this._filterEffect||(this._filterEffect=new ar),this._filterEffect.filterArea=s},get filterArea(){var s;return(s=this._filterEffect)==null?void 0:s.filterArea}},Ua={label:null,get name(){return X(_t,"Container.name property has been removed, use Container.label instead"),this.label},set name(s){X(_t,"Container.name property has been removed, use Container.label instead"),this.label=s},getChildByName(s,t=!1){return this.getChildByLabel(s,t)},getChildByLabel(s,t=!1){const e=this.children;for(let i=0;i<e.length;i++){const r=e[i];if(r.label===s||s instanceof RegExp&&s.test(r.label))return r}if(t)for(let i=0;i<e.length;i++){const n=e[i].getChildByLabel(s,!0);if(n)return n}return null},getChildrenByLabel(s,t=!1,e=[]){const i=this.children;for(let r=0;r<i.length;r++){const n=i[r];(n.label===s||s instanceof RegExp&&s.test(n.label))&&e.push(n)}if(t)for(let r=0;r<i.length;r++)i[r].getChildrenByLabel(s,!0,e);return e}},ut=At.getPool(W),Lt=At.getPool(vt),za=new W,Ha={getFastGlobalBounds(s,t){t||(t=new vt),t.clear(),this._getGlobalBoundsRecursive(!!s,t,this.parentRenderLayer),t.isValid||t.set(0,0,0,0);const e=this.renderGroup||this.parentRenderGroup;return t.applyMatrix(e.worldTransform),t},_getGlobalBoundsRecursive(s,t,e){let i=t;if(s&&this.parentRenderLayer&&this.parentRenderLayer!==e||this.localDisplayStatus!==7||!this.measurable)return;const r=!!this.effects.length;if((this.renderGroup||r)&&(i=Lt.get().clear()),this.boundsArea)t.addRect(this.boundsArea,this.worldTransform);else{if(this.renderPipeId){const o=this.bounds;i.addFrame(o.minX,o.minY,o.maxX,o.maxY,this.groupTransform)}const n=this.children;for(let o=0;o<n.length;o++)n[o]._getGlobalBoundsRecursive(s,i,e)}if(r){let n=!1;const o=this.renderGroup||this.parentRenderGroup;for(let a=0;a<this.effects.length;a++)this.effects[a].addBounds&&(n||(n=!0,i.applyMatrix(o.worldTransform)),this.effects[a].addBounds(i,!0));n&&i.applyMatrix(o.worldTransform.copyTo(za).invert()),t.addBounds(i),Lt.return(i)}else this.renderGroup&&(t.addBounds(i,this.relativeGroupTransform),Lt.return(i))}};function Tn(s,t,e){e.clear();let i,r;return s.parent?t?i=s.parent.worldTransform:(r=ut.get().identity(),i=Li(s,r)):i=W.IDENTITY,Pn(s,e,i,t),r&&ut.return(r),e.isValid||e.set(0,0,0,0),e}function Pn(s,t,e,i){var a,h;if(!s.visible||!s.measurable)return;let r;i?r=s.worldTransform:(s.updateLocalTransform(),r=ut.get(),r.appendFrom(s.localTransform,e));const n=t,o=!!s.effects.length;if(o&&(t=Lt.get().clear()),s.boundsArea)t.addRect(s.boundsArea,r);else{const l=s.bounds;l&&!l.isEmpty()&&(t.matrix=r,t.addBounds(l));for(let c=0;c<s.children.length;c++)Pn(s.children[c],t,r,i)}if(o){for(let l=0;l<s.effects.length;l++)(h=(a=s.effects[l]).addBounds)==null||h.call(a,t);n.addBounds(t,W.IDENTITY),Lt.return(t)}i||ut.return(r)}function Li(s,t){const e=s.parent;return e&&(Li(e,t),e.updateLocalTransform(),t.append(e.localTransform)),t}function Mn(s,t){if(s===16777215||!t)return t;if(t===16777215||!s)return s;const e=s>>16&255,i=s>>8&255,r=s&255,n=t>>16&255,o=t>>8&255,a=t&255,h=e*n/255|0,l=i*o/255|0,c=r*a/255|0;return(h<<16)+(l<<8)+c}const hr=16777215;function lr(s,t){return s===hr?t:t===hr?s:Mn(s,t)}function fs(s){return((s&255)<<16)+(s&65280)+(s>>16&255)}const Na={getGlobalAlpha(s){if(s)return this.renderGroup?this.renderGroup.worldAlpha:this.parentRenderGroup?this.parentRenderGroup.worldAlpha*this.alpha:this.alpha;let t=this.alpha,e=this.parent;for(;e;)t*=e.alpha,e=e.parent;return t},getGlobalTransform(s=new W,t){if(t)return s.copyFrom(this.worldTransform);this.updateLocalTransform();const e=Li(this,ut.get().identity());return s.appendFrom(this.localTransform,e),ut.return(e),s},getGlobalTint(s){if(s)return this.renderGroup?fs(this.renderGroup.worldColor):this.parentRenderGroup?fs(lr(this.localColor,this.parentRenderGroup.worldColor)):this.tint;let t=this.localColor,e=this.parent;for(;e;)t=lr(t,e.localColor),e=e.parent;return fs(t)}};function kn(s,t,e){return t.clear(),e||(e=W.IDENTITY),En(s,t,e,s,!0),t.isValid||t.set(0,0,0,0),t}function En(s,t,e,i,r){var h,l;let n;if(r)n=ut.get(),n=e.copyTo(n);else{if(!s.visible||!s.measurable)return;s.updateLocalTransform();const c=s.localTransform;n=ut.get(),n.appendFrom(c,e)}const o=t,a=!!s.effects.length;if(a&&(t=Lt.get().clear()),s.boundsArea)t.addRect(s.boundsArea,n);else{s.renderPipeId&&(t.matrix=n,t.addBounds(s.bounds));const c=s.children;for(let u=0;u<c.length;u++)En(c[u],t,n,i,!1)}if(a){for(let c=0;c<s.effects.length;c++)(l=(h=s.effects[c]).addLocalBounds)==null||l.call(h,t,i);o.addBounds(t,W.IDENTITY),Lt.return(t)}ut.return(n)}function In(s,t){const e=s.children;for(let i=0;i<e.length;i++){const r=e[i],n=r.uid,o=(r._didViewChangeTick&65535)<<16|r._didContainerChangeTick&65535,a=t.index;(t.data[a]!==n||t.data[a+1]!==o)&&(t.data[t.index]=n,t.data[t.index+1]=o,t.didChange=!0),t.index=a+2,r.children.length&&In(r,t)}return t.didChange}const Va=new W,$a={_localBoundsCacheId:-1,_localBoundsCacheData:null,_setWidth(s,t){const e=Math.sign(this.scale.x)||1;t!==0?this.scale.x=s/t*e:this.scale.x=e},_setHeight(s,t){const e=Math.sign(this.scale.y)||1;t!==0?this.scale.y=s/t*e:this.scale.y=e},getLocalBounds(){this._localBoundsCacheData||(this._localBoundsCacheData={data:[],index:1,didChange:!1,localBounds:new vt});const s=this._localBoundsCacheData;return s.index=1,s.didChange=!1,s.data[0]!==this._didViewChangeTick&&(s.didChange=!0,s.data[0]=this._didViewChangeTick),In(this,s),s.didChange&&kn(this,s.localBounds,Va),s.localBounds},getBounds(s,t){return Tn(this,s,t||new vt)}},ja={_onRender:null,set onRender(s){const t=this.renderGroup||this.parentRenderGroup;if(!s){this._onRender&&(t==null||t.removeOnRender(this)),this._onRender=null;return}this._onRender||t==null||t.addOnRender(this),this._onRender=s},get onRender(){return this._onRender}},Ya={_zIndex:0,sortDirty:!1,sortableChildren:!1,get zIndex(){return this._zIndex},set zIndex(s){this._zIndex!==s&&(this._zIndex=s,this.depthOfChildModified())},depthOfChildModified(){this.parent&&(this.parent.sortableChildren=!0,this.parent.sortDirty=!0),this.parentRenderGroup&&(this.parentRenderGroup.structureDidChange=!0)},sortChildren(){this.sortDirty&&(this.sortDirty=!1,this.children.sort(Xa))}};function Xa(s,t){return s._zIndex-t._zIndex}const qa={getGlobalPosition(s=new lt,t=!1){return this.parent?this.parent.toGlobal(this._position,s,t):(s.x=this._position.x,s.y=this._position.y),s},toGlobal(s,t,e=!1){const i=this.getGlobalTransform(ut.get(),e);return t=i.apply(s,t),ut.return(i),t},toLocal(s,t,e,i){t&&(s=t.toGlobal(s,e,i));const r=this.getGlobalTransform(ut.get(),i);return e=r.applyInverse(s,e),ut.return(r),e}};class Rn{constructor(){this.uid=J("instructionSet"),this.instructions=[],this.instructionSize=0,this.renderables=[],this.gcTick=0}reset(){this.instructionSize=0}destroy(){this.instructions.length=0,this.renderables.length=0,this.renderPipes=null,this.gcTick=0}add(t){this.instructions[this.instructionSize++]=t}log(){this.instructions.length=this.instructionSize,console.table(this.instructions,["type","action"])}}let Ka=0;class Qa{constructor(t){this._poolKeyHash=Object.create(null),this._texturePool={},this.textureOptions=t||{},this.enableFullScreen=!1,this.textureStyle=new ye(this.textureOptions)}createTexture(t,e,i,r){const n=new St({...this.textureOptions,width:t,height:e,resolution:1,antialias:i,autoGarbageCollect:!1,autoGenerateMipmaps:r});return new U({source:n,label:`texturePool_${Ka++}`})}getOptimalTexture(t,e,i=1,r,n=!1){let o=Math.ceil(t*i-1e-6),a=Math.ceil(e*i-1e-6);o=_e(o),a=_e(a);const h=r?1:0,l=n?1:0,c=(o<<17)+(a<<2)+(l<<1)+h;this._texturePool[c]||(this._texturePool[c]=[]);let u=this._texturePool[c].pop();return u||(u=this.createTexture(o,a,r,n)),u.source._resolution=i,u.source.width=o/i,u.source.height=a/i,u.source.pixelWidth=o,u.source.pixelHeight=a,u.frame.x=0,u.frame.y=0,u.frame.width=t,u.frame.height=e,u.updateUvs(),this._poolKeyHash[u.uid]=c,u}getSameSizeTexture(t,e=!1){const i=t.source;return this.getOptimalTexture(t.width,t.height,i._resolution,e)}returnTexture(t,e=!1){const i=this._poolKeyHash[t.uid];e&&(t.source.style=this.textureStyle),this._texturePool[i].push(t)}clear(t){if(t=t!==!1,t)for(const e in this._texturePool){const i=this._texturePool[e];if(i)for(let r=0;r<i.length;r++)i[r].destroy(!0)}this._texturePool={}}}const Ts=new Qa;Qe.register(Ts);class Za{constructor(){this.renderPipeId="renderGroup",this.root=null,this.canBundle=!1,this.renderGroupParent=null,this.renderGroupChildren=[],this.worldTransform=new W,this.worldColorAlpha=4294967295,this.worldColor=16777215,this.worldAlpha=1,this.childrenToUpdate=Object.create(null),this.updateTick=0,this.gcTick=0,this.childrenRenderablesToUpdate={list:[],index:0},this.structureDidChange=!0,this.instructionSet=new Rn,this._onRenderContainers=[],this.textureNeedsUpdate=!0,this.isCachedAsTexture=!1,this._matrixDirty=7}init(t){this.root=t,t._onRender&&this.addOnRender(t),t.didChange=!0;const e=t.children;for(let i=0;i<e.length;i++){const r=e[i];r._updateFlags=15,this.addChild(r)}}enableCacheAsTexture(t={}){this.textureOptions=t,this.isCachedAsTexture=!0,this.textureNeedsUpdate=!0}disableCacheAsTexture(){this.isCachedAsTexture=!1,this.texture&&(Ts.returnTexture(this.texture,!0),this.texture=null)}updateCacheTexture(){this.textureNeedsUpdate=!0;const t=this._parentCacheAsTextureRenderGroup;t&&!t.textureNeedsUpdate&&t.updateCacheTexture()}reset(){this.renderGroupChildren.length=0;for(const t in this.childrenToUpdate){const e=this.childrenToUpdate[t];e.list.fill(null),e.index=0}this.childrenRenderablesToUpdate.index=0,this.childrenRenderablesToUpdate.list.fill(null),this.root=null,this.updateTick=0,this.structureDidChange=!0,this._onRenderContainers.length=0,this.renderGroupParent=null,this.disableCacheAsTexture()}get localTransform(){return this.root.localTransform}addRenderGroupChild(t){t.renderGroupParent&&t.renderGroupParent._removeRenderGroupChild(t),t.renderGroupParent=this,this.renderGroupChildren.push(t)}_removeRenderGroupChild(t){const e=this.renderGroupChildren.indexOf(t);e>-1&&this.renderGroupChildren.splice(e,1),t.renderGroupParent=null}addChild(t){if(this.structureDidChange=!0,t.parentRenderGroup=this,t.updateTick=-1,t.parent===this.root?t.relativeRenderGroupDepth=1:t.relativeRenderGroupDepth=t.parent.relativeRenderGroupDepth+1,t.didChange=!0,this.onChildUpdate(t),t.renderGroup){this.addRenderGroupChild(t.renderGroup);return}t._onRender&&this.addOnRender(t);const e=t.children;for(let i=0;i<e.length;i++)this.addChild(e[i])}removeChild(t){if(this.structureDidChange=!0,t._onRender&&(t.renderGroup||this.removeOnRender(t)),t.parentRenderGroup=null,t.renderGroup){this._removeRenderGroupChild(t.renderGroup);return}const e=t.children;for(let i=0;i<e.length;i++)this.removeChild(e[i])}removeChildren(t){for(let e=0;e<t.length;e++)this.removeChild(t[e])}onChildUpdate(t){let e=this.childrenToUpdate[t.relativeRenderGroupDepth];e||(e=this.childrenToUpdate[t.relativeRenderGroupDepth]={index:0,list:[]}),e.list[e.index++]=t}updateRenderable(t){t.globalDisplayStatus<7||(this.instructionSet.renderPipes[t.renderPipeId].updateRenderable(t),t.didViewUpdate=!1)}onChildViewUpdate(t){this.childrenRenderablesToUpdate.list[this.childrenRenderablesToUpdate.index++]=t}get isRenderable(){return this.root.localDisplayStatus===7&&this.worldAlpha>0}addOnRender(t){this._onRenderContainers.push(t)}removeOnRender(t){this._onRenderContainers.splice(this._onRenderContainers.indexOf(t),1)}runOnRender(t){for(let e=0;e<this._onRenderContainers.length;e++)this._onRenderContainers[e]._onRender(t)}destroy(){this.disableCacheAsTexture(),this.renderGroupParent=null,this.root=null,this.childrenRenderablesToUpdate=null,this.childrenToUpdate=null,this.renderGroupChildren=null,this._onRenderContainers=null,this.instructionSet=null}getChildren(t=[]){const e=this.root.children;for(let i=0;i<e.length;i++)this._getChildren(e[i],t);return t}_getChildren(t,e=[]){if(e.push(t),t.renderGroup)return e;const i=t.children;for(let r=0;r<i.length;r++)this._getChildren(i[r],e);return e}invalidateMatrices(){this._matrixDirty=7}get inverseWorldTransform(){return(this._matrixDirty&1)===0?this._inverseWorldTransform:(this._matrixDirty&=-2,this._inverseWorldTransform||(this._inverseWorldTransform=new W),this._inverseWorldTransform.copyFrom(this.worldTransform).invert())}get textureOffsetInverseTransform(){return(this._matrixDirty&2)===0?this._textureOffsetInverseTransform:(this._matrixDirty&=-3,this._textureOffsetInverseTransform||(this._textureOffsetInverseTransform=new W),this._textureOffsetInverseTransform.copyFrom(this.inverseWorldTransform).translate(-this._textureBounds.x,-this._textureBounds.y))}get inverseParentTextureTransform(){if((this._matrixDirty&4)===0)return this._inverseParentTextureTransform;this._matrixDirty&=-5;const t=this._parentCacheAsTextureRenderGroup;return t?(this._inverseParentTextureTransform||(this._inverseParentTextureTransform=new W),this._inverseParentTextureTransform.copyFrom(this.worldTransform).prepend(t.inverseWorldTransform).translate(-t._textureBounds.x,-t._textureBounds.y)):this.worldTransform}get cacheToLocalTransform(){return this.isCachedAsTexture?this.textureOffsetInverseTransform:this._parentCacheAsTextureRenderGroup?this._parentCacheAsTextureRenderGroup.textureOffsetInverseTransform:null}}function Ja(s,t,e={}){for(const i in t)!e[i]&&t[i]!==void 0&&(s[i]=t[i])}const Us=new ot(null),is=new ot(null),zs=new ot(null,1,1),rs=new ot(null),cr=1,th=2,Hs=4;class Ut extends ft{constructor(t={}){var e,i;super(),this.uid=J("renderable"),this._updateFlags=15,this.renderGroup=null,this.parentRenderGroup=null,this.parentRenderGroupIndex=0,this.didChange=!1,this.didViewUpdate=!1,this.relativeRenderGroupDepth=0,this.children=[],this.parent=null,this.includeInBuild=!0,this.measurable=!0,this.isSimple=!0,this.parentRenderLayer=null,this.updateTick=-1,this.localTransform=new W,this.relativeGroupTransform=new W,this.groupTransform=this.relativeGroupTransform,this.destroyed=!1,this._position=new ot(this,0,0),this._scale=zs,this._pivot=is,this._origin=rs,this._skew=Us,this._cx=1,this._sx=0,this._cy=0,this._sy=1,this._rotation=0,this.localColor=16777215,this.localAlpha=1,this.groupAlpha=1,this.groupColor=16777215,this.groupColorAlpha=4294967295,this.localBlendMode="inherit",this.groupBlendMode="normal",this.localDisplayStatus=7,this.globalDisplayStatus=7,this._didContainerChangeTick=0,this._didViewChangeTick=0,this._didLocalTransformChangeId=-1,this.effects=[],Ja(this,t,{children:!0,parent:!0,effects:!0}),(e=t.children)==null||e.forEach(r=>this.addChild(r)),(i=t.parent)==null||i.addChild(this)}static mixin(t){X("8.8.0","Container.mixin is deprecated, please use extensions.mixin instead."),K.mixin(Ut,t)}set _didChangeId(t){this._didViewChangeTick=t>>12&4095,this._didContainerChangeTick=t&4095}get _didChangeId(){return this._didContainerChangeTick&4095|(this._didViewChangeTick&4095)<<12}addChild(...t){if(this.allowChildren||X(_t,"addChild: Only Containers will be allowed to add children in v8.0.0"),t.length>1){for(let r=0;r<t.length;r++)this.addChild(t[r]);return t[0]}const e=t[0],i=this.renderGroup||this.parentRenderGroup;return e.parent===this?(this.children.splice(this.children.indexOf(e),1),this.children.push(e),i&&(i.structureDidChange=!0),e):(e.parent&&e.parent.removeChild(e),this.children.push(e),this.sortableChildren&&(this.sortDirty=!0),e.parent=this,e.didChange=!0,e._updateFlags=15,i&&i.addChild(e),this.emit("childAdded",e,this,this.children.length-1),e.emit("added",this),this._didViewChangeTick++,e._zIndex!==0&&e.depthOfChildModified(),e)}removeChild(...t){if(t.length>1){for(let r=0;r<t.length;r++)this.removeChild(t[r]);return t[0]}const e=t[0],i=this.children.indexOf(e);return i>-1&&(this._didViewChangeTick++,this.children.splice(i,1),this.renderGroup?this.renderGroup.removeChild(e):this.parentRenderGroup&&this.parentRenderGroup.removeChild(e),e.parentRenderLayer&&e.parentRenderLayer.detach(e),e.parent=null,this.emit("childRemoved",e,this,i),e.emit("removed",this)),e}_onUpdate(t){t&&t===this._skew&&this._updateSkew(),this._didContainerChangeTick++,!this.didChange&&(this.didChange=!0,this.parentRenderGroup&&this.parentRenderGroup.onChildUpdate(this))}set isRenderGroup(t){!!this.renderGroup!==t&&(t?this.enableRenderGroup():this.disableRenderGroup())}get isRenderGroup(){return!!this.renderGroup}enableRenderGroup(){if(this.renderGroup)return;const t=this.parentRenderGroup;t==null||t.removeChild(this),this.renderGroup=At.get(Za,this),this.groupTransform=W.IDENTITY,t==null||t.addChild(this),this._updateIsSimple()}disableRenderGroup(){if(!this.renderGroup)return;const t=this.parentRenderGroup;t==null||t.removeChild(this),At.return(this.renderGroup),this.renderGroup=null,this.groupTransform=this.relativeGroupTransform,t==null||t.addChild(this),this._updateIsSimple()}_updateIsSimple(){this.isSimple=!this.renderGroup&&this.effects.length===0}get worldTransform(){return this._worldTransform||(this._worldTransform=new W),this.renderGroup?this._worldTransform.copyFrom(this.renderGroup.worldTransform):this.parentRenderGroup&&this._worldTransform.appendFrom(this.relativeGroupTransform,this.parentRenderGroup.worldTransform),this._worldTransform}get x(){return this._position.x}set x(t){this._position.x=t}get y(){return this._position.y}set y(t){this._position.y=t}get position(){return this._position}set position(t){this._position.copyFrom(t)}get rotation(){return this._rotation}set rotation(t){this._rotation!==t&&(this._rotation=t,this._onUpdate(this._skew))}get angle(){return this.rotation*pa}set angle(t){this.rotation=t*ma}get pivot(){return this._pivot===is&&(this._pivot=new ot(this,0,0)),this._pivot}set pivot(t){this._pivot===is&&(this._pivot=new ot(this,0,0),this._origin!==rs&&Y("Setting both a pivot and origin on a Container is not recommended. This can lead to unexpected behavior if not handled carefully.")),typeof t=="number"?this._pivot.set(t):this._pivot.copyFrom(t)}get skew(){return this._skew===Us&&(this._skew=new ot(this,0,0)),this._skew}set skew(t){this._skew===Us&&(this._skew=new ot(this,0,0)),this._skew.copyFrom(t)}get scale(){return this._scale===zs&&(this._scale=new ot(this,1,1)),this._scale}set scale(t){this._scale===zs&&(this._scale=new ot(this,0,0)),typeof t=="string"&&(t=parseFloat(t)),typeof t=="number"?this._scale.set(t):this._scale.copyFrom(t)}get origin(){return this._origin===rs&&(this._origin=new ot(this,0,0)),this._origin}set origin(t){this._origin===rs&&(this._origin=new ot(this,0,0),this._pivot!==is&&Y("Setting both a pivot and origin on a Container is not recommended. This can lead to unexpected behavior if not handled carefully.")),typeof t=="number"?this._origin.set(t):this._origin.copyFrom(t)}get width(){return Math.abs(this.scale.x*this.getLocalBounds().width)}set width(t){const e=this.getLocalBounds().width;this._setWidth(t,e)}get height(){return Math.abs(this.scale.y*this.getLocalBounds().height)}set height(t){const e=this.getLocalBounds().height;this._setHeight(t,e)}getSize(t){t||(t={});const e=this.getLocalBounds();return t.width=Math.abs(this.scale.x*e.width),t.height=Math.abs(this.scale.y*e.height),t}setSize(t,e){const i=this.getLocalBounds();typeof t=="object"?(e=t.height??t.width,t=t.width):e??(e=t),t!==void 0&&this._setWidth(t,i.width),e!==void 0&&this._setHeight(e,i.height)}_updateSkew(){const t=this._rotation,e=this._skew;this._cx=Math.cos(t+e._y),this._sx=Math.sin(t+e._y),this._cy=-Math.sin(t-e._x),this._sy=Math.cos(t-e._x)}updateTransform(t){return this.position.set(typeof t.x=="number"?t.x:this.position.x,typeof t.y=="number"?t.y:this.position.y),this.scale.set(typeof t.scaleX=="number"?t.scaleX:this.scale.x,typeof t.scaleY=="number"?t.scaleY:this.scale.y),this.rotation=typeof t.rotation=="number"?t.rotation:this.rotation,this.skew.set(typeof t.skewX=="number"?t.skewX:this.skew.x,typeof t.skewY=="number"?t.skewY:this.skew.y),this.pivot.set(typeof t.pivotX=="number"?t.pivotX:this.pivot.x,typeof t.pivotY=="number"?t.pivotY:this.pivot.y),this.origin.set(typeof t.originX=="number"?t.originX:this.origin.x,typeof t.originY=="number"?t.originY:this.origin.y),this}setFromMatrix(t){t.decompose(this)}updateLocalTransform(){const t=this._didContainerChangeTick;if(this._didLocalTransformChangeId===t)return;this._didLocalTransformChangeId=t;const e=this.localTransform,i=this._scale,r=this._pivot,n=this._origin,o=this._position,a=i._x,h=i._y,l=r._x,c=r._y,u=-n._x,f=-n._y;e.a=this._cx*a,e.b=this._sx*a,e.c=this._cy*h,e.d=this._sy*h,e.tx=o._x-(l*e.a+c*e.c)+(u*e.a+f*e.c)-u,e.ty=o._y-(l*e.b+c*e.d)+(u*e.b+f*e.d)-f}set alpha(t){t!==this.localAlpha&&(this.localAlpha=t,this._updateFlags|=cr,this._onUpdate())}get alpha(){return this.localAlpha}set tint(t){const i=q.shared.setValue(t??16777215).toBgrNumber();i!==this.localColor&&(this.localColor=i,this._updateFlags|=cr,this._onUpdate())}get tint(){return fs(this.localColor)}set blendMode(t){this.localBlendMode!==t&&(this.parentRenderGroup&&(this.parentRenderGroup.structureDidChange=!0),this._updateFlags|=th,this.localBlendMode=t,this._onUpdate())}get blendMode(){return this.localBlendMode}get visible(){return!!(this.localDisplayStatus&2)}set visible(t){const e=t?2:0;(this.localDisplayStatus&2)!==e&&(this.parentRenderGroup&&(this.parentRenderGroup.structureDidChange=!0),this._updateFlags|=Hs,this.localDisplayStatus^=2,this._onUpdate(),this.emit("visibleChanged",t))}get culled(){return!(this.localDisplayStatus&4)}set culled(t){const e=t?0:4;(this.localDisplayStatus&4)!==e&&(this.parentRenderGroup&&(this.parentRenderGroup.structureDidChange=!0),this._updateFlags|=Hs,this.localDisplayStatus^=4,this._onUpdate())}get renderable(){return!!(this.localDisplayStatus&1)}set renderable(t){const e=t?1:0;(this.localDisplayStatus&1)!==e&&(this._updateFlags|=Hs,this.localDisplayStatus^=1,this.parentRenderGroup&&(this.parentRenderGroup.structureDidChange=!0),this._onUpdate())}get isRenderable(){return this.localDisplayStatus===7&&this.groupAlpha>0}destroy(t=!1){var r;if(this.destroyed)return;this.destroyed=!0;let e;if(this.children.length&&(e=this.removeChildren(0,this.children.length)),this.removeFromParent(),this.parent=null,this._maskEffect=null,this._filterEffect=null,this.effects=null,this._position=null,this._scale=null,this._pivot=null,this._origin=null,this._skew=null,this.emit("destroyed",this),this.removeAllListeners(),(typeof t=="boolean"?t:t==null?void 0:t.children)&&e)for(let n=0;n<e.length;++n)e[n].destroy(t);(r=this.renderGroup)==null||r.destroy(),this.renderGroup=null}}K.mixin(Ut,Ga,Ha,qa,ja,$a,Wa,Ua,Ya,Ia,Ba,Na,Da);class Ln extends Ut{constructor(t){super(t),this.canBundle=!0,this.allowChildren=!1,this._roundPixels=0,this._lastUsed=-1,this._gpuData=Object.create(null),this.autoGarbageCollect=!0,this._gcLastUsed=-1,this._bounds=new vt(0,1,0,0),this._boundsDirty=!0,this.autoGarbageCollect=t.autoGarbageCollect??!0}get bounds(){return this._boundsDirty?(this.updateBounds(),this._boundsDirty=!1,this._bounds):this._bounds}get roundPixels(){return!!this._roundPixels}set roundPixels(t){this._roundPixels=t?1:0}containsPoint(t){const e=this.bounds,{x:i,y:r}=t;return i>=e.minX&&i<=e.maxX&&r>=e.minY&&r<=e.maxY}onViewUpdate(){if(this._didViewChangeTick++,this._boundsDirty=!0,this.didViewUpdate)return;this.didViewUpdate=!0;const t=this.renderGroup||this.parentRenderGroup;t&&t.onChildViewUpdate(this)}unload(){var t;this.emit("unload",this);for(const e in this._gpuData)(t=this._gpuData[e])==null||t.destroy();this._gpuData=Object.create(null),this.onViewUpdate()}destroy(t){this.unload(),super.destroy(t),this._bounds=null}collectRenderablesSimple(t,e,i){const{renderPipes:r}=e;r.blendMode.pushBlendMode(this,this.groupBlendMode,t);const o=r[this.renderPipeId];o!=null&&o.addRenderable&&o.addRenderable(this,t),this.didViewUpdate=!1;const a=this.children,h=a.length;for(let l=0;l<h;l++)a[l].collectRenderables(t,e,i);r.blendMode.popBlendMode(t)}}class yt extends Ln{constructor(t=U.EMPTY){t instanceof U&&(t={texture:t});const{texture:e=U.EMPTY,anchor:i,roundPixels:r,width:n,height:o,...a}=t;super({label:"Sprite",...a}),this.renderPipeId="sprite",this.batched=!0,this._visualBounds={minX:0,maxX:1,minY:0,maxY:0},this._anchor=new ot({_onUpdate:()=>{this.onViewUpdate()}}),i?this.anchor=i:e.defaultAnchor&&(this.anchor=e.defaultAnchor),this.texture=e,this.allowChildren=!1,this.roundPixels=r??!1,n!==void 0&&(this.width=n),o!==void 0&&(this.height=o)}static from(t,e=!1){return t instanceof U?new yt(t):new yt(U.from(t,e))}set texture(t){t||(t=U.EMPTY);const e=this._texture;e!==t&&(e&&e.dynamic&&e.off("update",this.onViewUpdate,this),t.dynamic&&t.on("update",this.onViewUpdate,this),this._texture=t,this._width&&this._setWidth(this._width,this._texture.orig.width),this._height&&this._setHeight(this._height,this._texture.orig.height),this.onViewUpdate())}get texture(){return this._texture}get visualBounds(){return vn(this._visualBounds,this._anchor,this._texture),this._visualBounds}get sourceBounds(){return X("8.6.1","Sprite.sourceBounds is deprecated, use visualBounds instead."),this.visualBounds}updateBounds(){const t=this._anchor,e=this._texture,i=this._bounds,{width:r,height:n}=e.orig;i.minX=-t._x*r,i.maxX=i.minX+r,i.minY=-t._y*n,i.maxY=i.minY+n}destroy(t=!1){if(super.destroy(t),typeof t=="boolean"?t:t==null?void 0:t.texture){const i=typeof t=="boolean"?t:t==null?void 0:t.textureSource;this._texture.destroy(i)}this._texture=null,this._visualBounds=null,this._bounds=null,this._anchor=null}get anchor(){return this._anchor}set anchor(t){typeof t=="number"?this._anchor.set(t):this._anchor.copyFrom(t)}get width(){return Math.abs(this.scale.x)*this._texture.orig.width}set width(t){this._setWidth(t,this._texture.orig.width),this._width=t}get height(){return Math.abs(this.scale.y)*this._texture.orig.height}set height(t){this._setHeight(t,this._texture.orig.height),this._height=t}getSize(t){return t||(t={}),t.width=Math.abs(this.scale.x)*this._texture.orig.width,t.height=Math.abs(this.scale.y)*this._texture.orig.height,t}setSize(t,e){typeof t=="object"?(e=t.height??t.width,t=t.width):e??(e=t),t!==void 0&&this._setWidth(t,this._texture.orig.width),e!==void 0&&this._setHeight(e,this._texture.orig.height)}}const eh=new vt;function Bn(s,t,e){const i=eh;s.measurable=!0,Tn(s,e,i),t.addBoundsMask(i),s.measurable=!1}function Fn(s,t,e){const i=Lt.get();s.measurable=!0;const r=ut.get().identity(),n=Gn(s,e,r);kn(s,i,n),s.measurable=!1,t.addBoundsMask(i),ut.return(r),Lt.return(i)}function Gn(s,t,e){return s?(s!==t&&(Gn(s.parent,t,e),s.updateLocalTransform(),e.append(s.localTransform)),e):(Y("Mask bounds, renderable is not inside the root container"),e)}class Dn{constructor(t){this.priority=0,this.inverse=!1,this.channel="red",this.pipe="alphaMask",t!=null&&t.mask&&this.init(t.mask)}init(t){this.mask=t,this.renderMaskToTexture=!(t instanceof yt),this.mask.renderable=this.renderMaskToTexture,this.mask.includeInBuild=!this.renderMaskToTexture,this.mask.measurable=!1}reset(){this.mask!==null&&(this.mask.measurable=!0,this.mask=null)}addBounds(t,e){this.inverse||Bn(this.mask,t,e)}addLocalBounds(t,e){Fn(this.mask,t,e)}containsPoint(t,e){const i=this.mask;return e(i,t)}destroy(){this.reset()}static test(t){return t instanceof yt}}Dn.extension=I.MaskEffect;class On{constructor(t){this.priority=0,this.pipe="colorMask",t!=null&&t.mask&&this.init(t.mask)}init(t){this.mask=t}destroy(){}static test(t){return typeof t=="number"}}On.extension=I.MaskEffect;class Wn{constructor(t){this.priority=0,this.pipe="stencilMask",t!=null&&t.mask&&this.init(t.mask)}init(t){this.mask=t,this.mask.includeInBuild=!1,this.mask.measurable=!1}reset(){this.mask!==null&&(this.mask.measurable=!0,this.mask.includeInBuild=!0,this.mask=null)}addBounds(t,e){Bn(this.mask,t,e)}addLocalBounds(t,e){Fn(this.mask,t,e)}containsPoint(t,e){const i=this.mask;return e(i,t)}destroy(){this.reset()}static test(t){return t instanceof Ut}}Wn.extension=I.MaskEffect;const sh={createCanvas:(s,t)=>{const e=document.createElement("canvas");return e.width=s,e.height=t,e},createImage:()=>new Image,getCanvasRenderingContext2D:()=>CanvasRenderingContext2D,getWebGLRenderingContext:()=>WebGLRenderingContext,getNavigator:()=>navigator,getBaseUrl:()=>document.baseURI??window.location.href,getFontFaceSet:()=>document.fonts,fetch:(s,t)=>fetch(s,t),parseXML:s=>new DOMParser().parseFromString(s,"text/xml")};let ur=sh;const z={get(){return ur},set(s){ur=s}};class Un extends St{constructor(t){t.resource||(t.resource=z.get().createCanvas()),t.width||(t.width=t.resource.width,t.autoDensity||(t.width/=t.resolution)),t.height||(t.height=t.resource.height,t.autoDensity||(t.height/=t.resolution)),super(t),this.uploadMethodId="image",this.autoDensity=t.autoDensity,this.resizeCanvas(),this.transparent=!!t.transparent}resizeCanvas(){this.autoDensity&&"style"in this.resource&&(this.resource.style.width=`${this.width}px`,this.resource.style.height=`${this.height}px`),(this.resource.width!==this.pixelWidth||this.resource.height!==this.pixelHeight)&&(this.resource.width=this.pixelWidth,this.resource.height=this.pixelHeight)}resize(t=this.width,e=this.height,i=this._resolution){const r=super.resize(t,e,i);return r&&this.resizeCanvas(),r}static test(t){return globalThis.HTMLCanvasElement&&t instanceof HTMLCanvasElement||globalThis.OffscreenCanvas&&t instanceof OffscreenCanvas}get context2D(){return this._context2D||(this._context2D=this.resource.getContext("2d"))}}Un.extension=I.TextureSource;class be extends St{constructor(t){super(t),this.uploadMethodId="image",this.autoGarbageCollect=!0}static test(t){return globalThis.HTMLImageElement&&t instanceof HTMLImageElement||typeof ImageBitmap<"u"&&t instanceof ImageBitmap||globalThis.VideoFrame&&t instanceof VideoFrame}}be.extension=I.TextureSource;var ze=(s=>(s[s.INTERACTION=50]="INTERACTION",s[s.HIGH=25]="HIGH",s[s.NORMAL=0]="NORMAL",s[s.LOW=-25]="LOW",s[s.UTILITY=-50]="UTILITY",s))(ze||{});class Ns{constructor(t,e=null,i=0,r=!1){this.next=null,this.previous=null,this._destroyed=!1,this._fn=t,this._context=e,this.priority=i,this._once=r}match(t,e=null){return this._fn===t&&this._context===e}emit(t){this._fn&&(this._context?this._fn.call(this._context,t):this._fn(t));const e=this.next;return this._once&&this.destroy(!0),this._destroyed&&(this.next=null),e}connect(t){this.previous=t,t.next&&(t.next.previous=this),this.next=t.next,t.next=this}destroy(t=!1){this._destroyed=!0,this._fn=null,this._context=null,this.previous&&(this.previous.next=this.next),this.next&&(this.next.previous=this.previous);const e=this.next;return this.next=t?null:e,this.previous=null,e}}const zn=class gt{constructor(){this.autoStart=!1,this.deltaTime=1,this.lastTime=-1,this.speed=1,this.started=!1,this._requestId=null,this._maxElapsedMS=100,this._minElapsedMS=0,this._protected=!1,this._lastFrame=-1,this._head=new Ns(null,null,1/0),this.deltaMS=1/gt.targetFPMS,this.elapsedMS=1/gt.targetFPMS,this._tick=t=>{this._requestId=null,this.started&&(this.update(t),this.started&&this._requestId===null&&this._head.next&&(this._requestId=requestAnimationFrame(this._tick)))}}_requestIfNeeded(){this._requestId===null&&this._head.next&&(this.lastTime=performance.now(),this._lastFrame=this.lastTime,this._requestId=requestAnimationFrame(this._tick))}_cancelIfNeeded(){this._requestId!==null&&(cancelAnimationFrame(this._requestId),this._requestId=null)}_startIfPossible(){this.started?this._requestIfNeeded():this.autoStart&&this.start()}add(t,e,i=ze.NORMAL){return this._addListener(new Ns(t,e,i))}addOnce(t,e,i=ze.NORMAL){return this._addListener(new Ns(t,e,i,!0))}_addListener(t){let e=this._head.next,i=this._head;if(!e)t.connect(i);else{for(;e;){if(t.priority>e.priority){t.connect(i);break}i=e,e=e.next}t.previous||t.connect(i)}return this._startIfPossible(),this}remove(t,e){let i=this._head.next;for(;i;)i.match(t,e)?i=i.destroy():i=i.next;return this._head.next||this._cancelIfNeeded(),this}get count(){if(!this._head)return 0;let t=0,e=this._head;for(;e=e.next;)t++;return t}start(){this.started||(this.started=!0,this._requestIfNeeded())}stop(){this.started&&(this.started=!1,this._cancelIfNeeded())}destroy(){if(!this._protected){this.stop();let t=this._head.next;for(;t;)t=t.destroy(!0);this._head.destroy(),this._head=null}}update(t=performance.now()){let e;if(t>this.lastTime){if(e=this.elapsedMS=t-this.lastTime,e>this._maxElapsedMS&&(e=this._maxElapsedMS),e*=this.speed,this._minElapsedMS){const n=t-this._lastFrame|0;if(n<this._minElapsedMS)return;this._lastFrame=t-n%this._minElapsedMS}this.deltaMS=e,this.deltaTime=this.deltaMS*gt.targetFPMS;const i=this._head;let r=i.next;for(;r;)r=r.emit(this);i.next||this._cancelIfNeeded()}else this.deltaTime=this.deltaMS=this.elapsedMS=0;this.lastTime=t}get FPS(){return 1e3/this.elapsedMS}get minFPS(){return 1e3/this._maxElapsedMS}set minFPS(t){const e=Math.min(Math.max(0,t)/1e3,gt.targetFPMS);this._maxElapsedMS=1/e,this._minElapsedMS&&t>this.maxFPS&&(this.maxFPS=t)}get maxFPS(){return this._minElapsedMS?Math.round(1e3/this._minElapsedMS):0}set maxFPS(t){t===0?this._minElapsedMS=0:(t<this.minFPS&&(this.minFPS=t),this._minElapsedMS=1/(t/1e3))}static get shared(){if(!gt._shared){const t=gt._shared=new gt;t.autoStart=!0,t._protected=!0}return gt._shared}static get system(){if(!gt._system){const t=gt._system=new gt;t.autoStart=!0,t._protected=!0}return gt._system}};zn.targetFPMS=.06;let dt=zn,Vs;async function Hn(){return Vs??(Vs=(async()=>{var o;const t=z.get().createCanvas(1,1).getContext("webgl");if(!t)return"premultiply-alpha-on-upload";const e=await new Promise(a=>{const h=document.createElement("video");h.onloadeddata=()=>a(h),h.onerror=()=>a(null),h.autoplay=!1,h.crossOrigin="anonymous",h.preload="auto",h.src="data:video/webm;base64,GkXfo59ChoEBQveBAULygQRC84EIQoKEd2VibUKHgQJChYECGFOAZwEAAAAAAAHTEU2bdLpNu4tTq4QVSalmU6yBoU27i1OrhBZUrmtTrIHGTbuMU6uEElTDZ1OsggEXTbuMU6uEHFO7a1OsggG97AEAAAAAAABZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVSalmoCrXsYMPQkBNgIRMYXZmV0GETGF2ZkSJiEBEAAAAAAAAFlSua8yuAQAAAAAAAEPXgQFzxYgAAAAAAAAAAZyBACK1nIN1bmSIgQCGhVZfVlA5g4EBI+ODhAJiWgDglLCBArqBApqBAlPAgQFVsIRVuYEBElTDZ9Vzc9JjwItjxYgAAAAAAAAAAWfInEWjh0VOQ09ERVJEh49MYXZjIGxpYnZweC12cDlnyKJFo4hEVVJBVElPTkSHlDAwOjAwOjAwLjA0MDAwMDAwMAAAH0O2dcfngQCgwqGggQAAAIJJg0IAABAAFgA4JBwYSgAAICAAEb///4r+AAB1oZ2mm+6BAaWWgkmDQgAAEAAWADgkHBhKAAAgIABIQBxTu2uRu4+zgQC3iveBAfGCAXHwgQM=",h.load()});if(!e)return"premultiply-alpha-on-upload";const i=t.createTexture();t.bindTexture(t.TEXTURE_2D,i);const r=t.createFramebuffer();t.bindFramebuffer(t.FRAMEBUFFER,r),t.framebufferTexture2D(t.FRAMEBUFFER,t.COLOR_ATTACHMENT0,t.TEXTURE_2D,i,0),t.pixelStorei(t.UNPACK_PREMULTIPLY_ALPHA_WEBGL,!1),t.pixelStorei(t.UNPACK_COLORSPACE_CONVERSION_WEBGL,t.NONE),t.texImage2D(t.TEXTURE_2D,0,t.RGBA,t.RGBA,t.UNSIGNED_BYTE,e);const n=new Uint8Array(4);return t.readPixels(0,0,1,1,t.RGBA,t.UNSIGNED_BYTE,n),t.deleteFramebuffer(r),t.deleteTexture(i),(o=t.getExtension("WEBGL_lose_context"))==null||o.loseContext(),n[0]<=n[3]?"premultiplied-alpha":"premultiply-alpha-on-upload"})()),Vs}const Ps=class Nn extends St{constructor(t){super(t),this.isReady=!1,this.uploadMethodId="video",t={...Nn.defaultOptions,...t},this._autoUpdate=!0,this._isConnectedToTicker=!1,this._updateFPS=t.updateFPS||0,this._msToNextUpdate=0,this.autoPlay=t.autoPlay!==!1,this.alphaMode=t.alphaMode??"premultiply-alpha-on-upload",this._videoFrameRequestCallback=this._videoFrameRequestCallback.bind(this),this._videoFrameRequestCallbackHandle=null,this._load=null,this._resolve=null,this._reject=null,this._onCanPlay=this._onCanPlay.bind(this),this._onCanPlayThrough=this._onCanPlayThrough.bind(this),this._onError=this._onError.bind(this),this._onPlayStart=this._onPlayStart.bind(this),this._onPlayStop=this._onPlayStop.bind(this),this._onSeeked=this._onSeeked.bind(this),this._onLoadedMetadata=this._onLoadedMetadata.bind(this),t.autoLoad!==!1&&this.load()}updateFrame(){if(!this.destroyed){if(this._updateFPS){const t=dt.shared.elapsedMS*this.resource.playbackRate;this._msToNextUpdate=Math.floor(this._msToNextUpdate-t)}(!this._updateFPS||this._msToNextUpdate<=0)&&(this._msToNextUpdate=this._updateFPS?Math.floor(1e3/this._updateFPS):0),this.isValid&&this.update()}}_videoFrameRequestCallback(){this.updateFrame(),this.destroyed?this._videoFrameRequestCallbackHandle=null:this._videoFrameRequestCallbackHandle=this.resource.requestVideoFrameCallback(this._videoFrameRequestCallback)}get isValid(){return!!this.resource.videoWidth&&!!this.resource.videoHeight}async load(){if(this._load)return this._load;const t=this.resource,e=this.options;return(t.readyState===t.HAVE_ENOUGH_DATA||t.readyState===t.HAVE_FUTURE_DATA)&&t.width&&t.height&&(t.complete=!0),t.addEventListener("play",this._onPlayStart),t.addEventListener("pause",this._onPlayStop),t.addEventListener("seeked",this._onSeeked),this._isSourceReady()?this._mediaReady():(e.preload||t.addEventListener("canplay",this._onCanPlay),t.addEventListener("canplaythrough",this._onCanPlayThrough),t.addEventListener("error",this._onError,!0)),this.isValid||t.addEventListener("loadedmetadata",this._onLoadedMetadata),this.alphaMode=await Hn(),this._load=new Promise((i,r)=>{this.isValid?i(this):(this._resolve=i,this._reject=r,e.preloadTimeoutMs!==void 0&&(this._preloadTimeout=setTimeout(()=>{this._onError(new ErrorEvent(`Preload exceeded timeout of ${e.preloadTimeoutMs}ms`))})),t.load())}),this._load}_onError(t){this.resource.removeEventListener("error",this._onError,!0),this.emit("error",t),this._reject&&(this._reject(t),this._reject=null,this._resolve=null)}_isSourcePlaying(){const t=this.resource;return!t.paused&&!t.ended}_isSourceReady(){return this.resource.readyState>2}_onPlayStart(){this._configureAutoUpdate()}_onPlayStop(){this._configureAutoUpdate()}_onSeeked(){this._autoUpdate&&!this._isSourcePlaying()&&(this._msToNextUpdate=0,this.updateFrame(),this._msToNextUpdate=0)}_onLoadedMetadata(){this.isValid&&this._mediaReady()}_onCanPlay(){this.resource.removeEventListener("canplay",this._onCanPlay),this._mediaReady()}_onCanPlayThrough(){this.resource.removeEventListener("canplaythrough",this._onCanPlayThrough),this._preloadTimeout&&(clearTimeout(this._preloadTimeout),this._preloadTimeout=void 0),this._mediaReady()}_mediaReady(){const t=this.resource;this.isValid&&(this.isReady=!0,this.resize(t.videoWidth,t.videoHeight)),this._msToNextUpdate=0,this.updateFrame(),this._msToNextUpdate=0,this._resolve&&this.isValid&&(this._resolve(this),this._resolve=null,this._reject=null),this._isSourcePlaying()?this._onPlayStart():this.autoPlay&&this.resource.play()}destroy(){this._configureAutoUpdate();const t=this.resource;t&&(t.removeEventListener("play",this._onPlayStart),t.removeEventListener("pause",this._onPlayStop),t.removeEventListener("seeked",this._onSeeked),t.removeEventListener("canplay",this._onCanPlay),t.removeEventListener("canplaythrough",this._onCanPlayThrough),t.removeEventListener("loadedmetadata",this._onLoadedMetadata),t.removeEventListener("error",this._onError,!0),t.pause(),t.src="",t.load()),super.destroy()}get autoUpdate(){return this._autoUpdate}set autoUpdate(t){t!==this._autoUpdate&&(this._autoUpdate=t,this._configureAutoUpdate())}get updateFPS(){return this._updateFPS}set updateFPS(t){t!==this._updateFPS&&(this._updateFPS=t,this._configureAutoUpdate())}_configureAutoUpdate(){this._autoUpdate&&this._isSourcePlaying()?!this._updateFPS&&this.resource.requestVideoFrameCallback?(this._isConnectedToTicker&&(dt.shared.remove(this.updateFrame,this),this._isConnectedToTicker=!1,this._msToNextUpdate=0),this._videoFrameRequestCallbackHandle===null&&(this._videoFrameRequestCallbackHandle=this.resource.requestVideoFrameCallback(this._videoFrameRequestCallback))):(this._videoFrameRequestCallbackHandle!==null&&(this.resource.cancelVideoFrameCallback(this._videoFrameRequestCallbackHandle),this._videoFrameRequestCallbackHandle=null),this._isConnectedToTicker||(dt.shared.add(this.updateFrame,this),this._isConnectedToTicker=!0,this._msToNextUpdate=0)):(this._videoFrameRequestCallbackHandle!==null&&(this.resource.cancelVideoFrameCallback(this._videoFrameRequestCallbackHandle),this._videoFrameRequestCallbackHandle=null),this._isConnectedToTicker&&(dt.shared.remove(this.updateFrame,this),this._isConnectedToTicker=!1,this._msToNextUpdate=0))}static test(t){return globalThis.HTMLVideoElement&&t instanceof HTMLVideoElement}};Ps.extension=I.TextureSource;Ps.defaultOptions={...St.defaultOptions,autoLoad:!0,autoPlay:!0,updateFPS:0,crossorigin:!0,loop:!1,muted:!0,playsinline:!0,preload:!1};Ps.MIME_TYPES={ogv:"video/ogg",mov:"video/quicktime",m4v:"video/mp4"};let De=Ps;const Tt=(s,t,e=!1)=>(Array.isArray(s)||(s=[s]),t?s.map(i=>typeof i=="string"||e?t(i):i):s);class ih{constructor(){this._parsers=[],this._cache=new Map,this._cacheMap=new Map}reset(){this._cacheMap.clear(),this._cache.clear()}has(t){return this._cache.has(t)}get(t){const e=this._cache.get(t);return e||Y(`[Assets] Asset id ${t} was not found in the Cache`),e}set(t,e){const i=Tt(t);let r;for(let h=0;h<this.parsers.length;h++){const l=this.parsers[h];if(l.test(e)){r=l.getCacheableAssets(i,e);break}}const n=new Map(Object.entries(r||{}));r||i.forEach(h=>{n.set(h,e)});const o=[...n.keys()],a={cacheKeys:o,keys:i};i.forEach(h=>{this._cacheMap.set(h,a)}),o.forEach(h=>{const l=r?r[h]:e;this._cache.has(h)&&this._cache.get(h)!==l&&Y("[Cache] already has key:",h),this._cache.set(h,n.get(h))})}remove(t){if(!this._cacheMap.has(t)){Y(`[Assets] Asset id ${t} was not found in the Cache`);return}const e=this._cacheMap.get(t);e.cacheKeys.forEach(r=>{this._cache.delete(r)}),e.keys.forEach(r=>{this._cacheMap.delete(r)})}get parsers(){return this._parsers}}const nt=new ih,ci=[];K.handleByList(I.TextureSource,ci);function Vn(s={}){const t=s&&s.resource,e=t?s.resource:s,i=t?s:{resource:s};for(let r=0;r<ci.length;r++){const n=ci[r];if(n.test(e))return new n(i)}throw new Error(`Could not find a source type for resource: ${i.resource}`)}function rh(s={},t=!1){const e=s&&s.resource,i=e?s.resource:s,r=e?s:{resource:s};if(!t&&nt.has(i))return nt.get(i);const n=new U({source:Vn(r)});return n.on("destroy",()=>{nt.has(i)&&nt.remove(i)}),t||nt.set(i,n),n}function nh(s,t=!1){return typeof s=="string"?nt.get(s):s instanceof St?new U({source:s}):rh(s,t)}U.from=nh;St.from=Vn;K.add(Dn,On,Wn,De,be,Un,Ri);var Gt=(s=>(s[s.Low=0]="Low",s[s.Normal=1]="Normal",s[s.High=2]="High",s))(Gt||{});function Ct(s){if(typeof s!="string")throw new TypeError(`Path must be a string. Received ${JSON.stringify(s)}`)}function Ce(s){return s.split("?")[0].split("#")[0]}function oh(s){return s.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}function ah(s,t,e){return s.replace(new RegExp(oh(t),"g"),e)}function hh(s,t){let e="",i=0,r=-1,n=0,o=-1;for(let a=0;a<=s.length;++a){if(a<s.length)o=s.charCodeAt(a);else{if(o===47)break;o=47}if(o===47){if(!(r===a-1||n===1))if(r!==a-1&&n===2){if(e.length<2||i!==2||e.charCodeAt(e.length-1)!==46||e.charCodeAt(e.length-2)!==46){if(e.length>2){const h=e.lastIndexOf("/");if(h!==e.length-1){h===-1?(e="",i=0):(e=e.slice(0,h),i=e.length-1-e.lastIndexOf("/")),r=a,n=0;continue}}else if(e.length===2||e.length===1){e="",i=0,r=a,n=0;continue}}}else e.length>0?e+=`/${s.slice(r+1,a)}`:e=s.slice(r+1,a),i=a-r-1;r=a,n=0}else o===46&&n!==-1?++n:n=-1}return e}const at={toPosix(s){return ah(s,"\\","/")},isUrl(s){return/^https?:/.test(this.toPosix(s))},isDataUrl(s){return/^data:([a-z]+\/[a-z0-9-+.]+(;[a-z0-9-.!#$%*+.{}|~`]+=[a-z0-9-.!#$%*+.{}()_|~`]+)*)?(;base64)?,([a-z0-9!$&',()*+;=\-._~:@\/?%\s<>]*?)$/i.test(s)},isBlobUrl(s){return s.startsWith("blob:")},hasProtocol(s){return/^[^/:]+:/.test(this.toPosix(s))},getProtocol(s){Ct(s),s=this.toPosix(s);const t=/^file:\/\/\//.exec(s);if(t)return t[0];const e=/^[^/:]+:\/{0,2}/.exec(s);return e?e[0]:""},toAbsolute(s,t,e){if(Ct(s),this.isDataUrl(s)||this.isBlobUrl(s))return s;const i=Ce(this.toPosix(t??z.get().getBaseUrl())),r=Ce(this.toPosix(e??this.rootname(i)));return s=this.toPosix(s),s.startsWith("/")?at.join(r,s.slice(1)):this.isAbsolute(s)?s:this.join(i,s)},normalize(s){if(Ct(s),s.length===0)return".";if(this.isDataUrl(s)||this.isBlobUrl(s))return s;s=this.toPosix(s);let t="";const e=s.startsWith("/");this.hasProtocol(s)&&(t=this.rootname(s),s=s.slice(t.length));const i=s.endsWith("/");return s=hh(s),s.length>0&&i&&(s+="/"),e?`/${s}`:t+s},isAbsolute(s){return Ct(s),s=this.toPosix(s),this.hasProtocol(s)?!0:s.startsWith("/")},join(...s){if(s.length===0)return".";let t;for(let e=0;e<s.length;++e){const i=s[e];if(Ct(i),i.length>0)if(t===void 0)t=i;else{const r=s[e-1]??"";this.joinExtensions.includes(this.extname(r).toLowerCase())?t+=`/../${i}`:t+=`/${i}`}}return t===void 0?".":this.normalize(t)},dirname(s){if(Ct(s),s.length===0)return".";s=this.toPosix(s);let t=s.charCodeAt(0);const e=t===47;let i=-1,r=!0;const n=this.getProtocol(s),o=s;s=s.slice(n.length);for(let a=s.length-1;a>=1;--a)if(t=s.charCodeAt(a),t===47){if(!r){i=a;break}}else r=!1;return i===-1?e?"/":this.isUrl(o)?n+s:n:e&&i===1?"//":n+s.slice(0,i)},rootname(s){Ct(s),s=this.toPosix(s);let t="";if(s.startsWith("/")?t="/":t=this.getProtocol(s),this.isUrl(s)){const e=s.indexOf("/",t.length);e!==-1?t=s.slice(0,e):t=s,t.endsWith("/")||(t+="/")}return t},basename(s,t){Ct(s),t&&Ct(t),s=Ce(this.toPosix(s));let e=0,i=-1,r=!0,n;if(t!==void 0&&t.length>0&&t.length<=s.length){if(t.length===s.length&&t===s)return"";let o=t.length-1,a=-1;for(n=s.length-1;n>=0;--n){const h=s.charCodeAt(n);if(h===47){if(!r){e=n+1;break}}else a===-1&&(r=!1,a=n+1),o>=0&&(h===t.charCodeAt(o)?--o===-1&&(i=n):(o=-1,i=a))}return e===i?i=a:i===-1&&(i=s.length),s.slice(e,i)}for(n=s.length-1;n>=0;--n)if(s.charCodeAt(n)===47){if(!r){e=n+1;break}}else i===-1&&(r=!1,i=n+1);return i===-1?"":s.slice(e,i)},extname(s){Ct(s),s=Ce(this.toPosix(s));let t=-1,e=0,i=-1,r=!0,n=0;for(let o=s.length-1;o>=0;--o){const a=s.charCodeAt(o);if(a===47){if(!r){e=o+1;break}continue}i===-1&&(r=!1,i=o+1),a===46?t===-1?t=o:n!==1&&(n=1):t!==-1&&(n=-1)}return t===-1||i===-1||n===0||n===1&&t===i-1&&t===e+1?"":s.slice(t,i)},parse(s){Ct(s);const t={root:"",dir:"",base:"",ext:"",name:""};if(s.length===0)return t;s=Ce(this.toPosix(s));let e=s.charCodeAt(0);const i=this.isAbsolute(s);let r;t.root=this.rootname(s),i||this.hasProtocol(s)?r=1:r=0;let n=-1,o=0,a=-1,h=!0,l=s.length-1,c=0;for(;l>=r;--l){if(e=s.charCodeAt(l),e===47){if(!h){o=l+1;break}continue}a===-1&&(h=!1,a=l+1),e===46?n===-1?n=l:c!==1&&(c=1):n!==-1&&(c=-1)}return n===-1||a===-1||c===0||c===1&&n===a-1&&n===o+1?a!==-1&&(o===0&&i?t.base=t.name=s.slice(1,a):t.base=t.name=s.slice(o,a)):(o===0&&i?(t.name=s.slice(1,n),t.base=s.slice(1,a)):(t.name=s.slice(o,n),t.base=s.slice(o,a)),t.ext=s.slice(n,a)),t.dir=this.dirname(s),t},sep:"/",delimiter:":",joinExtensions:[".html"]};function $n(s,t,e,i,r){const n=t[e];for(let o=0;o<n.length;o++){const a=n[o];e<t.length-1?$n(s.replace(i[e],a),t,e+1,i,r):r.push(s.replace(i[e],a))}}function lh(s){const t=/\{(.*?)\}/g,e=s.match(t),i=[];if(e){const r=[];e.forEach(n=>{const o=n.substring(1,n.length-1).split(",");r.push(o)}),$n(s,r,0,e,i)}else i.push(s);return i}const gs=s=>!Array.isArray(s);class ve{constructor(){this._defaultBundleIdentifierOptions={connector:"-",createBundleAssetId:(t,e)=>`${t}${this._bundleIdConnector}${e}`,extractAssetIdFromBundle:(t,e)=>e.replace(`${t}${this._bundleIdConnector}`,"")},this._bundleIdConnector=this._defaultBundleIdentifierOptions.connector,this._createBundleAssetId=this._defaultBundleIdentifierOptions.createBundleAssetId,this._extractAssetIdFromBundle=this._defaultBundleIdentifierOptions.extractAssetIdFromBundle,this._assetMap={},this._preferredOrder=[],this._parsers=[],this._resolverHash={},this._bundles={}}setBundleIdentifier(t){if(this._bundleIdConnector=t.connector??this._bundleIdConnector,this._createBundleAssetId=t.createBundleAssetId??this._createBundleAssetId,this._extractAssetIdFromBundle=t.extractAssetIdFromBundle??this._extractAssetIdFromBundle,this._extractAssetIdFromBundle("foo",this._createBundleAssetId("foo","bar"))!=="bar")throw new Error("[Resolver] GenerateBundleAssetId are not working correctly")}prefer(...t){t.forEach(e=>{this._preferredOrder.push(e),e.priority||(e.priority=Object.keys(e.params))}),this._resolverHash={}}set basePath(t){this._basePath=t}get basePath(){return this._basePath}set rootPath(t){this._rootPath=t}get rootPath(){return this._rootPath}get parsers(){return this._parsers}reset(){this.setBundleIdentifier(this._defaultBundleIdentifierOptions),this._assetMap={},this._preferredOrder=[],this._resolverHash={},this._rootPath=null,this._basePath=null,this._manifest=null,this._bundles={},this._defaultSearchParams=null}setDefaultSearchParams(t){if(typeof t=="string")this._defaultSearchParams=t;else{const e=t;this._defaultSearchParams=Object.keys(e).map(i=>`${encodeURIComponent(i)}=${encodeURIComponent(e[i])}`).join("&")}}getAlias(t){const{alias:e,src:i}=t;return Tt(e||i,n=>typeof n=="string"?n:Array.isArray(n)?n.map(o=>(o==null?void 0:o.src)??o):n!=null&&n.src?n.src:n,!0)}removeAlias(t,e){this._assetMap[t]&&(e&&e!==this._resolverHash[t]||(delete this._resolverHash[t],delete this._assetMap[t]))}addManifest(t){this._manifest&&Y("[Resolver] Manifest already exists, this will be overwritten"),this._manifest=t,t.bundles.forEach(e=>{this.addBundle(e.name,e.assets)})}addBundle(t,e){const i=[];let r=e;Array.isArray(e)||(r=Object.entries(e).map(([n,o])=>typeof o=="string"||Array.isArray(o)?{alias:n,src:o}:{alias:n,...o})),r.forEach(n=>{const o=n.src,a=n.alias;let h;if(typeof a=="string"){const l=this._createBundleAssetId(t,a);i.push(l),h=[a,l]}else{const l=a.map(c=>this._createBundleAssetId(t,c));i.push(...l),h=[...a,...l]}this.add({...n,alias:h,src:o})}),this._bundles[t]=i}add(t){const e=[];Array.isArray(t)?e.push(...t):e.push(t);let i;i=n=>{this.hasKey(n)&&Y(`[Resolver] already has key: ${n} overwriting`)},Tt(e).forEach(n=>{const{src:o}=n;let{data:a,format:h,loadParser:l,parser:c}=n;const u=Tt(o).map(g=>typeof g=="string"?lh(g):Array.isArray(g)?g:[g]),f=this.getAlias(n);Array.isArray(f)?f.forEach(i):i(f);const d=[],p=g=>{const m=this._parsers.find(_=>_.test(g));return{src:g,...m==null?void 0:m.parse(g)}};u.forEach(g=>{g.forEach(m=>{let _={};if(typeof m!="object"?_=p(m):(a=m.data??a,h=m.format??h,(m.loadParser||m.parser)&&(l=m.loadParser??l,c=m.parser??c),_={...p(m.src),...m}),!f)throw new Error(`[Resolver] alias is undefined for this asset: ${_.src}`);_=this._buildResolvedAsset(_,{aliases:f,data:a,format:h,loadParser:l,parser:c,progressSize:n.progressSize}),d.push(_)})}),f.forEach(g=>{this._assetMap[g]=d})})}resolveBundle(t){const e=gs(t);t=Tt(t);const i={};return t.forEach(r=>{const n=this._bundles[r];if(n){const o=this.resolve(n),a={};for(const h in o){const l=o[h];a[this._extractAssetIdFromBundle(r,h)]=l}i[r]=a}}),e?i[t[0]]:i}resolveUrl(t){const e=this.resolve(t);if(typeof t!="string"){const i={};for(const r in e)i[r]=e[r].src;return i}return e.src}resolve(t){const e=gs(t);t=Tt(t);const i={};return t.forEach(r=>{if(!this._resolverHash[r])if(this._assetMap[r]){let n=this._assetMap[r];const o=this._getPreferredOrder(n);o==null||o.priority.forEach(a=>{o.params[a].forEach(h=>{const l=n.filter(c=>c[a]?c[a]===h:!1);l.length&&(n=l)})}),this._resolverHash[r]=n[0]}else this._resolverHash[r]=this._buildResolvedAsset({alias:[r],src:r},{});i[r]=this._resolverHash[r]}),e?i[t[0]]:i}hasKey(t){return!!this._assetMap[t]}hasBundle(t){return!!this._bundles[t]}_getPreferredOrder(t){for(let e=0;e<t.length;e++){const i=t[e],r=this._preferredOrder.find(n=>n.params.format.includes(i.format));if(r)return r}return this._preferredOrder[0]}_appendDefaultSearchParams(t){if(!this._defaultSearchParams)return t;const e=/\?/.test(t)?"&":"?";return`${t}${e}${this._defaultSearchParams}`}_buildResolvedAsset(t,e){const{aliases:i,data:r,loadParser:n,parser:o,format:a,progressSize:h}=e;return(this._basePath||this._rootPath)&&(t.src=at.toAbsolute(t.src,this._basePath,this._rootPath)),t.alias=i??t.alias??[t.src],t.src=this._appendDefaultSearchParams(t.src),t.data={...r||{},...t.data},t.loadParser=n??t.loadParser,t.parser=o??t.parser,t.format=a??t.format??ch(t.src),h!==void 0&&(t.progressSize=h),t}}ve.RETINA_PREFIX=/@([0-9\.]+)x/;function ch(s){return s.split(".").pop().split("?").shift().split("#").shift()}const ui=(s,t)=>{const e=t.split("?")[1];return e&&(s+=`?${e}`),s},jn=class Fe{constructor(t,e){this.linkedSheets=[];let i=t;(t==null?void 0:t.source)instanceof St&&(i={texture:t,data:e});const{texture:r,data:n,cachePrefix:o=""}=i;this.cachePrefix=o,this._texture=r instanceof U?r:null,this.textureSource=r.source,this.textures={},this.animations={},this.data=n;const a=parseFloat(n.meta.scale);a?(this.resolution=a,r.source.resolution=this.resolution):this.resolution=r.source._resolution,this._frames=this.data.frames,this._frameKeys=Object.keys(this._frames),this._batchIndex=0,this._callback=null}parse(){return new Promise(t=>{this._callback=t,this._batchIndex=0,this._frameKeys.length<=Fe.BATCH_SIZE?(this._processFrames(0),this._processAnimations(),this._parseComplete()):this._nextBatch()})}parseSync(){return this._processFrames(0,!0),this._processAnimations(),this.textures}_processFrames(t,e=!1){let i=t;const r=e?1/0:Fe.BATCH_SIZE;for(;i-t<r&&i<this._frameKeys.length;){const n=this._frameKeys[i],o=this._frames[n],a=o.frame;if(a){let h=null,l=null;const c=o.trimmed!==!1&&o.sourceSize?o.sourceSize:o.frame,u=new tt(0,0,Math.floor(c.w)/this.resolution,Math.floor(c.h)/this.resolution);o.rotated?h=new tt(Math.floor(a.x)/this.resolution,Math.floor(a.y)/this.resolution,Math.floor(a.h)/this.resolution,Math.floor(a.w)/this.resolution):h=new tt(Math.floor(a.x)/this.resolution,Math.floor(a.y)/this.resolution,Math.floor(a.w)/this.resolution,Math.floor(a.h)/this.resolution),o.trimmed!==!1&&o.spriteSourceSize&&(l=new tt(Math.floor(o.spriteSourceSize.x)/this.resolution,Math.floor(o.spriteSourceSize.y)/this.resolution,Math.floor(a.w)/this.resolution,Math.floor(a.h)/this.resolution)),this.textures[n]=new U({source:this.textureSource,frame:h,orig:u,trim:l,rotate:o.rotated?2:0,defaultAnchor:o.anchor,defaultBorders:o.borders,label:n.toString()})}i++}}_processAnimations(){const t=this.data.animations||{};for(const e in t){this.animations[e]=[];for(let i=0;i<t[e].length;i++){const r=t[e][i];this.animations[e].push(this.textures[r])}}}_parseComplete(){const t=this._callback;this._callback=null,this._batchIndex=0,t.call(this,this.textures)}_nextBatch(){this._processFrames(this._batchIndex*Fe.BATCH_SIZE),this._batchIndex++,setTimeout(()=>{this._batchIndex*Fe.BATCH_SIZE<this._frameKeys.length?this._nextBatch():(this._processAnimations(),this._parseComplete())},0)}destroy(t=!1){var e;for(const i in this.textures)this.textures[i].destroy();this._frames=null,this._frameKeys=null,this.data=null,this.textures=null,t&&((e=this._texture)==null||e.destroy(),this.textureSource.destroy()),this._texture=null,this.textureSource=null,this.linkedSheets=[]}};jn.BATCH_SIZE=1e3;let dr=jn;const uh=["jpg","png","jpeg","avif","webp","basis","etc2","bc7","bc6h","bc5","bc4","bc3","bc2","bc1","eac","astc"];function Yn(s,t,e){const i={};if(s.forEach(r=>{i[r]=t}),Object.keys(t.textures).forEach(r=>{i[`${t.cachePrefix}${r}`]=t.textures[r]}),!e){const r=at.dirname(s[0]);t.linkedSheets.forEach((n,o)=>{const a=Yn([`${r}/${t.data.meta.related_multi_packs[o]}`],n,!0);Object.assign(i,a)})}return i}const dh={extension:I.Asset,cache:{test:s=>s instanceof dr,getCacheableAssets:(s,t)=>Yn(s,t,!1)},resolver:{extension:{type:I.ResolveParser,name:"resolveSpritesheet"},test:s=>{const e=s.split("?")[0].split("."),i=e.pop(),r=e.pop();return i==="json"&&uh.includes(r)},parse:s=>{var e;const t=s.split(".");return{resolution:parseFloat(((e=ve.RETINA_PREFIX.exec(s))==null?void 0:e[1])??"1"),format:t[t.length-2],src:s}}},loader:{name:"spritesheetLoader",id:"spritesheet",extension:{type:I.LoadParser,priority:Gt.Normal,name:"spritesheetLoader"},async testParse(s,t){return at.extname(t.src).toLowerCase()===".json"&&!!s.frames},async parse(s,t,e){var u,f;const{texture:i,imageFilename:r,textureOptions:n,cachePrefix:o}=(t==null?void 0:t.data)??{};let a=at.dirname(t.src);a&&a.lastIndexOf("/")!==a.length-1&&(a+="/");let h;if(i instanceof U)h=i;else{const d=ui(a+(r??s.meta.image),t.src);h=(await e.load([{src:d,data:n}]))[d]}const l=new dr({texture:h.source,data:s,cachePrefix:o});await l.parse();const c=(u=s==null?void 0:s.meta)==null?void 0:u.related_multi_packs;if(Array.isArray(c)){const d=[];for(const g of c){if(typeof g!="string")continue;let m=a+g;(f=t.data)!=null&&f.ignoreMultiPack||(m=ui(m,t.src),d.push(e.load({src:m,data:{textureOptions:n,ignoreMultiPack:!0}})))}const p=await Promise.all(d);l.linkedSheets=p,p.forEach(g=>{g.linkedSheets=[l].concat(l.linkedSheets.filter(m=>m!==g))})}return l},async unload(s,t,e){await e.unload(s.textureSource._sourceOrigin),s.destroy(!1)}}};K.add(dh);const $s=Object.create(null),fr=Object.create(null);function Bi(s,t){let e=fr[s];return e===void 0&&($s[t]===void 0&&($s[t]=1),fr[s]=e=$s[t]++),e}let ne;function Xn(){return(!ne||ne!=null&&ne.isContextLost())&&(ne=z.get().createCanvas().getContext("webgl",{})),ne}let ns;function fh(){if(!ns){ns="mediump";const s=Xn();s&&s.getShaderPrecisionFormat&&(ns=s.getShaderPrecisionFormat(s.FRAGMENT_SHADER,s.HIGH_FLOAT).precision?"highp":"mediump")}return ns}function ph(s,t,e){return t?s:e?(s=s.replace("out vec4 finalColor;",""),` + + #ifdef GL_ES // This checks if it is WebGL1 + #define in varying + #define finalColor gl_FragColor + #define texture texture2D + #endif + ${s} + `):` + + #ifdef GL_ES // This checks if it is WebGL1 + #define in attribute + #define out varying + #endif + ${s} + `}function mh(s,t,e){const i=e?t.maxSupportedFragmentPrecision:t.maxSupportedVertexPrecision;if(s.substring(0,9)!=="precision"){let r=e?t.requestedFragmentPrecision:t.requestedVertexPrecision;return r==="highp"&&i!=="highp"&&(r="mediump"),`precision ${r} float; +${s}`}else if(i!=="highp"&&s.substring(0,15)==="precision highp")return s.replace("precision highp","precision mediump");return s}function gh(s,t){return t?`#version 300 es +${s}`:s}const _h={},yh={};function xh(s,{name:t="pixi-program"},e=!0){t=t.replace(/\s+/g,"-"),t+=e?"-fragment":"-vertex";const i=e?_h:yh;return i[t]?(i[t]++,t+=`-${i[t]}`):i[t]=1,s.indexOf("#define SHADER_NAME")!==-1?s:`${`#define SHADER_NAME ${t}`} +${s}`}function bh(s,t){return t?s.replace("#version 300 es",""):s}const js={stripVersion:bh,ensurePrecision:mh,addProgramDefines:ph,setProgramName:xh,insertVersion:gh},Te=Object.create(null),qn=class di{constructor(t){t={...di.defaultOptions,...t};const e=t.fragment.indexOf("#version 300 es")!==-1,i={stripVersion:e,ensurePrecision:{requestedFragmentPrecision:t.preferredFragmentPrecision,requestedVertexPrecision:t.preferredVertexPrecision,maxSupportedVertexPrecision:"highp",maxSupportedFragmentPrecision:fh()},setProgramName:{name:t.name},addProgramDefines:e,insertVersion:e};let r=t.fragment,n=t.vertex;Object.keys(js).forEach(o=>{const a=i[o];r=js[o](r,a,!0),n=js[o](n,a,!1)}),this.fragment=r,this.vertex=n,this.transformFeedbackVaryings=t.transformFeedbackVaryings,this._key=Bi(`${this.vertex}:${this.fragment}`,"gl-program")}destroy(){this.fragment=null,this.vertex=null,this._attributeData=null,this._uniformData=null,this._uniformBlockData=null,this.transformFeedbackVaryings=null,Te[this._cacheKey]=null}static from(t){const e=`${t.vertex}:${t.fragment}`;return Te[e]||(Te[e]=new di(t),Te[e]._cacheKey=e),Te[e]}};qn.defaultOptions={preferredVertexPrecision:"highp",preferredFragmentPrecision:"mediump"};let Kn=qn;const pr={uint8x2:{size:2,stride:2,normalised:!1},uint8x4:{size:4,stride:4,normalised:!1},sint8x2:{size:2,stride:2,normalised:!1},sint8x4:{size:4,stride:4,normalised:!1},unorm8x2:{size:2,stride:2,normalised:!0},unorm8x4:{size:4,stride:4,normalised:!0},snorm8x2:{size:2,stride:2,normalised:!0},snorm8x4:{size:4,stride:4,normalised:!0},uint16x2:{size:2,stride:4,normalised:!1},uint16x4:{size:4,stride:8,normalised:!1},sint16x2:{size:2,stride:4,normalised:!1},sint16x4:{size:4,stride:8,normalised:!1},unorm16x2:{size:2,stride:4,normalised:!0},unorm16x4:{size:4,stride:8,normalised:!0},snorm16x2:{size:2,stride:4,normalised:!0},snorm16x4:{size:4,stride:8,normalised:!0},float16x2:{size:2,stride:4,normalised:!1},float16x4:{size:4,stride:8,normalised:!1},float32:{size:1,stride:4,normalised:!1},float32x2:{size:2,stride:8,normalised:!1},float32x3:{size:3,stride:12,normalised:!1},float32x4:{size:4,stride:16,normalised:!1},uint32:{size:1,stride:4,normalised:!1},uint32x2:{size:2,stride:8,normalised:!1},uint32x3:{size:3,stride:12,normalised:!1},uint32x4:{size:4,stride:16,normalised:!1},sint32:{size:1,stride:4,normalised:!1},sint32x2:{size:2,stride:8,normalised:!1},sint32x3:{size:3,stride:12,normalised:!1},sint32x4:{size:4,stride:16,normalised:!1}};function wh(s){return pr[s]??pr.float32}const vh={f32:"float32","vec2<f32>":"float32x2","vec3<f32>":"float32x3","vec4<f32>":"float32x4",vec2f:"float32x2",vec3f:"float32x3",vec4f:"float32x4",i32:"sint32","vec2<i32>":"sint32x2","vec3<i32>":"sint32x3","vec4<i32>":"sint32x4",vec2i:"sint32x2",vec3i:"sint32x3",vec4i:"sint32x4",u32:"uint32","vec2<u32>":"uint32x2","vec3<u32>":"uint32x3","vec4<u32>":"uint32x4",vec2u:"uint32x2",vec3u:"uint32x3",vec4u:"uint32x4",bool:"uint32","vec2<bool>":"uint32x2","vec3<bool>":"uint32x3","vec4<bool>":"uint32x4"},mr=/@location\((\d+)\)\s+([a-zA-Z0-9_]+)\s*:\s*([a-zA-Z0-9_<>]+)(?:,|\s|\)|$)/g;function gr(s,t){let e;for(;(e=mr.exec(s))!==null;){const i=vh[e[3]]??"float32";t[e[2]]={location:parseInt(e[1],10),format:i,stride:wh(i).stride,offset:0,instance:!1,start:0}}mr.lastIndex=0}function Ah(s){return s.replace(/\/\/.*$/gm,"").replace(/\/\*[\s\S]*?\*\//g,"")}function Sh({source:s,entryPoint:t}){const e={},i=Ah(s),r=i.indexOf(`fn ${t}(`);if(r===-1)return e;const n=i.indexOf("->",r);if(n===-1)return e;const o=i.substring(r,n);if(gr(o,e),Object.keys(e).length===0){const a=o.match(/\(\s*\w+\s*:\s*(\w+)/);if(a){const h=a[1],l=new RegExp(`struct\\s+${h}\\s*\\{([^}]+)\\}`,"s"),c=i.match(l);c&&gr(c[1],e)}}return e}function Ys(s){var u,f;const t=/(^|[^/])@(group|binding)\(\d+\)[^;]+;/g,e=/@group\((\d+)\)/,i=/@binding\((\d+)\)/,r=/var(<[^>]+>)? (\w+)/,n=/:\s*([\w<>]+)/,o=/struct\s+(\w+)\s*{([^}]+)}/g,a=/(\w+)\s*:\s*([\w\<\>]+)/g,h=/struct\s+(\w+)/,l=(u=s.match(t))==null?void 0:u.map(d=>({group:parseInt(d.match(e)[1],10),binding:parseInt(d.match(i)[1],10),name:d.match(r)[2],isUniform:d.match(r)[1]==="<uniform>",type:d.match(n)[1]}));if(!l)return{groups:[],structs:[]};const c=((f=s.match(o))==null?void 0:f.map(d=>{const p=d.match(h)[1],g=d.match(a).reduce((m,_)=>{const[y,x]=_.split(":");return m[y.trim()]=x.trim(),m},{});return g?{name:p,members:g}:null}).filter(({name:d})=>l.some(p=>p.type===d||p.type.includes(`<${d}>`))))??[];return{groups:l,structs:c}}var Jt=(s=>(s[s.VERTEX=1]="VERTEX",s[s.FRAGMENT=2]="FRAGMENT",s[s.COMPUTE=4]="COMPUTE",s))(Jt||{});function Ch({groups:s}){const t=[];for(let e=0;e<s.length;e++){const i=s[e];t[i.group]||(t[i.group]=[]),i.isUniform?t[i.group].push({binding:i.binding,visibility:Jt.VERTEX|Jt.FRAGMENT,buffer:{type:"uniform"}}):i.type==="sampler"?t[i.group].push({binding:i.binding,visibility:Jt.FRAGMENT,sampler:{type:"filtering"}}):i.type==="texture_2d"||i.type.startsWith("texture_2d<")?t[i.group].push({binding:i.binding,visibility:Jt.FRAGMENT,texture:{sampleType:"float",viewDimension:"2d",multisampled:!1}}):i.type==="texture_2d_array"||i.type.startsWith("texture_2d_array<")?t[i.group].push({binding:i.binding,visibility:Jt.FRAGMENT,texture:{sampleType:"float",viewDimension:"2d-array",multisampled:!1}}):(i.type==="texture_cube"||i.type.startsWith("texture_cube<"))&&t[i.group].push({binding:i.binding,visibility:Jt.FRAGMENT,texture:{sampleType:"float",viewDimension:"cube",multisampled:!1}})}for(let e=0;e<t.length;e++)t[e]||(t[e]=[]);return t}function Th({groups:s}){const t=[];for(let e=0;e<s.length;e++){const i=s[e];t[i.group]||(t[i.group]={}),t[i.group][i.name]=i.binding}return t}function Ph(s,t){const e=new Set,i=new Set,r=[...s.structs,...t.structs].filter(o=>e.has(o.name)?!1:(e.add(o.name),!0)),n=[...s.groups,...t.groups].filter(o=>{const a=`${o.name}-${o.binding}`;return i.has(a)?!1:(i.add(a),!0)});return{structs:r,groups:n}}const Pe=Object.create(null);class Ms{constructor(t){var a,h;this._layoutKey=0,this._attributeLocationsKey=0;const{fragment:e,vertex:i,layout:r,gpuLayout:n,name:o}=t;if(this.name=o,this.fragment=e,this.vertex=i,e.source===i.source){const l=Ys(e.source);this.structsAndGroups=l}else{const l=Ys(i.source),c=Ys(e.source);this.structsAndGroups=Ph(l,c)}this.layout=r??Th(this.structsAndGroups),this.gpuLayout=n??Ch(this.structsAndGroups),this.autoAssignGlobalUniforms=((a=this.layout[0])==null?void 0:a.globalUniforms)!==void 0,this.autoAssignLocalUniforms=((h=this.layout[1])==null?void 0:h.localUniforms)!==void 0,this._generateProgramKey()}_generateProgramKey(){const{vertex:t,fragment:e}=this,i=t.source+e.source+t.entryPoint+e.entryPoint;this._layoutKey=Bi(i,"program")}get attributeData(){return this._attributeData??(this._attributeData=Sh(this.vertex)),this._attributeData}destroy(){this.gpuLayout=null,this.layout=null,this.structsAndGroups=null,this.fragment=null,this.vertex=null,Pe[this._cacheKey]=null}static from(t){const e=`${t.vertex.source}:${t.fragment.source}:${t.fragment.entryPoint}:${t.vertex.entryPoint}`;return Pe[e]||(Pe[e]=new Ms(t),Pe[e]._cacheKey=e),Pe[e]}}const Qn=["f32","i32","vec2<f32>","vec3<f32>","vec4<f32>","mat2x2<f32>","mat3x3<f32>","mat4x4<f32>","mat3x2<f32>","mat4x2<f32>","mat2x3<f32>","mat4x3<f32>","mat2x4<f32>","mat3x4<f32>","vec2<i32>","vec3<i32>","vec4<i32>"],Mh=Qn.reduce((s,t)=>(s[t]=!0,s),{});function kh(s,t){switch(s){case"f32":return 0;case"vec2<f32>":return new Float32Array(2*t);case"vec3<f32>":return new Float32Array(3*t);case"vec4<f32>":return new Float32Array(4*t);case"mat2x2<f32>":return new Float32Array([1,0,0,1]);case"mat3x3<f32>":return new Float32Array([1,0,0,0,1,0,0,0,1]);case"mat4x4<f32>":return new Float32Array([1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1])}return null}const Zn=class Jn{constructor(t,e){this._touched=0,this.uid=J("uniform"),this._resourceType="uniformGroup",this._resourceId=J("resource"),this.isUniformGroup=!0,this._dirtyId=0,this.destroyed=!1,e={...Jn.defaultOptions,...e},this.uniformStructures=t;const i={};for(const r in t){const n=t[r];if(n.name=r,n.size=n.size??1,!Mh[n.type]){const o=n.type.match(/^array<(\w+(?:<\w+>)?),\s*(\d+)>$/);if(o){const[,a,h]=o;throw new Error(`Uniform type ${n.type} is not supported. Use type: '${a}', size: ${h} instead.`)}throw new Error(`Uniform type ${n.type} is not supported. Supported uniform types are: ${Qn.join(", ")}`)}n.value??(n.value=kh(n.type,n.size)),i[r]=n.value}this.uniforms=i,this._dirtyId=1,this.ubo=e.ubo,this.isStatic=e.isStatic,this._signature=Bi(Object.keys(i).map(r=>`${r}-${t[r].type}`).join("-"),"uniform-group")}update(){this._dirtyId++}};Zn.defaultOptions={ubo:!1,isStatic:!1};let to=Zn;class ps{constructor(t){this.resources=Object.create(null),this._dirty=!0;let e=0;for(const i in t){const r=t[i];this.setResource(r,e++)}this._updateKey()}_updateKey(){if(!this._dirty)return;this._dirty=!1;const t=[];let e=0;for(const i in this.resources)t[e++]=this.resources[i]._resourceId;this._key=t.join("|")}setResource(t,e){var r,n;const i=this.resources[e];t!==i&&((r=i==null?void 0:i.off)==null||r.call(i,"change",this.onResourceChange,this),(n=t.on)==null||n.call(t,"change",this.onResourceChange,this),this.resources[e]=t,this._dirty=!0)}getResource(t){return this.resources[t]}_touch(t,e){const i=this.resources;for(const r in i)i[r]._gcLastUsed=t,i[r]._touched=e}destroy(){var e;const t=this.resources;for(const i in t){const r=t[i];(e=r==null?void 0:r.off)==null||e.call(r,"change",this.onResourceChange,this)}this.resources=null}onResourceChange(t){this._dirty=!0,t.destroyed?this.destroy():this._updateKey()}}var fi=(s=>(s[s.WEBGL=1]="WEBGL",s[s.WEBGPU=2]="WEBGPU",s[s.CANVAS=4]="CANVAS",s[s.BOTH=3]="BOTH",s))(fi||{});class Fi extends ft{constructor(t){super(),this.uid=J("shader"),this._uniformBindMap=Object.create(null),this._ownedBindGroups=[],this._destroyed=!1;let{gpuProgram:e,glProgram:i,groups:r,resources:n,compatibleRenderers:o,groupMap:a}=t;this.gpuProgram=e,this.glProgram=i,o===void 0&&(o=0,e&&(o|=fi.WEBGPU),i&&(o|=fi.WEBGL)),this.compatibleRenderers=o;const h={};if(!n&&!r&&(n={}),n&&r)throw new Error("[Shader] Cannot have both resources and groups");if(!e&&r&&!a)throw new Error("[Shader] No group map or WebGPU shader provided - consider using resources instead.");if(!e&&r&&a)for(const l in a)for(const c in a[l]){const u=a[l][c];h[u]={group:l,binding:c,name:u}}else if(e&&r&&!a){const l=e.structsAndGroups.groups;a={},l.forEach(c=>{a[c.group]=a[c.group]||{},a[c.group][c.binding]=c.name,h[c.name]=c})}else if(n){r={},a={},e&&e.structsAndGroups.groups.forEach(u=>{a[u.group]=a[u.group]||{},a[u.group][u.binding]=u.name,h[u.name]=u});let l=0;for(const c in n)h[c]||(r[99]||(r[99]=new ps,this._ownedBindGroups.push(r[99])),h[c]={group:99,binding:l,name:c},a[99]=a[99]||{},a[99][l]=c,l++);for(const c in n){const u=c;let f=n[c];!f.source&&!f._resourceType&&(f=new to(f));const d=h[u];d&&(r[d.group]||(r[d.group]=new ps,this._ownedBindGroups.push(r[d.group])),r[d.group].setResource(f,d.binding))}}this.groups=r,this._uniformBindMap=a,this.resources=this._buildResourceAccessor(r,h)}addResource(t,e,i){var r,n;(r=this._uniformBindMap)[e]||(r[e]={}),(n=this._uniformBindMap[e])[i]||(n[i]=t),this.groups[e]||(this.groups[e]=new ps,this._ownedBindGroups.push(this.groups[e]))}_buildResourceAccessor(t,e){const i={};for(const r in e){const n=e[r];Object.defineProperty(i,n.name,{get(){return t[n.group].getResource(n.binding)},set(o){t[n.group].setResource(o,n.binding)}})}return i}destroy(t=!1){var e,i;this._destroyed||(this._destroyed=!0,this.emit("destroy",this),t&&((e=this.gpuProgram)==null||e.destroy(),(i=this.glProgram)==null||i.destroy()),this.gpuProgram=null,this.glProgram=null,this.removeAllListeners(),this._uniformBindMap=null,this._ownedBindGroups.forEach(r=>{r.destroy()}),this._ownedBindGroups=null,this.resources=null,this.groups=null)}static from(t){const{gpu:e,gl:i,...r}=t;let n,o;return e&&(n=Ms.from(e)),i&&(o=Kn.from(i)),new Fi({gpuProgram:n,glProgram:o,...r})}}const pi=[];K.handleByNamedList(I.Environment,pi);async function Eh(s){if(!s)for(let t=0;t<pi.length;t++){const e=pi[t];if(e.value.test()){await e.value.load();return}}}let Me;function Ih(){if(typeof Me=="boolean")return Me;try{Me=new Function("param1","param2","param3","return param1[param2] === param3;")({a:"b"},"a","b")===!0}catch{Me=!1}return Me}const He=new Set;let mi=!1;function _r(s,t,e=2){const i=t&&t.length,r=i?t[0]*e:s.length;He.size&&He.clear();let n=eo(s,0,r,e,!0);const o=[];if(!n||n.next===n.prev)return o;let a=0,h=0,l=0;if(i&&(n=Gh(s,t,n,e)),s.length>80*e){a=s[0],h=s[1];let c=a,u=h;for(let f=e;f<r;f+=e){const d=s[f],p=s[f+1];d<a&&(a=d),p<h&&(h=p),d>c&&(c=d),p>u&&(u=p)}l=Math.max(c-a,u-h),l=l!==0?32767/l:0}return gi(n,o,a,h,l),o}function eo(s,t,e,i,r){let n=null;if(r===qh(s,t,e,i)>0)for(let o=t;o<e;o+=i)n=br(o/i|0,s[o],s[o+1],n);else for(let o=e-i;o>=t;o-=i)n=br(o/i|0,s[o],s[o+1],n);return n&&Ne(n,n.next)&&($e(n),n=n.next),n}function ie(s,t=s){const e=t===s;let i=s,r;do r=!1,i!==i.next&&(He.size===0||!He.has(i))&&(Ne(i,i.next)||st(i.prev,i,i.next)===0)?((e||i===t)&&(t=i.prev),mi=!0,$e(i),i=i.prev,r=!0):(e||i!==t)&&(i=i.next,r=!e);while(r||i!==t);return t}function gi(s,t,e,i,r){r&&Nh(s,e,i,r);let n=s,o=!1;for(;s.prev!==s.next;){const a=s.prev,h=s.next;if(st(a,s,h)<0&&(r?Lh(s,e,i,r):Rh(s))){t.push(a.i,s.i,h.i),$e(s),s=h,n=h;continue}if(s=h,s===n){if(mi=!1,s=ie(s),mi){n=s;continue}if(!o){s=Bh(s,t),n=s,o=!0;continue}Fh(s,t,e,i,r);break}}}function Rh(s){const t=s.prev,e=s,i=s.next,r=t.x,n=e.x,o=i.x,a=t.y,h=e.y,l=i.y,c=Math.min(r,n,o),u=Math.min(a,h,l),f=Math.max(r,n,o),d=Math.max(a,h,l);let p=i.next;for(;p!==t;){if(p.x>=c&&p.x<=f&&p.y>=u&&p.y<=d&&!(r===p.x&&a===p.y)&&ys(r,a,n,h,o,l,p.x,p.y)&&st(p.prev,p,p.next)>=0)return!1;p=p.next}return!0}function Lh(s,t,e,i){const r=s.prev,n=s,o=s.next,a=r.x,h=n.x,l=o.x,c=r.y,u=n.y,f=o.y,d=Math.min(a,h,l),p=Math.min(c,u,f),g=Math.max(a,h,l),m=Math.max(c,u,f),_=bi(d,p,t,e,i),y=bi(g,m,t,e,i);let x=s.prevZ;for(;x&&x.z>=_;){if(x.x>=d&&x.x<=g&&x.y>=p&&x.y<=m&&x!==o&&!(a===x.x&&c===x.y)&&ys(a,c,h,u,l,f,x.x,x.y)&&st(x.prev,x,x.next)>=0)return!1;x=x.prevZ}let w=s.nextZ;for(;w&&w.z<=y;){if(w.x>=d&&w.x<=g&&w.y>=p&&w.y<=m&&w!==o&&!(a===w.x&&c===w.y)&&ys(a,c,h,u,l,f,w.x,w.y)&&st(w.prev,w,w.next)>=0)return!1;w=w.nextZ}return!0}function Bh(s,t){let e=s,i=!1;do{const r=e.prev,n=e.next.next;ro(r,e,e.next,n,!1)&&Ve(r,n)&&Ve(n,r)&&(t.push(r.i,e.i,n.i),$e(e),$e(e.next),e=s=n,i=!0),e=e.next}while(e!==s);return i?ie(e):e}function Fh(s,t,e,i,r){let n=s;do{let o=n.next.next;for(;o!==n.prev;){if(n.i!==o.i&&jh(n,o)){let a=no(n,o);n=ie(n,n.next),a=ie(a,a.next),gi(n,t,e,i,r),gi(a,t,e,i,r);return}o=o.next}n=n.next}while(n!==s)}let _i=!1;function Gh(s,t,e,i){const r=[];for(let n=0,o=t.length;n<o;n++){const a=t[n]*i,h=n<o-1?t[n+1]*i:s.length,l=eo(s,a,h,i,!1);l===l.next&&He.add(l),r.push($h(l))}r.sort(Dh),Wh(s.length/i,t.length),io(e,e),_i=!0;for(let n=0;n<r.length;n++)e=Oh(r[n],e);return _i=!1,ie(e)}function Dh(s,t){return s.x-t.x||s.y-t.y||(s.next.y-s.y)/(s.next.x-s.x)-(t.next.y-t.y)/(t.next.x-t.x)}function Oh(s,t){const e=zh(s,t);if(!e)return t;const i=no(e,s),r=i.next;return io(e,r.next),ie(i,i.next),ie(e,e.next)}const so=16;let Z=new Float64Array(0),_s=0;const yi=[],xi=[];function Wh(s,t){const e=Math.ceil((s+2*t)/so)+t+2;Z.length<e*4&&(Z=new Float64Array(e*4)),_s=0}function io(s,t){let e=s;do{const i=_s++;yi[i]=e;let r=1/0,n=1/0,o=-1/0,a=-1/0,h=0;do{const c=e.next;e.z=i,e.x<r&&(r=e.x),e.x>o&&(o=e.x),e.y<n&&(n=e.y),e.y>a&&(a=e.y),c.x<r&&(r=c.x),c.x>o&&(o=c.x),c.y<n&&(n=c.y),c.y>a&&(a=c.y),e=c}while(++h<so&&e!==t);xi[i]=e;const l=i*4;Z[l]=r,Z[l+1]=n,Z[l+2]=o,Z[l+3]=a}while(e!==t)}function Uh(s,t){const e=s.z*4;t.x<Z[e]&&(Z[e]=t.x),t.y<Z[e+1]&&(Z[e+1]=t.y),t.x>Z[e+2]&&(Z[e+2]=t.x),t.y>Z[e+3]&&(Z[e+3]=t.y)}function yr(s){let t=xi[s];for(;t.prev.next!==t;)t=t.next;return xi[s]=t,t}function xr(s){let t=yi[s];for(;t.prev.next!==t;)t=t.next;return yi[s]=t,t}function zh(s,t){let e=t;const i=s.x,r=s.y;let n=-1/0,o;if(Ne(s,e))return e;for(let f=0,d=0;f<_s;f++,d+=4){if(r<Z[d+1]||r>Z[d+3]||Z[d]>i||Z[d+2]<=n)continue;const p=yr(f);e=xr(f);do{if(e.prev.next===e){if(Ne(s,e.next))return e.next;if(r<=e.y&&r>=e.next.y&&e.next.y!==e.y){const g=e.x+(r-e.y)*(e.next.x-e.x)/(e.next.y-e.y);if(g<=i&&g>n&&(n=g,o=e.x<e.next.x?e:e.next,g===i))return o}}e=e.next}while(e!==p)}if(!o)return null;const a=o.x,h=o.y,l=Math.min(r,h),c=Math.max(r,h);let u=1/0;for(let f=0,d=0;f<_s;f++,d+=4){if(Z[d+2]<a||Z[d]>i||Z[d+3]<l||Z[d+1]>c)continue;const p=yr(f);e=xr(f);do{if(e.prev.next===e&&i>=e.x&&e.x>=a&&i!==e.x&&ys(r<h?i:n,r,a,h,r<h?n:i,r,e.x,e.y)){const g=Math.abs(r-e.y)/(i-e.x);(Ve(e,s)||e.y===r&&e.next.y===r&&e.next.x>i)&&(g<u||g===u&&(e.x>o.x||e.x===o.x&&Hh(o,e)))&&(o=e,u=g)}e=e.next}while(e!==p)}return o}function Hh(s,t){return st(s.prev,s,t.prev)<0&&st(t.next,s,s.next)<0}const xt=[];let ke=[],jt=new Uint32Array(0),Ee=new Uint32Array(0);const Ie=new Uint32Array(256);function Nh(s,t,e,i){let r=s,n=0;do r.z=bi(r.x,r.y,t,e,i),xt[n++]=r,r=r.next;while(r!==s);Vh(n);let o=null;for(let a=0;a<n;a++){const h=xt[a];h.prevZ=o,o&&(o.nextZ=h),o=h}o.nextZ=null}function Vh(s){if(s<=32){for(let t=1;t<s;t++){const e=xt[t],i=e.z;let r=t-1;for(;r>=0&&xt[r].z>i;)xt[r+1]=xt[r],r--;xt[r+1]=e}return}jt.length<s&&(jt=new Uint32Array(s),Ee=new Uint32Array(s),ke=new Array(s));for(let t=0;t<s;t++)jt[t]=xt[t].z;os(s,xt,jt,ke,Ee,0),os(s,ke,Ee,xt,jt,8),os(s,xt,jt,ke,Ee,16),os(s,ke,Ee,xt,jt,24)}function os(s,t,e,i,r,n){Ie.fill(0);for(let a=0;a<s;a++)Ie[e[a]>>>n&255]++;let o=0;for(let a=0;a<256;a++){const h=Ie[a];Ie[a]=o,o+=h}for(let a=0;a<s;a++){const h=e[a],l=Ie[h>>>n&255]++;i[l]=t[a],r[l]=h}}function bi(s,t,e,i,r){return s=(s-e)*r|0,t=(t-i)*r|0,s=(s|s<<8)&16711935,s=(s|s<<4)&252645135,s=(s|s<<2)&858993459,s=(s|s<<1)&1431655765,t=(t|t<<8)&16711935,t=(t|t<<4)&252645135,t=(t|t<<2)&858993459,t=(t|t<<1)&1431655765,s|t<<1}function $h(s){let t=s,e=s;do(t.x<e.x||t.x===e.x&&t.y<e.y)&&(e=t),t=t.next;while(t!==s);return e}function ys(s,t,e,i,r,n,o,a){return(r-o)*(t-a)>=(s-o)*(n-a)&&(s-o)*(i-a)>=(e-o)*(t-a)&&(e-o)*(n-a)>=(r-o)*(i-a)}function jh(s,t){const e=Ne(s,t)&&st(s.prev,s,s.next)>0&&st(t.prev,t,t.next)>0;return s.next.i!==t.i&&(e||Ve(s,t)&&Ve(t,s)&&(st(s.prev,s,t.prev)!==0||st(s,t.prev,t)!==0))&&!Yh(s,t)&&(e||Xh(s,t))}function st(s,t,e){return(t.y-s.y)*(e.x-t.x)-(t.x-s.x)*(e.y-t.y)}function Ne(s,t){return s.x===t.x&&s.y===t.y}function ro(s,t,e,i,r=!0){const n=st(s,t,e),o=st(s,t,i),a=st(e,i,s),h=st(e,i,t);return(n>0&&o<0||n<0&&o>0)&&(a>0&&h<0||a<0&&h>0)?!0:r?!!(n===0&&as(s,e,t)||o===0&&as(s,i,t)||a===0&&as(e,s,i)||h===0&&as(e,t,i)):!1}function as(s,t,e){return t.x<=Math.max(s.x,e.x)&&t.x>=Math.min(s.x,e.x)&&t.y<=Math.max(s.y,e.y)&&t.y>=Math.min(s.y,e.y)}function Yh(s,t){const e=Math.min(s.x,t.x),i=Math.max(s.x,t.x),r=Math.min(s.y,t.y),n=Math.max(s.y,t.y);let o=s;do{const a=o.next;if(o.x>i&&a.x>i||o.x<e&&a.x<e||o.y>n&&a.y>n||o.y<r&&a.y<r){o=a;continue}if(o.i!==s.i&&a.i!==s.i&&o.i!==t.i&&a.i!==t.i&&ro(o,a,s,t))return!0;o=a}while(o!==s);return!1}function Ve(s,t){return st(s.prev,s,s.next)<0?st(s,t,s.next)>=0&&st(s,s.prev,t)>=0:st(s,t,s.prev)<0||st(s,s.next,t)<0}function Xh(s,t){let e=s,i=!1;const r=(s.x+t.x)/2,n=(s.y+t.y)/2;do{const o=e.next;e.y>n!=o.y>n&&r<(o.x-e.x)*(n-e.y)/(o.y-e.y)+e.x&&(i=!i),e=o}while(e!==s);return i}function no(s,t){const e=wi(s.i,s.x,s.y),i=wi(t.i,t.x,t.y),r=s.next,n=t.prev;return s.next=t,t.prev=s,e.next=r,r.prev=e,i.next=e,e.prev=i,n.next=i,i.prev=n,i}function br(s,t,e,i){const r=wi(s,t,e);return i?(r.next=i.next,r.prev=i,i.next.prev=r,i.next=r):(r.prev=r,r.next=r),r}function $e(s){s.next.prev=s.prev,s.prev.next=s.next,s.prevZ&&(s.prevZ.nextZ=s.nextZ),s.nextZ&&(s.nextZ.prevZ=s.prevZ),_i&&Uh(s.prev,s.next)}function wi(s,t,e){return{i:s,x:t,y:e,prev:null,next:null,z:0,prevZ:null,nextZ:null}}function qh(s,t,e,i){let r=0;for(let n=t,o=e-i;n<e;n+=i)r+=(s[o]-s[n])*(s[n+1]+s[o+1]),o=n;return r}const Kh=_r.default||_r;var oo=(s=>(s[s.NONE=0]="NONE",s[s.COLOR=16384]="COLOR",s[s.STENCIL=1024]="STENCIL",s[s.DEPTH=256]="DEPTH",s[s.COLOR_DEPTH=16640]="COLOR_DEPTH",s[s.COLOR_STENCIL=17408]="COLOR_STENCIL",s[s.DEPTH_STENCIL=1280]="DEPTH_STENCIL",s[s.ALL=17664]="ALL",s))(oo||{});class Qh{constructor(t){this.items=[],this._name=t}emit(t,e,i,r,n,o,a,h){const{name:l,items:c}=this;for(let u=0,f=c.length;u<f;u++)c[u][l](t,e,i,r,n,o,a,h);return this}add(t){return t[this._name]&&(this.remove(t),this.items.push(t)),this}remove(t){const e=this.items.indexOf(t);return e!==-1&&this.items.splice(e,1),this}contains(t){return this.items.indexOf(t)!==-1}removeAll(){return this.items.length=0,this}destroy(){this.removeAll(),this.items=null,this._name=null}get empty(){return this.items.length===0}get name(){return this._name}}const Zh=["init","destroy","contextChange","resolutionChange","resetState","renderEnd","renderStart","render","update","postrender","prerender"],ao=class ho extends ft{constructor(t){super(),this.tick=0,this.uid=J("renderer"),this.runners=Object.create(null),this.renderPipes=Object.create(null),this._initOptions={},this._systemsHash=Object.create(null),this.type=t.type,this.name=t.name,this.config=t;const e=[...Zh,...this.config.runners??[]];this._addRunners(...e),this._unsafeEvalCheck()}async init(t={}){const e=t.skipExtensionImports===!0?!0:t.manageImports===!1;await Eh(e),this._addSystems(this.config.systems),this._addPipes(this.config.renderPipes,this.config.renderPipeAdaptors);for(const i in this._systemsHash)t={...this._systemsHash[i].constructor.defaultOptions,...t};t={...ho.defaultOptions,...t},this._roundPixels=t.roundPixels?1:0;for(let i=0;i<this.runners.init.items.length;i++)await this.runners.init.items[i].init(t);this._initOptions=t}render(t,e){this.tick++;let i=t;if(i instanceof Ut&&(i={container:i},e&&(X(_t,"passing a second argument is deprecated, please use render options instead"),i.target=e.renderTexture)),i.target||(i.target=this.view.renderTarget),i.target===this.view.renderTarget&&(this._lastObjectRendered=i.container,i.clearColor??(i.clearColor=this.background.colorRgba),i.clear??(i.clear=this.background.clearBeforeRender)),i.clearColor){const r=Array.isArray(i.clearColor)&&i.clearColor.length===4;i.clearColor=r?i.clearColor:q.shared.setValue(i.clearColor).toArray()}i.transform||(i.container.updateLocalTransform(),i.transform=i.container.localTransform),i.container.visible&&(i.container.enableRenderGroup(),this.runners.prerender.emit(i),this.runners.renderStart.emit(i),this.runners.render.emit(i),this.runners.renderEnd.emit(i),this.runners.postrender.emit(i))}resize(t,e,i){const r=this.view.resolution;this.view.resize(t,e,i),this.emit("resize",this.view.screen.width,this.view.screen.height,this.view.resolution),i!==void 0&&i!==r&&this.runners.resolutionChange.emit(i)}clear(t={}){const e=this;t.target||(t.target=e.renderTarget.renderTarget),t.clearColor||(t.clearColor=this.background.colorRgba),t.clear??(t.clear=oo.ALL);const{clear:i,clearColor:r,target:n,mipLevel:o,layer:a}=t;q.shared.setValue(r??this.background.colorRgba),e.renderTarget.clear(n,i,q.shared.toArray(),o??0,a??0)}get resolution(){return this.view.resolution}set resolution(t){this.view.resolution=t,this.runners.resolutionChange.emit(t)}get width(){return this.view.texture.frame.width}get height(){return this.view.texture.frame.height}get canvas(){return this.view.canvas}get lastObjectRendered(){return this._lastObjectRendered}get renderingToScreen(){return this.renderTarget.renderingToScreen}get screen(){return this.view.screen}_addRunners(...t){t.forEach(e=>{this.runners[e]=new Qh(e)})}_addSystems(t){let e;for(e in t){const i=t[e];this._addSystem(i.value,i.name)}}_addSystem(t,e){const i=new t(this);if(this[e])throw new Error(`Whoops! The name "${e}" is already in use`);this[e]=i,this._systemsHash[e]=i;for(const r in this.runners)this.runners[r].add(i);return this}_addPipes(t,e){const i=e.reduce((r,n)=>(r[n.name]=n.value,r),{});t.forEach(r=>{const n=r.value,o=r.name,a=i[o];this.renderPipes[o]=new n(this,a?new a:null),this.runners.destroy.add(this.renderPipes[o])})}destroy(t=!1){this.runners.destroy.items.reverse(),this.runners.destroy.emit(t),(t===!0||typeof t=="object"&&t.releaseGlobalResources)&&Qe.release(),Object.values(this.runners).forEach(e=>{e.destroy()}),this._systemsHash=null,this.renderPipes=null,this.removeAllListeners()}generateTexture(t){return this.textureGenerator.generateTexture(t)}get roundPixels(){return!!this._roundPixels}_unsafeEvalCheck(){if(!Ih())throw new Error("Current environment does not allow unsafe-eval, please use pixi.js/unsafe-eval module to enable support.")}resetState(){this.runners.resetState.emit()}};ao.defaultOptions={resolution:1,failIfMajorPerformanceCaveat:!1,roundPixels:!1};let lo=ao,hs;function Jh(s){return hs!==void 0||(hs=(()=>{var e;const t={stencil:!0,failIfMajorPerformanceCaveat:s??lo.defaultOptions.failIfMajorPerformanceCaveat};try{if(!z.get().getWebGLRenderingContext())return!1;let r=z.get().createCanvas().getContext("webgl",t);const n=!!((e=r==null?void 0:r.getContextAttributes())!=null&&e.stencil);if(r){const o=r.getExtension("WEBGL_lose_context");o&&o.loseContext()}return r=null,n}catch{return!1}})()),hs}let ls;async function tl(s={}){return ls!==void 0||(ls=await(async()=>{const t=z.get().getNavigator().gpu;if(!t)return!1;try{return await(await t.requestAdapter(s)).requestDevice(),!0}catch{return!1}})()),ls}const wr=["webgl","webgpu","canvas"];async function el(s){let t=[];s.preference?Array.isArray(s.preference)?t=s.preference.slice():(t.push(s.preference),wr.forEach(n=>{n!==s.preference&&t.push(n)})):t=wr.slice();let e,i={};for(let n=0;n<t.length;n++){const o=t[n];if(o==="webgpu"&&await tl()){const{WebGPURenderer:a}=await pe(async()=>{const{WebGPURenderer:h}=await import("./WebGPURenderer-Ddwua8JA.js");return{WebGPURenderer:h}},__vite__mapDeps([3,4,2,5]));e=a,i={...s,...s.webgpu};break}else if(o==="webgl"&&Jh(s.failIfMajorPerformanceCaveat??lo.defaultOptions.failIfMajorPerformanceCaveat)){const{WebGLRenderer:a}=await pe(async()=>{const{WebGLRenderer:h}=await import("./WebGLRenderer-CdpFaPwH.js");return{WebGLRenderer:h}},__vite__mapDeps([6,4,2,5]));e=a,i={...s,...s.webgl};break}else if(o==="canvas"){const{CanvasRenderer:a}=await pe(async()=>{const{CanvasRenderer:h}=await import("./CanvasRenderer-Yf_04ykh.js");return{CanvasRenderer:h}},__vite__mapDeps([7,5,2]));e=a,i={...s,...s.canvasOptions};break}}if(delete i.webgpu,delete i.webgl,delete i.canvasOptions,!e)throw new Error("No available renderer for the current environment");const r=new e;return await r.init(i),r}const co="8.19.0";class uo{static init(){var t;(t=globalThis.__PIXI_APP_INIT__)==null||t.call(globalThis,this,co)}static destroy(){}}uo.extension=I.Application;class sl{constructor(t){this._renderer=t}init(){var t;(t=globalThis.__PIXI_RENDERER_INIT__)==null||t.call(globalThis,this._renderer,co)}destroy(){this._renderer=null}}sl.extension={type:[I.WebGLSystem,I.WebGPUSystem],name:"initHook",priority:-10};class fo{static init(t){Object.defineProperty(this,"resizeTo",{configurable:!0,set(e){globalThis.removeEventListener("resize",this.queueResize),this._resizeTo=e,e&&(globalThis.addEventListener("resize",this.queueResize),this.resize())},get(){return this._resizeTo}}),this.queueResize=()=>{this._resizeTo&&(this._cancelResize(),this._resizeId=requestAnimationFrame(()=>this.resize()))},this._cancelResize=()=>{this._resizeId&&(cancelAnimationFrame(this._resizeId),this._resizeId=null)},this.resize=()=>{if(!this._resizeTo)return;this._cancelResize();let e,i;if(this._resizeTo===globalThis.window)e=globalThis.innerWidth,i=globalThis.innerHeight;else{const{clientWidth:r,clientHeight:n}=this._resizeTo;e=r,i=n}this.renderer.resize(e,i),this.render()},this._resizeId=null,this._resizeTo=null,this.resizeTo=t.resizeTo||null}static destroy(){globalThis.removeEventListener("resize",this.queueResize),this._cancelResize(),this._cancelResize=null,this.queueResize=null,this.resizeTo=null,this.resize=null}}fo.extension=I.Application;class po{static init(t){t=Object.assign({autoStart:!0,sharedTicker:!1},t),Object.defineProperty(this,"ticker",{configurable:!0,set(e){this._ticker&&this._ticker.remove(this.render,this),this._ticker=e,e&&e.add(this.render,this,ze.LOW)},get(){return this._ticker}}),this.stop=()=>{this._ticker.stop()},this.start=()=>{this._ticker.start()},this._ticker=null,this.ticker=t.sharedTicker?dt.shared:new dt,t.autoStart&&this.start()}static destroy(){if(this._ticker){const t=this._ticker;this.ticker=null,t.destroy()}}}po.extension=I.Application;K.add(fo);K.add(po);const mo=class vi{constructor(...t){this.stage=new Ut,t[0]!==void 0&&X(_t,"Application constructor options are deprecated, please use Application.init() instead.")}async init(t){t={...t},this.stage||(this.stage=new Ut),this.renderer=await el(t),vi._plugins.forEach(e=>{e.init.call(this,t)})}render(){this.renderer.render({container:this.stage})}get canvas(){return this.renderer.canvas}get view(){return X(_t,"Application.view is deprecated, please use Application.canvas instead."),this.renderer.canvas}get screen(){return this.renderer.screen}get domContainerRoot(){var t;return(t=this.renderer.renderPipes.dom)==null?void 0:t._domElement}destroy(t=!1,e=!1){const i=vi._plugins.slice(0);i.reverse(),i.forEach(r=>{r.destroy.call(this)}),this.stage.destroy(e),this.stage=null,this.renderer.destroy(t),this.renderer=null}};mo._plugins=[];let go=mo;K.handleByList(I.Application,go._plugins);K.add(uo);const Xs={test(s){return typeof s=="string"&&s.startsWith("info face=")},parse(s){const t=s.match(/^[a-z]+\s+.+$/gm),e={info:[],common:[],page:[],char:[],chars:[],kerning:[],kernings:[],distanceField:[]};for(const u in t){const f=t[u].match(/^[a-z]+/gm)[0],d=t[u].match(/[a-zA-Z]+=([^\s"']+|"([^"]*)")/gm),p={};for(const g in d){const m=d[g].split("="),_=m[0],y=m[1].replace(/"/gm,""),x=parseFloat(y),w=isNaN(x)?y:x;p[_]=w}e[f].push(p)}const i={chars:{},pages:[],lineHeight:0,fontSize:0,fontFamily:"",distanceField:null,baseLineOffset:0},[r]=e.info,[n]=e.common,[o]=e.distanceField??[];o&&(i.distanceField={range:parseInt(o.distanceRange,10),type:o.fieldType}),i.fontSize=parseInt(r.size,10),i.fontFamily=r.face,i.lineHeight=parseInt(n.lineHeight,10);const a=e.page;for(let u=0;u<a.length;u++)i.pages.push({id:parseInt(a[u].id,10)||0,file:a[u].file});const h={};i.baseLineOffset=i.lineHeight-parseInt(n.base,10);const l=e.char;for(let u=0;u<l.length;u++){const f=l[u],d=parseInt(f.id,10);let p=f.letter??f.char??String.fromCharCode(d);p==="space"&&(p=" "),h[d]=p,i.chars[p]={id:d,page:parseInt(f.page,10)||0,x:parseInt(f.x,10),y:parseInt(f.y,10),width:parseInt(f.width,10),height:parseInt(f.height,10),xOffset:parseInt(f.xoffset,10),yOffset:parseInt(f.yoffset,10),xAdvance:parseInt(f.xadvance,10),kerning:{}}}const c=e.kerning||[];for(let u=0;u<c.length;u++){const f=parseInt(c[u].first,10),d=parseInt(c[u].second,10),p=parseInt(c[u].amount,10);i.chars[h[d]]&&(i.chars[h[d]].kerning[h[f]]=p)}return i}},vr={test(s){const t=s;return typeof t!="string"&&"getElementsByTagName"in t&&t.getElementsByTagName("page").length&&t.getElementsByTagName("info")[0].getAttribute("face")!==null},parse(s){const t={chars:{},pages:[],lineHeight:0,fontSize:0,fontFamily:"",distanceField:null,baseLineOffset:0},e=s.getElementsByTagName("info")[0],i=s.getElementsByTagName("common")[0],r=s.getElementsByTagName("distanceField")[0];r&&(t.distanceField={type:r.getAttribute("fieldType"),range:parseInt(r.getAttribute("distanceRange"),10)});const n=s.getElementsByTagName("page"),o=s.getElementsByTagName("char"),a=s.getElementsByTagName("kerning");t.fontSize=parseInt(e.getAttribute("size"),10),t.fontFamily=e.getAttribute("face"),t.lineHeight=parseInt(i.getAttribute("lineHeight"),10);for(let l=0;l<n.length;l++)t.pages.push({id:parseInt(n[l].getAttribute("id"),10)||0,file:n[l].getAttribute("file")});const h={};t.baseLineOffset=t.lineHeight-parseInt(i.getAttribute("base"),10);for(let l=0;l<o.length;l++){const c=o[l],u=parseInt(c.getAttribute("id"),10);let f=c.getAttribute("letter")??c.getAttribute("char")??String.fromCharCode(u);f==="space"&&(f=" "),h[u]=f,t.chars[f]={id:u,page:parseInt(c.getAttribute("page"),10)||0,x:parseInt(c.getAttribute("x"),10),y:parseInt(c.getAttribute("y"),10),width:parseInt(c.getAttribute("width"),10),height:parseInt(c.getAttribute("height"),10),xOffset:parseInt(c.getAttribute("xoffset"),10),yOffset:parseInt(c.getAttribute("yoffset"),10),xAdvance:parseInt(c.getAttribute("xadvance"),10),kerning:{}}}for(let l=0;l<a.length;l++){const c=parseInt(a[l].getAttribute("first"),10),u=parseInt(a[l].getAttribute("second"),10),f=parseInt(a[l].getAttribute("amount"),10);t.chars[h[u]]&&(t.chars[h[u]].kerning[h[c]]=f)}return t}},Ar={test(s){return typeof s=="string"&&s.match(/<font(\s|>)/)?vr.test(z.get().parseXML(s)):!1},parse(s){return vr.parse(z.get().parseXML(s))}},il=[".xml",".fnt"],rl={extension:{type:I.CacheParser,name:"cacheBitmapFont"},test:s=>!!(s!=null&&s.pages)&&!!(s!=null&&s.chars)&&typeof(s==null?void 0:s.fontFamily)=="string"&&s.fontFamily!=="",getCacheableAssets(s,t){const e={};return s.forEach(i=>{e[i]=t,e[`${i}-bitmap`]=t}),e[`${t.fontFamily}-bitmap`]=t,e}},nl={extension:{type:I.LoadParser,priority:Gt.Normal},name:"loadBitmapFont",id:"bitmap-font",test(s){return il.includes(at.extname(s).toLowerCase())},async testParse(s){return Xs.test(s)||Ar.test(s)},async parse(s,t,e){const i=Xs.test(s)?Xs.parse(s):Ar.parse(s),{src:r}=t,{pages:n}=i,o=[],a=i.distanceField?{scaleMode:"linear",alphaMode:"premultiply-alpha-on-upload",autoGenerateMipmaps:!1,resolution:1}:{};for(let f=0;f<n.length;++f){const d=n[f].file;let p=at.join(at.dirname(r),d);p=ui(p,r),o.push({src:p,data:a})}const[h,{BitmapFont:l}]=await Promise.all([e.load(o),pe(()=>import("./BitmapFont-CoN36Cy_.js"),[])]),c=o.map(f=>h[f.src]);return new l({data:i,textures:c},r)},async load(s,t){return await(await z.get().fetch(s)).text()},async unload(s,t,e){await Promise.all(s.pages.map(i=>e.unload(i.texture.source._sourceOrigin))),s.destroy()}};class ol{constructor(t,e=!1){this._loader=t,this._assetList=[],this._isLoading=!1,this._maxConcurrent=1,this.verbose=e}add(t){t.forEach(e=>{this._assetList.push(e)}),this.verbose&&console.log("[BackgroundLoader] assets: ",this._assetList),this._isActive&&!this._isLoading&&this._next()}async _next(){if(this._assetList.length&&this._isActive){this._isLoading=!0;const t=[],e=Math.min(this._assetList.length,this._maxConcurrent);for(let i=0;i<e;i++)t.push(this._assetList.pop());await this._loader.load(t),this._isLoading=!1,this._next()}}get active(){return this._isActive}set active(t){this._isActive!==t&&(this._isActive=t,t&&!this._isLoading&&this._next())}}const al={extension:{type:I.CacheParser,name:"cacheTextureArray"},test:s=>Array.isArray(s)&&s.every(t=>t instanceof U),getCacheableAssets:(s,t)=>{const e={};return s.forEach(i=>{t.forEach((r,n)=>{e[i+(n===0?"":n+1)]=r})}),e}};async function _o(s){if("Image"in globalThis)return new Promise(t=>{const e=new Image;e.onload=()=>{t(!0)},e.onerror=()=>{t(!1)},e.src=s});if("createImageBitmap"in globalThis&&"fetch"in globalThis){try{const t=await(await fetch(s)).blob();await createImageBitmap(t)}catch{return!1}return!0}return!1}const hl={extension:{type:I.DetectionParser,priority:1},test:async()=>_o("data:image/avif;base64,AAAAIGZ0eXBhdmlmAAAAAGF2aWZtaWYxbWlhZk1BMUIAAADybWV0YQAAAAAAAAAoaGRscgAAAAAAAAAAcGljdAAAAAAAAAAAAAAAAGxpYmF2aWYAAAAADnBpdG0AAAAAAAEAAAAeaWxvYwAAAABEAAABAAEAAAABAAABGgAAAB0AAAAoaWluZgAAAAAAAQAAABppbmZlAgAAAAABAABhdjAxQ29sb3IAAAAAamlwcnAAAABLaXBjbwAAABRpc3BlAAAAAAAAAAIAAAACAAAAEHBpeGkAAAAAAwgICAAAAAxhdjFDgQ0MAAAAABNjb2xybmNseAACAAIAAYAAAAAXaXBtYQAAAAAAAAABAAEEAQKDBAAAACVtZGF0EgAKCBgANogQEAwgMg8f8D///8WfhwB8+ErK42A="),add:async s=>[...s,"avif"],remove:async s=>s.filter(t=>t!=="avif")},Sr=["png","jpg","jpeg"],ll={extension:{type:I.DetectionParser,priority:-1},test:()=>Promise.resolve(!0),add:async s=>[...s,...Sr],remove:async s=>s.filter(t=>!Sr.includes(t))},cl="WorkerGlobalScope"in globalThis&&globalThis instanceof globalThis.WorkerGlobalScope;function ks(s){return cl?!1:document.createElement("video").canPlayType(s)!==""}const ul={extension:{type:I.DetectionParser,priority:0},test:async()=>ks("video/mp4"),add:async s=>[...s,"mp4","m4v"],remove:async s=>s.filter(t=>t!=="mp4"&&t!=="m4v")},dl={extension:{type:I.DetectionParser,priority:0},test:async()=>ks("video/ogg"),add:async s=>[...s,"ogv"],remove:async s=>s.filter(t=>t!=="ogv")},fl={extension:{type:I.DetectionParser,priority:0},test:async()=>ks("video/webm"),add:async s=>[...s,"webm"],remove:async s=>s.filter(t=>t!=="webm")},pl={extension:{type:I.DetectionParser,priority:0},test:async()=>_o("data:image/webp;base64,UklGRh4AAABXRUJQVlA4TBEAAAAvAAAAAAfQ//73v/+BiOh/AAA="),add:async s=>[...s,"webp"],remove:async s=>s.filter(t=>t!=="webp")},yo=class ms{constructor(){this.loadOptions={...ms.defaultOptions},this._parsers=[],this._parsersValidated=!1,this.parsers=new Proxy(this._parsers,{set:(t,e,i)=>(this._parsersValidated=!1,t[e]=i,!0)}),this.promiseCache={}}reset(){this._parsersValidated=!1,this.promiseCache={}}_getLoadPromiseAndParser(t,e){const i={promise:null,parser:null};return i.promise=(async()=>{var o,a;let r=null,n=null;if((e.parser||e.loadParser)&&(n=this._parserHash[e.parser||e.loadParser],e.loadParser&&Y(`[Assets] "loadParser" is deprecated, use "parser" instead for ${t}`),n||Y(`[Assets] specified load parser "${e.parser||e.loadParser}" not found while loading ${t}`)),!n){for(let h=0;h<this.parsers.length;h++){const l=this.parsers[h];if(l.load&&((o=l.test)!=null&&o.call(l,t,e,this))){n=l;break}}if(!n)return Y(`[Assets] ${t} could not be loaded as we don't know how to parse it, ensure the correct parser has been added`),null}r=await n.load(t,e,this),i.parser=n;for(let h=0;h<this.parsers.length;h++){const l=this.parsers[h];l.parse&&l.parse&&await((a=l.testParse)==null?void 0:a.call(l,r,e,this))&&(r=await l.parse(r,e,this)||r,i.parser=l)}return r})(),i}async load(t,e){this._parsersValidated||this._validateParsers();const i=typeof e=="function"?{...ms.defaultOptions,...this.loadOptions,onProgress:e}:{...ms.defaultOptions,...this.loadOptions,...e||{}},{onProgress:r,onError:n,strategy:o,retryCount:a,retryDelay:h}=i;let l=0;const c={},u=gs(t),f=Tt(t,g=>({alias:[g],src:g,data:{}})),d=f.reduce((g,m)=>g+(m.progressSize||1),0),p=f.map(async g=>{const m=at.toAbsolute(g.src);c[g.src]||(await this._loadAssetWithRetry(m,g,{onProgress:r,onError:n,strategy:o,retryCount:a,retryDelay:h},c),l+=g.progressSize||1,r&&r(l/d))});return await Promise.all(p),u?c[f[0].src]:c}async unload(t){const i=Tt(t,r=>({alias:[r],src:r})).map(async r=>{var a,h;const n=at.toAbsolute(r.src),o=this.promiseCache[n];if(o){const l=await o.promise;delete this.promiseCache[n],await((h=(a=o.parser)==null?void 0:a.unload)==null?void 0:h.call(a,l,r,this))}});await Promise.all(i)}_validateParsers(){this._parsersValidated=!0,this._parserHash=this._parsers.filter(t=>t.name||t.id).reduce((t,e)=>(!e.name&&!e.id?Y("[Assets] parser should have an id"):(t[e.name]||t[e.id])&&Y(`[Assets] parser id conflict "${e.id}"`),t[e.name]=e,e.id&&(t[e.id]=e),t),{})}async _loadAssetWithRetry(t,e,i,r){let n=0;const{onError:o,strategy:a,retryCount:h,retryDelay:l}=i,c=u=>new Promise(f=>setTimeout(f,u));for(;;)try{this.promiseCache[t]||(this.promiseCache[t]=this._getLoadPromiseAndParser(t,e)),r[e.src]=await this.promiseCache[t].promise;return}catch(u){delete this.promiseCache[t],delete r[e.src],n++;const f=a!=="retry"||n>h;if(a==="retry"&&!f){o&&o(u,e),await c(l);continue}if(a==="skip"){o&&o(u,e);return}o&&o(u,e);const d=new Error(`[Loader.load] Failed to load ${t}. +${u}`);throw u instanceof Error&&u.stack&&(d.stack=u.stack),d}}};yo.defaultOptions={onProgress:void 0,onError:void 0,strategy:"throw",retryCount:3,retryDelay:250};let ml=yo;function Ae(s,t){if(Array.isArray(t)){for(const e of t)if(s.startsWith(`data:${e}`))return!0;return!1}return s.startsWith(`data:${t}`)}function Se(s,t){const e=s.split("?")[0],i=at.extname(e).toLowerCase();return Array.isArray(t)?t.includes(i):i===t}const gl=".json",_l="application/json",yl={extension:{type:I.LoadParser,priority:Gt.Low},name:"loadJson",id:"json",test(s){return Ae(s,_l)||Se(s,gl)},async load(s){return await(await z.get().fetch(s)).json()}},xl=".txt",bl="text/plain",wl={name:"loadTxt",id:"text",extension:{type:I.LoadParser,priority:Gt.Low,name:"loadTxt"},test(s){return Ae(s,bl)||Se(s,xl)},async load(s){return await(await z.get().fetch(s)).text()}},vl=["normal","bold","100","200","300","400","500","600","700","800","900"],Al=[".ttf",".otf",".woff",".woff2"],Sl=["font/ttf","font/otf","font/woff","font/woff2"],Cl=/^(--|-?[A-Z_])[0-9A-Z_-]*$/i;function Tl(s){const t=at.extname(s),r=at.basename(s,t).replace(/(-|_)/g," ").toLowerCase().split(" ").map(a=>a.charAt(0).toUpperCase()+a.slice(1));let n=r.length>0;for(const a of r)if(!a.match(Cl)){n=!1;break}let o=r.join(" ");return n||(o=`"${o.replace(/[\\"]/g,"\\$&")}"`),o}const Pl=/^[0-9A-Za-z%:/?#\[\]@!\$&'()\*\+,;=\-._~]*$/;function Ml(s){return Pl.test(s)?s:encodeURI(s)}const kl={extension:{type:I.LoadParser,priority:Gt.Low},name:"loadWebFont",id:"web-font",test(s){return Ae(s,Sl)||Se(s,Al)},async load(s,t){var i,r,n;const e=z.get().getFontFaceSet();if(e){const o=[],a=((i=t.data)==null?void 0:i.family)??Tl(s),h=((n=(r=t.data)==null?void 0:r.weights)==null?void 0:n.filter(c=>vl.includes(c)))??["normal"],l=t.data??{};for(let c=0;c<h.length;c++){const u=h[c],f=new FontFace(a,`url('${Ml(s)}')`,{...l,weight:u});await f.load(),e.add(f),o.push(f)}return nt.has(`${a}-and-url`)?nt.get(`${a}-and-url`).entries.push({url:s,faces:o}):nt.set(`${a}-and-url`,{entries:[{url:s,faces:o}]}),o.length===1?o[0]:o}return Y("[loadWebFont] FontFace API is not supported. Skipping loading font"),null},unload(s){const t=Array.isArray(s)?s:[s],e=t[0].family,i=nt.get(`${e}-and-url`),r=i.entries.find(n=>n.faces.some(o=>t.indexOf(o)!==-1));r.faces=r.faces.filter(n=>t.indexOf(n)===-1),r.faces.length===0&&(i.entries=i.entries.filter(n=>n!==r)),t.forEach(n=>{z.get().getFontFaceSet().delete(n)}),i.entries.length===0&&nt.remove(`${e}-and-url`)}},qs={a:7,c:6,h:1,l:2,m:2,q:4,s:4,t:2,v:1,z:0},El=/([astvzqmhlc])([^astvzqmhlc]*)/gi,Il=/-?[0-9]*\.?[0-9]+(?:e[-+]?\d+)?/gi;function Rl(s){const t=[];return s.replace(El,(e,i,r)=>{let n=i.toLowerCase(),o=i;const a=Ll(r);for(n==="m"&&a.length>2&&(t.push([o,...a.splice(0,2)]),n="l",o=o==="m"?"l":"L");;){if(a.length===qs[n])return t.push([o,...a]),"";if(a.length<qs[n])throw new Error("malformed path data");t.push([o,...a.splice(0,qs[n])])}}),t}function Ll(s){const t=s.match(Il);return t?t.map(Number):[]}function Bl(s,t){const e=Rl(s),i=[];let r=null,n=0,o=0;for(let a=0;a<e.length;a++){const h=e[a],l=h[0],c=h;switch(l){case"M":n=c[1],o=c[2],t.moveTo(n,o);break;case"m":n+=c[1],o+=c[2],t.moveTo(n,o);break;case"H":n=c[1],t.lineTo(n,o);break;case"h":n+=c[1],t.lineTo(n,o);break;case"V":o=c[1],t.lineTo(n,o);break;case"v":o+=c[1],t.lineTo(n,o);break;case"L":n=c[1],o=c[2],t.lineTo(n,o);break;case"l":n+=c[1],o+=c[2],t.lineTo(n,o);break;case"C":n=c[5],o=c[6],t.bezierCurveTo(c[1],c[2],c[3],c[4],n,o);break;case"c":t.bezierCurveTo(n+c[1],o+c[2],n+c[3],o+c[4],n+c[5],o+c[6]),n+=c[5],o+=c[6];break;case"S":n=c[3],o=c[4],t.bezierCurveToShort(c[1],c[2],n,o);break;case"s":t.bezierCurveToShort(n+c[1],o+c[2],n+c[3],o+c[4]),n+=c[3],o+=c[4];break;case"Q":n=c[3],o=c[4],t.quadraticCurveTo(c[1],c[2],n,o);break;case"q":t.quadraticCurveTo(n+c[1],o+c[2],n+c[3],o+c[4]),n+=c[3],o+=c[4];break;case"T":n=c[1],o=c[2],t.quadraticCurveToShort(n,o);break;case"t":n+=c[1],o+=c[2],t.quadraticCurveToShort(n,o);break;case"A":n=c[6],o=c[7],t.arcToSvg(c[1],c[2],c[3],c[4],c[5],n,o);break;case"a":n+=c[6],o+=c[7],t.arcToSvg(c[1],c[2],c[3],c[4],c[5],n,o);break;case"Z":case"z":t.closePath(),i.length>0&&(r=i.pop(),r?(n=r.startX,o=r.startY):(n=0,o=0)),r=null;break;default:Y(`Unknown SVG path command: ${l}`)}l!=="Z"&&l!=="z"&&r===null&&(r={startX:n,startY:o},i.push(r))}return t}class Gi{constructor(t=0,e=0,i=0){this.type="circle",this.x=t,this.y=e,this.radius=i}clone(){return new Gi(this.x,this.y,this.radius)}contains(t,e){if(this.radius<=0)return!1;const i=this.radius*this.radius;let r=this.x-t,n=this.y-e;return r*=r,n*=n,r+n<=i}strokeContains(t,e,i,r=.5){if(this.radius===0)return!1;const n=this.x-t,o=this.y-e,a=this.radius,h=(1-r)*i,l=Math.sqrt(n*n+o*o);return l<=a+h&&l>a-(i-h)}getBounds(t){return t||(t=new tt),t.x=this.x-this.radius,t.y=this.y-this.radius,t.width=this.radius*2,t.height=this.radius*2,t}copyFrom(t){return this.x=t.x,this.y=t.y,this.radius=t.radius,this}copyTo(t){return t.copyFrom(this),t}toString(){return`[pixi.js/math:Circle x=${this.x} y=${this.y} radius=${this.radius}]`}}class Di{constructor(t=0,e=0,i=0,r=0){this.type="ellipse",this.x=t,this.y=e,this.halfWidth=i,this.halfHeight=r}clone(){return new Di(this.x,this.y,this.halfWidth,this.halfHeight)}contains(t,e){if(this.halfWidth<=0||this.halfHeight<=0)return!1;let i=(t-this.x)/this.halfWidth,r=(e-this.y)/this.halfHeight;return i*=i,r*=r,i+r<=1}strokeContains(t,e,i,r=.5){const{halfWidth:n,halfHeight:o}=this;if(n<=0||o<=0)return!1;const a=i*(1-r),h=i-a,l=n-h,c=o-h,u=n+a,f=o+a,d=t-this.x,p=e-this.y,g=d*d/(l*l)+p*p/(c*c),m=d*d/(u*u)+p*p/(f*f);return g>1&&m<=1}getBounds(t){return t||(t=new tt),t.x=this.x-this.halfWidth,t.y=this.y-this.halfHeight,t.width=this.halfWidth*2,t.height=this.halfHeight*2,t}copyFrom(t){return this.x=t.x,this.y=t.y,this.halfWidth=t.halfWidth,this.halfHeight=t.halfHeight,this}copyTo(t){return t.copyFrom(this),t}toString(){return`[pixi.js/math:Ellipse x=${this.x} y=${this.y} halfWidth=${this.halfWidth} halfHeight=${this.halfHeight}]`}}function Fl(s,t,e,i,r,n){const o=s-e,a=t-i,h=r-e,l=n-i,c=o*h+a*l,u=h*h+l*l;let f=-1;u!==0&&(f=c/u);let d,p;f<0?(d=e,p=i):f>1?(d=r,p=n):(d=e+f*h,p=i+f*l);const g=s-d,m=t-p;return g*g+m*m}let Gl,Dl;class Oe{constructor(...t){this.type="polygon";let e=Array.isArray(t[0])?t[0]:t;if(typeof e[0]!="number"){const i=[];for(let r=0,n=e.length;r<n;r++)i.push(e[r].x,e[r].y);e=i}this.points=e,this.closePath=!0}isClockwise(){let t=0;const e=this.points,i=e.length;for(let r=0;r<i;r+=2){const n=e[r],o=e[r+1],a=e[(r+2)%i],h=e[(r+3)%i];t+=(a-n)*(h+o)}return t<0}containsPolygon(t){const e=this.getBounds(Gl),i=t.getBounds(Dl);if(!e.containsRect(i))return!1;const r=t.points;for(let n=0;n<r.length;n+=2){const o=r[n],a=r[n+1];if(!this.contains(o,a))return!1}return!0}clone(){const t=this.points.slice(),e=new Oe(t);return e.closePath=this.closePath,e}contains(t,e){let i=!1;const r=this.points.length/2;for(let n=0,o=r-1;n<r;o=n++){const a=this.points[n*2],h=this.points[n*2+1],l=this.points[o*2],c=this.points[o*2+1];h>e!=c>e&&t<(l-a)*((e-h)/(c-h))+a&&(i=!i)}return i}strokeContains(t,e,i,r=.5){const n=i*i,o=n*(1-r),a=n-o,{points:h}=this,l=h.length-(this.closePath?0:2);for(let c=0;c<l;c+=2){const u=h[c],f=h[c+1],d=h[(c+2)%h.length],p=h[(c+3)%h.length],g=Fl(t,e,u,f,d,p),m=Math.sign((d-u)*(e-f)-(p-f)*(t-u));if(g<=(m<0?a:o))return!0}return!1}getBounds(t){t||(t=new tt);const e=this.points;let i=1/0,r=-1/0,n=1/0,o=-1/0;for(let a=0,h=e.length;a<h;a+=2){const l=e[a],c=e[a+1];i=l<i?l:i,r=l>r?l:r,n=c<n?c:n,o=c>o?c:o}return t.x=i,t.width=r-i,t.y=n,t.height=o-n,t}copyFrom(t){return this.points=t.points.slice(),this.closePath=t.closePath,this}copyTo(t){return t.copyFrom(this),t}toString(){return`[pixi.js/math:PolygoncloseStroke=${this.closePath}points=${this.points.reduce((t,e)=>`${t}, ${e}`,"")}]`}get lastX(){return this.points[this.points.length-2]}get lastY(){return this.points[this.points.length-1]}get x(){return X("8.11.0","Polygon.lastX is deprecated, please use Polygon.lastX instead."),this.points[this.points.length-2]}get y(){return X("8.11.0","Polygon.y is deprecated, please use Polygon.lastY instead."),this.points[this.points.length-1]}get startX(){return this.points[0]}get startY(){return this.points[1]}}const cs=(s,t,e,i,r,n,o)=>{const a=s-e,h=t-i,l=Math.sqrt(a*a+h*h);return l>=r-n&&l<=r+o};class Oi{constructor(t=0,e=0,i=0,r=0,n=20){this.type="roundedRectangle",this.x=t,this.y=e,this.width=i,this.height=r,this.radius=n}getBounds(t){return t||(t=new tt),t.x=this.x,t.y=this.y,t.width=this.width,t.height=this.height,t}clone(){return new Oi(this.x,this.y,this.width,this.height,this.radius)}copyFrom(t){return this.x=t.x,this.y=t.y,this.width=t.width,this.height=t.height,this}copyTo(t){return t.copyFrom(this),t}contains(t,e){if(this.width<=0||this.height<=0)return!1;if(t>=this.x&&t<=this.x+this.width&&e>=this.y&&e<=this.y+this.height){const i=Math.max(0,Math.min(this.radius,Math.min(this.width,this.height)/2));if(e>=this.y+i&&e<=this.y+this.height-i||t>=this.x+i&&t<=this.x+this.width-i)return!0;let r=t-(this.x+i),n=e-(this.y+i);const o=i*i;if(r*r+n*n<=o||(r=t-(this.x+this.width-i),r*r+n*n<=o)||(n=e-(this.y+this.height-i),r*r+n*n<=o)||(r=t-(this.x+i),r*r+n*n<=o))return!0}return!1}strokeContains(t,e,i,r=.5){const{x:n,y:o,width:a,height:h,radius:l}=this,c=i*(1-r),u=i-c,f=n+l,d=o+l,p=a-l*2,g=h-l*2,m=n+a,_=o+h;return(t>=n-c&&t<=n+u||t>=m-u&&t<=m+c)&&e>=d&&e<=d+g||(e>=o-c&&e<=o+u||e>=_-u&&e<=_+c)&&t>=f&&t<=f+p?!0:t<f&&e<d&&cs(t,e,f,d,l,u,c)||t>m-l&&e<d&&cs(t,e,m-l,d,l,u,c)||t>m-l&&e>_-l&&cs(t,e,m-l,_-l,l,u,c)||t<f&&e>_-l&&cs(t,e,f,_-l,l,u,c)}toString(){return`[pixi.js/math:RoundedRectangle x=${this.x} y=${this.y}width=${this.width} height=${this.height} radius=${this.radius}]`}}const xo={};function Ol(s,t,e){let i=2166136261;for(let r=0;r<t;r++)i^=s[r].uid,i=Math.imul(i,16777619),i>>>=0;return xo[i]||Wl(s,t,i,e)}function Wl(s,t,e,i){const r={};let n=0;for(let a=0;a<i;a++){const h=a<t?s[a]:U.EMPTY.source;r[n++]=h.source,r[n++]=h.style}const o=new ps(r);return xo[e]=o,o}class Cr{constructor(t){typeof t=="number"?this.rawBinaryData=new ArrayBuffer(t):t instanceof Uint8Array?this.rawBinaryData=t.buffer:this.rawBinaryData=t,this.uint32View=new Uint32Array(this.rawBinaryData),this.float32View=new Float32Array(this.rawBinaryData),this.size=this.rawBinaryData.byteLength}get int8View(){return this._int8View||(this._int8View=new Int8Array(this.rawBinaryData)),this._int8View}get uint8View(){return this._uint8View||(this._uint8View=new Uint8Array(this.rawBinaryData)),this._uint8View}get int16View(){return this._int16View||(this._int16View=new Int16Array(this.rawBinaryData)),this._int16View}get int32View(){return this._int32View||(this._int32View=new Int32Array(this.rawBinaryData)),this._int32View}get float64View(){return this._float64Array||(this._float64Array=new Float64Array(this.rawBinaryData)),this._float64Array}get bigUint64View(){return this._bigUint64Array||(this._bigUint64Array=new BigUint64Array(this.rawBinaryData)),this._bigUint64Array}view(t){return this[`${t}View`]}destroy(){this.rawBinaryData=null,this.uint32View=null,this.float32View=null,this.uint16View=null,this._int8View=null,this._uint8View=null,this._int16View=null,this._int32View=null,this._float64Array=null,this._bigUint64Array=null}static sizeOf(t){switch(t){case"int8":case"uint8":return 1;case"int16":case"uint16":return 2;case"int32":case"uint32":case"float32":return 4;default:throw new Error(`${t} isn't a valid view type`)}}}function Tr(s,t,e,i){if(e??(e=0),i??(i=Math.min(s.byteLength-e,t.byteLength)),!(e&7)&&!(i&7)){const r=i/8;new Float64Array(t,0,r).set(new Float64Array(s,e,r))}else if(!(e&3)&&!(i&3)){const r=i/4;new Float32Array(t,0,r).set(new Float32Array(s,e,r))}else new Uint8Array(t).set(new Uint8Array(s,e,i))}const Ul={normal:"normal-npm",add:"add-npm",screen:"screen-npm"};var zl=(s=>(s[s.DISABLED=0]="DISABLED",s[s.RENDERING_MASK_ADD=1]="RENDERING_MASK_ADD",s[s.MASK_ACTIVE=2]="MASK_ACTIVE",s[s.INVERSE_MASK_ACTIVE=3]="INVERSE_MASK_ACTIVE",s[s.RENDERING_MASK_REMOVE=4]="RENDERING_MASK_REMOVE",s[s.NONE=5]="NONE",s))(zl||{});function Pr(s,t){return t.alphaMode==="no-premultiply-alpha"&&Ul[s]||s}const Hl=["precision mediump float;","void main(void){","float test = 0.1;","%forloop%","gl_FragColor = vec4(0.0);","}"].join(` +`);function Nl(s){let t="";for(let e=0;e<s;++e)e>0&&(t+=` +else `),e<s-1&&(t+=`if(test == ${e}.0){}`);return t}function Vl(s,t){if(s===0)throw new Error("Invalid value of `0` passed to `checkMaxIfStatementsInShader`");const e=t.createShader(t.FRAGMENT_SHADER);try{for(;;){const i=Hl.replace(/%forloop%/gi,Nl(s));if(t.shaderSource(e,i),t.compileShader(e),!t.getShaderParameter(e,t.COMPILE_STATUS))s=s/2|0;else break}}finally{t.deleteShader(e)}return s}let oe=null;function $l(){var t;if(oe)return oe;const s=Xn();return oe=s.getParameter(s.MAX_TEXTURE_IMAGE_UNITS),oe=Vl(oe,s),(t=s.getExtension("WEBGL_lose_context"))==null||t.loseContext(),oe}class jl{constructor(){this.ids=Object.create(null),this.textures=[],this.count=0}clear(){for(let t=0;t<this.count;t++){const e=this.textures[t];this.textures[t]=null,this.ids[e.uid]=null}this.count=0}}class Yl{constructor(){this.renderPipeId="batch",this.action="startBatch",this.start=0,this.size=0,this.textures=new jl,this.blendMode="normal",this.topology="triangle-strip",this.canBundle=!0}destroy(){this.textures=null,this.gpuBindGroup=null,this.bindGroup=null,this.batcher=null,this.elements=null}}const We=[];let xs=0;Qe.register({clear:()=>{if(We.length>0)for(const s of We)s&&s.destroy();We.length=0,xs=0}});function Mr(){return xs>0?We[--xs]:new Yl}function kr(s){s.elements=null,We[xs++]=s}let Re=0;const bo=class wo{constructor(t){this.uid=J("batcher"),this.dirty=!0,this.batchIndex=0,this.batches=[],this._elements=[],t={...wo.defaultOptions,...t},t.maxTextures||(X("v8.8.0","maxTextures is a required option for Batcher now, please pass it in the options"),t.maxTextures=$l());const{maxTextures:e,attributesInitialSize:i,indicesInitialSize:r}=t;this.attributeBuffer=new Cr(i*4),this.indexBuffer=new Uint16Array(r),this.maxTextures=e}begin(){this.elementSize=0,this.elementStart=0,this.indexSize=0,this.attributeSize=0;for(let t=0;t<this.batchIndex;t++)kr(this.batches[t]);this.batchIndex=0,this._batchIndexStart=0,this._batchIndexSize=0,this.dirty=!0}add(t){this._elements[this.elementSize++]=t,t._indexStart=this.indexSize,t._attributeStart=this.attributeSize,t._batcher=this,this.indexSize+=t.indexSize,this.attributeSize+=t.attributeSize*this.vertexSize}checkAndUpdateTexture(t,e){const i=t._batch.textures.ids[e._source.uid];return!i&&i!==0?!1:(t._textureId=i,t.texture=e,!0)}updateElement(t){this.dirty=!0;const e=this.attributeBuffer;t.packAsQuad?this.packQuadAttributes(t,e.float32View,e.uint32View,t._attributeStart,t._textureId):this.packAttributes(t,e.float32View,e.uint32View,t._attributeStart,t._textureId)}break(t){const e=this._elements;if(!e[this.elementStart])return;let i=Mr(),r=i.textures;r.clear();const n=e[this.elementStart];let o=Pr(n.blendMode,n.texture._source),a=n.topology;this.attributeSize*4>this.attributeBuffer.size&&this._resizeAttributeBuffer(this.attributeSize*4),this.indexSize>this.indexBuffer.length&&this._resizeIndexBuffer(this.indexSize);const h=this.attributeBuffer.float32View,l=this.attributeBuffer.uint32View,c=this.indexBuffer;let u=this._batchIndexSize,f=this._batchIndexStart,d="startBatch",p=[];const g=this.maxTextures;for(let m=this.elementStart;m<this.elementSize;++m){const _=e[m];e[m]=null;const x=_.texture._source,w=Pr(_.blendMode,x),v=o!==w||a!==_.topology;if(x._batchTick===Re&&!v){_._textureId=x._textureBindLocation,u+=_.indexSize,_.packAsQuad?(this.packQuadAttributes(_,h,l,_._attributeStart,_._textureId),this.packQuadIndex(c,_._indexStart,_._attributeStart/this.vertexSize)):(this.packAttributes(_,h,l,_._attributeStart,_._textureId),this.packIndex(_,c,_._indexStart,_._attributeStart/this.vertexSize)),_._batch=i,p.push(_);continue}x._batchTick=Re,(r.count>=g||v)&&(this._finishBatch(i,f,u-f,r,o,a,t,d,p),d="renderBatch",f=u,o=w,a=_.topology,i=Mr(),r=i.textures,r.clear(),p=[],++Re),_._textureId=x._textureBindLocation=r.count,r.ids[x.uid]=r.count,r.textures[r.count++]=x,_._batch=i,p.push(_),u+=_.indexSize,_.packAsQuad?(this.packQuadAttributes(_,h,l,_._attributeStart,_._textureId),this.packQuadIndex(c,_._indexStart,_._attributeStart/this.vertexSize)):(this.packAttributes(_,h,l,_._attributeStart,_._textureId),this.packIndex(_,c,_._indexStart,_._attributeStart/this.vertexSize))}r.count>0&&(this._finishBatch(i,f,u-f,r,o,a,t,d,p),f=u,++Re),this.elementStart=this.elementSize,this._batchIndexStart=f,this._batchIndexSize=u}_finishBatch(t,e,i,r,n,o,a,h,l){t.gpuBindGroup=null,t.bindGroup=null,t.action=h,t.batcher=this,t.textures=r,t.blendMode=n,t.topology=o,t.start=e,t.size=i,t.elements=l,++Re,this.batches[this.batchIndex++]=t,a.add(t)}finish(t){this.break(t)}ensureAttributeBuffer(t){t*4<=this.attributeBuffer.size||this._resizeAttributeBuffer(t*4)}ensureIndexBuffer(t){t<=this.indexBuffer.length||this._resizeIndexBuffer(t)}_resizeAttributeBuffer(t){const e=Math.max(t,this.attributeBuffer.size*2),i=new Cr(e);Tr(this.attributeBuffer.rawBinaryData,i.rawBinaryData),this.attributeBuffer=i}_resizeIndexBuffer(t){const e=this.indexBuffer;let i=Math.max(t,e.length*1.5);i+=i%2;const r=i>65535?new Uint32Array(i):new Uint16Array(i);if(r.BYTES_PER_ELEMENT!==e.BYTES_PER_ELEMENT)for(let n=0;n<e.length;n++)r[n]=e[n];else Tr(e.buffer,r.buffer);this.indexBuffer=r}packQuadIndex(t,e,i){t[e]=i+0,t[e+1]=i+1,t[e+2]=i+2,t[e+3]=i+0,t[e+4]=i+2,t[e+5]=i+3}packIndex(t,e,i,r){const n=t.indices,o=t.indexSize,a=t.indexOffset,h=t.attributeOffset;for(let l=0;l<o;l++)e[i++]=r+n[l+a]-h}destroy(t={}){var e;if(this.batches!==null){for(let i=0;i<this.batchIndex;i++)kr(this.batches[i]);this.batches=null,this.geometry.destroy(!0),this.geometry=null,t.shader&&((e=this.shader)==null||e.destroy(),this.shader=null);for(let i=0;i<this._elements.length;i++)this._elements[i]&&(this._elements[i]._batch=null);this._elements=null,this.indexBuffer=null,this.attributeBuffer.destroy(),this.attributeBuffer=null}}};bo.defaultOptions={maxTextures:null,attributesInitialSize:4,indicesInitialSize:6};let Xl=bo;var pt=(s=>(s[s.MAP_READ=1]="MAP_READ",s[s.MAP_WRITE=2]="MAP_WRITE",s[s.COPY_SRC=4]="COPY_SRC",s[s.COPY_DST=8]="COPY_DST",s[s.INDEX=16]="INDEX",s[s.VERTEX=32]="VERTEX",s[s.UNIFORM=64]="UNIFORM",s[s.STORAGE=128]="STORAGE",s[s.INDIRECT=256]="INDIRECT",s[s.QUERY_RESOLVE=512]="QUERY_RESOLVE",s[s.STATIC=1024]="STATIC",s))(pt||{});class je extends ft{constructor(t){let{data:e,size:i}=t;const{usage:r,label:n,shrinkToFit:o}=t;super(),this._gpuData=Object.create(null),this._gcLastUsed=-1,this.autoGarbageCollect=!0,this.uid=J("buffer"),this._resourceType="buffer",this._resourceId=J("resource"),this._touched=0,this._updateID=1,this._dataInt32=null,this.shrinkToFit=!0,this.destroyed=!1,e instanceof Array&&(e=new Float32Array(e)),this._data=e,i??(i=e==null?void 0:e.byteLength);const a=!!e;this.descriptor={size:i,usage:r,mappedAtCreation:a,label:n},this.shrinkToFit=o??!0}get data(){return this._data}set data(t){this.setDataWithSize(t,t.length,!0)}get dataInt32(){return this._dataInt32||(this._dataInt32=new Int32Array(this.data.buffer)),this._dataInt32}get static(){return!!(this.descriptor.usage&pt.STATIC)}set static(t){t?this.descriptor.usage|=pt.STATIC:this.descriptor.usage&=~pt.STATIC}setDataWithSize(t,e,i){if(this._updateID++,this._updateSize=e*t.BYTES_PER_ELEMENT,this._data===t){i&&this.emit("update",this);return}const r=this._data;if(this._data=t,this._dataInt32=null,!r||r.length!==t.length){!this.shrinkToFit&&r&&t.byteLength<r.byteLength?i&&this.emit("update",this):(this.descriptor.size=t.byteLength,this._resourceId=J("resource"),this.emit("change",this));return}i&&this.emit("update",this)}update(t){this._updateSize=t??this._updateSize,this._updateID++,this.emit("update",this)}unload(){var t;this.emit("unload",this);for(const e in this._gpuData)(t=this._gpuData[e])==null||t.destroy();this._gpuData=Object.create(null)}destroy(){this.destroyed=!0,this.unload(),this.emit("destroy",this),this.emit("change",this),this._data=null,this.descriptor=null,this.removeAllListeners()}}function vo(s,t){if(!(s instanceof je)){let e=t?pt.INDEX:pt.VERTEX;s instanceof Array&&(t?(s=new Uint32Array(s),e=pt.INDEX|pt.COPY_DST):(s=new Float32Array(s),e=pt.VERTEX|pt.COPY_DST)),s=new je({data:s,label:t?"index-mesh-buffer":"vertex-mesh-buffer",usage:e})}return s}function ql(s,t,e){const i=s.getAttribute(t);if(!i)return e.minX=0,e.minY=0,e.maxX=0,e.maxY=0,e;const r=i.buffer.data;let n=1/0,o=1/0,a=-1/0,h=-1/0;const l=r.BYTES_PER_ELEMENT,c=(i.offset||0)/l,u=(i.stride||8)/l;for(let f=c;f<r.length;f+=u){const d=r[f],p=r[f+1];d>a&&(a=d),p>h&&(h=p),d<n&&(n=d),p<o&&(o=p)}return e.minX=n,e.minY=o,e.maxX=a,e.maxY=h,e}function Kl(s){return(s instanceof je||Array.isArray(s)||s.BYTES_PER_ELEMENT)&&(s={buffer:s}),s.buffer=vo(s.buffer,!1),s}class Ql extends ft{constructor(t={}){super(),this._gpuData=Object.create(null),this.autoGarbageCollect=!0,this._gcLastUsed=-1,this.uid=J("geometry"),this._layoutKey=0,this.instanceCount=1,this._bounds=new vt,this._boundsDirty=!0;const{attributes:e,indexBuffer:i,topology:r}=t;if(this.buffers=[],this.attributes={},e)for(const n in e)this.addAttribute(n,e[n]);this.instanceCount=t.instanceCount??1,i&&this.addIndex(i),this.topology=r||"triangle-list"}onBufferUpdate(){this._boundsDirty=!0,this.emit("update",this)}getAttribute(t){return this.attributes[t]}getIndex(){return this.indexBuffer}getBuffer(t){return this.getAttribute(t).buffer}getSize(){for(const t in this.attributes){const e=this.attributes[t];return e.buffer.data.length/(e.stride/4||e.size)}return 0}addAttribute(t,e){const i=Kl(e);this.buffers.indexOf(i.buffer)===-1&&(this.buffers.push(i.buffer),i.buffer.on("update",this.onBufferUpdate,this),i.buffer.on("change",this.onBufferUpdate,this)),this.attributes[t]=i}addIndex(t){this.indexBuffer=vo(t,!0),this.buffers.push(this.indexBuffer)}get bounds(){return this._boundsDirty?(this._boundsDirty=!1,ql(this,"aPosition",this._bounds)):this._bounds}unload(){var t;this.emit("unload",this);for(const e in this._gpuData)(t=this._gpuData[e])==null||t.destroy();this._gpuData=Object.create(null)}destroy(t=!1){var e;this.emit("destroy",this),this.removeAllListeners(),t&&this.buffers.forEach(i=>i.destroy()),this.unload(),(e=this.indexBuffer)==null||e.destroy(),this.attributes=null,this.buffers=null,this.indexBuffer=null,this._bounds=null}}const Zl=new Float32Array(1),Jl=new Uint32Array(1);class tc extends Ql{constructor(){const e=new je({data:Zl,label:"attribute-batch-buffer",usage:pt.VERTEX|pt.COPY_DST,shrinkToFit:!1}),i=new je({data:Jl,label:"index-batch-buffer",usage:pt.INDEX|pt.COPY_DST,shrinkToFit:!1}),r=24;super({attributes:{aPosition:{buffer:e,format:"float32x2",stride:r,offset:0},aUV:{buffer:e,format:"float32x2",stride:r,offset:8},aColor:{buffer:e,format:"unorm8x4",stride:r,offset:16},aTextureIdAndRound:{buffer:e,format:"uint16x2",stride:r,offset:20}},indexBuffer:i})}}function Er(s,t,e){if(s)for(const i in s){const r=i.toLocaleLowerCase(),n=t[r];if(n){let o=s[i];i==="header"&&(o=o.replace(/@in\s+[^;]+;\s*/g,"").replace(/@out\s+[^;]+;\s*/g,"")),e&&n.push(`//----${e}----//`),n.push(o)}else Y(`${i} placement hook does not exist in shader`)}}const ec=/\{\{(.*?)\}\}/g;function Ir(s){var i;const t={};return(((i=s.match(ec))==null?void 0:i.map(r=>r.replace(/[{()}]/g,"")))??[]).forEach(r=>{t[r]=[]}),t}function Rr(s,t){let e;const i=/@in\s+([^;]+);/g;for(;(e=i.exec(s))!==null;)t.push(e[1])}function Lr(s,t,e=!1){const i=[];Rr(t,i),s.forEach(a=>{a.header&&Rr(a.header,i)});const r=i;e&&r.sort();const n=r.map((a,h)=>` @location(${h}) ${a},`).join(` +`);let o=t.replace(/@in\s+[^;]+;\s*/g,"");return o=o.replace("{{in}}",` +${n} +`),o}function Br(s,t){let e;const i=/@out\s+([^;]+);/g;for(;(e=i.exec(s))!==null;)t.push(e[1])}function sc(s){const e=/\b(\w+)\s*:/g.exec(s);return e?e[1]:""}function ic(s){const t=/@.*?\s+/g;return s.replace(t,"")}function rc(s,t){const e=[];Br(t,e),s.forEach(h=>{h.header&&Br(h.header,e)});let i=0;const r=e.sort().map(h=>h.indexOf("builtin")>-1?h:`@location(${i++}) ${h}`).join(`, +`),n=e.sort().map(h=>` var ${ic(h)};`).join(` +`),o=`return VSOutput( + ${e.sort().map(h=>` ${sc(h)}`).join(`, +`)});`;let a=t.replace(/@out\s+[^;]+;\s*/g,"");return a=a.replace("{{struct}}",` +${r} +`),a=a.replace("{{start}}",` +${n} +`),a=a.replace("{{return}}",` +${o} +`),a}function Fr(s,t){let e=s;for(const i in t){const r=t[i];r.join(` +`).length?e=e.replace(`{{${i}}}`,`//-----${i} START-----// +${r.join(` +`)} +//----${i} FINISH----//`):e=e.replace(`{{${i}}}`,"")}return e}const Wt=Object.create(null),Ks=new Map;let nc=0;function oc({template:s,bits:t}){const e=Ao(s,t);if(Wt[e])return Wt[e];const{vertex:i,fragment:r}=hc(s,t);return Wt[e]=So(i,r,t),Wt[e]}function ac({template:s,bits:t}){const e=Ao(s,t);return Wt[e]||(Wt[e]=So(s.vertex,s.fragment,t)),Wt[e]}function hc(s,t){const e=t.map(o=>o.vertex).filter(o=>!!o),i=t.map(o=>o.fragment).filter(o=>!!o);let r=Lr(e,s.vertex,!0);r=rc(e,r);const n=Lr(i,s.fragment,!0);return{vertex:r,fragment:n}}function Ao(s,t){return t.map(e=>(Ks.has(e)||Ks.set(e,nc++),Ks.get(e))).sort((e,i)=>e-i).join("-")+s.vertex+s.fragment}function So(s,t,e){const i=Ir(s),r=Ir(t);return e.forEach(n=>{Er(n.vertex,i,n.name),Er(n.fragment,r,n.name)}),{vertex:Fr(s,i),fragment:Fr(t,r)}}const lc=` + @in aPosition: vec2<f32>; + @in aUV: vec2<f32>; + + @out @builtin(position) vPosition: vec4<f32>; + @out vUV : vec2<f32>; + @out vColor : vec4<f32>; + + {{header}} + + struct VSOutput { + {{struct}} + }; + + @vertex + fn main( {{in}} ) -> VSOutput { + + var worldTransformMatrix = globalUniforms.uWorldTransformMatrix; + var modelMatrix = mat3x3<f32>( + 1.0, 0.0, 0.0, + 0.0, 1.0, 0.0, + 0.0, 0.0, 1.0 + ); + var position = aPosition; + var uv = aUV; + + {{start}} + + vColor = vec4<f32>(1., 1., 1., 1.); + + {{main}} + + vUV = uv; + + var modelViewProjectionMatrix = globalUniforms.uProjectionMatrix * worldTransformMatrix * modelMatrix; + + vPosition = vec4<f32>((modelViewProjectionMatrix * vec3<f32>(position, 1.0)).xy, 0.0, 1.0); + + vColor *= globalUniforms.uWorldColorAlpha; + + {{end}} + + {{return}} + }; +`,cc=` + @in vUV : vec2<f32>; + @in vColor : vec4<f32>; + + {{header}} + + @fragment + fn main( + {{in}} + ) -> @location(0) vec4<f32> { + + {{start}} + + var outColor:vec4<f32>; + + {{main}} + + var finalColor:vec4<f32> = outColor * vColor; + + {{end}} + + return finalColor; + }; +`,uc=` + in vec2 aPosition; + in vec2 aUV; + + out vec4 vColor; + out vec2 vUV; + + {{header}} + + void main(void){ + + mat3 worldTransformMatrix = uWorldTransformMatrix; + mat3 modelMatrix = mat3( + 1.0, 0.0, 0.0, + 0.0, 1.0, 0.0, + 0.0, 0.0, 1.0 + ); + vec2 position = aPosition; + vec2 uv = aUV; + + {{start}} + + vColor = vec4(1.); + + {{main}} + + vUV = uv; + + mat3 modelViewProjectionMatrix = uProjectionMatrix * worldTransformMatrix * modelMatrix; + + gl_Position = vec4((modelViewProjectionMatrix * vec3(position, 1.0)).xy, 0.0, 1.0); + + vColor *= uWorldColorAlpha; + + {{end}} + } +`,dc=` + + in vec4 vColor; + in vec2 vUV; + + out vec4 finalColor; + + {{header}} + + void main(void) { + + {{start}} + + vec4 outColor; + + {{main}} + + finalColor = outColor * vColor; + + {{end}} + } +`,fc={name:"global-uniforms-bit",vertex:{header:` + struct GlobalUniforms { + uProjectionMatrix:mat3x3<f32>, + uWorldTransformMatrix:mat3x3<f32>, + uWorldColorAlpha: vec4<f32>, + uResolution: vec2<f32>, + } + + @group(0) @binding(0) var<uniform> globalUniforms : GlobalUniforms; + `}},pc={name:"global-uniforms-bit",vertex:{header:` + uniform mat3 uProjectionMatrix; + uniform mat3 uWorldTransformMatrix; + uniform vec4 uWorldColorAlpha; + uniform vec2 uResolution; + `}};function mc({bits:s,name:t}){const e=oc({template:{fragment:cc,vertex:lc},bits:[fc,...s]});return Ms.from({name:t,vertex:{source:e.vertex,entryPoint:"main"},fragment:{source:e.fragment,entryPoint:"main"}})}function gc({bits:s,name:t}){return new Kn({name:t,...ac({template:{vertex:uc,fragment:dc},bits:[pc,...s]})})}const _c={name:"color-bit",vertex:{header:` + @in aColor: vec4<f32>; + `,main:` + vColor *= vec4<f32>(aColor.rgb * aColor.a, aColor.a); + `}},yc={name:"color-bit",vertex:{header:` + in vec4 aColor; + `,main:` + vColor *= vec4(aColor.rgb * aColor.a, aColor.a); + `}},Qs={};function xc(s){const t=[];if(s===1)t.push("@group(1) @binding(0) var textureSource1: texture_2d<f32>;"),t.push("@group(1) @binding(1) var textureSampler1: sampler;");else{let e=0;for(let i=0;i<s;i++)t.push(`@group(1) @binding(${e++}) var textureSource${i+1}: texture_2d<f32>;`),t.push(`@group(1) @binding(${e++}) var textureSampler${i+1}: sampler;`)}return t.join(` +`)}function bc(s){const t=[];if(s===1)t.push("outColor = textureSampleGrad(textureSource1, textureSampler1, vUV, uvDx, uvDy);");else{t.push("switch vTextureId {");for(let e=0;e<s;e++)e===s-1?t.push(" default:{"):t.push(` case ${e}:{`),t.push(` outColor = textureSampleGrad(textureSource${e+1}, textureSampler${e+1}, vUV, uvDx, uvDy);`),t.push(" break;}");t.push("}")}return t.join(` +`)}function wc(s){return Qs[s]||(Qs[s]={name:"texture-batch-bit",vertex:{header:` + @in aTextureIdAndRound: vec2<u32>; + @out @interpolate(flat) vTextureId : u32; + `,main:` + vTextureId = aTextureIdAndRound.y; + `,end:` + if(aTextureIdAndRound.x == 1) + { + vPosition = vec4<f32>(roundPixels(vPosition.xy, globalUniforms.uResolution), vPosition.zw); + } + `},fragment:{header:` + @in @interpolate(flat) vTextureId: u32; + + ${xc(s)} + `,main:` + var uvDx = dpdx(vUV); + var uvDy = dpdy(vUV); + + ${bc(s)} + `}}),Qs[s]}const Zs={};function vc(s){const t=[];for(let e=0;e<s;e++)e>0&&t.push("else"),e<s-1&&t.push(`if(vTextureId < ${e}.5)`),t.push("{"),t.push(` outColor = texture(uTextures[${e}], vUV);`),t.push("}");return t.join(` +`)}function Ac(s){return Zs[s]||(Zs[s]={name:"texture-batch-bit",vertex:{header:` + in vec2 aTextureIdAndRound; + out float vTextureId; + + `,main:` + vTextureId = aTextureIdAndRound.y; + `,end:` + if(aTextureIdAndRound.x == 1.) + { + gl_Position.xy = roundPixels(gl_Position.xy, uResolution); + } + `},fragment:{header:` + in float vTextureId; + + uniform sampler2D uTextures[${s}]; + + `,main:` + + ${vc(s)} + `}}),Zs[s]}const Sc={name:"round-pixels-bit",vertex:{header:` + fn roundPixels(position: vec2<f32>, targetSize: vec2<f32>) -> vec2<f32> + { + return (floor(((position * 0.5 + 0.5) * targetSize) + 0.5) / targetSize) * 2.0 - 1.0; + } + `}},Cc={name:"round-pixels-bit",vertex:{header:` + vec2 roundPixels(vec2 position, vec2 targetSize) + { + return (floor(((position * 0.5 + 0.5) * targetSize) + 0.5) / targetSize) * 2.0 - 1.0; + } + `}},Gr={};function Tc(s){let t=Gr[s];if(t)return t;const e=new Int32Array(s);for(let i=0;i<s;i++)e[i]=i;return t=Gr[s]=new to({uTextures:{value:e,type:"i32",size:s}},{isStatic:!0}),t}class Dr extends Fi{constructor(t){const e=gc({name:"batch",bits:[yc,Ac(t),Cc]}),i=mc({name:"batch",bits:[_c,wc(t),Sc]});super({glProgram:e,gpuProgram:i,resources:{batchSamplers:Tc(t)}}),this.maxTextures=t}}let Le=null;const Co=class To extends Xl{constructor(t){super(t),this.geometry=new tc,this.name=To.extension.name,this.vertexSize=6,Le??(Le=new Dr(t.maxTextures)),this.shader=Le}packAttributes(t,e,i,r,n){const o=n<<16|t.roundPixels&65535,a=t.transform,h=a.a,l=a.b,c=a.c,u=a.d,f=a.tx,d=a.ty,{positions:p,uvs:g}=t,m=t.color,_=t.attributeOffset,y=_+t.attributeSize;for(let x=_;x<y;x++){const w=x*2,v=p[w],b=p[w+1];e[r++]=h*v+c*b+f,e[r++]=u*b+l*v+d,e[r++]=g[w],e[r++]=g[w+1],i[r++]=m,i[r++]=o}}packQuadAttributes(t,e,i,r,n){const o=t.texture,a=t.transform,h=a.a,l=a.b,c=a.c,u=a.d,f=a.tx,d=a.ty,p=t.bounds,g=p.maxX,m=p.minX,_=p.maxY,y=p.minY,x=o.uvs,w=t.color,v=n<<16|t.roundPixels&65535;e[r+0]=h*m+c*y+f,e[r+1]=u*y+l*m+d,e[r+2]=x.x0,e[r+3]=x.y0,i[r+4]=w,i[r+5]=v,e[r+6]=h*g+c*y+f,e[r+7]=u*y+l*g+d,e[r+8]=x.x1,e[r+9]=x.y1,i[r+10]=w,i[r+11]=v,e[r+12]=h*g+c*_+f,e[r+13]=u*_+l*g+d,e[r+14]=x.x2,e[r+15]=x.y2,i[r+16]=w,i[r+17]=v,e[r+18]=h*m+c*_+f,e[r+19]=u*_+l*m+d,e[r+20]=x.x3,e[r+21]=x.y3,i[r+22]=w,i[r+23]=v}_updateMaxTextures(t){this.shader.maxTextures!==t&&(Le=new Dr(t),this.shader=Le)}destroy(){this.shader=null,super.destroy()}};Co.extension={type:[I.Batcher],name:"default"};let Pc=Co;class Po{constructor(t){this.items=Object.create(null);const{renderer:e,type:i,onUnload:r,priority:n,name:o}=t;this._renderer=e,e.gc.addResourceHash(this,"items",i,n??0),this._onUnload=r,this.name=o}add(t){return this.items[t.uid]?!1:(this.items[t.uid]=t,t.once("unload",this.remove,this),t._gcLastUsed=this._renderer.gc.now,!0)}remove(t,...e){var r;if(!this.items[t.uid])return;const i=t._gpuData[this._renderer.uid];i&&((r=this._onUnload)==null||r.call(this,t,...e),i.destroy(),t._gpuData[this._renderer.uid]=null,this.items[t.uid]=null)}removeAll(...t){Object.values(this.items).forEach(e=>e&&this.remove(e,...t))}destroy(...t){this.removeAll(...t),this.items=Object.create(null),this._renderer=null,this._onUnload=null}}function Mc(s,t,e,i,r,n,o,a=null){let h=0;e*=t,r*=n;const l=a.a,c=a.b,u=a.c,f=a.d,d=a.tx,p=a.ty;for(;h<o;){const g=s[e],m=s[e+1];i[r]=l*g+u*m+d,i[r+1]=c*g+f*m+p,r+=n,e+=t,h++}}function kc(s,t,e,i){let r=0;for(t*=e;r<i;)s[t]=0,s[t+1]=0,t+=e,r++}function Mo(s,t,e,i,r){const n=t.a,o=t.b,a=t.c,h=t.d,l=t.tx,c=t.ty;e||(e=0),i||(i=2),r||(r=s.length/i-e);let u=e*i;for(let f=0;f<r;f++){const d=s[u],p=s[u+1];s[u]=n*d+a*p+l,s[u+1]=o*d+h*p+c,u+=i}}const Ec=new W;class ko{constructor(){this.packAsQuad=!1,this.batcherName="default",this.topology="triangle-list",this.applyTransform=!0,this.roundPixels=0,this._batcher=null,this._batch=null}get uvs(){return this.geometryData.uvs}get positions(){return this.geometryData.vertices}get indices(){return this.geometryData.indices}get blendMode(){return this.renderable&&this.applyTransform?this.renderable.groupBlendMode:"normal"}get color(){const t=this.baseColor,e=t>>16|t&65280|(t&255)<<16,i=this.renderable;return i?Mn(e,i.groupColor)+(this.alpha*i.groupAlpha*255<<24):e+(this.alpha*255<<24)}get transform(){var t;return((t=this.renderable)==null?void 0:t.groupTransform)||Ec}copyTo(t){t.indexOffset=this.indexOffset,t.indexSize=this.indexSize,t.attributeOffset=this.attributeOffset,t.attributeSize=this.attributeSize,t.baseColor=this.baseColor,t.alpha=this.alpha,t.texture=this.texture,t.geometryData=this.geometryData,t.topology=this.topology}reset(){this.applyTransform=!0,this.renderable=null,this.topology="triangle-list"}destroy(){this.renderable=null,this.texture=null,this.geometryData=null,this._batcher=null,this._batch=null}}const Ye={extension:{type:I.ShapeBuilder,name:"circle"},build(s,t){let e,i,r,n,o,a;if(s.type==="circle"){const w=s;if(o=a=w.radius,o<=0)return!1;e=w.x,i=w.y,r=n=0}else if(s.type==="ellipse"){const w=s;if(o=w.halfWidth,a=w.halfHeight,o<=0||a<=0)return!1;e=w.x,i=w.y,r=n=0}else{const w=s,v=w.width/2,b=w.height/2;e=w.x+v,i=w.y+b,o=a=Math.max(0,Math.min(w.radius,Math.min(v,b))),r=v-o,n=b-a}if(r<0||n<0)return!1;const h=Math.ceil(2.3*Math.sqrt(o+a)),l=h*8+(r?4:0)+(n?4:0);if(l===0)return!1;if(h===0)return t[0]=t[6]=e+r,t[1]=t[3]=i+n,t[2]=t[4]=e-r,t[5]=t[7]=i-n,!0;let c=0,u=h*4+(r?2:0)+2,f=u,d=l,p=r+o,g=n,m=e+p,_=e-p,y=i+g;if(t[c++]=m,t[c++]=y,t[--u]=y,t[--u]=_,n){const w=i-g;t[f++]=_,t[f++]=w,t[--d]=w,t[--d]=m}for(let w=1;w<h;w++){const v=Math.PI/2*(w/h),b=r+Math.cos(v)*o,A=n+Math.sin(v)*a,k=e+b,P=e-b,S=i+A,T=i-A;t[c++]=k,t[c++]=S,t[--u]=S,t[--u]=P,t[f++]=P,t[f++]=T,t[--d]=T,t[--d]=k}p=r,g=n+a,m=e+p,_=e-p,y=i+g;const x=i-g;return t[c++]=m,t[c++]=y,t[--d]=x,t[--d]=m,r&&(t[c++]=_,t[c++]=y,t[--d]=x,t[--d]=_),!0},triangulate(s,t,e,i,r,n){if(s.length===0)return;let o=0,a=0;for(let c=0;c<s.length;c+=2)o+=s[c],a+=s[c+1];o/=s.length/2,a/=s.length/2;let h=i;t[h*e]=o,t[h*e+1]=a;const l=h++;for(let c=0;c<s.length;c+=2)t[h*e]=s[c],t[h*e+1]=s[c+1],c>0&&(r[n++]=h,r[n++]=l,r[n++]=h-1),h++;r[n++]=l+1,r[n++]=l,r[n++]=h-1}},Ic={...Ye,extension:{...Ye.extension,name:"ellipse"}},Rc={...Ye,extension:{...Ye.extension,name:"roundedRectangle"}},Eo=1e-4,Or=1e-4;function Lc(s){const t=s.length;if(t<6)return 1;let e=0;for(let i=0,r=s[t-2],n=s[t-1];i<t;i+=2){const o=s[i],a=s[i+1];e+=(o-r)*(a+n),r=o,n=a}return e<0?-1:1}function Wr(s,t,e,i,r,n,o,a){const h=s-e*r,l=t-i*r,c=s+e*n,u=t+i*n;let f,d;o?(f=i,d=-e):(f=-i,d=e);const p=h+f,g=l+d,m=c+f,_=u+d;return a.push(p,g),a.push(m,_),2}function Yt(s,t,e,i,r,n,o,a){const h=e-s,l=i-t;let c=Math.atan2(h,l),u=Math.atan2(r-s,n-t);a&&c<u?c+=Math.PI*2:!a&&c>u&&(u+=Math.PI*2);let f=c;const d=u-c,p=Math.abs(d),g=Math.sqrt(h*h+l*l),m=(15*p*Math.sqrt(g)/Math.PI>>0)+1,_=d/m;if(f+=_,a){o.push(s,t),o.push(e,i);for(let y=1,x=f;y<m;y++,x+=_)o.push(s,t),o.push(s+Math.sin(x)*g,t+Math.cos(x)*g);o.push(s,t),o.push(r,n)}else{o.push(e,i),o.push(s,t);for(let y=1,x=f;y<m;y++,x+=_)o.push(s+Math.sin(x)*g,t+Math.cos(x)*g),o.push(s,t);o.push(r,n),o.push(s,t)}return m*2}function Bc(s,t,e,i,r,n){const o=Eo;if(s.length===0)return;const a=t;let h=a.alignment;if(t.alignment!==.5){let L=Lc(s);h=(h-.5)*L+.5}const l=new lt(s[0],s[1]),c=new lt(s[s.length-2],s[s.length-1]),u=i,f=Math.abs(l.x-c.x)<o&&Math.abs(l.y-c.y)<o;if(u){s=s.slice(),f&&(s.pop(),s.pop(),c.set(s[s.length-2],s[s.length-1]));const L=(l.x+c.x)*.5,H=(c.y+l.y)*.5;s.unshift(L,H),s.push(L,H)}const d=r,p=s.length/2;let g=s.length;const m=d.length/2,_=a.width/2,y=_*_,x=a.miterLimit*a.miterLimit;let w=s[0],v=s[1],b=s[2],A=s[3],k=0,P=0,S=-(v-A),T=w-b,M=0,R=0,B=Math.sqrt(S*S+T*T);S/=B,T/=B,S*=_,T*=_;const ht=h,C=(1-ht)*2,E=ht*2;u||(a.cap==="round"?g+=Yt(w-S*(C-E)*.5,v-T*(C-E)*.5,w-S*C,v-T*C,w+S*E,v+T*E,d,!0)+2:a.cap==="square"&&(g+=Wr(w,v,S,T,C,E,!0,d))),d.push(w-S*C,v-T*C),d.push(w+S*E,v+T*E);for(let L=1;L<p-1;++L){w=s[(L-1)*2],v=s[(L-1)*2+1],b=s[L*2],A=s[L*2+1],k=s[(L+1)*2],P=s[(L+1)*2+1],S=-(v-A),T=w-b,B=Math.sqrt(S*S+T*T),S/=B,T/=B,S*=_,T*=_,M=-(A-P),R=b-k,B=Math.sqrt(M*M+R*R),M/=B,R/=B,M*=_,R*=_;const H=b-w,V=v-A,D=b-k,et=P-A,ct=H*D+V*et,mt=V*D-et*H,it=mt<0;if(Math.abs(mt)<.001*Math.abs(ct)){d.push(b-S*C,A-T*C),d.push(b+S*E,A+T*E),ct>=0&&(a.join==="round"?g+=Yt(b,A,b-S*C,A-T*C,b-M*C,A-R*C,d,!1)+4:g+=2,d.push(b-M*E,A-R*E),d.push(b+M*C,A+R*C));continue}const kt=(-S+w)*(-T+A)-(-S+b)*(-T+v),zt=(-M+k)*(-R+A)-(-M+b)*(-R+P),re=(H*zt-D*kt)/mt,Ze=(et*kt-V*zt)/mt,Rs=(re-b)*(re-b)+(Ze-A)*(Ze-A),Ht=b+(re-b)*C,Nt=A+(Ze-A)*C,Vt=b-(re-b)*E,$t=A-(Ze-A)*E,sa=Math.min(H*H+V*V,D*D+et*et),$i=it?C:E,ia=sa+$i*$i*y;Rs<=ia?a.join==="bevel"||Rs/y>x?(it?(d.push(Ht,Nt),d.push(b+S*E,A+T*E),d.push(Ht,Nt),d.push(b+M*E,A+R*E)):(d.push(b-S*C,A-T*C),d.push(Vt,$t),d.push(b-M*C,A-R*C),d.push(Vt,$t)),g+=2):a.join==="round"?it?(d.push(Ht,Nt),d.push(b+S*E,A+T*E),g+=Yt(b,A,b+S*E,A+T*E,b+M*E,A+R*E,d,!0)+4,d.push(Ht,Nt),d.push(b+M*E,A+R*E)):(d.push(b-S*C,A-T*C),d.push(Vt,$t),g+=Yt(b,A,b-S*C,A-T*C,b-M*C,A-R*C,d,!1)+4,d.push(b-M*C,A-R*C),d.push(Vt,$t)):(d.push(Ht,Nt),d.push(Vt,$t)):(d.push(b-S*C,A-T*C),d.push(b+S*E,A+T*E),a.join==="round"?it?g+=Yt(b,A,b+S*E,A+T*E,b+M*E,A+R*E,d,!0)+2:g+=Yt(b,A,b-S*C,A-T*C,b-M*C,A-R*C,d,!1)+2:a.join==="miter"&&Rs/y<=x&&(it?(d.push(Vt,$t),d.push(Vt,$t)):(d.push(Ht,Nt),d.push(Ht,Nt)),g+=2),d.push(b-M*C,A-R*C),d.push(b+M*E,A+R*E),g+=2)}w=s[(p-2)*2],v=s[(p-2)*2+1],b=s[(p-1)*2],A=s[(p-1)*2+1],S=-(v-A),T=w-b,B=Math.sqrt(S*S+T*T),S/=B,T/=B,S*=_,T*=_,d.push(b-S*C,A-T*C),d.push(b+S*E,A+T*E),u||(a.cap==="round"?g+=Yt(b-S*(C-E)*.5,A-T*(C-E)*.5,b-S*C,A-T*C,b+S*E,A+T*E,d,!1)+2:a.cap==="square"&&(g+=Wr(b,A,S,T,C,E,!1,d)));const N=Or*Or;for(let L=m;L<g+m-2;++L)w=d[L*2],v=d[L*2+1],b=d[(L+1)*2],A=d[(L+1)*2+1],k=d[(L+2)*2],P=d[(L+2)*2+1],!(Math.abs(w*(A-P)+b*(P-v)+k*(v-A))<N)&&n.push(L,L+1,L+2)}function Fc(s,t,e,i){const r=Eo;if(s.length===0)return;const n=s[0],o=s[1],a=s[s.length-2],h=s[s.length-1],l=t||Math.abs(n-a)<r&&Math.abs(o-h)<r,c=e,u=s.length/2,f=c.length/2;for(let d=0;d<u;d++)c.push(s[d*2]),c.push(s[d*2+1]);for(let d=0;d<u-1;d++)i.push(f+d,f+d+1);l&&i.push(f+u-1,f)}function Io(s,t,e,i,r,n,o){const a=Kh(s,t,2);if(!a)return;for(let l=0;l<a.length;l+=3)n[o++]=a[l]+r,n[o++]=a[l+1]+r,n[o++]=a[l+2]+r;let h=r*i;for(let l=0;l<s.length;l+=2)e[h]=s[l],e[h+1]=s[l+1],h+=i}const Gc=[],Dc={extension:{type:I.ShapeBuilder,name:"polygon"},build(s,t){for(let e=0;e<s.points.length;e++)t[e]=s.points[e];return!0},triangulate(s,t,e,i,r,n){Io(s,Gc,t,e,i,r,n)}},Oc={extension:{type:I.ShapeBuilder,name:"rectangle"},build(s,t){const e=s,i=e.x,r=e.y,n=e.width,o=e.height;return n>0&&o>0?(t[0]=i,t[1]=r,t[2]=i+n,t[3]=r,t[4]=i+n,t[5]=r+o,t[6]=i,t[7]=r+o,!0):!1},triangulate(s,t,e,i,r,n){let o=0;i*=e,t[i+o]=s[0],t[i+o+1]=s[1],o+=e,t[i+o]=s[2],t[i+o+1]=s[3],o+=e,t[i+o]=s[6],t[i+o+1]=s[7],o+=e,t[i+o]=s[4],t[i+o+1]=s[5],o+=e;const a=i/e;r[n++]=a,r[n++]=a+1,r[n++]=a+2,r[n++]=a+1,r[n++]=a+3,r[n++]=a+2}},Wc={extension:{type:I.ShapeBuilder,name:"triangle"},build(s,t){return t[0]=s.x,t[1]=s.y,t[2]=s.x2,t[3]=s.y2,t[4]=s.x3,t[5]=s.y3,!0},triangulate(s,t,e,i,r,n){let o=0;i*=e,t[i+o]=s[0],t[i+o+1]=s[1],o+=e,t[i+o]=s[2],t[i+o+1]=s[3],o+=e,t[i+o]=s[4],t[i+o+1]=s[5];const a=i/e;r[n++]=a,r[n++]=a+1,r[n++]=a+2}},Ur=[{offset:0,color:"white"},{offset:1,color:"black"}],Wi=class Ai{constructor(...t){this.uid=J("fillGradient"),this._tick=0,this.type="linear",this.colorStops=[];let e=Uc(t);e={...e.type==="radial"?Ai.defaultRadialOptions:Ai.defaultLinearOptions,..._n(e)},this._textureSize=e.textureSize,this._wrapMode=e.wrapMode,e.type==="radial"?(this.center=e.center,this.outerCenter=e.outerCenter??this.center,this.innerRadius=e.innerRadius,this.outerRadius=e.outerRadius,this.scale=e.scale,this.rotation=e.rotation):(this.start=e.start,this.end=e.end),this.textureSpace=e.textureSpace,this.type=e.type,e.colorStops.forEach(r=>{this.addColorStop(r.offset,r.color)})}addColorStop(t,e){return this.colorStops.push({offset:t,color:q.shared.setValue(e).toHexa()}),this}buildLinearGradient(){if(this.texture)return;let{x:t,y:e}=this.start,{x:i,y:r}=this.end,n=i-t,o=r-e;const a=n<0||o<0;if(this._wrapMode==="clamp-to-edge"){if(n<0){const m=t;t=i,i=m,n*=-1}if(o<0){const m=e;e=r,r=m,o*=-1}}const h=this.colorStops.length?this.colorStops:Ur,l=this._textureSize,{canvas:c,context:u}=Hr(l,1),f=a?u.createLinearGradient(this._textureSize,0,0,0):u.createLinearGradient(0,0,this._textureSize,0);zr(f,h),u.fillStyle=f,u.fillRect(0,0,l,1),this.texture=new U({source:new be({resource:c,addressMode:this._wrapMode})});const d=Math.sqrt(n*n+o*o),p=Math.atan2(o,n),g=new W;g.scale(d/l,1),g.rotate(p),g.translate(t,e),this.textureSpace==="local"&&g.scale(l,l),this.transform=g}buildGradient(){this.texture||this._tick++,this.type==="linear"?this.buildLinearGradient():this.buildRadialGradient()}buildRadialGradient(){if(this.texture)return;const t=this.colorStops.length?this.colorStops:Ur,e=this._textureSize,{canvas:i,context:r}=Hr(e,e),{x:n,y:o}=this.center,{x:a,y:h}=this.outerCenter,l=this.innerRadius,c=this.outerRadius,u=a-c,f=h-c,d=e/(c*2),p=(n-u)*d,g=(o-f)*d,m=r.createRadialGradient(p,g,l*d,(a-u)*d,(h-f)*d,c*d);zr(m,t),r.fillStyle=t[t.length-1].color,r.fillRect(0,0,e,e),r.fillStyle=m,r.translate(p,g),r.rotate(this.rotation),r.scale(1,this.scale),r.translate(-p,-g),r.fillRect(0,0,e,e),this.texture=new U({source:new be({resource:i,addressMode:this._wrapMode})});const _=new W;this.textureSpace==="local"?_.scale(2*c,2*c):_.scale(1/d,1/d),_.translate(u,f),this.transform=_}destroy(){var t;(t=this.texture)==null||t.destroy(!0),this.texture=null,this.transform=null,this.colorStops=[],this.start=null,this.end=null,this.center=null,this.outerCenter=null}get styleKey(){return`fill-gradient-${this.uid}-${this._tick}`}};Wi.defaultLinearOptions={start:{x:0,y:0},end:{x:0,y:1},colorStops:[],textureSpace:"local",type:"linear",textureSize:256,wrapMode:"clamp-to-edge"};Wi.defaultRadialOptions={center:{x:.5,y:.5},innerRadius:0,outerRadius:.5,colorStops:[],scale:1,rotation:0,textureSpace:"local",type:"radial",textureSize:256,wrapMode:"clamp-to-edge"};let Ft=Wi;function zr(s,t){for(let e=0;e<t.length;e++){const i=t[e];s.addColorStop(i.offset,i.color)}}function Hr(s,t){const e=z.get().createCanvas(s,t),i=e.getContext("2d");return{canvas:e,context:i}}function Uc(s){let t=s[0]??{};return(typeof t=="number"||s[1])&&(X("8.5.2","use options object instead"),t={type:"linear",start:{x:s[0],y:s[1]},end:{x:s[2],y:s[3]},textureSpace:s[4],textureSize:s[5]??Ft.defaultLinearOptions.textureSize}),t}const zc=new W,Hc=new tt;function Nc(s,t,e,i){const r=t.matrix?s.copyFrom(t.matrix).invert():s.identity();if(t.textureSpace==="local"){const o=e.getBounds(Hc);t.width&&o.pad(t.width);const{x:a,y:h}=o,l=1/o.width,c=1/o.height,u=-a*l,f=-h*c,d=r.a,p=r.b,g=r.c,m=r.d;r.a*=l,r.b*=l,r.c*=c,r.d*=c,r.tx=u*d+f*g+r.tx,r.ty=u*p+f*m+r.ty}else r.translate(t.texture.frame.x,t.texture.frame.y),r.scale(1/t.texture.source.width,1/t.texture.source.height);const n=t.texture.source.style;return!(t.fill instanceof Ft)&&n.addressMode==="clamp-to-edge"&&(n.addressMode="repeat",n.update()),i&&r.append(zc.copyFrom(i).invert()),r}const Es={};K.handleByMap(I.ShapeBuilder,Es);K.add(Oc,Dc,Wc,Ye,Ic,Rc);const Vc=new tt,$c=new W;function jc(s,t){const{geometryData:e,batches:i}=t;i.length=0,e.indices.length=0,e.vertices.length=0,e.uvs.length=0;for(let r=0;r<s.instructions.length;r++){const n=s.instructions[r];if(n.action==="texture")Yc(n.data,i,e);else if(n.action==="fill"||n.action==="stroke"){const o=n.action==="stroke",a=n.data.path.shapePath,h=n.data.style,l=n.data.hole;o&&l&&Nr(l.shapePath,h,!0,i,e),l&&(a.shapePrimitives[a.shapePrimitives.length-1].holes=l.shapePath.shapePrimitives),Nr(a,h,o,i,e)}}}function Yc(s,t,e){const i=[],r=Es.rectangle,n=Vc;n.x=s.dx,n.y=s.dy,n.width=s.dw,n.height=s.dh;const o=s.transform;if(!r.build(n,i))return;const{vertices:a,uvs:h,indices:l}=e,c=l.length,u=a.length/2;o&&Mo(i,o),r.triangulate(i,a,2,u,l,c);const f=s.image,d=f.uvs;h.push(d.x0,d.y0,d.x1,d.y1,d.x3,d.y3,d.x2,d.y2);const p=At.get(ko);p.indexOffset=c,p.indexSize=l.length-c,p.attributeOffset=u,p.attributeSize=a.length/2-u,p.baseColor=s.style,p.alpha=s.alpha,p.texture=f,p.geometryData=e,t.push(p)}function Nr(s,t,e,i,r){const{vertices:n,uvs:o,indices:a}=r;s.shapePrimitives.forEach(({shape:h,transform:l,holes:c})=>{const u=[],f=Es[h.type];if(!f.build(h,u))return;const d=a.length,p=n.length/2;let g="triangle-list";if(l&&Mo(u,l),e){const x=h.closePath??!0,w=t;w.pixelLine?(Fc(u,x,n,a),g="line-list"):Bc(u,w,!1,x,n,a)}else if(c){const x=[],w=u.slice();Xc(c).forEach(b=>{x.push(w.length/2),w.push(...b)}),Io(w,x,n,2,p,a,d)}else f.triangulate(u,n,2,p,a,d);const m=o.length/2,_=t.texture;if(_!==U.WHITE){const x=Nc($c,t,h,l);Mc(n,2,p,o,m,2,n.length/2-p,x)}else kc(o,m,2,n.length/2-p);const y=At.get(ko);y.indexOffset=d,y.indexSize=a.length-d,y.attributeOffset=p,y.attributeSize=n.length/2-p,y.baseColor=t.color,y.alpha=t.alpha,y.texture=_,y.geometryData=r,y.topology=g,i.push(y)})}function Xc(s){const t=[];for(let e=0;e<s.length;e++){const i=s[e].shape,r=[];Es[i.type].build(i,r)&&t.push(r)}return t}class qc{constructor(){this.batches=[],this.geometryData={vertices:[],uvs:[],indices:[]}}reset(){this.batches&&this.batches.forEach(t=>{At.return(t)}),this.graphicsData&&At.return(this.graphicsData),this.isBatchable=!1,this.context=null,this.batches.length=0,this.geometryData.indices.length=0,this.geometryData.vertices.length=0,this.geometryData.uvs.length=0,this.graphicsData=null}destroy(){this.reset(),this.batches=null,this.geometryData=null}}class Kc{constructor(){this.instructions=new Rn}init(t){const e=t.maxTextures;this.batcher?this.batcher._updateMaxTextures(e):this.batcher=new Pc({maxTextures:e}),this.instructions.reset()}get geometry(){return X(xa,"GraphicsContextRenderData#geometry is deprecated, please use batcher.geometry instead."),this.batcher.geometry}destroy(){this.batcher.destroy(),this.instructions.destroy(),this.batcher=null,this.instructions=null}}const Ui=class Si{constructor(t){this._renderer=t,this._managedContexts=new Po({renderer:t,type:"resource",name:"graphicsContext"})}init(t){Si.defaultOptions.bezierSmoothness=(t==null?void 0:t.bezierSmoothness)??Si.defaultOptions.bezierSmoothness}getContextRenderData(t){return t._gpuData[this._renderer.uid].graphicsData||this._initContextRenderData(t)}updateGpuContext(t){const e=!!t._gpuData[this._renderer.uid],i=t._gpuData[this._renderer.uid]||this._initContext(t);if(t.dirty||!e){e&&i.reset(),jc(t,i);const r=t.batchMode;t.customShader||r==="no-batch"?i.isBatchable=!1:r==="auto"?i.isBatchable=i.geometryData.vertices.length<400:i.isBatchable=!0,t.dirty=!1}return i}getGpuContext(t){return t._gpuData[this._renderer.uid]||this._initContext(t)}_initContextRenderData(t){const e=At.get(Kc,{maxTextures:this._renderer.limits.maxBatchableTextures}),i=t._gpuData[this._renderer.uid],{batches:r,geometryData:n}=i;i.graphicsData=e;const o=n.vertices.length,a=n.indices.length;for(let u=0;u<r.length;u++)r[u].applyTransform=!1;const h=e.batcher;h.ensureAttributeBuffer(o),h.ensureIndexBuffer(a),h.begin();for(let u=0;u<r.length;u++){const f=r[u];h.add(f)}h.finish(e.instructions);const l=h.geometry;l.indexBuffer.setDataWithSize(h.indexBuffer,h.indexSize,!0),l.buffers[0].setDataWithSize(h.attributeBuffer.float32View,h.attributeSize,!0);const c=h.batches;for(let u=0;u<c.length;u++){const f=c[u];f.bindGroup=Ol(f.textures.textures,f.textures.count,this._renderer.limits.maxBatchableTextures)}return e}_initContext(t){const e=new qc;return e.context=t,t._gpuData[this._renderer.uid]=e,this._managedContexts.add(t),e}destroy(){this._managedContexts.destroy(),this._renderer=null}};Ui.extension={type:[I.WebGLSystem,I.WebGPUSystem],name:"graphicsContext"};Ui.defaultOptions={bezierSmoothness:.5};let Ro=Ui;const Qc=8,us=11920929e-14,Zc=1;function Lo(s,t,e,i,r,n,o,a,h,l){const u=Math.min(.99,Math.max(0,l??Ro.defaultOptions.bezierSmoothness));let f=(Zc-u)/1;return f*=f,Jc(t,e,i,r,n,o,a,h,s,f),s}function Jc(s,t,e,i,r,n,o,a,h,l){Ci(s,t,e,i,r,n,o,a,h,l,0),h.push(o,a)}function Ci(s,t,e,i,r,n,o,a,h,l,c){if(c>Qc)return;const u=(s+e)/2,f=(t+i)/2,d=(e+r)/2,p=(i+n)/2,g=(r+o)/2,m=(n+a)/2,_=(u+d)/2,y=(f+p)/2,x=(d+g)/2,w=(p+m)/2,v=(_+x)/2,b=(y+w)/2;if(c>0){let A=o-s,k=a-t;const P=Math.abs((e-o)*k-(i-a)*A),S=Math.abs((r-o)*k-(n-a)*A);if(P>us&&S>us){if((P+S)*(P+S)<=l*(A*A+k*k)){h.push(v,b);return}}else if(P>us){if(P*P<=l*(A*A+k*k)){h.push(v,b);return}}else if(S>us){if(S*S<=l*(A*A+k*k)){h.push(v,b);return}}else if(A=v-(s+o)/2,k=b-(t+a)/2,A*A+k*k<=l){h.push(v,b);return}}Ci(s,t,u,f,_,y,v,b,h,l,c+1),Ci(v,b,x,w,g,m,o,a,h,l,c+1)}const tu=8,eu=11920929e-14,su=1;function iu(s,t,e,i,r,n,o,a){const l=Math.min(.99,Math.max(0,a??Ro.defaultOptions.bezierSmoothness));let c=(su-l)/1;return c*=c,ru(t,e,i,r,n,o,s,c),s}function ru(s,t,e,i,r,n,o,a){Ti(o,s,t,e,i,r,n,a,0),o.push(r,n)}function Ti(s,t,e,i,r,n,o,a,h){if(h>tu)return;const l=(t+i)/2,c=(e+r)/2,u=(i+n)/2,f=(r+o)/2,d=(l+u)/2,p=(c+f)/2;let g=n-t,m=o-e;const _=Math.abs((i-n)*m-(r-o)*g);if(_>eu){if(_*_<=a*(g*g+m*m)){s.push(d,p);return}}else if(g=d-(t+n)/2,m=p-(e+o)/2,g*g+m*m<=a){s.push(d,p);return}Ti(s,t,e,l,c,d,p,a,h+1),Ti(s,d,p,u,f,n,o,a,h+1)}function Bo(s,t,e,i,r,n,o,a){let h=Math.abs(r-n);(!o&&r>n||o&&n>r)&&(h=2*Math.PI-h),a||(a=Math.max(6,Math.floor(6*Math.pow(i,1/3)*(h/Math.PI)))),a=Math.max(a,3);let l=h/a,c=r;l*=o?-1:1;for(let u=0;u<a+1;u++){const f=Math.cos(c),d=Math.sin(c),p=t+f*i,g=e+d*i;s.push(p,g),c+=l}}function nu(s,t,e,i,r,n){const o=s[s.length-2],h=s[s.length-1]-e,l=o-t,c=r-e,u=i-t,f=Math.abs(h*u-l*c);if(f<1e-8||n===0){(s[s.length-2]!==t||s[s.length-1]!==e)&&s.push(t,e);return}const d=h*h+l*l,p=c*c+u*u,g=h*c+l*u,m=n*Math.sqrt(d)/f,_=n*Math.sqrt(p)/f,y=m*g/d,x=_*g/p,w=m*u+_*l,v=m*c+_*h,b=l*(_+y),A=h*(_+y),k=u*(m+x),P=c*(m+x),S=Math.atan2(A-v,b-w),T=Math.atan2(P-v,k-w);Bo(s,w+t,v+e,n,S,T,l*c>u*h)}const Ue=Math.PI*2,Js={centerX:0,centerY:0,ang1:0,ang2:0},ti=({x:s,y:t},e,i,r,n,o,a,h)=>{s*=e,t*=i;const l=r*s-n*t,c=n*s+r*t;return h.x=l+o,h.y=c+a,h};function ou(s,t){const e=t===-1.5707963267948966?-.551915024494:1.3333333333333333*Math.tan(t/4),i=t===1.5707963267948966?.551915024494:e,r=Math.cos(s),n=Math.sin(s),o=Math.cos(s+t),a=Math.sin(s+t);return[{x:r-n*i,y:n+r*i},{x:o+a*i,y:a-o*i},{x:o,y:a}]}const Vr=(s,t,e,i)=>{const r=s*i-t*e<0?-1:1;let n=s*e+t*i;return n>1&&(n=1),n<-1&&(n=-1),r*Math.acos(n)},au=(s,t,e,i,r,n,o,a,h,l,c,u,f)=>{const d=Math.pow(r,2),p=Math.pow(n,2),g=Math.pow(c,2),m=Math.pow(u,2);let _=d*p-d*m-p*g;_<0&&(_=0),_/=d*m+p*g,_=Math.sqrt(_)*(o===a?-1:1);const y=_*r/n*u,x=_*-n/r*c,w=l*y-h*x+(s+e)/2,v=h*y+l*x+(t+i)/2,b=(c-y)/r,A=(u-x)/n,k=(-c-y)/r,P=(-u-x)/n,S=Vr(1,0,b,A);let T=Vr(b,A,k,P);a===0&&T>0&&(T-=Ue),a===1&&T<0&&(T+=Ue),f.centerX=w,f.centerY=v,f.ang1=S,f.ang2=T};function hu(s,t,e,i,r,n,o,a=0,h=0,l=0){if(n===0||o===0)return;const c=Math.sin(a*Ue/360),u=Math.cos(a*Ue/360),f=u*(t-i)/2+c*(e-r)/2,d=-c*(t-i)/2+u*(e-r)/2;if(f===0&&d===0)return;n=Math.abs(n),o=Math.abs(o);const p=Math.pow(f,2)/Math.pow(n,2)+Math.pow(d,2)/Math.pow(o,2);p>1&&(n*=Math.sqrt(p),o*=Math.sqrt(p)),au(t,e,i,r,n,o,h,l,c,u,f,d,Js);let{ang1:g,ang2:m}=Js;const{centerX:_,centerY:y}=Js;let x=Math.abs(m)/(Ue/4);Math.abs(1-x)<1e-7&&(x=1);const w=Math.max(Math.ceil(x),1);m/=w;let v=s[s.length-2],b=s[s.length-1];const A={x:0,y:0};for(let k=0;k<w;k++){const P=ou(g,m),{x:S,y:T}=ti(P[0],n,o,u,c,_,y,A),{x:M,y:R}=ti(P[1],n,o,u,c,_,y,A),{x:B,y:ht}=ti(P[2],n,o,u,c,_,y,A);Lo(s,v,b,S,T,M,R,B,ht),v=B,b=ht,g+=m}}function lu(s,t,e){const i=(o,a)=>{const h=a.x-o.x,l=a.y-o.y,c=Math.sqrt(h*h+l*l),u=h/c,f=l/c;return{len:c,nx:u,ny:f}},r=(o,a)=>{o===0?s.moveTo(a.x,a.y):s.lineTo(a.x,a.y)};let n=t[t.length-1];for(let o=0;o<t.length;o++){const a=t[o%t.length],h=a.radius??e;if(h<=0){r(o,a),n=a;continue}const l=t[(o+1)%t.length],c=i(a,n),u=i(a,l);if(c.len<1e-4||u.len<1e-4){r(o,a),n=a;continue}let f=Math.asin(c.nx*u.ny-c.ny*u.nx),d=1,p=!1;c.nx*u.nx-c.ny*-u.ny<0?f<0?f=Math.PI+f:(f=Math.PI-f,d=-1,p=!0):f>0&&(d=-1,p=!0);const g=f/2;let m,_=Math.abs(Math.cos(g)*h/Math.sin(g));_>Math.min(c.len/2,u.len/2)?(_=Math.min(c.len/2,u.len/2),m=Math.abs(_*Math.sin(g)/Math.cos(g))):m=h;const y=a.x+u.nx*_+-u.ny*m*d,x=a.y+u.ny*_+u.nx*m*d,w=Math.atan2(c.ny,c.nx)+Math.PI/2*d,v=Math.atan2(u.ny,u.nx)-Math.PI/2*d;o===0&&s.moveTo(y+Math.cos(w)*m,x+Math.sin(w)*m),s.arc(y,x,m,w,v,p),n=a}}function cu(s,t,e,i){const r=(a,h)=>Math.sqrt((a.x-h.x)**2+(a.y-h.y)**2),n=(a,h,l)=>({x:a.x+(h.x-a.x)*l,y:a.y+(h.y-a.y)*l}),o=t.length;for(let a=0;a<o;a++){const h=t[(a+1)%o],l=h.radius??e;if(l<=0){a===0?s.moveTo(h.x,h.y):s.lineTo(h.x,h.y);continue}const c=t[a],u=t[(a+2)%o],f=r(c,h);let d;if(f<1e-4)d=h;else{const m=Math.min(f/2,l);d=n(h,c,m/f)}const p=r(u,h);let g;if(p<1e-4)g=h;else{const m=Math.min(p/2,l);g=n(h,u,m/p)}a===0?s.moveTo(d.x,d.y):s.lineTo(d.x,d.y),s.quadraticCurveTo(h.x,h.y,g.x,g.y,i)}}const uu=new tt;class du{constructor(t){this.shapePrimitives=[],this._currentPoly=null,this._bounds=new vt,this._graphicsPath2D=t,this.signed=t.checkForHoles}moveTo(t,e){return this.startPoly(t,e),this}lineTo(t,e){this._ensurePoly();const i=this._currentPoly.points,r=i[i.length-2],n=i[i.length-1];return(r!==t||n!==e)&&i.push(t,e),this}arc(t,e,i,r,n,o){this._ensurePoly(!1);const a=this._currentPoly.points;return Bo(a,t,e,i,r,n,o),this}arcTo(t,e,i,r,n){this._ensurePoly();const o=this._currentPoly.points;return nu(o,t,e,i,r,n),this}arcToSvg(t,e,i,r,n,o,a){const h=this._currentPoly.points;return hu(h,this._currentPoly.lastX,this._currentPoly.lastY,o,a,t,e,i,r,n),this}bezierCurveTo(t,e,i,r,n,o,a){this._ensurePoly();const h=this._currentPoly;return Lo(this._currentPoly.points,h.lastX,h.lastY,t,e,i,r,n,o,a),this}quadraticCurveTo(t,e,i,r,n){this._ensurePoly();const o=this._currentPoly;return iu(this._currentPoly.points,o.lastX,o.lastY,t,e,i,r,n),this}closePath(){return this.endPoly(!0),this}addPath(t,e){this.endPoly(),e&&!e.isIdentity()&&(t=t.clone(!0),t.transform(e));const i=this.shapePrimitives,r=i.length;for(let n=0;n<t.instructions.length;n++){const o=t.instructions[n];this[o.action](...o.data)}if(t.checkForHoles&&i.length-r>1){let n=null;for(let o=r;o<i.length;o++){const a=i[o];if(a.shape.type==="polygon"){const h=a.shape,l=n==null?void 0:n.shape;l&&l.containsPolygon(h)?(n.holes||(n.holes=[]),n.holes.push(a),i.copyWithin(o,o+1),i.length--,o--):n=a}}}return this}finish(t=!1){this.endPoly(t)}rect(t,e,i,r,n){return this.drawShape(new tt(t,e,i,r),n),this}circle(t,e,i,r){return this.drawShape(new Gi(t,e,i),r),this}poly(t,e,i){const r=new Oe(t);return r.closePath=e,this.drawShape(r,i),this}regularPoly(t,e,i,r,n=0,o){r=Math.max(r|0,3);const a=-1*Math.PI/2+n,h=Math.PI*2/r,l=[];for(let c=0;c<r;c++){const u=a-c*h;l.push(t+i*Math.cos(u),e+i*Math.sin(u))}return this.poly(l,!0,o),this}roundPoly(t,e,i,r,n,o=0,a){if(r=Math.max(r|0,3),n<=0)return this.regularPoly(t,e,i,r,o);const h=i*Math.sin(Math.PI/r)-.001;n=Math.min(n,h);const l=-1*Math.PI/2+o,c=Math.PI*2/r,u=(r-2)*Math.PI/r/2;for(let f=0;f<r;f++){const d=f*c+l,p=t+i*Math.cos(d),g=e+i*Math.sin(d),m=d+Math.PI+u,_=d-Math.PI-u,y=p+n*Math.cos(m),x=g+n*Math.sin(m),w=p+n*Math.cos(_),v=g+n*Math.sin(_);f===0?this.moveTo(y,x):this.lineTo(y,x),this.quadraticCurveTo(p,g,w,v,a)}return this.closePath()}roundShape(t,e,i=!1,r){return t.length<3?this:(i?cu(this,t,e,r):lu(this,t,e),this.closePath())}filletRect(t,e,i,r,n){if(n===0)return this.rect(t,e,i,r);const o=Math.min(i,r)/2,a=Math.min(o,Math.max(-o,n)),h=t+i,l=e+r,c=a<0?-a:0,u=Math.abs(a);return this.moveTo(t,e+u).arcTo(t+c,e+c,t+u,e,u).lineTo(h-u,e).arcTo(h-c,e+c,h,e+u,u).lineTo(h,l-u).arcTo(h-c,l-c,t+i-u,l,u).lineTo(t+u,l).arcTo(t+c,l-c,t,l-u,u).closePath()}chamferRect(t,e,i,r,n,o){if(n<=0)return this.rect(t,e,i,r);const a=Math.min(n,Math.min(i,r)/2),h=t+i,l=e+r,c=[t+a,e,h-a,e,h,e+a,h,l-a,h-a,l,t+a,l,t,l-a,t,e+a];for(let u=c.length-1;u>=2;u-=2)c[u]===c[u-2]&&c[u-1]===c[u-3]&&c.splice(u-1,2);return this.poly(c,!0,o)}ellipse(t,e,i,r,n){return this.drawShape(new Di(t,e,i,r),n),this}roundRect(t,e,i,r,n,o){return this.drawShape(new Oi(t,e,i,r,n),o),this}drawShape(t,e){return this.endPoly(),this.shapePrimitives.push({shape:t,transform:e}),this}startPoly(t,e){let i=this._currentPoly;return i&&this.endPoly(),i=new Oe,i.points.push(t,e),this._currentPoly=i,this}endPoly(t=!1){const e=this._currentPoly;return e&&e.points.length>2&&(e.closePath=t,this.shapePrimitives.push({shape:e})),this._currentPoly=null,this}_ensurePoly(t=!0){if(!this._currentPoly&&(this._currentPoly=new Oe,t)){const e=this.shapePrimitives[this.shapePrimitives.length-1];if(e){let i=e.shape.x,r=e.shape.y;if(e.transform&&!e.transform.isIdentity()){const n=e.transform,o=i;i=n.a*i+n.c*r+n.tx,r=n.b*o+n.d*r+n.ty}this._currentPoly.points.push(i,r)}else this._currentPoly.points.push(0,0)}}buildPath(){const t=this._graphicsPath2D;this.shapePrimitives.length=0,this._currentPoly=null;for(let e=0;e<t.instructions.length;e++){const i=t.instructions[e];this[i.action](...i.data)}this.finish()}get bounds(){const t=this._bounds;t.clear();const e=this.shapePrimitives;for(let i=0;i<e.length;i++){const r=e[i],n=r.shape.getBounds(uu);r.transform?t.addRect(n,r.transform):t.addRect(n)}return t}}class Bt{constructor(t,e=!1){this.instructions=[],this.uid=J("graphicsPath"),this._dirty=!0,this.checkForHoles=e,typeof t=="string"?Bl(t,this):this.instructions=(t==null?void 0:t.slice())??[]}get shapePath(){return this._shapePath||(this._shapePath=new du(this)),this._dirty&&(this._dirty=!1,this._shapePath.buildPath()),this._shapePath}addPath(t,e){return t=t.clone(),this.instructions.push({action:"addPath",data:[t,e]}),this._dirty=!0,this}arc(...t){return this.instructions.push({action:"arc",data:t}),this._dirty=!0,this}arcTo(...t){return this.instructions.push({action:"arcTo",data:t}),this._dirty=!0,this}arcToSvg(...t){return this.instructions.push({action:"arcToSvg",data:t}),this._dirty=!0,this}bezierCurveTo(...t){return this.instructions.push({action:"bezierCurveTo",data:t}),this._dirty=!0,this}bezierCurveToShort(t,e,i,r,n){const o=this.instructions[this.instructions.length-1],a=this.getLastPoint(lt.shared);let h=0,l=0;if(!o||o.action!=="bezierCurveTo")h=a.x,l=a.y;else{h=o.data[2],l=o.data[3];const c=a.x,u=a.y;h=c+(c-h),l=u+(u-l)}return this.instructions.push({action:"bezierCurveTo",data:[h,l,t,e,i,r,n]}),this._dirty=!0,this}closePath(){return this.instructions.push({action:"closePath",data:[]}),this._dirty=!0,this}ellipse(...t){return this.instructions.push({action:"ellipse",data:t}),this._dirty=!0,this}lineTo(...t){return this.instructions.push({action:"lineTo",data:t}),this._dirty=!0,this}moveTo(...t){return this.instructions.push({action:"moveTo",data:t}),this}quadraticCurveTo(...t){return this.instructions.push({action:"quadraticCurveTo",data:t}),this._dirty=!0,this}quadraticCurveToShort(t,e,i){const r=this.instructions[this.instructions.length-1],n=this.getLastPoint(lt.shared);let o=0,a=0;if(!r||r.action!=="quadraticCurveTo")o=n.x,a=n.y;else{o=r.data[0],a=r.data[1];const h=n.x,l=n.y;o=h+(h-o),a=l+(l-a)}return this.instructions.push({action:"quadraticCurveTo",data:[o,a,t,e,i]}),this._dirty=!0,this}rect(t,e,i,r,n){return this.instructions.push({action:"rect",data:[t,e,i,r,n]}),this._dirty=!0,this}circle(t,e,i,r){return this.instructions.push({action:"circle",data:[t,e,i,r]}),this._dirty=!0,this}roundRect(...t){return this.instructions.push({action:"roundRect",data:t}),this._dirty=!0,this}poly(...t){return this.instructions.push({action:"poly",data:t}),this._dirty=!0,this}regularPoly(...t){return this.instructions.push({action:"regularPoly",data:t}),this._dirty=!0,this}roundPoly(...t){return this.instructions.push({action:"roundPoly",data:t}),this._dirty=!0,this}roundShape(...t){return this.instructions.push({action:"roundShape",data:t}),this._dirty=!0,this}filletRect(...t){return this.instructions.push({action:"filletRect",data:t}),this._dirty=!0,this}chamferRect(...t){return this.instructions.push({action:"chamferRect",data:t}),this._dirty=!0,this}star(t,e,i,r,n,o,a){n||(n=r/2);const h=-1*Math.PI/2+o,l=i*2,c=Math.PI*2/l,u=[];for(let f=0;f<l;f++){const d=f%2?n:r,p=f*c+h;u.push(t+d*Math.cos(p),e+d*Math.sin(p))}return this.poly(u,!0,a),this}clone(t=!1){const e=new Bt;if(e.checkForHoles=this.checkForHoles,!t)e.instructions=this.instructions.slice();else for(let i=0;i<this.instructions.length;i++){const r=this.instructions[i];e.instructions.push({action:r.action,data:r.data.slice()})}return e}clear(){return this.instructions.length=0,this._dirty=!0,this}transform(t){if(t.isIdentity())return this;const e=t.a,i=t.b,r=t.c,n=t.d,o=t.tx,a=t.ty;let h=0,l=0,c=0,u=0,f=0,d=0,p=0,g=0;for(let m=0;m<this.instructions.length;m++){const _=this.instructions[m],y=_.data;switch(_.action){case"moveTo":case"lineTo":h=y[0],l=y[1],y[0]=e*h+r*l+o,y[1]=i*h+n*l+a;break;case"bezierCurveTo":c=y[0],u=y[1],f=y[2],d=y[3],h=y[4],l=y[5],y[0]=e*c+r*u+o,y[1]=i*c+n*u+a,y[2]=e*f+r*d+o,y[3]=i*f+n*d+a,y[4]=e*h+r*l+o,y[5]=i*h+n*l+a;break;case"quadraticCurveTo":c=y[0],u=y[1],h=y[2],l=y[3],y[0]=e*c+r*u+o,y[1]=i*c+n*u+a,y[2]=e*h+r*l+o,y[3]=i*h+n*l+a;break;case"arcToSvg":h=y[5],l=y[6],p=y[0],g=y[1],y[0]=e*p+r*g,y[1]=i*p+n*g,y[5]=e*h+r*l+o,y[6]=i*h+n*l+a;break;case"circle":y[4]=ae(y[3],t);break;case"rect":y[4]=ae(y[4],t);break;case"ellipse":y[8]=ae(y[8],t);break;case"roundRect":y[5]=ae(y[5],t);break;case"addPath":y[0].transform(t);break;case"poly":y[2]=ae(y[2],t);break;case"regularPoly":case"chamferRect":y[5]=ae(y[5],t);break;case"closePath":break;default:Y("unknown transform action",_.action);break}}return this._dirty=!0,this}get bounds(){return this.shapePath.bounds}getLastPoint(t){let e=this.instructions.length-1,i=this.instructions[e];if(!i)return t.x=0,t.y=0,t;for(;i.action==="closePath";){if(e--,e<0)return t.x=0,t.y=0,t;i=this.instructions[e]}switch(i.action){case"moveTo":case"lineTo":t.x=i.data[0],t.y=i.data[1];break;case"quadraticCurveTo":t.x=i.data[2],t.y=i.data[3];break;case"bezierCurveTo":t.x=i.data[4],t.y=i.data[5];break;case"arc":case"arcToSvg":t.x=i.data[5],t.y=i.data[6];break;case"addPath":i.data[0].getLastPoint(t);break}return t}}function ae(s,t){return s?s.prepend(t):t.clone()}function Q(s,t,e){const i=s.getAttribute(t);return i?Number(i):e}function fu(s,t){const e=s.querySelectorAll("defs");for(let i=0;i<e.length;i++){const r=e[i];for(let n=0;n<r.children.length;n++){const o=r.children[n];switch(o.nodeName.toLowerCase()){case"lineargradient":t.defs[o.id]=pu(o);break;case"radialgradient":t.defs[o.id]=mu();break}}}}function pu(s){const t=Q(s,"x1",0),e=Q(s,"y1",0),i=Q(s,"x2",1),r=Q(s,"y2",0),n=s.getAttribute("gradientUnits")||"objectBoundingBox",o=new Ft(t,e,i,r,n==="objectBoundingBox"?"local":"global");for(let a=0;a<s.children.length;a++){const h=s.children[a],l=Q(h,"offset",0),c=q.shared.setValue(h.getAttribute("stop-color")).toNumber();o.addColorStop(l,c)}return o}function mu(s){return Y("[SVG Parser] Radial gradients are not yet supported"),new Ft(0,0,1,0)}function $r(s){const t=s.match(/url\s*\(\s*['"]?\s*#([^'"\s)]+)\s*['"]?\s*\)/i);return t?t[1]:""}const jr={fill:{type:"paint",default:0},"fill-opacity":{type:"number",default:1},stroke:{type:"paint",default:0},"stroke-width":{type:"number",default:1},"stroke-opacity":{type:"number",default:1},"stroke-linecap":{type:"string",default:"butt"},"stroke-linejoin":{type:"string",default:"miter"},"stroke-miterlimit":{type:"number",default:10},"stroke-dasharray":{type:"string",default:"none"},"stroke-dashoffset":{type:"number",default:0},opacity:{type:"number",default:1}};function Fo(s,t){const e=s.getAttribute("style"),i={},r={},n={strokeStyle:i,fillStyle:r,useFill:!1,useStroke:!1};for(const o in jr){const a=s.getAttribute(o);a&&Yr(t,n,o,a.trim())}if(e){const o=e.split(";");for(let a=0;a<o.length;a++){const h=o[a].trim(),[l,c]=h.split(":");jr[l]&&Yr(t,n,l,c.trim())}}return{strokeStyle:n.useStroke?i:null,fillStyle:n.useFill?r:null,useFill:n.useFill,useStroke:n.useStroke}}function Yr(s,t,e,i){switch(e){case"stroke":if(i!=="none"){if(i.startsWith("url(")){const r=$r(i);t.strokeStyle.fill=s.defs[r]}else t.strokeStyle.color=q.shared.setValue(i).toNumber();t.useStroke=!0}break;case"stroke-width":t.strokeStyle.width=Number(i);break;case"fill":if(i!=="none"){if(i.startsWith("url(")){const r=$r(i);t.fillStyle.fill=s.defs[r]}else t.fillStyle.color=q.shared.setValue(i).toNumber();t.useFill=!0}break;case"fill-opacity":t.fillStyle.alpha=Number(i);break;case"stroke-opacity":t.strokeStyle.alpha=Number(i);break;case"opacity":t.fillStyle.alpha=Number(i),t.strokeStyle.alpha=Number(i);break}}function gu(s){if(s.length<=2)return!0;const t=s.map(a=>a.area).sort((a,h)=>h-a),[e,i]=t,r=t[t.length-1],n=e/i,o=i/r;return!(n>3&&o<2)}function _u(s){return s.split(/(?=[Mm])/).filter(i=>i.trim().length>0)}function yu(s){const t=s.match(/[-+]?[0-9]*\.?[0-9]+/g);if(!t||t.length<4)return 0;const e=t.map(Number),i=[],r=[];for(let c=0;c<e.length;c+=2)c+1<e.length&&(i.push(e[c]),r.push(e[c+1]));if(i.length===0||r.length===0)return 0;const n=Math.min(...i),o=Math.max(...i),a=Math.min(...r),h=Math.max(...r);return(o-n)*(h-a)}function Xr(s,t){const e=new Bt(s,!1);for(const i of e.instructions)t.instructions.push(i)}function xu(s,t){if(typeof s=="string"){const o=document.createElement("div");o.innerHTML=s.trim(),s=o.querySelector("svg")}const e={context:t,defs:{},path:new Bt};fu(s,e);const i=s.children,{fillStyle:r,strokeStyle:n}=Fo(s,e);for(let o=0;o<i.length;o++){const a=i[o];a.nodeName.toLowerCase()!=="defs"&&Go(a,e,r,n)}return t}function Go(s,t,e,i){const r=s.children,{fillStyle:n,strokeStyle:o}=Fo(s,t);n&&e?e={...e,...n}:n&&(e=n),o&&i?i={...i,...o}:o&&(i=o);const a=!e&&!i;a&&(e={color:0});let h,l,c,u,f,d,p,g,m,_,y,x,w,v,b,A,k;switch(s.nodeName.toLowerCase()){case"path":{v=s.getAttribute("d");const P=s.getAttribute("fill-rule"),S=_u(v),T=P==="evenodd",M=S.length>1;if(T&&M){const B=S.map(C=>({path:C,area:yu(C)}));if(B.sort((C,E)=>E.area-C.area),S.length>3||!gu(B))for(let C=0;C<B.length;C++){const E=B[C],N=C===0;t.context.beginPath();const L=new Bt(void 0,!0);Xr(E.path,L),t.context.path(L),N?(e&&t.context.fill(e),i&&t.context.stroke(i)):t.context.cut()}else for(let C=0;C<B.length;C++){const E=B[C],N=C%2===1;t.context.beginPath();const L=new Bt(void 0,!0);Xr(E.path,L),t.context.path(L),N?t.context.cut():(e&&t.context.fill(e),i&&t.context.stroke(i))}}else{const B=P?P==="evenodd":!0;b=new Bt(v,B),t.context.path(b),e&&t.context.fill(e),i&&t.context.stroke(i)}break}case"circle":p=Q(s,"cx",0),g=Q(s,"cy",0),m=Q(s,"r",0),t.context.ellipse(p,g,m,m),e&&t.context.fill(e),i&&t.context.stroke(i);break;case"rect":h=Q(s,"x",0),l=Q(s,"y",0),A=Q(s,"width",0),k=Q(s,"height",0),_=Q(s,"rx",0),y=Q(s,"ry",0),_||y?t.context.roundRect(h,l,A,k,_||y):t.context.rect(h,l,A,k),e&&t.context.fill(e),i&&t.context.stroke(i);break;case"ellipse":p=Q(s,"cx",0),g=Q(s,"cy",0),_=Q(s,"rx",0),y=Q(s,"ry",0),t.context.beginPath(),t.context.ellipse(p,g,_,y),e&&t.context.fill(e),i&&t.context.stroke(i);break;case"line":c=Q(s,"x1",0),u=Q(s,"y1",0),f=Q(s,"x2",0),d=Q(s,"y2",0),t.context.beginPath(),t.context.moveTo(c,u),t.context.lineTo(f,d),i&&t.context.stroke(i);break;case"polygon":w=s.getAttribute("points"),x=w.match(/-?\d+/g).map(P=>parseInt(P,10)),t.context.poly(x,!0),e&&t.context.fill(e),i&&t.context.stroke(i);break;case"polyline":w=s.getAttribute("points"),x=w.match(/-?\d+/g).map(P=>parseInt(P,10)),t.context.poly(x,!1),i&&t.context.stroke(i);break;case"g":case"svg":break;default:{Y(`[SVG parser] <${s.nodeName}> elements unsupported`);break}}a&&(e=null);for(let P=0;P<r.length;P++)Go(r[P],t,e,i)}function bu(s){return s.texture!==void 0}const qr={repeat:{addressModeU:"repeat",addressModeV:"repeat"},"repeat-x":{addressModeU:"repeat",addressModeV:"clamp-to-edge"},"repeat-y":{addressModeU:"clamp-to-edge",addressModeV:"repeat"},"no-repeat":{addressModeU:"clamp-to-edge",addressModeV:"clamp-to-edge"}};class Is{constructor(t,e){this.uid=J("fillPattern"),this._tick=0,this.transform=new W;const i=bu(t)?t:{texture:t,repetition:e};this.texture=i.texture,this.textureSpace=i.textureSpace??"global";const r=i.repetition;r&&(this.texture.source.style.addressModeU=qr[r].addressModeU,this.texture.source.style.addressModeV=qr[r].addressModeV)}setTransform(t){if(t){if(this.transform.equals(t))return;this.transform.copyFrom(t)}else{if(this.transform.isIdentity())return;this.transform.identity()}this._tick++}get texture(){return this._texture}set texture(t){this._texture!==t&&(this._texture=t,this._tick++)}get styleKey(){return`fill-pattern-${this.uid}-${this._tick}`}destroy(){this.texture.destroy(!0),this.texture=null}}function wu(s){return q.isColorLike(s)}function Kr(s){return s instanceof Is}function Qr(s){return s instanceof Ft}function vu(s){return s instanceof U}function Au(s,t,e){const i=q.shared.setValue(t??0);return s.color=i.toNumber(),s.alpha=i.alpha===1?e.alpha:i.alpha,s.texture=U.WHITE,{...e,...s}}function Su(s,t,e){return s.texture=t,{...e,...s}}function Zr(s,t,e){return s.fill=t,s.color=16777215,s.texture=t.texture,s.matrix=t.transform,s.textureSpace=t.textureSpace,{...e,...s}}function Jr(s,t,e){return t.buildGradient(),s.fill=t,s.color=16777215,s.texture=t.texture,s.matrix=t.transform,s.textureSpace=t.textureSpace,{...e,...s}}function Cu(s,t){const e={...t,...s},i=q.shared.setValue(e.color);return e.alpha*=i.alpha,e.color=i.toNumber(),e}function se(s,t){if(s==null)return null;const e={},i=s;return wu(s)?Au(e,s,t):vu(s)?Su(e,s,t):Kr(s)?Zr(e,s,t):Qr(s)?Jr(e,s,t):i.fill&&Kr(i.fill)?Zr(i,i.fill,t):i.fill&&Qr(i.fill)?Jr(i,i.fill,t):Cu(i,t)}function bs(s,t){const{width:e,alignment:i,miterLimit:r,cap:n,join:o,pixelLine:a,...h}=t,l=se(s,h);return l?{width:e,alignment:i,miterLimit:r,cap:n,join:o,pixelLine:a,...l}:null}function Tu(s,t){let e=1;const i=s.shapePath.shapePrimitives;for(let r=0;r<i.length;r++){const n=i[r].shape;if(n.type!=="polygon")continue;const o=n.points,a=o.length;if(a<6)continue;const h=n.closePath;for(let l=0;l<a;l+=2){if(!h&&(l===0||l===a-2))continue;const c=(l-2+a)%a,u=(l+2)%a,f=o[c],d=o[c+1],p=o[l],g=o[l+1],m=o[u],_=o[u+1],y=f-p,x=d-g,w=m-p,v=_-g,b=y*y+x*x,A=w*w+v*v;if(b<1e-12||A<1e-12)continue;let S=(y*w+x*v)/Math.sqrt(b*A);S<-1?S=-1:S>1&&(S=1);const T=Math.sqrt((1-S)*.5);if(T<1e-6)continue;const M=Math.min(1/T,t);M>e&&(e=M)}}return e}const Pu=new lt,tn=new W,zi=class Mt extends ft{constructor(){super(...arguments),this._gpuData=Object.create(null),this.autoGarbageCollect=!0,this._gcLastUsed=-1,this.uid=J("graphicsContext"),this.dirty=!0,this.batchMode="auto",this.instructions=[],this.destroyed=!1,this._activePath=new Bt,this._transform=new W,this._fillStyle={...Mt.defaultFillStyle},this._strokeStyle={...Mt.defaultStrokeStyle},this._stateStack=[],this._tick=0,this._bounds=new vt,this._boundsDirty=!0}clone(){const t=new Mt;return t.batchMode=this.batchMode,t.instructions=this.instructions.slice(),t._activePath=this._activePath.clone(),t._transform=this._transform.clone(),t._fillStyle={...this._fillStyle},t._strokeStyle={...this._strokeStyle},t._stateStack=this._stateStack.slice(),t._bounds=this._bounds.clone(),t._boundsDirty=!0,t}get fillStyle(){return this._fillStyle}set fillStyle(t){this._fillStyle=se(t,Mt.defaultFillStyle)}get strokeStyle(){return this._strokeStyle}set strokeStyle(t){this._strokeStyle=bs(t,Mt.defaultStrokeStyle)}setFillStyle(t){return this._fillStyle=se(t,Mt.defaultFillStyle),this}setStrokeStyle(t){return this._strokeStyle=se(t,Mt.defaultStrokeStyle),this}texture(t,e,i,r,n,o){return this.instructions.push({action:"texture",data:{image:t,dx:i||0,dy:r||0,dw:n||t.frame.width,dh:o||t.frame.height,transform:this._transform.clone(),alpha:this._fillStyle.alpha,style:e||e===0?q.shared.setValue(e).toNumber():16777215}}),this.onUpdate(),this}beginPath(){return this._activePath=new Bt,this}fill(t,e){let i;const r=this.instructions[this.instructions.length-1];return this._tick===0&&(r==null?void 0:r.action)==="stroke"?i=r.data.path:i=this._activePath.clone(),i?(t!=null&&(e!==void 0&&typeof t=="number"&&(X(_t,"GraphicsContext.fill(color, alpha) is deprecated, use GraphicsContext.fill({ color, alpha }) instead"),t={color:t,alpha:e}),this._fillStyle=se(t,Mt.defaultFillStyle)),this.instructions.push({action:"fill",data:{style:this.fillStyle,path:i}}),this.onUpdate(),this._initNextPathLocation(),this._tick=0,this):this}_initNextPathLocation(){const{x:t,y:e}=this._activePath.getLastPoint(lt.shared);this._activePath.clear(),this._activePath.moveTo(t,e)}stroke(t){let e;const i=this.instructions[this.instructions.length-1];return this._tick===0&&(i==null?void 0:i.action)==="fill"?e=i.data.path:e=this._activePath.clone(),e?(t!=null&&(this._strokeStyle=bs(t,Mt.defaultStrokeStyle)),this.instructions.push({action:"stroke",data:{style:this.strokeStyle,path:e}}),this.onUpdate(),this._initNextPathLocation(),this._tick=0,this):this}cut(){for(let t=0;t<2;t++){const e=this.instructions[this.instructions.length-1-t],i=this._activePath.clone();if(e&&(e.action==="stroke"||e.action==="fill"))if(e.data.hole)e.data.hole.addPath(i);else{e.data.hole=i;break}}return this._initNextPathLocation(),this}arc(t,e,i,r,n,o){this._tick++;const a=this._transform;return this._activePath.arc(a.a*t+a.c*e+a.tx,a.b*t+a.d*e+a.ty,i,r,n,o),this}arcTo(t,e,i,r,n){this._tick++;const o=this._transform;return this._activePath.arcTo(o.a*t+o.c*e+o.tx,o.b*t+o.d*e+o.ty,o.a*i+o.c*r+o.tx,o.b*i+o.d*r+o.ty,n),this}arcToSvg(t,e,i,r,n,o,a){this._tick++;const h=this._transform;return this._activePath.arcToSvg(t,e,i,r,n,h.a*o+h.c*a+h.tx,h.b*o+h.d*a+h.ty),this}bezierCurveTo(t,e,i,r,n,o,a){this._tick++;const h=this._transform;return this._activePath.bezierCurveTo(h.a*t+h.c*e+h.tx,h.b*t+h.d*e+h.ty,h.a*i+h.c*r+h.tx,h.b*i+h.d*r+h.ty,h.a*n+h.c*o+h.tx,h.b*n+h.d*o+h.ty,a),this}closePath(){var t;return this._tick++,(t=this._activePath)==null||t.closePath(),this}ellipse(t,e,i,r){return this._tick++,this._activePath.ellipse(t,e,i,r,this._transform.clone()),this}circle(t,e,i){return this._tick++,this._activePath.circle(t,e,i,this._transform.clone()),this}path(t){return this._tick++,this._activePath.addPath(t,this._transform.clone()),this}lineTo(t,e){this._tick++;const i=this._transform;return this._activePath.lineTo(i.a*t+i.c*e+i.tx,i.b*t+i.d*e+i.ty),this}moveTo(t,e){this._tick++;const i=this._transform,r=this._activePath.instructions,n=i.a*t+i.c*e+i.tx,o=i.b*t+i.d*e+i.ty;return r.length===1&&r[0].action==="moveTo"?(r[0].data[0]=n,r[0].data[1]=o,this):(this._activePath.moveTo(n,o),this)}quadraticCurveTo(t,e,i,r,n){this._tick++;const o=this._transform;return this._activePath.quadraticCurveTo(o.a*t+o.c*e+o.tx,o.b*t+o.d*e+o.ty,o.a*i+o.c*r+o.tx,o.b*i+o.d*r+o.ty,n),this}rect(t,e,i,r){return this._tick++,this._activePath.rect(t,e,i,r,this._transform.clone()),this}roundRect(t,e,i,r,n){return this._tick++,this._activePath.roundRect(t,e,i,r,n,this._transform.clone()),this}poly(t,e){return this._tick++,this._activePath.poly(t,e,this._transform.clone()),this}regularPoly(t,e,i,r,n=0,o){return this._tick++,this._activePath.regularPoly(t,e,i,r,n,o),this}roundPoly(t,e,i,r,n,o){return this._tick++,this._activePath.roundPoly(t,e,i,r,n,o),this}roundShape(t,e,i,r){return this._tick++,this._activePath.roundShape(t,e,i,r),this}filletRect(t,e,i,r,n){return this._tick++,this._activePath.filletRect(t,e,i,r,n),this}chamferRect(t,e,i,r,n,o){return this._tick++,this._activePath.chamferRect(t,e,i,r,n,o),this}star(t,e,i,r,n=0,o=0){return this._tick++,this._activePath.star(t,e,i,r,n,o,this._transform.clone()),this}svg(t){return this._tick++,xu(t,this),this}restore(){const t=this._stateStack.pop();return t&&(this._transform=t.transform,this._fillStyle=t.fillStyle,this._strokeStyle=t.strokeStyle),this}save(){return this._stateStack.push({transform:this._transform.clone(),fillStyle:{...this._fillStyle},strokeStyle:{...this._strokeStyle}}),this}getTransform(){return this._transform}resetTransform(){return this._transform.identity(),this}rotate(t){return this._transform.rotate(t),this}scale(t,e=t){return this._transform.scale(t,e),this}setTransform(t,e,i,r,n,o){return t instanceof W?(this._transform.set(t.a,t.b,t.c,t.d,t.tx,t.ty),this):(this._transform.set(t,e,i,r,n,o),this)}transform(t,e,i,r,n,o){return t instanceof W?(this._transform.append(t),this):(tn.set(t,e,i,r,n,o),this._transform.append(tn),this)}translate(t,e=t){return this._transform.translate(t,e),this}clear(){return this._activePath.clear(),this.instructions.length=0,this.resetTransform(),this.onUpdate(),this}onUpdate(){this._boundsDirty=!0,this.dirty=!0,this.emit("update",this,16)}get bounds(){if(!this._boundsDirty)return this._bounds;this._boundsDirty=!1;const t=this._bounds;t.clear();for(let e=0;e<this.instructions.length;e++){const i=this.instructions[e],r=i.action;if(r==="fill"){const n=i.data;t.addBounds(n.path.bounds)}else if(r==="texture"){const n=i.data;t.addFrame(n.dx,n.dy,n.dx+n.dw,n.dy+n.dh,n.transform)}if(r==="stroke"){const n=i.data,o=n.style.alignment;let a=n.style.width*(1-o);n.style.join==="miter"&&(a*=Tu(n.path,n.style.miterLimit));const h=n.path.bounds;t.addFrame(h.minX-a,h.minY-a,h.maxX+a,h.maxY+a)}}return t.isValid||t.set(0,0,0,0),t}containsPoint(t){var r;if(!this.bounds.containsPoint(t.x,t.y))return!1;const e=this.instructions;let i=!1;for(let n=0;n<e.length;n++){const o=e[n],a=o.data,h=a.path;if(!o.action||!h)continue;const l=a.style,c=h.shapePath.shapePrimitives;for(let u=0;u<c.length;u++){const f=c[u].shape;if(!l||!f)continue;const d=c[u].transform,p=d?d.applyInverse(t,Pu):t;if(o.action==="fill")i=f.contains(p.x,p.y);else{const m=l;i=f.strokeContains(p.x,p.y,m.width,m.alignment)}const g=a.hole;if(g){const m=(r=g.shapePath)==null?void 0:r.shapePrimitives;if(m)for(let _=0;_<m.length;_++)m[_].shape.contains(p.x,p.y)&&(i=!1)}if(i)return!0}}return i}unload(){var t;this.emit("unload",this);for(const e in this._gpuData)(t=this._gpuData[e])==null||t.destroy();this._gpuData=Object.create(null)}destroy(t=!1){if(this.destroyed)return;if(this.destroyed=!0,this._stateStack.length=0,this._transform=null,this.unload(),this.emit("destroy",this),this.removeAllListeners(),typeof t=="boolean"?t:t==null?void 0:t.texture){const i=typeof t=="boolean"?t:t==null?void 0:t.textureSource;this._fillStyle.texture&&(this._fillStyle.fill&&"uid"in this._fillStyle.fill?this._fillStyle.fill.destroy():this._fillStyle.texture.destroy(i)),this._strokeStyle.texture&&(this._strokeStyle.fill&&"uid"in this._strokeStyle.fill?this._strokeStyle.fill.destroy():this._strokeStyle.texture.destroy(i))}this._fillStyle=null,this._strokeStyle=null,this.instructions=null,this._activePath=null,this._bounds=null,this._stateStack=null,this.customShader=null,this._transform=null}};zi.defaultFillStyle={color:16777215,alpha:1,texture:U.WHITE,matrix:null,fill:null,textureSpace:"local"};zi.defaultStrokeStyle={width:1,color:16777215,alpha:1,alignment:.5,miterLimit:10,cap:"butt",join:"miter",texture:U.WHITE,matrix:null,fill:null,textureSpace:"local",pixelLine:!1};let te=zi;function Hi(s,t=1){var i;const e=(i=ve.RETINA_PREFIX)==null?void 0:i.exec(s);return e?parseFloat(e[1]):t}function Ni(s,t,e){s.label=e,s._sourceOrigin=e;const i=new U({source:s,label:e}),r=()=>{delete t.promiseCache[e],nt.has(e)&&nt.remove(e)};return i.source.once("destroy",()=>{t.promiseCache[e]&&(Y("[Assets] A TextureSource managed by Assets was destroyed instead of unloaded! Use Assets.unload() instead of destroying the TextureSource."),r())}),i.once("destroy",()=>{s.destroyed||(Y("[Assets] A Texture managed by Assets was destroyed instead of unloaded! Use Assets.unload() instead of destroying the Texture."),r())}),i}const Mu=".svg",ku="image/svg+xml",Eu={extension:{type:I.LoadParser,priority:Gt.Low,name:"loadSVG"},name:"loadSVG",id:"svg",config:{crossOrigin:"anonymous",parseAsGraphicsContext:!1},test(s){return Ae(s,ku)||Se(s,Mu)},async load(s,t,e){var i;return((i=t.data)==null?void 0:i.parseAsGraphicsContext)??this.config.parseAsGraphicsContext?Ru(s):Iu(s,t,e,this.config.crossOrigin)},unload(s){s.destroy(!0)}};async function Iu(s,t,e,i){var m,_,y;const r=await z.get().fetch(s),n=z.get().createImage();n.src=`data:image/svg+xml;charset=utf-8,${encodeURIComponent(await r.text())}`,n.crossOrigin=i,await n.decode();const o=((m=t.data)==null?void 0:m.width)??n.width,a=((_=t.data)==null?void 0:_.height)??n.height,h=((y=t.data)==null?void 0:y.resolution)||Hi(s),l=Math.ceil(o*h),c=Math.ceil(a*h),u=z.get().createCanvas(l,c),f=u.getContext("2d");f.imageSmoothingEnabled=!0,f.imageSmoothingQuality="high",f.drawImage(n,0,0,o*h,a*h);const{parseAsGraphicsContext:d,...p}=t.data??{},g=new be({resource:u,alphaMode:"premultiply-alpha-on-upload",resolution:h,...p});return Ni(g,e,s)}async function Ru(s){const e=await(await z.get().fetch(s)).text(),i=new te;return i.svg(e),i}const Lu=`(function () { + 'use strict'; + + const WHITE_PNG = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+ip1sAAAAASUVORK5CYII="; + async function checkImageBitmap() { + try { + if (typeof createImageBitmap !== "function") return false; + const response = await fetch(WHITE_PNG); + const imageBlob = await response.blob(); + const imageBitmap = await createImageBitmap(imageBlob); + return imageBitmap.width === 1 && imageBitmap.height === 1; + } catch (_e) { + return false; + } + } + void checkImageBitmap().then((result) => { + self.postMessage(result); + }); + +})(); +`;let me=null,Pi=class{constructor(){me||(me=URL.createObjectURL(new Blob([Lu],{type:"application/javascript"}))),this.worker=new Worker(me)}};Pi.revokeObjectURL=function(){me&&(URL.revokeObjectURL(me),me=null)};const Bu=`(function () { + 'use strict'; + + async function loadImageBitmap(url, alphaMode) { + const response = await fetch(url); + if (!response.ok) { + throw new Error(\`[WorkerManager.loadImageBitmap] Failed to fetch \${url}: \${response.status} \${response.statusText}\`); + } + const imageBlob = await response.blob(); + return alphaMode === "premultiplied-alpha" ? createImageBitmap(imageBlob, { premultiplyAlpha: "none" }) : createImageBitmap(imageBlob); + } + self.onmessage = async (event) => { + try { + const imageBitmap = await loadImageBitmap(event.data.data[0], event.data.data[1]); + self.postMessage({ + data: imageBitmap, + uuid: event.data.uuid, + id: event.data.id + }, [imageBitmap]); + } catch (e) { + self.postMessage({ + error: e, + uuid: event.data.uuid, + id: event.data.id + }); + } + }; + +})(); +`;let ge=null;class Do{constructor(){ge||(ge=URL.createObjectURL(new Blob([Bu],{type:"application/javascript"}))),this.worker=new Worker(ge)}}Do.revokeObjectURL=function(){ge&&(URL.revokeObjectURL(ge),ge=null)};let en=0,ei;class Fu{constructor(){this._initialized=!1,this._createdWorkers=0,this._workerPool=[],this._queue=[],this._resolveHash={}}isImageBitmapSupported(){return this._isImageBitmapSupported!==void 0?this._isImageBitmapSupported:(this._isImageBitmapSupported=new Promise(t=>{const{worker:e}=new Pi;e.addEventListener("message",i=>{e.terminate(),Pi.revokeObjectURL(),t(i.data)})}),this._isImageBitmapSupported)}loadImageBitmap(t,e){var i;return this._run("loadImageBitmap",[t,(i=e==null?void 0:e.data)==null?void 0:i.alphaMode])}async _initWorkers(){this._initialized||(this._initialized=!0)}_getWorker(){ei===void 0&&(ei=navigator.hardwareConcurrency||4);let t=this._workerPool.pop();return!t&&this._createdWorkers<ei&&(this._createdWorkers++,t=new Do().worker,t.addEventListener("message",e=>{this._complete(e.data),this._returnWorker(e.target),this._next()})),t}_returnWorker(t){this._workerPool.push(t)}_complete(t){this._resolveHash[t.uuid]&&(t.error!==void 0?this._resolveHash[t.uuid].reject(t.error):this._resolveHash[t.uuid].resolve(t.data),delete this._resolveHash[t.uuid])}async _run(t,e){await this._initWorkers();const i=new Promise((r,n)=>{this._queue.push({id:t,arguments:e,resolve:r,reject:n})});return this._next(),i}_next(){if(!this._queue.length)return;const t=this._getWorker();if(!t)return;const e=this._queue.pop(),i=e.id;this._resolveHash[en]={resolve:e.resolve,reject:e.reject},t.postMessage({data:e.arguments,uuid:en++,id:i})}reset(){this._workerPool.forEach(t=>t.terminate()),this._workerPool.length=0,Object.values(this._resolveHash).forEach(({reject:t})=>{t==null||t(new Error("WorkerManager has been reset before completion"))}),this._resolveHash={},this._queue.length=0,this._initialized=!1,this._createdWorkers=0}}const sn=new Fu,Gu=[".jpeg",".jpg",".png",".webp",".avif"],Du=["image/jpeg","image/png","image/webp","image/avif"];async function Ou(s,t){var r;const e=await z.get().fetch(s);if(!e.ok)throw new Error(`[loadImageBitmap] Failed to fetch ${s}: ${e.status} ${e.statusText}`);const i=await e.blob();return((r=t==null?void 0:t.data)==null?void 0:r.alphaMode)==="premultiplied-alpha"?createImageBitmap(i,{premultiplyAlpha:"none"}):createImageBitmap(i)}const Oo={name:"loadTextures",id:"texture",extension:{type:I.LoadParser,priority:Gt.High,name:"loadTextures"},config:{preferWorkers:!0,preferCreateImageBitmap:!0,crossOrigin:"anonymous"},test(s){return Ae(s,Du)||Se(s,Gu)},async load(s,t,e){var n;let i=null;globalThis.createImageBitmap&&this.config.preferCreateImageBitmap?this.config.preferWorkers&&await sn.isImageBitmapSupported()?i=await sn.loadImageBitmap(s,t):i=await Ou(s,t):i=await new Promise((o,a)=>{i=z.get().createImage(),i.crossOrigin=this.config.crossOrigin,i.src=s,i.complete?o(i):(i.onload=()=>{o(i)},i.onerror=a)});const r=new be({resource:i,alphaMode:"premultiply-alpha-on-upload",resolution:((n=t.data)==null?void 0:n.resolution)||Hi(s),...t.data});return Ni(r,e,s)},unload(s){s.destroy(!0)}},Wu=[".mp4",".m4v",".webm",".ogg",".ogv",".h264",".avi",".mov"];let si,ii;function Uu(s,t,e){e===void 0&&!t.startsWith("data:")?s.crossOrigin=Hu(t):e!==!1&&(s.crossOrigin=typeof e=="string"?e:"anonymous")}function zu(s){return new Promise((t,e)=>{s.addEventListener("canplaythrough",i),s.addEventListener("error",r),s.load();function i(){n(),t()}function r(o){n(),e(o)}function n(){s.removeEventListener("canplaythrough",i),s.removeEventListener("error",r)}})}function Hu(s,t=globalThis.location){if(s.startsWith("data:"))return"";t||(t=globalThis.location);const e=new URL(s,document.baseURI);return e.hostname!==t.hostname||e.port!==t.port||e.protocol!==t.protocol?"anonymous":""}function Nu(){const s=[],t=[];for(const e of Wu){const i=De.MIME_TYPES[e.substring(1)]||`video/${e.substring(1)}`;ks(i)&&(s.push(e),t.includes(i)||t.push(i))}return{validVideoExtensions:s,validVideoMime:t}}const Vu={name:"loadVideo",id:"video",extension:{type:I.LoadParser,name:"loadVideo"},test(s){if(!si||!ii){const{validVideoExtensions:i,validVideoMime:r}=Nu();si=i,ii=r}const t=Ae(s,ii),e=Se(s,si);return t||e},async load(s,t,e){var h,l;const i={...De.defaultOptions,resolution:((h=t.data)==null?void 0:h.resolution)||Hi(s),alphaMode:((l=t.data)==null?void 0:l.alphaMode)||await Hn(),...t.data},r=document.createElement("video"),n={preload:i.autoLoad!==!1?"auto":void 0,"webkit-playsinline":i.playsinline!==!1?"":void 0,playsinline:i.playsinline!==!1?"":void 0,muted:i.muted===!0?"":void 0,loop:i.loop===!0?"":void 0,autoplay:i.autoPlay!==!1?"":void 0};Object.keys(n).forEach(c=>{const u=n[c];u!==void 0&&r.setAttribute(c,u)}),i.muted===!0&&(r.muted=!0),Uu(r,s,i.crossorigin);const o=document.createElement("source");let a;if(i.mime)a=i.mime;else if(s.startsWith("data:"))a=s.slice(5,s.indexOf(";"));else if(!s.startsWith("blob:")){const c=s.split("?")[0].slice(s.lastIndexOf(".")+1).toLowerCase();a=De.MIME_TYPES[c]||`video/${c}`}return o.src=s,a&&(o.type=a),new Promise((c,u)=>{i.preload&&!i.autoPlay&&r.load(),r.addEventListener("canplay",f),r.addEventListener("error",d),o.addEventListener("error",d),r.appendChild(o);async function f(){const g=new De({...i,resource:r});p(),t.data.preload&&await zu(r),c(Ni(g,e,s))}function d(g){p(),u(g)}function p(){r.removeEventListener("canplay",f),r.removeEventListener("error",d),o.removeEventListener("error",d)}})},unload(s){s.destroy(!0)}},Wo={extension:{type:I.ResolveParser,name:"resolveTexture"},test:Oo.test,parse:s=>{var t;return{resolution:parseFloat(((t=ve.RETINA_PREFIX.exec(s))==null?void 0:t[1])??"1"),format:s.split(".").pop(),src:s}}},$u={extension:{type:I.ResolveParser,priority:-2,name:"resolveJson"},test:s=>ve.RETINA_PREFIX.test(s)&&s.endsWith(".json"),parse:Wo.parse};class ju{constructor(){this._detections=[],this._initialized=!1,this.resolver=new ve,this.loader=new ml,this.cache=nt,this._backgroundLoader=new ol(this.loader),this._backgroundLoader.active=!0,this.reset()}async init(t={}){var n,o;if(this._initialized){Y("[Assets]AssetManager already initialized, did you load before calling this Assets.init()?");return}if(this._initialized=!0,t.defaultSearchParams&&this.resolver.setDefaultSearchParams(t.defaultSearchParams),t.basePath&&(this.resolver.basePath=t.basePath),t.bundleIdentifier&&this.resolver.setBundleIdentifier(t.bundleIdentifier),t.manifest){let a=t.manifest;typeof a=="string"&&(a=await this.load(a)),this.resolver.addManifest(a)}const e=((n=t.texturePreference)==null?void 0:n.resolution)??1,i=typeof e=="number"?[e]:e,r=await this._detectFormats({preferredFormats:(o=t.texturePreference)==null?void 0:o.format,skipDetections:t.skipDetections,detections:this._detections});this.resolver.prefer({params:{format:r,resolution:i}}),t.preferences&&this.setPreferences(t.preferences),t.loadOptions&&(this.loader.loadOptions={...this.loader.loadOptions,...t.loadOptions})}add(t){this.resolver.add(t)}async load(t,e){this._initialized||await this.init();const i=gs(t),r=Tt(t).map(a=>{if(typeof a!="string"){const h=this.resolver.getAlias(a);return h.some(l=>!this.resolver.hasKey(l))&&this.add(a),Array.isArray(h)?h[0]:h}return this.resolver.hasKey(a)||this.add({alias:a,src:a}),a}),n=this.resolver.resolve(r),o=await this._mapLoadToResolve(n,e);return i?o[r[0]]:o}addBundle(t,e){this.resolver.addBundle(t,e)}async loadBundle(t,e){this._initialized||await this.init();let i=!1;typeof t=="string"&&(i=!0,t=[t]);const r=this.resolver.resolveBundle(t),n={},o=Object.keys(r);let a=0;const h=[],l=()=>{e==null||e(h.reduce((u,f)=>u+f,0)/a)},c=o.map((u,f)=>{const d=r[u],p=Object.values(d),m=[...new Set(p.flat())].reduce((_,y)=>_+(y.progressSize||1),0);return h.push(0),a+=m,this._mapLoadToResolve(d,_=>{h[f]=_*m,l()}).then(_=>{n[u]=_})});return await Promise.all(c),i?n[t[0]]:n}async backgroundLoad(t){this._initialized||await this.init(),typeof t=="string"&&(t=[t]);const e=this.resolver.resolve(t);this._backgroundLoader.add(Object.values(e))}async backgroundLoadBundle(t){this._initialized||await this.init(),typeof t=="string"&&(t=[t]);const e=this.resolver.resolveBundle(t);Object.values(e).forEach(i=>{this._backgroundLoader.add(Object.values(i))})}reset(){this.resolver.reset(),this.loader.reset(),this.cache.reset(),this._initialized=!1}get(t){if(typeof t=="string")return nt.get(t);const e={};for(let i=0;i<t.length;i++)e[i]=nt.get(t[i]);return e}async _mapLoadToResolve(t,e){const i=[...new Set(Object.values(t))];this._backgroundLoader.active=!1;const r=await this.loader.load(i,e);this._backgroundLoader.active=!0;const n={};return i.forEach(o=>{const a=r[o.src],h=[o.src];o.alias&&h.push(...o.alias),h.forEach(l=>{n[l]=a}),nt.set(h,a)}),n}async unload(t){this._initialized||await this.init();const e=Tt(t).map(r=>typeof r!="string"?r.src:r),i=this.resolver.resolve(e);await this._unloadFromResolved(i)}async unloadBundle(t){this._initialized||await this.init(),t=Tt(t);const e=this.resolver.resolveBundle(t),i=Object.keys(e).map(r=>this._unloadFromResolved(e[r]));await Promise.all(i)}async _unloadFromResolved(t){const e=Object.values(t);e.forEach(i=>{nt.remove(i.src)}),await this.loader.unload(e)}async _detectFormats(t){let e=[];t.preferredFormats&&(e=Array.isArray(t.preferredFormats)?t.preferredFormats:[t.preferredFormats]);for(const i of t.detections)t.skipDetections||await i.test()?e=await i.add(e):t.skipDetections||(e=await i.remove(e));return e=e.filter((i,r)=>e.indexOf(i)===r),e}get detections(){return this._detections}setPreferences(t){this.loader.parsers.forEach(e=>{e.config&&Object.keys(e.config).filter(i=>i in t).forEach(i=>{e.config[i]=t[i]})})}}const de=new ju;K.handleByList(I.LoadParser,de.loader.parsers).handleByList(I.ResolveParser,de.resolver.parsers).handleByList(I.CacheParser,de.cache.parsers).handleByList(I.DetectionParser,de.detections);K.add(al,ll,hl,pl,ul,dl,fl,yl,wl,kl,Eu,Oo,Vu,nl,rl,Wo,$u);const rn={loader:I.LoadParser,resolver:I.ResolveParser,cache:I.CacheParser,detection:I.DetectionParser};K.handle(I.Asset,s=>{const t=s.ref;Object.entries(rn).filter(([e])=>!!t[e]).forEach(([e,i])=>K.add(Object.assign(t[e],{extension:t[e].extension??i})))},s=>{const t=s.ref;Object.keys(rn).filter(e=>!!t[e]).forEach(e=>K.remove(t[e]))});let he;function nn(s){const t=z.get().createCanvas(6,1),e=t.getContext("2d");return e.fillStyle=s,e.fillRect(0,0,6,1),t}function Yu(){if(he!==void 0)return he;try{const s=nn("#ff00ff"),t=nn("#ffff00"),i=z.get().createCanvas(6,1).getContext("2d");i.globalCompositeOperation="multiply",i.drawImage(s,0,0),i.drawImage(t,2,0);const r=i.getImageData(2,0,1,1);if(!r)he=!1;else{const n=r.data;he=n[0]===255&&n[1]===0&&n[2]===0}}catch{he=!1}return he}const $={canvas:null,convertTintToImage:!1,cacheStepsPerColorChannel:8,canUseMultiply:Yu(),tintMethod:null,_canvasSourceCache:new WeakMap,_unpremultipliedCache:new WeakMap,getCanvasSource:s=>{const t=s.source,e=t==null?void 0:t.resource;if(!e)return null;const i=t.alphaMode==="premultiplied-alpha",r=t.resourceWidth??t.pixelWidth,n=t.resourceHeight??t.pixelHeight,o=r!==t.pixelWidth||n!==t.pixelHeight;if(i){if((e instanceof HTMLCanvasElement||typeof OffscreenCanvas<"u"&&e instanceof OffscreenCanvas)&&!o)return e;const a=$._unpremultipliedCache.get(t);if((a==null?void 0:a.resourceId)===t._resourceId)return a.canvas}if(e instanceof Uint8Array||e instanceof Uint8ClampedArray||e instanceof Int8Array||e instanceof Uint16Array||e instanceof Int16Array||e instanceof Uint32Array||e instanceof Int32Array||e instanceof Float32Array||e instanceof ArrayBuffer){const a=$._canvasSourceCache.get(t);if((a==null?void 0:a.resourceId)===t._resourceId)return a.canvas;const h=z.get().createCanvas(t.pixelWidth,t.pixelHeight),l=h.getContext("2d"),c=l.createImageData(t.pixelWidth,t.pixelHeight),u=c.data,f=e instanceof ArrayBuffer?new Uint8Array(e):new Uint8Array(e.buffer,e.byteOffset,e.byteLength);if(t.format==="bgra8unorm")for(let d=0;d<u.length&&d+3<f.length;d+=4)u[d]=f[d+2],u[d+1]=f[d+1],u[d+2]=f[d],u[d+3]=f[d+3];else u.set(f.subarray(0,u.length));return l.putImageData(c,0,0),$._canvasSourceCache.set(t,{canvas:h,resourceId:t._resourceId}),h}if(i){const a=z.get().createCanvas(t.pixelWidth,t.pixelHeight),h=a.getContext("2d",{willReadFrequently:!0});a.width=t.pixelWidth,a.height=t.pixelHeight,h.drawImage(e,0,0);const l=h.getImageData(0,0,a.width,a.height),c=l.data;for(let u=0;u<c.length;u+=4){const f=c[u+3];if(f>0){const d=255/f;c[u]=Math.min(255,c[u]*d+.5),c[u+1]=Math.min(255,c[u+1]*d+.5),c[u+2]=Math.min(255,c[u+2]*d+.5)}}return h.putImageData(l,0,0),$._unpremultipliedCache.set(t,{canvas:a,resourceId:t._resourceId}),a}if(o){const a=$._canvasSourceCache.get(t);if((a==null?void 0:a.resourceId)===t._resourceId)return a.canvas;const h=z.get().createCanvas(t.pixelWidth,t.pixelHeight),l=h.getContext("2d");return h.width=t.pixelWidth,h.height=t.pixelHeight,l.drawImage(e,0,0),$._canvasSourceCache.set(t,{canvas:h,resourceId:t._resourceId}),h}return e},getTintedCanvas:(s,t)=>{const e=s.texture,i=q.shared.setValue(t).toHex(),r=e.tintCache||(e.tintCache={}),n=r[i],o=e.source._resourceId;if((n==null?void 0:n.tintId)===o)return n;const a=n&&"getContext"in n?n:z.get().createCanvas();return $.tintMethod(e,t,a),a.tintId=o,r[i]=a,r[i]},getTintedPattern:(s,t)=>{const e=q.shared.setValue(t).toHex(),i=s.patternCache||(s.patternCache={}),r=s.source._resourceId;let n=i[e];return(n==null?void 0:n.tintId)===r||($.canvas||($.canvas=z.get().createCanvas()),$.tintMethod(s,t,$.canvas),n=$.canvas.getContext("2d").createPattern($.canvas,"repeat"),n.tintId=r,i[e]=n),n},applyPatternTransform:(s,t,e=!0)=>{if(!t)return;const i=s;if(!i.setTransform)return;const r=globalThis.DOMMatrix;if(!r)return;const n=new r([t.a,t.b,t.c,t.d,t.tx,t.ty]);i.setTransform(e?n.inverse():n)},tintWithMultiply:(s,t,e)=>{const i=e.getContext("2d"),r=s.frame.clone(),n=s.source._resolution??s.source.resolution??1,o=s.rotate;r.x*=n,r.y*=n,r.width*=n,r.height*=n;const a=O.isVertical(o),h=a?r.height:r.width,l=a?r.width:r.height;e.width=Math.ceil(h),e.height=Math.ceil(l),i.save(),i.fillStyle=q.shared.setValue(t).toHex(),i.fillRect(0,0,h,l),i.globalCompositeOperation="multiply";const c=$.getCanvasSource(s);if(!c){i.restore();return}o&&$._applyInverseRotation(i,o,r.width,r.height),i.drawImage(c,r.x,r.y,r.width,r.height,0,0,r.width,r.height),i.globalCompositeOperation="destination-atop",i.drawImage(c,r.x,r.y,r.width,r.height,0,0,r.width,r.height),i.restore()},tintWithOverlay:(s,t,e)=>{const i=e.getContext("2d"),r=s.frame.clone(),n=s.source._resolution??s.source.resolution??1,o=s.rotate;r.x*=n,r.y*=n,r.width*=n,r.height*=n;const a=O.isVertical(o),h=a?r.height:r.width,l=a?r.width:r.height;e.width=Math.ceil(h),e.height=Math.ceil(l),i.save(),i.globalCompositeOperation="copy",i.fillStyle=q.shared.setValue(t).toHex(),i.fillRect(0,0,h,l),i.globalCompositeOperation="destination-atop";const c=$.getCanvasSource(s);if(!c){i.restore();return}o&&$._applyInverseRotation(i,o,r.width,r.height),i.drawImage(c,r.x,r.y,r.width,r.height,0,0,r.width,r.height),i.restore()},tintWithPerPixel:(s,t,e)=>{const i=e.getContext("2d"),r=s.frame.clone(),n=s.source._resolution??s.source.resolution??1,o=s.rotate;r.x*=n,r.y*=n,r.width*=n,r.height*=n;const a=O.isVertical(o),h=a?r.height:r.width,l=a?r.width:r.height;e.width=Math.ceil(h),e.height=Math.ceil(l),i.save(),i.globalCompositeOperation="copy";const c=$.getCanvasSource(s);if(!c){i.restore();return}o&&$._applyInverseRotation(i,o,r.width,r.height),i.drawImage(c,r.x,r.y,r.width,r.height,0,0,r.width,r.height),i.restore();const u=t>>16&255,f=t>>8&255,d=t&255,p=i.getImageData(0,0,h,l),g=p.data;for(let m=0;m<g.length;m+=4)g[m]=g[m]*u/255,g[m+1]=g[m+1]*f/255,g[m+2]=g[m+2]*d/255;i.putImageData(p,0,0)},_applyInverseRotation:(s,t,e,i)=>{const r=O.inv(t),n=O.uX(r),o=O.uY(r),a=O.vX(r),h=O.vY(r),l=-Math.min(0,n*e,a*i,n*e+a*i),c=-Math.min(0,o*e,h*i,o*e+h*i);s.transform(n,o,a,h,l,c)}};$.tintMethod=$.canUseMultiply?$.tintWithMultiply:$.tintWithPerPixel;class Xu{constructor(t){this._canvasPool=Object.create(null),this.canvasOptions=t||{},this.enableFullScreen=!1}_createCanvasAndContext(t,e){const i=z.get().createCanvas();i.width=t,i.height=e;const r=i.getContext("2d");return{canvas:i,context:r}}getOptimalCanvasAndContext(t,e,i=1){t=Math.ceil(t*i-1e-6),e=Math.ceil(e*i-1e-6),t=_e(t),e=_e(e);const r=(t<<17)+(e<<1);this._canvasPool[r]||(this._canvasPool[r]=[]);let n=this._canvasPool[r].pop();return n||(n=this._createCanvasAndContext(t,e)),n}returnCanvasAndContext(t){const e=t.canvas,{width:i,height:r}=e,n=(i<<17)+(r<<1);t.context.resetTransform(),t.context.clearRect(0,0,i,r),this._canvasPool[n].push(t)}clear(){this._canvasPool={}}}const Mi=new Xu;Qe.register(Mi);const qu=new vt;function Ku(s,t,e,i,r=!1){const n=qu;n.minX=0,n.minY=0,n.maxX=s.width/i|0,n.maxY=s.height/i|0;const o=Ts.getOptimalTexture(n.width,n.height,i,!1,r);return o.source.uploadMethodId="image",o.source.resource=s,o.source.alphaMode="premultiply-alpha-on-upload",o.frame.width=t/i,o.frame.height=e/i,o.source.emit("update",o.source),o.updateUvs(),o}class ws extends yt{constructor(...t){let e=t[0];Array.isArray(t[0])&&(e={textures:t[0],autoUpdate:t[1]});const{animationSpeed:i=1,autoPlay:r=!1,autoUpdate:n=!0,loop:o=!0,onComplete:a=null,onFrameChange:h=null,onLoop:l=null,textures:c,updateAnchor:u=!1,...f}=e,[d]=c;super({...f,texture:d instanceof U?d:d.texture}),this._textures=null,this._durations=null,this._autoUpdate=n,this._isConnectedToTicker=!1,this.animationSpeed=i,this.loop=o,this.updateAnchor=u,this.onComplete=a,this.onFrameChange=h,this.onLoop=l,this._currentTime=0,this._playing=!1,this._previousFrame=null,this.textures=c,r&&this.play()}stop(){this._playing&&(this._playing=!1,this._autoUpdate&&this._isConnectedToTicker&&(dt.shared.remove(this.update,this),this._isConnectedToTicker=!1))}play(){this._playing||(this._playing=!0,this._autoUpdate&&!this._isConnectedToTicker&&(dt.shared.add(this.update,this,ze.HIGH),this._isConnectedToTicker=!0))}gotoAndStop(t){this.stop(),this.currentFrame=t}gotoAndPlay(t){this.currentFrame=t,this.play()}update(t){if(!this._playing)return;const e=t.deltaTime,i=this.animationSpeed*e,r=this.currentFrame;if(this._durations!==null){let n=this._currentTime%1*this._durations[this.currentFrame];for(n+=i/60*1e3;n<0;)this._currentTime--,n+=this._durations[this.currentFrame];const o=Math.sign(this.animationSpeed*e);for(this._currentTime=Math.floor(this._currentTime);n>=this._durations[this.currentFrame];)n-=this._durations[this.currentFrame]*o,this._currentTime+=o;this._currentTime+=n/this._durations[this.currentFrame]}else this._currentTime+=i;this._currentTime<0&&!this.loop?(this.gotoAndStop(0),this.onComplete&&this.onComplete()):this._currentTime>=this._textures.length&&!this.loop?(this.gotoAndStop(this._textures.length-1),this.onComplete&&this.onComplete()):r!==this.currentFrame&&(this.loop&&this.onLoop&&(this.animationSpeed>0&&this.currentFrame<r||this.animationSpeed<0&&this.currentFrame>r)&&this.onLoop(),this._updateTexture())}_updateTexture(){const t=this.currentFrame;this._previousFrame!==t&&(this._previousFrame=t,this.texture=this._textures[t],this.updateAnchor&&this.texture.defaultAnchor&&this.anchor.copyFrom(this.texture.defaultAnchor),this.onFrameChange&&this.onFrameChange(this.currentFrame))}destroy(t=!1){if(typeof t=="boolean"?t:t==null?void 0:t.texture){const i=typeof t=="boolean"?t:t==null?void 0:t.textureSource;this._textures.forEach(r=>{this.texture!==r&&r.destroy(i)})}this._textures=[],this._durations=null,this.stop(),super.destroy(t),this.onComplete=null,this.onFrameChange=null,this.onLoop=null}static fromFrames(t){const e=[];for(let i=0;i<t.length;++i)e.push(U.from(t[i]));return new ws(e)}static fromImages(t){const e=[];for(let i=0;i<t.length;++i)e.push(U.from(t[i]));return new ws(e)}get totalFrames(){return this._textures.length}get textures(){return this._textures}set textures(t){if(t[0]instanceof U)this._textures=t,this._durations=null;else{this._textures=[],this._durations=[];for(let e=0;e<t.length;e++)this._textures.push(t[e].texture),this._durations.push(t[e].time)}this._previousFrame=null,this.gotoAndStop(0),this._updateTexture()}get currentFrame(){let t=Math.floor(this._currentTime)%this._textures.length;return t<0&&(t+=this._textures.length),t}set currentFrame(t){if(t<0||t>this.totalFrames-1)throw new Error(`[AnimatedSprite]: Invalid frame index value ${t}, expected to be between 0 and totalFrames ${this.totalFrames}.`);const e=this.currentFrame;this._currentTime=t,e!==this.currentFrame&&this._updateTexture()}get playing(){return this._playing}get autoUpdate(){return this._autoUpdate}set autoUpdate(t){t!==this._autoUpdate&&(this._autoUpdate=t,!this._autoUpdate&&this._isConnectedToTicker?(dt.shared.remove(this.update,this),this._isConnectedToTicker=!1):this._autoUpdate&&!this._isConnectedToTicker&&this._playing&&(dt.shared.add(this.update,this),this._isConnectedToTicker=!0))}}class Qu extends Ln{constructor(t,e){const{text:i,resolution:r,style:n,anchor:o,width:a,height:h,roundPixels:l,...c}=t;super({...c}),this.batched=!0,this._resolution=null,this._autoResolution=!0,this._didTextUpdate=!0,this._styleClass=e,this.text=i??"",this.style=n,this.resolution=r??null,this.allowChildren=!1,this._anchor=new ot({_onUpdate:()=>{this.onViewUpdate()}}),o&&(this.anchor=o),this.roundPixels=l??!1,a!==void 0&&(this.width=a),h!==void 0&&(this.height=h)}get anchor(){return this._anchor}set anchor(t){typeof t=="number"?this._anchor.set(t):this._anchor.copyFrom(t)}set text(t){t=t.toString(),this._text!==t&&(this._text=t,this.onViewUpdate())}get text(){return this._text}set resolution(t){this._autoResolution=t===null,this._resolution=t,this.onViewUpdate()}get resolution(){return this._resolution}get style(){return this._style}set style(t){var e;t||(t={}),(e=this._style)==null||e.off("update",this.onViewUpdate,this),t instanceof this._styleClass?this._style=t:this._style=new this._styleClass(t),this._style.on("update",this.onViewUpdate,this),this.onViewUpdate()}get width(){return Math.abs(this.scale.x)*this.bounds.width}set width(t){this._setWidth(t,this.bounds.width)}get height(){return Math.abs(this.scale.y)*this.bounds.height}set height(t){this._setHeight(t,this.bounds.height)}getSize(t){return t||(t={}),t.width=Math.abs(this.scale.x)*this.bounds.width,t.height=Math.abs(this.scale.y)*this.bounds.height,t}setSize(t,e){typeof t=="object"?(e=t.height??t.width,t=t.width):e??(e=t),t!==void 0&&this._setWidth(t,this.bounds.width),e!==void 0&&this._setHeight(e,this.bounds.height)}containsPoint(t){const e=this.bounds.width,i=this.bounds.height,r=-e*this.anchor.x;let n=0;return t.x>=r&&t.x<=r+e&&(n=-i*this.anchor.y,t.y>=n&&t.y<=n+i)}onViewUpdate(){this.didViewUpdate||(this._didTextUpdate=!0),super.onViewUpdate()}destroy(t=!1){super.destroy(t),this.owner=null,this._bounds=null,this._anchor=null,(typeof t=="boolean"?t:t!=null&&t.style)&&this._style.destroy(t),this._style=null,this._text=null}get styleKey(){return`${this._text}:${this._style.styleKey}:${this._resolution}`}}function Zu(s,t){let e=s[0]??{};return(typeof e=="string"||s[1])&&(X(_t,`use new ${t}({ text: "hi!", style }) instead`),e={text:e,style:s[1]}),e}let Xt=null,Rt=null;function Ju(s,t){Xt||(Xt=z.get().createCanvas(256,128),Rt=Xt.getContext("2d",{willReadFrequently:!0}),Rt.globalCompositeOperation="copy",Rt.globalAlpha=1),(Xt.width<s||Xt.height<t)&&(Xt.width=_e(s),Xt.height=_e(t))}function on(s,t,e){for(let i=0,r=4*e*t;i<t;++i,r+=4)if(s[r+3]!==0)return!1;return!0}function an(s,t,e,i,r){const n=4*t;for(let o=i,a=i*n+4*e;o<=r;++o,a+=n)if(s[a+3]!==0)return!1;return!0}function td(...s){let t=s[0];t.canvas||(t={canvas:s[0],resolution:s[1]});const{canvas:e}=t,i=Math.min(t.resolution??1,1),r=t.width??e.width,n=t.height??e.height;let o=t.output;if(Ju(r,n),!Rt)throw new TypeError("Failed to get canvas 2D context");Rt.drawImage(e,0,0,r,n,0,0,r*i,n*i);const h=Rt.getImageData(0,0,r,n).data;let l=0,c=0,u=r-1,f=n-1;for(;c<n&&on(h,r,c);)++c;if(c===n)return tt.EMPTY;for(;on(h,r,f);)--f;for(;an(h,r,l,c,f);)++l;for(;an(h,r,u,c,f);)--u;return++u,++f,Rt.globalCompositeOperation="source-over",Rt.strokeRect(l,c,u-l,f-c),Rt.globalCompositeOperation="copy",o??(o=new tt),o.set(l/i,c/i,(u-l)/i,(f-c)/i),o}/** + * tiny-lru + * + * @copyright 2026 Jason Mulligan <jason.mulligan@avoidwork.com> + * @license BSD-3-Clause + * @version 11.4.7 + */class ed{constructor(t=0,e=0,i=!1){this.first=null,this.items=Object.create(null),this.last=null,this.max=t,this.resetTtl=i,this.size=0,this.ttl=e}clear(){return this.first=null,this.items=Object.create(null),this.last=null,this.size=0,this}delete(t){if(this.has(t)){const e=this.items[t];delete this.items[t],this.size--,e.prev!==null&&(e.prev.next=e.next),e.next!==null&&(e.next.prev=e.prev),this.first===e&&(this.first=e.next),this.last===e&&(this.last=e.prev)}return this}entries(t=this.keys()){const e=new Array(t.length);for(let i=0;i<t.length;i++){const r=t[i];e[i]=[r,this.get(r)]}return e}evict(t=!1){if(t||this.size>0){const e=this.first;delete this.items[e.key],--this.size===0?(this.first=null,this.last=null):(this.first=e.next,this.first.prev=null)}return this}expiresAt(t){let e;return this.has(t)&&(e=this.items[t].expiry),e}get(t){const e=this.items[t];if(e!==void 0){if(this.ttl>0&&e.expiry<=Date.now()){this.delete(t);return}return this.moveToEnd(e),e.value}}has(t){return t in this.items}moveToEnd(t){this.last!==t&&(t.prev!==null&&(t.prev.next=t.next),t.next!==null&&(t.next.prev=t.prev),this.first===t&&(this.first=t.next),t.prev=this.last,t.next=null,this.last!==null&&(this.last.next=t),this.last=t,this.first===null&&(this.first=t))}keys(){const t=new Array(this.size);let e=this.first,i=0;for(;e!==null;)t[i++]=e.key,e=e.next;return t}setWithEvicted(t,e,i=this.resetTtl){let r=null;if(this.has(t))this.set(t,e,!0,i);else{this.max>0&&this.size===this.max&&(r={...this.first},this.evict(!0));let n=this.items[t]={expiry:this.ttl>0?Date.now()+this.ttl:this.ttl,key:t,prev:this.last,next:null,value:e};++this.size===1?this.first=n:this.last.next=n,this.last=n}return r}set(t,e,i=!1,r=this.resetTtl){let n=this.items[t];return i||n!==void 0?(n.value=e,i===!1&&r&&(n.expiry=this.ttl>0?Date.now()+this.ttl:this.ttl),this.moveToEnd(n)):(this.max>0&&this.size===this.max&&this.evict(!0),n=this.items[t]={expiry:this.ttl>0?Date.now()+this.ttl:this.ttl,key:t,prev:this.last,next:null,value:e},++this.size===1?this.first=n:this.last.next=n,this.last=n),this}values(t=this.keys()){const e=new Array(t.length);for(let i=0;i<t.length;i++)e[i]=this.get(t[i]);return e}}function sd(s=1e3,t=0,e=!1){if(isNaN(s)||s<0)throw new TypeError("Invalid max value");if(isNaN(t)||t<0)throw new TypeError("Invalid ttl value");if(typeof e!="boolean")throw new TypeError("Invalid resetTtl value");return new ed(s,t,e)}function Uo(s){return!!s.tagStyles&&Object.keys(s.tagStyles).length>0}function zo(s){return s.includes("<")}function id(s,t){return s.clone().assign(t)}function rd(s,t){const e=[],i=t.tagStyles;if(!Uo(t)||!zo(s))return e.push({text:s,style:t}),e;const r=[t],n=[];let o="",a=0;for(;a<s.length;){const h=s[a];if(h==="<"){const l=s.indexOf(">",a);if(l===-1){o+=h,a++;continue}const c=s.indexOf("<",a+1);if(c!==-1&&c<l){o+=h,a++;continue}const u=s.slice(a+1,l);if(u.startsWith("/")){const f=u.slice(1).trim();if(n.length>0&&n[n.length-1]===f){o.length>0&&(e.push({text:o,style:r[r.length-1]}),o=""),r.pop(),n.pop(),a=l+1;continue}else{o+=s.slice(a,l+1),a=l+1;continue}}else{const f=u.trim();if(i[f]){o.length>0&&(e.push({text:o,style:r[r.length-1]}),o="");const d=r[r.length-1],p=id(d,i[f]);r.push(p),n.push(f),a=l+1;continue}else{o+=s.slice(a,l+1),a=l+1;continue}}}else o+=h,a++}return o.length>0&&e.push({text:o,style:r[r.length-1]}),e}const nd=[10,13],od=new Set(nd),ad=[9,32,8192,8193,8194,8195,8196,8197,8198,8200,8201,8202,8287,12288],hd=new Set(ad),ld=[9,32],cd=new Set(ld),ud=[45,8208,8211,8212,173],dd=new Set(ud),fd=/(\r\n|\r|\n)/,pd=/(?:\r\n|\r|\n)/;function vs(s){return typeof s!="string"?!1:od.has(s.charCodeAt(0))}function wt(s,t){return typeof s!="string"?!1:hd.has(s.charCodeAt(0))}function Yd(s){return typeof s!="string"?!1:cd.has(s.charCodeAt(0))}function md(s){return typeof s!="string"?!1:dd.has(s.charCodeAt(0))}function Ho(s){return s==="normal"||s==="pre-line"}function No(s){return s==="normal"}function It(s){if(typeof s!="string")return"";let t=s.length-1;for(;t>=0&&wt(s[t]);)t--;return t<s.length-1?s.slice(0,t+1):s}function Vo(s){const t=[],e=[];if(typeof s!="string")return t;for(let i=0;i<s.length;i++){const r=s[i],n=s[i+1];if(wt(r)||vs(r)){e.length>0&&(t.push(e.join("")),e.length=0),r==="\r"&&n===` +`?(t.push(`\r +`),i++):t.push(r);continue}e.push(r),md(r)&&n&&!wt(n)&&!vs(n)&&(t.push(e.join("")),e.length=0)}return e.length>0&&t.push(e.join("")),t}function $o(s,t,e,i){const r=e(s),n=[];for(let o=0;o<r.length;o++){let a=r[o],h=a,l=1;for(;r[o+l];){const c=r[o+l];if(!i(h,c,s,o,t))a+=c,h=c,l++;else break}o+=l-1,n.push(a)}return n}const gd=/\r\n|\r|\n/g;function _d(s,t,e,i,r,n,o,a,h){var B,ht;const l=rd(s,t);if(No(t.whiteSpace))for(let C=0;C<l.length;C++){const E=l[C];l[C]={text:E.text.replace(gd," "),style:E.style}}const u=[];let f=[];for(const C of l){const E=C.text.split(fd);for(let N=0;N<E.length;N++){const L=E[N];L===`\r +`||L==="\r"||L===` +`?(u.push(f),f=[]):L.length>0&&f.push({text:L,style:C.style})}}(f.length>0||u.length===0)&&u.push(f);const d=e?yd(u,t,i,n,a,h):u,p=[],g=[],m=[],_=[],y=[];let x=0;const w=t._fontString,v=o(w);v.fontSize===0&&(v.fontSize=t.fontSize,v.ascent=t.fontSize);let b="",A=!!t.dropShadow,k=((B=t._stroke)==null?void 0:B.width)||0;for(const C of d){let E=0,N=v.ascent,L=v.descent,H="";for(const D of C){const et=D.style._fontString,ct=o(et);et!==b&&(i.font=et,b=et);const mt=r(D.text,D.style.letterSpacing,i);E+=mt,N=Math.max(N,ct.ascent),L=Math.max(L,ct.descent),H+=D.text;const it=((ht=D.style._stroke)==null?void 0:ht.width)||0;it>k&&(k=it),!A&&D.style.dropShadow&&(A=!0)}C.length===0&&(N=v.ascent,L=v.descent),p.push(E),g.push(N),m.push(L),y.push(H);const V=t.lineHeight||N+L;_.push(V+t.leading),x=Math.max(x,E)}const P=k,S=x+P+(t.dropShadow?t.dropShadow.distance:0);let T=0;for(let C=0;C<_.length;C++)T+=_[C];T=Math.max(T,_[0]+P);const M=T+(t.dropShadow?t.dropShadow.distance:0),R=t.lineHeight||v.fontSize;return{width:S,height:M,lines:y,lineWidths:p,lineHeight:R+t.leading,maxLineWidth:x,fontProperties:v,runsByLine:d,lineAscents:g,lineDescents:m,lineHeights:_,hasDropShadow:A}}function yd(s,t,e,i,r,n){var m;const{letterSpacing:o,whiteSpace:a,wordWrapWidth:h,breakWords:l}=t,c=Ho(a),u=h+o,f={};let d="";const p=(_,y)=>{const x=`${_}|${y.styleKey}`;let w=f[x];if(w===void 0){const v=y._fontString;v!==d&&(e.font=v,d=v),w=i(_,y.letterSpacing,e)+y.letterSpacing,f[x]=w}return w},g=[];for(const _ of s){const y=xd(_),x=g.length,w=M=>{let R=0,B=M;do{const{token:ht,style:C}=y[B];R+=p(ht,C),B++}while(B<y.length&&y[B].continuesFromPrevious);return R},v=M=>{const R=[];let B=M;do R.push({token:y[B].token,style:y[B].style}),B++;while(B<y.length&&y[B].continuesFromPrevious);return R};let b=[],A=0,k=!c,P=null;const S=()=>{P&&P.text.length>0&&b.push(P),P=null},T=()=>{if(S(),b.length>0){const M=b[b.length-1];M.text=It(M.text),M.text.length===0&&b.pop()}g.push(b),b=[],A=0,k=!1};for(let M=0;M<y.length;M++){const{token:R,style:B,continuesFromPrevious:ht}=y[M],C=p(R,B);if(c){const L=wt(R),H=(P==null?void 0:P.text[P.text.length-1])??((m=b[b.length-1])==null?void 0:m.text.slice(-1))??"",V=H?wt(H):!1;if(L&&V)continue}const E=!ht,N=E?w(M):C;if(N>u&&E)if(A>0&&T(),l){const L=v(M);for(let H=0;H<L.length;H++){const V=L[H].token,D=L[H].style,et=$o(V,l,n,r);for(const ct of et){const mt=p(ct,D);mt+A>u&&T(),!P||P.style!==D?(S(),P={text:ct,style:D}):P.text+=ct,A+=mt}}M+=L.length-1}else{const L=v(M);S(),g.push(L.map(H=>({text:H.token,style:H.style}))),k=!1,M+=L.length-1}else if(N+A>u&&E){if(wt(R)){k=!1;continue}T(),P={text:R,style:B},A=C}else if(ht&&!l)!P||P.style!==B?(S(),P={text:R,style:B}):P.text+=R,A+=C;else{const L=wt(R);if(A===0&&L&&!k)continue;!P||P.style!==B?(S(),P={text:R,style:B}):P.text+=R,A+=C}}if(S(),b.length>0){const M=b[b.length-1];M.text=It(M.text),M.text.length===0&&b.pop()}(b.length>0||g.length===x)&&g.push(b)}return g}function xd(s){const t=[];let e=!1;for(const i of s){const r=Vo(i.text);let n=!0;for(const o of r){const a=wt(o)||vs(o),h=n&&e&&!a;t.push({token:o,style:i.style,continuesFromPrevious:h}),e=!a,n=!1}}return t}const bd={willReadFrequently:!0};function hn(s,t,e,i,r){let n=e[s];return typeof n!="number"&&(n=r(s,t,i)+t,e[s]=n),n}function wd(s,t,e,i,r,n,o){const a=e.getContext("2d",bd);a.font=t._fontString;let h=0,l="";const c=[],u=Object.create(null),{letterSpacing:f,whiteSpace:d}=t,p=Ho(d),g=No(d);let m=!p;const _=t.wordWrapWidth+f,y=Vo(s);for(let w=0;w<y.length;w++){let v=y[w];if(vs(v)){if(!g){c.push(It(l)),m=!p,l="",h=0;continue}v=" "}if(p){const A=wt(v),k=wt(l[l.length-1]);if(A&&k)continue}const b=hn(v,f,u,a,i);if(b>_)if(l!==""&&(c.push(It(l)),l="",h=0),r(v,t.breakWords)){const A=$o(v,t.breakWords,o,n);for(const k of A){const P=hn(k,f,u,a,i);P+h>_&&(c.push(It(l)),m=!1,l="",h=0),l+=k,h+=P}}else l.length>0&&(c.push(It(l)),l="",h=0),c.push(It(v)),m=!1,l="",h=0;else b+h>_&&(m=!1,c.push(It(l)),l="",h=0),(l.length>0||!wt(v)||m)&&(l+=v,h+=b)}const x=It(l);return x.length>0&&c.push(x),c.join(` +`)}const ln={willReadFrequently:!0},Dt=class F{static get experimentalLetterSpacingSupported(){let t=F._experimentalLetterSpacingSupported;if(t===void 0){const e=z.get().getCanvasRenderingContext2D().prototype;t=F._experimentalLetterSpacingSupported="letterSpacing"in e||"textLetterSpacing"in e}return t}constructor(t,e,i,r,n,o,a,h,l,c){this.text=t,this.style=e,this.width=i,this.height=r,this.lines=n,this.lineWidths=o,this.lineHeight=a,this.maxLineWidth=h,this.fontProperties=l,c&&(this.runsByLine=c.runsByLine,this.lineAscents=c.lineAscents,this.lineDescents=c.lineDescents,this.lineHeights=c.lineHeights,this.hasDropShadow=c.hasDropShadow)}static measureText(t=" ",e,i=F._canvas,r=e.wordWrap){var w;const n=`${t}-${e.styleKey}-wordWrap-${r}`;if(F._measurementCache.has(n))return F._measurementCache.get(n);if(Uo(e)&&zo(t)){const v=_d(t,e,r,F._context,F._measureText,F._measureTextAdvance,F.measureFont,F.canBreakChars,F.wordWrapSplit),b=new F(t,e,v.width,v.height,v.lines,v.lineWidths,v.lineHeight,v.maxLineWidth,v.fontProperties,{runsByLine:v.runsByLine,lineAscents:v.lineAscents,lineDescents:v.lineDescents,lineHeights:v.lineHeights,hasDropShadow:v.hasDropShadow});return F._measurementCache.set(n,b),b}const a=e._fontString,h=F.measureFont(a);h.fontSize===0&&(h.fontSize=e.fontSize,h.ascent=e.fontSize,h.descent=0);const l=F._context;l.font=a;const u=(r?F._wordWrap(t,e,i):t).split(pd),f=new Array(u.length);let d=0;for(let v=0;v<u.length;v++){const b=F._measureText(u[v],e.letterSpacing,l);f[v]=b,d=Math.max(d,b)}const p=((w=e._stroke)==null?void 0:w.width)??0,g=e.lineHeight||h.fontSize,m=F._adjustWidthForStyle(d,e),_=Math.max(g,h.fontSize+p)+(u.length-1)*(g+e.leading),y=F._adjustHeightForStyle(_,e),x=new F(t,e,m,y,u,f,g+e.leading,d,h);return F._measurementCache.set(n,x),x}static _adjustWidthForStyle(t,e){var n;const i=((n=e._stroke)==null?void 0:n.width)||0;let r=t+i;return e.dropShadow&&(r+=e.dropShadow.distance),r}static _adjustHeightForStyle(t,e){let i=t;return e.dropShadow&&(i+=e.dropShadow.distance),i}static _measureText(t,e,i){const{metricWidth:r,metrics:n,letterSpacingVal:o}=F._measureTextCore(t,e,i),a=-(n.actualBoundingBoxLeft??0);let l=(n.actualBoundingBoxRight??0)-a;return n.width>0&&(l+=o),Math.max(r,l)}static _measureTextAdvance(t,e,i){return F._measureTextCore(t,e,i).metricWidth}static _measureTextCore(t,e,i){let r=!1;F.experimentalLetterSpacingSupported&&(F.experimentalLetterSpacing?(i.letterSpacing=`${e}px`,i.textLetterSpacing=`${e}px`,r=!0):(i.letterSpacing="0px",i.textLetterSpacing="0px"));const n=i.measureText(t);let o=n.width,a=0;return o>0&&(r?a=-e:a=(F.graphemeSegmenter(t).length-1)*e,o+=a),{metricWidth:o,metrics:n,letterSpacingVal:a}}static _wordWrap(t,e,i=F._canvas){return wd(t,e,i,F._measureTextAdvance,F.canBreakWords,F.canBreakChars,F.wordWrapSplit)}static isBreakingSpace(t,e){return wt(t)}static canBreakWords(t,e){return e}static canBreakChars(t,e,i,r,n){return!0}static wordWrapSplit(t){return F.graphemeSegmenter(t)}static measureFont(t){if(F._fonts[t])return F._fonts[t];const e=F._context;e.font=t;const i=e.measureText(F.METRICS_STRING+F.BASELINE_SYMBOL),r=i.actualBoundingBoxAscent??0,n=i.actualBoundingBoxDescent??0,o={ascent:r,descent:n,fontSize:r+n};return F._fonts[t]=o,o}static clearMetrics(t=""){t?delete F._fonts[t]:F._fonts={}}static get _canvas(){if(!F.__canvas){let t;try{const e=new OffscreenCanvas(0,0),i=e.getContext("2d",ln);if(i!=null&&i.measureText)return F.__canvas=e,e;t=z.get().createCanvas()}catch{t=z.get().createCanvas()}t.width=t.height=10,F.__canvas=t}return F.__canvas}static get _context(){return F.__context||(F.__context=F._canvas.getContext("2d",ln)),F.__context}};Dt.METRICS_STRING="|ÉqÅ";Dt.BASELINE_SYMBOL="M";Dt.BASELINE_MULTIPLIER=1.4;Dt.HEIGHT_MULTIPLIER=2;Dt.graphemeSegmenter=(()=>{if(typeof(Intl==null?void 0:Intl.Segmenter)=="function"){const s=new Intl.Segmenter;return t=>{const e=s.segment(t),i=[];let r=0;for(const n of e)i[r++]=n.segment;return i}}return s=>[...s]})();Dt.experimentalLetterSpacing=!1;Dt._fonts={};Dt._measurementCache=sd(1e3);let Ot=Dt;const vd=["serif","sans-serif","monospace","cursive","fantasy","system-ui"];function ki(s){const t=typeof s.fontSize=="number"?`${s.fontSize}px`:s.fontSize;let e=s.fontFamily;Array.isArray(s.fontFamily)||(e=s.fontFamily.split(","));for(let i=e.length-1;i>=0;i--){let r=e[i].trim();!/([\"\'])[^\'\"]+\1/.test(r)&&!vd.includes(r)&&(r=`"${r}"`),e[i]=r}return`${s.fontStyle} ${s.fontVariant} ${s.fontWeight} ${t} ${e.join(",")}`}const cn=1e5;function ds(s,t,e,i=0,r=0,n=0){if(s.texture===U.WHITE&&!s.fill)return q.shared.setValue(s.color).setAlpha(s.alpha??1).toHexa();if(s.fill){if(s.fill instanceof Is){const o=s.fill,a=t.createPattern(o.texture.source.resource,"repeat");return $.applyPatternTransform(a,o.transform,!1),a}else if(s.fill instanceof Ft){const o=s.fill,a=o.type==="linear",h=o.textureSpace==="local";let l=1,c=1;h&&e&&(l=e.width+i,c=e.height+i);let u,f=!1;if(a){const{start:d,end:p}=o;u=t.createLinearGradient(d.x*l+r,d.y*c+n,p.x*l+r,p.y*c+n),f=Math.abs(p.x-d.x)<Math.abs((p.y-d.y)*.1)}else{const{center:d,innerRadius:p,outerCenter:g,outerRadius:m}=o;u=t.createRadialGradient(d.x*l+r,d.y*c+n,p*l,g.x*l+r,g.y*c+n,m*l)}if(f&&h&&e){const d=e.lineHeight/c;for(let p=0;p<e.lines.length;p++){const g=(p*e.lineHeight+i/2)/c;o.colorStops.forEach(m=>{let _=g+m.offset*d;_=Math.max(0,Math.min(1,_)),u.addColorStop(Math.floor(_*cn)/cn,q.shared.setValue(m.color).toHex())})}}else o.colorStops.forEach(d=>{u.addColorStop(d.offset,q.shared.setValue(d.color).toHex())});return u}}else{const o=t.createPattern(s.texture.source.resource,"repeat"),a=s.matrix.copyTo(W.shared);return a.scale(s.texture.source.pixelWidth,s.texture.source.pixelHeight),o.setTransform(a),o}return Y("FillStyle not recognised",s),"red"}const un=new tt;function le(s){let t=0;for(let e=0;e<s.length;e++)s.charCodeAt(e)===32&&t++;return t}class Ad{getCanvasAndContext(t){const{text:e,style:i,resolution:r=1}=t,n=i._getFinalPadding(),o=Ot.measureText(e||" ",i),a=Math.ceil(Math.ceil(Math.max(1,o.width)+n*2)*r),h=Math.ceil(Math.ceil(Math.max(1,o.height)+n*2)*r),l=Mi.getOptimalCanvasAndContext(a,h);this._renderTextToCanvas(i,n,r,l,o);const c=i.trim?td({canvas:l.canvas,width:a,height:h,resolution:1,output:un}):un.set(0,0,a,h);return{canvasAndContext:l,frame:c}}returnCanvasAndContext(t){Mi.returnCanvasAndContext(t)}_renderTextToCanvas(t,e,i,r,n){var v,b,A;if(n.runsByLine&&n.runsByLine.length>0){this._renderTaggedTextToCanvas(n,t,e,i,r);return}const{canvas:o,context:a}=r,h=ki(t),l=n.lines,c=n.lineHeight,u=n.lineWidths,f=n.maxLineWidth,d=n.fontProperties,p=o.height;if(a.resetTransform(),a.scale(i,i),a.textBaseline=t.textBaseline,(v=t._stroke)!=null&&v.width){const k=t._stroke;a.lineWidth=k.width,a.miterLimit=k.miterLimit,a.lineJoin=k.join,a.lineCap=k.cap}a.font=h;let g,m;const _=t.dropShadow?2:1,x=(((b=t._stroke)==null?void 0:b.width)??0)/2;let w=(c-d.fontSize)/2;c-d.fontSize<0&&(w=0);for(let k=0;k<_;++k){const P=t.dropShadow&&k===0,S=P?Math.ceil(Math.max(1,p)+e*2):0,T=S*i;if(P)this._setupDropShadow(a,t,i,T);else{const M=t._gradientBounds,R=t._gradientOffset;if(M){const B={width:M.width,height:M.height,lineHeight:M.height,lines:n.lines};this._setFillAndStrokeStyles(a,t,B,e,x,(R==null?void 0:R.x)??0,(R==null?void 0:R.y)??0)}else R?this._setFillAndStrokeStyles(a,t,n,e,x,R.x,R.y):this._setFillAndStrokeStyles(a,t,n,e,x);a.shadowColor="rgba(0,0,0,0)"}for(let M=0;M<l.length;M++){g=x,m=x+M*c+d.ascent+w,g+=this._getAlignmentOffset(u[M],f,t.align);let R=0;if(t.align==="justify"&&t.wordWrap&&M<l.length-1){const B=le(l[M]);B>0&&(R=(f-u[M])/B)}(A=t._stroke)!=null&&A.width&&this._drawLetterSpacing(l[M],t,r,g+e,m+e-S,!0,R),t._fill!==void 0&&this._drawLetterSpacing(l[M],t,r,g+e,m+e-S,!1,R)}}}_renderTaggedTextToCanvas(t,e,i,r,n){var x,w,v;const{canvas:o,context:a}=n,{runsByLine:h,lineWidths:l,maxLineWidth:c,lineAscents:u,lineHeights:f,hasDropShadow:d}=t,p=o.height;a.resetTransform(),a.scale(r,r),a.textBaseline=e.textBaseline;const g=d?2:1;let m=((x=e._stroke)==null?void 0:x.width)??0;for(const b of h)for(const A of b){const k=((w=A.style._stroke)==null?void 0:w.width)??0;k>m&&(m=k)}const _=m/2,y=[];for(let b=0;b<h.length;b++){const A=h[b],k=[];for(const P of A){const S=ki(P.style);a.font=S,k.push({width:Ot._measureText(P.text,P.style.letterSpacing,a),font:S})}y.push(k)}for(let b=0;b<g;++b){const A=d&&b===0,k=A?Math.ceil(Math.max(1,p)+i*2):0,P=k*r;A||(a.shadowColor="rgba(0,0,0,0)");let S=_;for(let T=0;T<h.length;T++){const M=h[T],R=l[T],B=u[T],ht=f[T],C=y[T];let E=_;E+=this._getAlignmentOffset(R,c,e.align);let N=0;if(e.align==="justify"&&e.wordWrap&&T<h.length-1){let V=0;for(const D of M)V+=le(D.text);V>0&&(N=(c-R)/V)}const L=S+B;let H=E+i;for(let V=0;V<M.length;V++){const D=M[V],{width:et,font:ct}=C[V];if(a.font=ct,a.textBaseline=D.style.textBaseline,(v=D.style._stroke)!=null&&v.width){const it=D.style._stroke;if(a.lineWidth=it.width,a.miterLimit=it.miterLimit,a.lineJoin=it.join,a.lineCap=it.cap,A)if(D.style.dropShadow)this._setupDropShadow(a,D.style,r,P);else{const kt=le(D.text);H+=et+kt*N;continue}else{const kt=Ot.measureFont(ct),zt=D.style.lineHeight||kt.fontSize,re={width:et,height:zt,lineHeight:zt,lines:[D.text]};a.strokeStyle=ds(it,a,re,i*2,H-i,S)}this._drawLetterSpacing(D.text,D.style,n,H,L+i-k,!0,N)}const mt=le(D.text);H+=et+mt*N}H=E+i;for(let V=0;V<M.length;V++){const D=M[V],{width:et,font:ct}=C[V];if(a.font=ct,a.textBaseline=D.style.textBaseline,D.style._fill!==void 0){if(A)if(D.style.dropShadow)this._setupDropShadow(a,D.style,r,P);else{const it=le(D.text);H+=et+it*N;continue}else{const it=Ot.measureFont(ct),kt=D.style.lineHeight||it.fontSize,zt={width:et,height:kt,lineHeight:kt,lines:[D.text]};a.fillStyle=ds(D.style._fill,a,zt,i*2,H-i,S)}this._drawLetterSpacing(D.text,D.style,n,H,L+i-k,!1,N)}const mt=le(D.text);H+=et+mt*N}S+=ht}}}_setFillAndStrokeStyles(t,e,i,r,n,o=0,a=0){var h;if(t.fillStyle=e._fill?ds(e._fill,t,i,r*2,o,a):null,(h=e._stroke)!=null&&h.width){const l=n+r*2;t.strokeStyle=ds(e._stroke,t,i,l,o,a)}}_setupDropShadow(t,e,i,r){t.fillStyle="black",t.strokeStyle="black";const n=e.dropShadow,o=n.color,a=n.alpha;t.shadowColor=q.shared.setValue(o).setAlpha(a).toRgbaString();const h=n.blur*i,l=n.distance*i;t.shadowBlur=h,t.shadowOffsetX=Math.cos(n.angle)*l,t.shadowOffsetY=Math.sin(n.angle)*l+r}_getAlignmentOffset(t,e,i){return i==="right"?e-t:i==="center"?(e-t)/2:0}_drawLetterSpacing(t,e,i,r,n,o=!1,a=0){const{context:h}=i,l=e.letterSpacing;let c=!1;if(Ot.experimentalLetterSpacingSupported&&(Ot.experimentalLetterSpacing?(h.letterSpacing=`${l}px`,h.textLetterSpacing=`${l}px`,c=!0):(h.letterSpacing="0px",h.textLetterSpacing="0px")),(l===0||c)&&a===0){o?h.strokeText(t,r,n):h.fillText(t,r,n);return}if(a!==0&&(l===0||c)){const g=t.split(" ");let m=r;const _=h.measureText(" ").width;for(let y=0;y<g.length;y++)o?h.strokeText(g[y],m,n):h.fillText(g[y],m,n),m+=h.measureText(g[y]).width+_+a;return}let u=r;const f=Ot.graphemeSegmenter(t);let d=h.measureText(t).width,p=0;for(let g=0;g<f.length;++g){const m=f[g];o?h.strokeText(m,u,n):h.fillText(m,u,n);let _="";for(let y=g+1;y<f.length;++y)_+=f[y];p=h.measureText(_).width,u+=d-p+l,m===" "&&(u+=a),d=p}}}const fe=new Ad,Vi=class ee extends ft{constructor(t={}){super(),this.uid=J("textStyle"),this._tick=0,this._cachedFontString=null,Sd(t),t instanceof ee&&(t=t._toObject());const r={...ee.defaultTextStyle,...t};for(const n in r){const o=n;this[o]=r[n]}this._tagStyles=t.tagStyles??void 0,this.update(),this._tick=0}get align(){return this._align}set align(t){this._align!==t&&(this._align=t,this.update())}get breakWords(){return this._breakWords}set breakWords(t){this._breakWords!==t&&(this._breakWords=t,this.update())}get dropShadow(){return this._dropShadow}set dropShadow(t){this._dropShadow!==t&&(t!==null&&typeof t=="object"?this._dropShadow=this._createProxy({...ee.defaultDropShadow,...t}):this._dropShadow=t?this._createProxy({...ee.defaultDropShadow}):null,this.update())}get fontFamily(){return this._fontFamily}set fontFamily(t){this._fontFamily!==t&&(this._fontFamily=t,this.update())}get fontSize(){return this._fontSize}set fontSize(t){this._fontSize!==t&&(typeof t=="string"?this._fontSize=parseInt(t,10):this._fontSize=t,this.update())}get fontStyle(){return this._fontStyle}set fontStyle(t){this._fontStyle!==t&&(this._fontStyle=t.toLowerCase(),this.update())}get fontVariant(){return this._fontVariant}set fontVariant(t){this._fontVariant!==t&&(this._fontVariant=t,this.update())}get fontWeight(){return this._fontWeight}set fontWeight(t){this._fontWeight!==t&&(this._fontWeight=t,this.update())}get leading(){return this._leading}set leading(t){this._leading!==t&&(this._leading=t,this.update())}get letterSpacing(){return this._letterSpacing}set letterSpacing(t){this._letterSpacing!==t&&(this._letterSpacing=t,this.update())}get lineHeight(){return this._lineHeight}set lineHeight(t){this._lineHeight!==t&&(this._lineHeight=t,this.update())}get padding(){return this._padding}set padding(t){this._padding!==t&&(this._padding=t,this.update())}get filters(){return this._filters}set filters(t){this._filters!==t&&(this._filters=Object.freeze(t),this.update())}get trim(){return this._trim}set trim(t){this._trim!==t&&(this._trim=t,this.update())}get textBaseline(){return this._textBaseline}set textBaseline(t){this._textBaseline!==t&&(this._textBaseline=t,this.update())}get whiteSpace(){return this._whiteSpace}set whiteSpace(t){this._whiteSpace!==t&&(this._whiteSpace=t,this.update())}get wordWrap(){return this._wordWrap}set wordWrap(t){this._wordWrap!==t&&(this._wordWrap=t,this.update())}get wordWrapWidth(){return this._wordWrapWidth}set wordWrapWidth(t){this._wordWrapWidth!==t&&(this._wordWrapWidth=t,this.update())}get fill(){return this._originalFill}set fill(t){t!==this._originalFill&&(this._originalFill=t,this._isFillStyle(t)&&(this._originalFill=this._createProxy({...te.defaultFillStyle,...t},()=>{this._fill=se({...this._originalFill},te.defaultFillStyle)})),this._fill=se(t===0?"black":t,te.defaultFillStyle),this.update())}get stroke(){return this._originalStroke}set stroke(t){t!==this._originalStroke&&(this._originalStroke=t,this._isFillStyle(t)&&(this._originalStroke=this._createProxy({...te.defaultStrokeStyle,...t},()=>{this._stroke=bs({...this._originalStroke},te.defaultStrokeStyle)})),this._stroke=bs(t,te.defaultStrokeStyle),this.update())}get tagStyles(){return this._tagStyles}set tagStyles(t){this._tagStyles!==t&&(this._tagStyles=t??void 0,this.update())}update(){this._tick++,this._cachedFontString=null,this.emit("update",this)}reset(){const t=ee.defaultTextStyle;for(const e in t)this[e]=t[e]}assign(t){for(const e in t){const i=e;this[i]=t[e]}return this}get styleKey(){return`${this.uid}-${this._tick}`}get _fontString(){return this._cachedFontString===null&&(this._cachedFontString=ki(this)),this._cachedFontString}_toObject(){return{align:this.align,breakWords:this.breakWords,dropShadow:this._dropShadow?{...this._dropShadow}:null,fill:this._fill?{...this._fill}:void 0,fontFamily:this.fontFamily,fontSize:this.fontSize,fontStyle:this.fontStyle,fontVariant:this.fontVariant,fontWeight:this.fontWeight,leading:this.leading,letterSpacing:this.letterSpacing,lineHeight:this.lineHeight,padding:this.padding,stroke:this._stroke?{...this._stroke}:void 0,textBaseline:this.textBaseline,trim:this.trim,whiteSpace:this.whiteSpace,wordWrap:this.wordWrap,wordWrapWidth:this.wordWrapWidth,filters:this._filters?[...this._filters]:void 0,tagStyles:this._tagStyles?{...this._tagStyles}:void 0}}clone(){return new ee(this._toObject())}_getFinalPadding(){let t=0;if(this._filters)for(let e=0;e<this._filters.length;e++)t+=this._filters[e].padding;return Math.max(this._padding,t)}destroy(t=!1){var i,r,n,o;if(this.removeAllListeners(),typeof t=="boolean"?t:t==null?void 0:t.texture){const a=typeof t=="boolean"?t:t==null?void 0:t.textureSource;(i=this._fill)!=null&&i.texture&&this._fill.texture.destroy(a),(r=this._originalFill)!=null&&r.texture&&this._originalFill.texture.destroy(a),(n=this._stroke)!=null&&n.texture&&this._stroke.texture.destroy(a),(o=this._originalStroke)!=null&&o.texture&&this._originalStroke.texture.destroy(a)}this._fill=null,this._stroke=null,this.dropShadow=null,this._originalStroke=null,this._originalFill=null}_createProxy(t,e){return new Proxy(t,{set:(i,r,n)=>(i[r]===n||(i[r]=n,e==null||e(r,n),this.update()),!0)})}_isFillStyle(t){return(t??null)!==null&&!(q.isColorLike(t)||t instanceof Ft||t instanceof Is)}};Vi.defaultDropShadow={alpha:1,angle:Math.PI/6,blur:0,color:"black",distance:5};Vi.defaultTextStyle={align:"left",breakWords:!1,dropShadow:null,fill:"black",fontFamily:"Arial",fontSize:26,fontStyle:"normal",fontVariant:"normal",fontWeight:"normal",leading:0,letterSpacing:0,lineHeight:0,padding:0,stroke:null,textBaseline:"alphabetic",trim:!1,whiteSpace:"pre",wordWrap:!1,wordWrapWidth:100};let As=Vi;function Sd(s){const t=s;if(typeof t.dropShadow=="boolean"&&t.dropShadow){const e=As.defaultDropShadow;s.dropShadow={alpha:t.dropShadowAlpha??e.alpha,angle:t.dropShadowAngle??e.angle,blur:t.dropShadowBlur??e.blur,color:t.dropShadowColor??e.color,distance:t.dropShadowDistance??e.distance}}if(t.strokeThickness!==void 0){X(_t,"strokeThickness is now a part of stroke");const e=t.stroke;let i={};if(q.isColorLike(e))i.color=e;else if(e instanceof Ft||e instanceof Is)i.fill=e;else if(Object.hasOwnProperty.call(e,"color")||Object.hasOwnProperty.call(e,"fill"))i=e;else throw new Error("Invalid stroke value.");s.stroke={...i,width:t.strokeThickness}}if(Array.isArray(t.fillGradientStops)){if(X(_t,"gradient fill is now a fill pattern: `new FillGradient(...)`"),!Array.isArray(t.fill)||t.fill.length===0)throw new Error("Invalid fill value. Expected an array of colors for gradient fill.");t.fill.length!==t.fillGradientStops.length&&Y("The number of fill colors must match the number of fill gradient stops.");const e=new Ft({start:{x:0,y:0},end:{x:0,y:1},textureSpace:"local"}),i=t.fillGradientStops.slice(),r=t.fill.map(n=>q.shared.setValue(n).toNumber());i.forEach((n,o)=>{e.addColorStop(n,r[o])}),s.fill={fill:e}}}function Cd(s,t){const{texture:e,bounds:i}=s,r=t._style._getFinalPadding();vn(i,t._anchor,e);const n=t._anchor._x*r*2,o=t._anchor._y*r*2;i.minX-=r-n,i.minY-=r-o,i.maxX-=r-n,i.maxY-=r-o}class Td{constructor(){this.batcherName="default",this.topology="triangle-list",this.attributeSize=4,this.indexSize=6,this.packAsQuad=!0,this.roundPixels=0,this._attributeStart=0,this._batcher=null,this._batch=null}get blendMode(){return this.renderable.groupBlendMode}get color(){return this.renderable.groupColorAlpha}reset(){this.renderable=null,this.texture=null,this._batcher=null,this._batch=null,this.bounds=null}destroy(){this.reset()}}class Pd extends Td{}class jo{constructor(t){this._renderer=t,t.runners.resolutionChange.add(this),this._managedTexts=new Po({renderer:t,type:"renderable",onUnload:this.onTextUnload.bind(this),name:"canvasText"})}resolutionChange(){for(const t in this._managedTexts.items){const e=this._managedTexts.items[t];e!=null&&e._autoResolution&&e.onViewUpdate()}}validateRenderable(t){const e=this._getGpuText(t),i=t.styleKey;return e.currentKey!==i?!0:t._didTextUpdate}addRenderable(t,e){const i=this._getGpuText(t);if(t._didTextUpdate){const r=t._autoResolution?this._renderer.resolution:t.resolution;(i.currentKey!==t.styleKey||t._resolution!==r)&&this._updateGpuText(t),t._didTextUpdate=!1,Cd(i,t)}this._renderer.renderPipes.batch.addToBatch(i,e)}updateRenderable(t){const e=this._getGpuText(t);e._batcher.updateElement(e)}_updateGpuText(t){const e=this._getGpuText(t);e.texture&&this._renderer.canvasText.decreaseReferenceCount(e.currentKey),t._resolution=t._autoResolution?this._renderer.resolution:t.resolution,e.texture=this._renderer.canvasText.getManagedTexture(t),e.currentKey=t.styleKey}_getGpuText(t){return t._gpuData[this._renderer.uid]||this.initGpuText(t)}initGpuText(t){const e=new Pd;return e.currentKey="--",e.renderable=t,e.transform=t.groupTransform,e.bounds={minX:0,maxX:1,minY:0,maxY:0},e.roundPixels=this._renderer._roundPixels|t._roundPixels,t._gpuData[this._renderer.uid]=e,this._managedTexts.add(t),e}onTextUnload(t){const e=t._gpuData[this._renderer.uid];if(!e)return;const{canvasText:i}=this._renderer;i.getReferenceCount(e.currentKey)>0?i.decreaseReferenceCount(e.currentKey):e.texture&&i.returnTexture(e.texture)}destroy(){this._managedTexts.destroy(),this._renderer=null}}jo.extension={type:[I.WebGLPipes,I.WebGPUPipes,I.CanvasPipes],name:"text"};class Yo{constructor(t,e){this._activeTextures={},this._renderer=t,this._retainCanvasContext=e}getTexture(t,e,i,r){typeof t=="string"&&(X("8.0.0","CanvasTextSystem.getTexture: Use object TextOptions instead of separate arguments"),t={text:t,style:i,resolution:e}),t.style instanceof As||(t.style=new As(t.style)),t.textureStyle instanceof ye||(t.textureStyle=new ye(t.textureStyle)),typeof t.text!="string"&&(t.text=t.text.toString());const{text:n,style:o,textureStyle:a,autoGenerateMipmaps:h}=t,l=t.resolution??this._renderer.resolution,{frame:c,canvasAndContext:u}=fe.getCanvasAndContext({text:n,style:o,resolution:l}),f=Ku(u.canvas,c.width,c.height,l,h);if(a&&(f.source.style=a),o.trim&&(c.pad(o.padding),f.frame.copyFrom(c),f.frame.scale(1/l),f.updateUvs()),o.filters){const d=this._applyFilters(f,o.filters);return this.returnTexture(f),fe.returnCanvasAndContext(u),d}return this._renderer.texture.initSource(f._source),this._retainCanvasContext||fe.returnCanvasAndContext(u),f}returnTexture(t){const e=t.source,i=e.resource;if(this._retainCanvasContext&&(i!=null&&i.getContext)){const r=i.getContext("2d");r&&fe.returnCanvasAndContext({canvas:i,context:r})}e.resource=null,e.uploadMethodId="unknown",e.alphaMode="no-premultiply-alpha",Ts.returnTexture(t,!0)}renderTextToCanvas(){X("8.10.0","CanvasTextSystem.renderTextToCanvas: no longer supported, use CanvasTextSystem.getTexture instead")}getManagedTexture(t){t._resolution=t._autoResolution?this._renderer.resolution:t.resolution;const e=t.styleKey;if(this._activeTextures[e])return this._increaseReferenceCount(e),this._activeTextures[e].texture;const i=this.getTexture({text:t.text,style:t.style,resolution:t._resolution,textureStyle:t.textureStyle,autoGenerateMipmaps:t.autoGenerateMipmaps});return this._activeTextures[e]={texture:i,usageCount:1},i}decreaseReferenceCount(t){const e=this._activeTextures[t];e&&(e.usageCount--,e.usageCount===0&&(this.returnTexture(e.texture),this._activeTextures[t]=null))}getReferenceCount(t){var e;return((e=this._activeTextures[t])==null?void 0:e.usageCount)??0}_increaseReferenceCount(t){this._activeTextures[t].usageCount++}_applyFilters(t,e){const i=this._renderer.renderTarget.renderTarget,r=this._renderer.filter.generateFilteredTexture({texture:t,filters:e});return this._renderer.renderTarget.bind(i,!1),r}destroy(){this._renderer=null;for(const t in this._activeTextures)this._activeTextures[t]&&this.returnTexture(this._activeTextures[t].texture);this._activeTextures=null}}class Xo extends Yo{constructor(t){super(t,!0)}}Xo.extension={type:[I.CanvasSystem],name:"canvasText"};class qo extends Yo{constructor(t){super(t,!1)}}qo.extension={type:[I.WebGLSystem,I.WebGPUSystem],name:"canvasText"};K.add(Xo);K.add(qo);K.add(jo);class Md extends Qu{constructor(...t){const e=Zu(t,"Text");super(e,As),this.renderPipeId="text",e.textureStyle&&(this.textureStyle=e.textureStyle instanceof ye?e.textureStyle:new ye(e.textureStyle)),this.autoGenerateMipmaps=e.autoGenerateMipmaps??St.defaultOptions.autoGenerateMipmaps}updateBounds(){const t=this._bounds,e=this._anchor;let i=0,r=0;if(this._style.trim){const{frame:n,canvasAndContext:o}=fe.getCanvasAndContext({text:this.text,style:this._style,resolution:1});fe.returnCanvasAndContext(o),i=n.width,r=n.height}else{const n=Ot.measureText(this._text,this._style);i=n.width,r=n.height}t.minX=-e._x*i,t.maxX=t.minX+i,t.minY=-e._y*r,t.maxY=t.minY+r}}K.add(ha,la);let Ko;function kd(s){return Ko=s,s}function Xe(){return Ko}class Ei{static setParamValue(t,e){if(t.setValueAtTime){const i=Xe().context;t.setValueAtTime(e,i.audioContext.currentTime)}else t.value=e;return e}}class Ed extends ft{constructor(){super(...arguments),this.speed=1,this.muted=!1,this.volume=1,this.paused=!1}refresh(){this.emit("refresh")}refreshPaused(){this.emit("refreshPaused")}get filters(){return console.warn("HTML Audio does not support filters"),null}set filters(t){console.warn("HTML Audio does not support filters")}get audioContext(){return console.warn("HTML Audio does not support audioContext"),null}toggleMute(){return this.muted=!this.muted,this.refresh(),this.muted}togglePause(){return this.paused=!this.paused,this.refreshPaused(),this.paused}destroy(){this.removeAllListeners()}}let Id=0;const Ii=class extends ft{constructor(s){super(),this.id=Id++,this.init(s)}set(s,t){if(this[s]===void 0)throw new Error(`Property with name ${s} does not exist.`);switch(s){case"speed":this.speed=t;break;case"volume":this.volume=t;break;case"paused":this.paused=t;break;case"loop":this.loop=t;break;case"muted":this.muted=t;break}return this}get progress(){const{currentTime:s}=this._source;return s/this._duration}get paused(){return this._paused}set paused(s){this._paused=s,this.refreshPaused()}_onPlay(){this._playing=!0}_onPause(){this._playing=!1}init(s){this._playing=!1,this._duration=s.source.duration;const t=this._source=s.source.cloneNode(!1);t.src=s.parent.url,t.onplay=this._onPlay.bind(this),t.onpause=this._onPause.bind(this),s.context.on("refresh",this.refresh,this),s.context.on("refreshPaused",this.refreshPaused,this),this._media=s}_internalStop(){this._source&&this._playing&&(this._source.onended=null,this._source.pause())}stop(){this._internalStop(),this._source&&this.emit("stop")}get speed(){return this._speed}set speed(s){this._speed=s,this.refresh()}get volume(){return this._volume}set volume(s){this._volume=s,this.refresh()}get loop(){return this._loop}set loop(s){this._loop=s,this.refresh()}get muted(){return this._muted}set muted(s){this._muted=s,this.refresh()}get filters(){return console.warn("HTML Audio does not support filters"),null}set filters(s){console.warn("HTML Audio does not support filters")}refresh(){const s=this._media.context,t=this._media.parent;this._source.loop=this._loop||t.loop;const e=s.volume*(s.muted?0:1),i=t.volume*(t.muted?0:1),r=this._volume*(this._muted?0:1);this._source.volume=r*e*i,this._source.playbackRate=this._speed*s.speed*t.speed}refreshPaused(){const s=this._media.context,t=this._media.parent,e=this._paused||t.paused||s.paused;e!==this._pausedReal&&(this._pausedReal=e,e?(this._internalStop(),this.emit("paused")):(this.emit("resumed"),this.play({start:this._source.currentTime,end:this._end,volume:this._volume,speed:this._speed,loop:this._loop})),this.emit("pause",e))}play(s){const{start:t,end:e,speed:i,loop:r,volume:n,muted:o}=s;e&&console.assert(e>t,"End time is before start time"),this._speed=i,this._volume=n,this._loop=!!r,this._muted=o,this.refresh(),this.loop&&e!==null&&(console.warn('Looping not support when specifying an "end" time'),this.loop=!1),this._start=t,this._end=e||this._duration,this._start=Math.max(0,this._start-Ii.PADDING),this._end=Math.min(this._end+Ii.PADDING,this._duration),this._source.onloadedmetadata=()=>{this._source&&(this._source.currentTime=t,this._source.onloadedmetadata=null,this.emit("progress",t/this._duration,this._duration),dt.shared.add(this._onUpdate,this))},this._source.onended=this._onComplete.bind(this),this._source.play(),this.emit("start")}_onUpdate(){this.emit("progress",this.progress,this._duration),this._source.currentTime>=this._end&&!this._source.loop&&this._onComplete()}_onComplete(){dt.shared.remove(this._onUpdate,this),this._internalStop(),this.emit("progress",1,this._duration),this.emit("end",this)}destroy(){dt.shared.remove(this._onUpdate,this),this.removeAllListeners();const s=this._source;s&&(s.onended=null,s.onplay=null,s.onpause=null,this._internalStop()),this._source=null,this._speed=1,this._volume=1,this._loop=!1,this._end=null,this._start=0,this._duration=0,this._playing=!1,this._pausedReal=!1,this._paused=!1,this._muted=!1,this._media&&(this._media.context.off("refresh",this.refresh,this),this._media.context.off("refreshPaused",this.refreshPaused,this),this._media=null)}toString(){return`[HTMLAudioInstance id=${this.id}]`}};let Qo=Ii;Qo.PADDING=.1;class Rd extends ft{init(t){this.parent=t,this._source=t.options.source||new Audio,t.url&&(this._source.src=t.url)}create(){return new Qo(this)}get isPlayable(){return!!this._source&&this._source.readyState===4}get duration(){return this._source.duration}get context(){return this.parent.context}get filters(){return null}set filters(t){console.warn("HTML Audio does not support filters")}destroy(){this.removeAllListeners(),this.parent=null,this._source&&(this._source.src="",this._source.load(),this._source=null)}get source(){return this._source}load(t){const e=this._source,i=this.parent;if(e.readyState===4){i.isLoaded=!0;const h=i.autoPlayStart();t&&setTimeout(()=>{t(null,i,h)},0);return}if(!i.url){t(new Error("sound.url or sound.source must be set"));return}e.src=i.url;const r=()=>{a(),i.isLoaded=!0;const h=i.autoPlayStart();t&&t(null,i,h)},n=()=>{a(),t&&t(new Error("Sound loading has been aborted"))},o=()=>{a();const h=`Failed to load audio element (code: ${e.error.code})`;t?t(new Error(h)):console.error(h)},a=()=>{e.removeEventListener("canplaythrough",r),e.removeEventListener("load",r),e.removeEventListener("abort",n),e.removeEventListener("error",o)};e.addEventListener("canplaythrough",r,!1),e.addEventListener("load",r,!1),e.addEventListener("abort",n,!1),e.addEventListener("error",o,!1),e.load()}}class Ld{constructor(t,e){this.parent=t,Object.assign(this,e),this.duration=this.end-this.start,console.assert(this.duration>0,"End time must be after start time")}play(t){return this.parent.play({complete:t,speed:this.speed||this.parent.speed,end:this.end,start:this.start,loop:this.loop})}destroy(){this.parent=null}}const Ss=["ogg","oga","opus","m4a","mp3","mpeg","wav","aiff","wma","mid","caf"],Bd=["audio/mpeg","audio/ogg"],Cs={};function Fd(s){const t={m4a:"audio/mp4",oga:"audio/ogg",opus:'audio/ogg; codecs="opus"',caf:'audio/x-caf; codecs="opus"'},e=document.createElement("audio"),i={},r=/^no$/;Ss.forEach(n=>{const o=e.canPlayType(`audio/${n}`).replace(r,""),a=t[n]?e.canPlayType(t[n]).replace(r,""):"";i[n]=!!o||!!a}),Object.assign(Cs,i)}Fd();let Gd=0;class Dd extends ft{constructor(t){super(),this.id=Gd++,this._media=null,this._paused=!1,this._muted=!1,this._elapsed=0,this.init(t)}set(t,e){if(this[t]===void 0)throw new Error(`Property with name ${t} does not exist.`);switch(t){case"speed":this.speed=e;break;case"volume":this.volume=e;break;case"muted":this.muted=e;break;case"loop":this.loop=e;break;case"paused":this.paused=e;break}return this}stop(){this._source&&(this._internalStop(),this.emit("stop"))}get speed(){return this._speed}set speed(t){this._speed=t,this.refresh(),this._update(!0)}get volume(){return this._volume}set volume(t){this._volume=t,this.refresh()}get muted(){return this._muted}set muted(t){this._muted=t,this.refresh()}get loop(){return this._loop}set loop(t){this._loop=t,this.refresh()}get filters(){return this._filters}set filters(t){var e;this._filters&&((e=this._filters)==null||e.filter(i=>i).forEach(i=>i.disconnect()),this._filters=null,this._source.connect(this._gain)),this._filters=t!=null&&t.length?t.slice(0):null,this.refresh()}refresh(){if(!this._source)return;const t=this._media.context,e=this._media.parent;this._source.loop=this._loop||e.loop;const i=t.volume*(t.muted?0:1),r=e.volume*(e.muted?0:1),n=this._volume*(this._muted?0:1);Ei.setParamValue(this._gain.gain,n*r*i),Ei.setParamValue(this._source.playbackRate,this._speed*e.speed*t.speed),this.applyFilters()}applyFilters(){var t;if((t=this._filters)!=null&&t.length){this._source.disconnect();let e=this._source;this._filters.forEach(i=>{e.connect(i.destination),e=i}),e.connect(this._gain)}}refreshPaused(){const t=this._media.context,e=this._media.parent,i=this._paused||e.paused||t.paused;i!==this._pausedReal&&(this._pausedReal=i,i?(this._internalStop(),this.emit("paused")):(this.emit("resumed"),this.play({start:this._elapsed%this._duration,end:this._end,speed:this._speed,loop:this._loop,volume:this._volume})),this.emit("pause",i))}play(t){const{start:e,end:i,speed:r,loop:n,volume:o,muted:a,filters:h}=t;i&&console.assert(i>e,"End time is before start time"),this._paused=!1;const{source:l,gain:c}=this._media.nodes.cloneBufferSource();this._source=l,this._gain=c,this._speed=r,this._volume=o,this._loop=!!n,this._muted=a,this._filters=h,this.refresh();const u=this._source.buffer.duration;this._duration=u,this._end=i,this._lastUpdate=this._now(),this._elapsed=e,this._source.onended=this._onComplete.bind(this),this._loop?(this._source.loopEnd=i,this._source.loopStart=e,this._source.start(0,e)):i?this._source.start(0,e,i-e):this._source.start(0,e),this.emit("start"),this._update(!0),this.enableTicker(!0)}enableTicker(t){dt.shared.remove(this._updateListener,this),t&&dt.shared.add(this._updateListener,this)}get progress(){return this._progress}get paused(){return this._paused}set paused(t){this._paused=t,this.refreshPaused()}destroy(){var t;this.removeAllListeners(),this._internalStop(),this._gain&&(this._gain.disconnect(),this._gain=null),this._media&&(this._media.context.events.off("refresh",this.refresh,this),this._media.context.events.off("refreshPaused",this.refreshPaused,this),this._media=null),(t=this._filters)==null||t.forEach(e=>e.disconnect()),this._filters=null,this._end=null,this._speed=1,this._volume=1,this._loop=!1,this._elapsed=0,this._duration=0,this._paused=!1,this._muted=!1,this._pausedReal=!1}toString(){return`[WebAudioInstance id=${this.id}]`}_now(){return this._media.context.audioContext.currentTime}_updateListener(){this._update()}_update(t=!1){if(this._source){const e=this._now(),i=e-this._lastUpdate;if(i>0||t){const r=this._source.playbackRate.value;this._elapsed+=i*r,this._lastUpdate=e;const n=this._duration;let o;if(this._source.loopStart){const a=this._source.loopEnd-this._source.loopStart;o=(this._source.loopStart+this._elapsed%a)/n}else o=this._elapsed%n/n;this._progress=o,this.emit("progress",this._progress,n)}}}init(t){this._media=t,t.context.events.on("refresh",this.refresh,this),t.context.events.on("refreshPaused",this.refreshPaused,this)}_internalStop(){if(this._source){this.enableTicker(!1),this._source.onended=null,this._source.stop(0),this._source.disconnect();try{this._source.buffer=null}catch(t){console.warn("Failed to set AudioBufferSourceNode.buffer to null:",t)}this._source=null}}_onComplete(){if(this._source){this.enableTicker(!1),this._source.onended=null,this._source.disconnect();try{this._source.buffer=null}catch(t){console.warn("Failed to set AudioBufferSourceNode.buffer to null:",t)}}this._source=null,this._progress=1,this.emit("progress",1,this._duration),this.emit("end",this)}}class Zo{constructor(t,e){this._output=e,this._input=t}get destination(){return this._input}get filters(){return this._filters}set filters(t){if(this._filters&&(this._filters.forEach(e=>{e&&e.disconnect()}),this._filters=null,this._input.connect(this._output)),t&&t.length){this._filters=t.slice(0),this._input.disconnect();let e=null;t.forEach(i=>{e===null?this._input.connect(i.destination):e.connect(i.destination),e=i}),e.connect(this._output)}}destroy(){this.filters=null,this._input=null,this._output=null}}const Jo=class extends Zo{constructor(s){const t=s.audioContext,e=t.createBufferSource(),i=t.createGain(),r=t.createAnalyser();e.connect(r),r.connect(i),i.connect(s.destination),super(r,i),this.context=s,this.bufferSource=e,this.gain=i,this.analyser=r}get script(){return this._script||(this._script=this.context.audioContext.createScriptProcessor(Jo.BUFFER_SIZE),this._script.connect(this.context.destination)),this._script}destroy(){super.destroy(),this.bufferSource.disconnect(),this._script&&this._script.disconnect(),this.gain.disconnect(),this.analyser.disconnect(),this.bufferSource=null,this._script=null,this.gain=null,this.analyser=null,this.context=null}cloneBufferSource(){const s=this.bufferSource,t=this.context.audioContext.createBufferSource();t.buffer=s.buffer,Ei.setParamValue(t.playbackRate,s.playbackRate.value),t.loop=s.loop;const e=this.context.audioContext.createGain();return t.connect(e),e.connect(this.destination),{source:t,gain:e}}get bufferSize(){return this.script.bufferSize}};let ta=Jo;ta.BUFFER_SIZE=0;class Od{init(t){this.parent=t,this._nodes=new ta(this.context),this._source=this._nodes.bufferSource,this.source=t.options.source}destroy(){this.parent=null,this._nodes.destroy(),this._nodes=null;try{this._source.buffer=null}catch(t){console.warn("Failed to set AudioBufferSourceNode.buffer to null:",t)}this._source=null,this.source=null}create(){return new Dd(this)}get context(){return this.parent.context}get isPlayable(){return!!this._source&&!!this._source.buffer}get filters(){return this._nodes.filters}set filters(t){this._nodes.filters=t}get duration(){return console.assert(this.isPlayable,"Sound not yet playable, no duration"),this._source.buffer.duration}get buffer(){return this._source.buffer}set buffer(t){this._source.buffer=t}get nodes(){return this._nodes}load(t){this.source?this._decode(this.source,t):this.parent.url?this._loadUrl(t):t?t(new Error("sound.url or sound.source must be set")):console.error("sound.url or sound.source must be set")}async _loadUrl(t){const e=this.parent.url,i=await z.get().fetch(e);this._decode(await i.arrayBuffer(),t)}_decode(t,e){const i=(r,n)=>{if(r)e&&e(r);else{this.parent.isLoaded=!0,this.buffer=n;const o=this.parent.autoPlayStart();e&&e(null,this.parent,o)}};t instanceof AudioBuffer?i(null,t):this.parent.context.decode(t,i)}}const ce=class{static from(s){let t={};typeof s=="string"?t.url=s:s instanceof ArrayBuffer||s instanceof AudioBuffer||s instanceof HTMLAudioElement?t.source=s:Array.isArray(s)?t.url=s:t=s,t={autoPlay:!1,singleInstance:!1,url:null,source:null,preload:!1,volume:1,speed:1,complete:null,loaded:null,loop:!1,...t},Object.freeze(t);const e=Xe().useLegacy?new Rd:new Od;return new ce(e,t)}constructor(s,t){this.media=s,this.options=t,this._instances=[],this._sprites={},this.media.init(this);const e=t.complete;this._autoPlayOptions=e?{complete:e}:null,this.isLoaded=!1,this._preloadQueue=null,this.isPlaying=!1,this.autoPlay=t.autoPlay,this.singleInstance=t.singleInstance,this.preload=t.preload||this.autoPlay,this.url=Array.isArray(t.url)?this.preferUrl(t.url):t.url,this.speed=t.speed,this.volume=t.volume,this.loop=t.loop,t.sprites&&this.addSprites(t.sprites),this.preload&&this._preload(t.loaded)}preferUrl(s){const[t]=s.map(e=>({url:e,ext:at.extname(e).slice(1)})).filter(({ext:e})=>Cs[e]).sort((e,i)=>Ss.indexOf(e.ext)-Ss.indexOf(i.ext));if(!t)throw new Error("No supported file type found");return t.url}get context(){return Xe().context}pause(){return this.isPlaying=!1,this.paused=!0,this}resume(){return this.isPlaying=this._instances.length>0,this.paused=!1,this}get paused(){return this._paused}set paused(s){this._paused=s,this.refreshPaused()}get speed(){return this._speed}set speed(s){this._speed=s,this.refresh()}get filters(){return this.media.filters}set filters(s){this.media.filters=s}addSprites(s,t){if(typeof s=="object"){const i={};for(const r in s)i[r]=this.addSprites(r,s[r]);return i}console.assert(!this._sprites[s],`Alias ${s} is already taken`);const e=new Ld(this,t);return this._sprites[s]=e,e}destroy(){this._removeInstances(),this.removeSprites(),this.media.destroy(),this.media=null,this._sprites=null,this._instances=null}removeSprites(s){if(s){const t=this._sprites[s];t!==void 0&&(t.destroy(),delete this._sprites[s])}else for(const t in this._sprites)this.removeSprites(t);return this}get isPlayable(){return this.isLoaded&&this.media&&this.media.isPlayable}stop(){if(!this.isPlayable)return this.autoPlay=!1,this._autoPlayOptions=null,this;this.isPlaying=!1;for(let s=this._instances.length-1;s>=0;s--)this._instances[s].stop();return this}play(s,t){let e;if(typeof s=="string"?e={sprite:s,loop:this.loop,complete:t}:typeof s=="function"?(e={},e.complete=s):e=s,e={complete:null,loaded:null,sprite:null,end:null,start:0,volume:1,speed:1,muted:!1,loop:!1,...e||{}},e.sprite){const r=e.sprite;console.assert(!!this._sprites[r],`Alias ${r} is not available`);const n=this._sprites[r];e.start=n.start+(e.start||0),e.end=n.end,e.speed=n.speed||1,e.loop=n.loop||e.loop,delete e.sprite}if(e.offset&&(e.start=e.offset),!this.isLoaded)return this._preloadQueue?new Promise(r=>{this._preloadQueue.push(()=>{r(this.play(e))})}):(this._preloadQueue=[],this.autoPlay=!0,this._autoPlayOptions=e,new Promise((r,n)=>{this._preload((o,a,h)=>{this._preloadQueue.forEach(l=>l()),this._preloadQueue=null,o?n(o):(e.loaded&&e.loaded(o,a,h),r(h))})}));(this.singleInstance||e.singleInstance)&&this._removeInstances();const i=this._createInstance();return this._instances.push(i),this.isPlaying=!0,i.once("end",()=>{e.complete&&e.complete(this),this._onComplete(i)}),i.once("stop",()=>{this._onComplete(i)}),i.play(e),i}refresh(){const s=this._instances.length;for(let t=0;t<s;t++)this._instances[t].refresh()}refreshPaused(){const s=this._instances.length;for(let t=0;t<s;t++)this._instances[t].refreshPaused()}get volume(){return this._volume}set volume(s){this._volume=s,this.refresh()}get muted(){return this._muted}set muted(s){this._muted=s,this.refresh()}get loop(){return this._loop}set loop(s){this._loop=s,this.refresh()}_preload(s){this.media.load(s)}get instances(){return this._instances}get sprites(){return this._sprites}get duration(){return this.media.duration}autoPlayStart(){let s;return this.autoPlay&&(s=this.play(this._autoPlayOptions)),s}_removeInstances(){for(let s=this._instances.length-1;s>=0;s--)this._poolInstance(this._instances[s]);this._instances.length=0}_onComplete(s){if(this._instances){const t=this._instances.indexOf(s);t>-1&&this._instances.splice(t,1),this.isPlaying=this._instances.length>0}this._poolInstance(s)}_createInstance(){if(ce._pool.length>0){const s=ce._pool.pop();return s.init(this.media),s}return this.media.create()}_poolInstance(s){s.destroy(),ce._pool.indexOf(s)<0&&ce._pool.push(s)}};let qe=ce;qe._pool=[];class Ke extends Zo{constructor(){const t=window,e=new Ke.AudioContext,i=e.createDynamicsCompressor(),r=e.createAnalyser();r.connect(i),i.connect(e.destination),super(r,i),this.autoPause=!0,this._ctx=e,this._offlineCtx=new Ke.OfflineAudioContext(1,2,t.OfflineAudioContext?Math.max(8e3,Math.min(96e3,e.sampleRate)):44100),this.compressor=i,this.analyser=r,this.events=new ft,this.volume=1,this.speed=1,this.muted=!1,this.paused=!1,this._locked=e.state==="suspended"&&("ontouchstart"in globalThis||"onclick"in globalThis),this._locked&&(this._unlock(),this._unlock=this._unlock.bind(this),document.addEventListener("mousedown",this._unlock,!0),document.addEventListener("touchstart",this._unlock,!0),document.addEventListener("touchend",this._unlock,!0)),this.onFocus=this.onFocus.bind(this),this.onBlur=this.onBlur.bind(this),globalThis.addEventListener("focus",this.onFocus),globalThis.addEventListener("blur",this.onBlur)}onFocus(){if(!this.autoPause)return;const t=this._ctx.state;(t==="suspended"||t==="interrupted"||!this._locked)&&(this.paused=this._pausedOnBlur,this.refreshPaused())}onBlur(){this.autoPause&&(this._locked||(this._pausedOnBlur=this._paused,this.paused=!0,this.refreshPaused()))}_unlock(){this._locked&&(this.playEmptySound(),this._ctx.state==="running"&&(document.removeEventListener("mousedown",this._unlock,!0),document.removeEventListener("touchend",this._unlock,!0),document.removeEventListener("touchstart",this._unlock,!0),this._locked=!1))}playEmptySound(){const t=this._ctx.createBufferSource();t.buffer=this._ctx.createBuffer(1,1,22050),t.connect(this._ctx.destination),t.start(0,0,0),t.context.state==="suspended"&&t.context.resume()}static get AudioContext(){const t=window;return t.AudioContext||t.webkitAudioContext||null}static get OfflineAudioContext(){const t=window;return t.OfflineAudioContext||t.webkitOfflineAudioContext||null}destroy(){super.destroy();const t=this._ctx;typeof t.close<"u"&&t.close(),globalThis.removeEventListener("focus",this.onFocus),globalThis.removeEventListener("blur",this.onBlur),this.events.removeAllListeners(),this.analyser.disconnect(),this.compressor.disconnect(),this.analyser=null,this.compressor=null,this.events=null,this._offlineCtx=null,this._ctx=null}get audioContext(){return this._ctx}get offlineContext(){return this._offlineCtx}set paused(t){t&&this._ctx.state==="running"?this._ctx.suspend():!t&&this._ctx.state==="suspended"&&this._ctx.resume(),this._paused=t}get paused(){return this._paused}refresh(){this.events.emit("refresh")}refreshPaused(){this.events.emit("refreshPaused")}toggleMute(){return this.muted=!this.muted,this.refresh(),this.muted}togglePause(){return this.paused=!this.paused,this.refreshPaused(),this._paused}decode(t,e){const i=n=>{e(new Error((n==null?void 0:n.message)||"Unable to decode file"))},r=this._offlineCtx.decodeAudioData(t,n=>{e(null,n)},i);r&&r.catch(i)}}class Wd{constructor(){this.init()}init(){return this.supported&&(this._webAudioContext=new Ke),this._htmlAudioContext=new Ed,this._sounds={},this.useLegacy=!this.supported,this}get context(){return this._context}get filtersAll(){return this.useLegacy?[]:this._context.filters}set filtersAll(t){this.useLegacy||(this._context.filters=t)}get supported(){return Ke.AudioContext!==null}add(t,e){if(typeof t=="object"){const n={};for(const o in t){const a=this._getOptions(t[o],e);n[o]=this.add(o,a)}return n}if(console.assert(!this._sounds[t],`Sound with alias ${t} already exists.`),e instanceof qe)return this._sounds[t]=e,e;const i=this._getOptions(e),r=qe.from(i);return this._sounds[t]=r,r}_getOptions(t,e){let i;return typeof t=="string"?i={url:t}:Array.isArray(t)?i={url:t}:t instanceof ArrayBuffer||t instanceof AudioBuffer||t instanceof HTMLAudioElement?i={source:t}:i=t,i={...i,...e||{}},i}get useLegacy(){return this._useLegacy}set useLegacy(t){this._useLegacy=t,this._context=!t&&this.supported?this._webAudioContext:this._htmlAudioContext}get disableAutoPause(){return!this._webAudioContext.autoPause}set disableAutoPause(t){this._webAudioContext.autoPause=!t}remove(t){return this.exists(t,!0),this._sounds[t].destroy(),delete this._sounds[t],this}get volumeAll(){return this._context.volume}set volumeAll(t){this._context.volume=t,this._context.refresh()}get speedAll(){return this._context.speed}set speedAll(t){this._context.speed=t,this._context.refresh()}togglePauseAll(){return this._context.togglePause()}pauseAll(){return this._context.paused=!0,this._context.refreshPaused(),this}resumeAll(){return this._context.paused=!1,this._context.refreshPaused(),this}toggleMuteAll(){return this._context.toggleMute()}muteAll(){return this._context.muted=!0,this._context.refresh(),this}unmuteAll(){return this._context.muted=!1,this._context.refresh(),this}removeAll(){for(const t in this._sounds)this._sounds[t].destroy(),delete this._sounds[t];return this}stopAll(){for(const t in this._sounds)this._sounds[t].stop();return this}exists(t,e=!1){const i=!!this._sounds[t];return e&&console.assert(i,`No sound matching alias '${t}'.`),i}isPlaying(){for(const t in this._sounds)if(this._sounds[t].isPlaying)return!0;return!1}find(t){return this.exists(t,!0),this._sounds[t]}play(t,e){return this.find(t).play(e)}stop(t){return this.find(t).stop()}pause(t){return this.find(t).pause()}resume(t){return this.find(t).resume()}volume(t,e){const i=this.find(t);return e!==void 0&&(i.volume=e),i.volume}speed(t,e){const i=this.find(t);return e!==void 0&&(i.speed=e),i.speed}duration(t){return this.find(t).duration}close(){return this.removeAll(),this._sounds=null,this._webAudioContext&&(this._webAudioContext.destroy(),this._webAudioContext=null),this._htmlAudioContext&&(this._htmlAudioContext.destroy(),this._htmlAudioContext=null),this._context=null,this}}const dn=s=>{var i;const t=s.src;let e=(i=s==null?void 0:s.alias)==null?void 0:i[0];return(!e||s.src===e)&&(e=at.basename(t,at.extname(t))),e},Ud={extension:I.Asset,detection:{test:async()=>!0,add:async s=>[...s,...Ss.filter(t=>Cs[t])],remove:async s=>s.filter(t=>s.includes(t))},loader:{name:"sound",extension:{type:[I.LoadParser],priority:Gt.High},test(s){const t=at.extname(s).slice(1);return!!Cs[t]||Bd.some(e=>s.startsWith(`data:${e}`))},async load(s,t){const e=await new Promise((i,r)=>qe.from({...t.data,url:s,preload:!0,loaded(n,o){var a,h;n?r(n):i(o),(h=(a=t.data)==null?void 0:a.loaded)==null||h.call(a,n,o)}}));return Xe().add(dn(t),e),e},async unload(s,t){Xe().remove(dn(t))}}};K.add(Ud);const j=kd(new Wd);class fn{constructor(t,e){G(this,"font");G(this,"difficulty");G(this,"game");G(this,"currentPlayerLives");G(this,"updatePlayerLives",!0);G(this,"updateEnemyLives",!0);G(this,"playerLives");G(this,"enemyLives");G(this,"outcome",null);this.font="",this.difficulty=t,this.game=e,this.currentPlayerLives=3,this.playerLives=[],this.enemyLives=[]}render(){this.updatePlayerLives&&(this.drawLives(this.game.playerLives),this.updatePlayerLives=!1,this.drawEnemyLives())}drawLives(t){let e=0;for(;e<t;){const i=yt.from("life");i.anchor=.5,i.x=10+15*e,i.y=10,i.width=12.5,i.height=12.5,i.label=`life${e+1}`,this.playerLives.push(i),this.game.app.stage.addChild(i),e++}}removeLife(){const t=this.game.app.stage.getChildByLabel("life1"),e=this.game.app.stage.getChildByLabel("life2"),i=this.game.app.stage.getChildByLabel("life3");i!==null&&!i.destroyed?i.destroy():e!==null&&!e.destroyed?e.destroy():t!==null&&t.destroy()}removeEnemyLife(){const t=this.game.app.stage.getChildByLabel("enemyLife1"),e=this.game.app.stage.getChildByLabel("enemyLife2"),i=this.game.app.stage.getChildByLabel("enemyLife3");i!==null&&!i.destroyed?i.destroy():e!==null&&!e.destroyed?e.destroy():t!==null&&t.destroy()}drawEnemyLives(){let t=0;for(;t<3;){const e=yt.from("wave");e.anchor=.5,e.x=this.game.app.screen.width-(10+t*15),e.y=10,e.width=12.5,e.height=12.5,e.label=`enemyLife${t+1}`,this.enemyLives.push(e),this.game.app.stage.addChild(e),t++}}shakeLives(t){if(this.game.framesRendered%30==0){const e=this.playerLives.filter(r=>!r.destroyed);this.playerLives.forEach(r=>{e.length==1&&(r.rotation==0?r.rotation=.5*1*t.deltaTime:r.rotation>0?r.rotation=.5*-1*t.deltaTime:r.rotation<0&&(r.rotation=.5*1*t.deltaTime))});const i=this.enemyLives.filter(r=>r.destroyed).length;this.enemyLives.forEach(r=>{i===2&&!r.destroyed&&r.label==="enemyLife1"&&(r.y==10||r.y>10?r.y=r.y-2*t.deltaTime:r.y<10&&(r.y=r.y+2*t.deltaTime))})}}renderOutcome(t,e,i){if(!this.game.app.stage.getChildByLabel("outcome")){const r=new Md({text:t,style:{fill:"#ffffff",fontSize:36,fontFamily:"silkscreen"},anchor:.5});return r.x=e,r.y=i,r.label="outcome",this.game.app.stage.addChild(r),r}}update(t){this.shakeLives(t)}}class we{constructor(t,e,i,r,n){G(this,"type");G(this,"texture");G(this,"sound");G(this,"speed");G(this,"yDirection");G(this,"behavior");G(this,"sprite");G(this,"entity");G(this,"stats");G(this,"game");G(this,"scattered",!1);G(this,"scatterSpeed",.25);this.stats=this.getStats(e),this.game=t.game,this.entity=t,this.type=e,this.texture=this.stats.texture,this.behavior=this.stats.behavior,this.speed=this.stats.speed,this.sound=this.stats.sound,this.yDirection=i,this.sprite=this.spawn(r,n),this.scatterSpeed=.25}spawn(t,e){const i=yt.from(this.texture);return i.x=t,i.y=e,i.anchor.set(.5),i.scale.set(.075),this.game.app.stage.addChild(i),j.play(this.sound,{volume:.45}),i}update(t){if(this.sprite.destroyed){this.entity.bullets=this.entity.bullets.filter(i=>!i.sprite.destroyed);return}const e=this.sprite.getBounds();if(e.y<-(this.sprite.height+5)||e.y>this.game.app.screen.height+this.sprite.height)this.sprite.destroy(),this.entity.bullets=this.entity.bullets.filter(i=>!i.sprite.destroyed);else{switch(this.type){case 1:this.entity.constructor.name=="Enemy"&&(console.log(this.entity.constructor.name),this.sprite.tint="#ff1362");break;case 2:this.sprite.width+=.2*t.deltaTime,this.sprite.height+=.2*t.deltaTime;break;case 3:this.sprite.y>this.game.app.screen.height/2-20&&!this.scattered&&this.sprite.label!=="left"&&this.sprite.label!=="right"&&this.scatter(this),this.sprite.rotation+=.5*t.deltaTime;break}this.sprite.y+=this.stats.speed*this.yDirection*.2*t.deltaTime,this.sprite.label=="left"?this.sprite.x-=this.scatterSpeed*t.deltaTime:this.sprite.label=="right"&&(this.sprite.x+=this.scatterSpeed*t.deltaTime)}}scatter(t){let e=t.sprite.x-t.sprite.width/2;const i=t.sprite.y,r=new we(t.entity,t.type,t.yDirection,e,i);r.sprite.label="left",r.sprite.alpha=.5,this.entity.bullets.push(r),e=t.sprite.x+t.sprite.width/2;const n=new we(t.entity,t.type,t.yDirection,e,i);n.sprite.label="right",n.sprite.alpha=.5,t.scattered=!0,this.entity.bullets.push(n)}getStats(t){return{1:{texture:"bullet1",behavior:"normal",speed:9,sound:"enemyShoot1"},2:{texture:"bullet2",behavior:"grow",speed:6,sound:"shoot1"},3:{texture:"bullet3",behavior:"scatter",speed:10-.75,sound:"enemyShoot"}}[t]}}class ea{constructor(t,e,i){G(this,"health");G(this,"texture");G(this,"fireRate");G(this,"bulletType");G(this,"sprite");G(this,"game");G(this,"shootCooldown",250);G(this,"shootOnCooldown",!1);G(this,"bullets",[]);this.health=e,this.texture="",this.fireRate=0,this.bulletType=t,this.sprite=yt.from(""),this.game=i}takeDamage(){this.health--,this.health<=0?(this.destroy(),this.game.removeLife(this)):j.play("hit")}collided(t){if(this.sprite.destroyed||t.destroyed)return!1;const e=this.sprite.getBounds(),i=t.getBounds();return e.x<i.x+i.width&&e.x+e.width>i.x&&e.y<i.y+i.height&&e.y+e.height>i.y}shoot(){if(!this.sprite)return;const t=this.sprite.x,e=this.sprite.y;new we(this,this.bulletType,1,t,e)}update(t){this.bullets.forEach(e=>{e.update(t)})}destroy(){const t=de.cache.get("explosion").animations,e=new ws(t.explosion),i=this.sprite.getBounds();e.animationSpeed=.16,e.loop=!1,e.position.set(i.x,i.y),e.play(),j.play("explosion2"),this.game.app.stage.addChild(e),this.sprite.destroy(),setTimeout(()=>{e.destroy()},500)}}class ri extends ea{constructor(t,e){super(1,t,e),this.texture="player"}spawn(){const t=yt.from(this.texture);return t.anchor.set(.5),t.scale.set(.05),t.position.set(this.game.app.screen.width/2,this.game.app.screen.height-t.height),t.label="player",this.game.app.stage.addChild(t),this.sprite=t,this.game.app.stage.on("pointermove",this.move.bind(this)),t}shoot(){if(!this.sprite||this.shootOnCooldown)return;const t=this.sprite.x,e=this.sprite.y,i=new we(this,this.bulletType,-1,t,e);this.sprite&&this.bullets.push(i),this.cooldown()}cooldown(){this.shootOnCooldown=!0,setTimeout(()=>{this.shootOnCooldown=!1},this.shootCooldown)}move(t){if(!this.sprite.destroyed){const e=this.sprite.width/2,i=this.sprite.height/2,r=t.global;r.x<=this.game.app.screen.width-e&&r.x>=e&&(this.sprite.x=r.x),r.y<=this.game.app.screen.height-i&&r.y>=i&&(this.sprite.y=r.y)}}takeDamage(){if(this.health--,this.game.playerDamageTaken++,this.game.removeLife(this),this.health<=0){this.game.music.stop(),this.destroy();const t=Math.floor(Math.random()*2)+1;setTimeout(()=>{j.play(`player_death_${t}`,{complete:()=>{this.game.end(!1)}})},400)}else j.play(`player_hit_0${this.game.playerDamageTaken}`)}update(t){super.update(t),this.game.enemies.forEach(e=>{e.bullets.forEach(i=>{this.collided(i.sprite)&&(i.sprite.destroy(),this.takeDamage())})})}}class pn extends ea{constructor(e,i){super(e,0,i);G(this,"direction",1);G(this,"stats");this.stats=this.getStats(e),this.health=this.stats.health,this.texture=this.stats.texture,this.fireRate=this.stats.fireRate,this.sprite=this.spawn(),this.shootCooldown=this.stats.fireRate}spawn(){const e=yt.from(this.texture);return e.anchor=.5,e.scale.set(.075),e.x=Math.floor(Math.random()*this.game.app.stage.width),e.y=-e.height,e.rotation=Math.PI,this.game.app.stage.addChild(e),e}update(e){this.sprite.destroyed?this.sprite.destroyed&&this.bullets.length===0&&(this.game.enemies=[]):(this.move(),this.shoot()),this.bullets.forEach(i=>{i.update(e)}),this.game.player.bullets.forEach(i=>{this.collided(i.sprite)&&(i.sprite.destroy(),this.takeDamage())})}shoot(){if(!this.sprite||this.shootOnCooldown||this.game.player.sprite.destroyed)return;const e=this.sprite.x,i=this.sprite.y,r=new we(this,this.bulletType,1,e,i);this.sprite&&this.bullets.push(r),this.cooldown()}move(){if(this.sprite.y<25)this.sprite.y+=1;else{const e=this.direction;let i=e;Math.floor(Math.random()*500)===1?i=-i:(this.sprite.x>=this.game.app.screen.width-this.sprite.width/2&&e==1||this.sprite.x>=this.game.app.screen.width&&e==-1?i=-1:(this.sprite.x<=this.game.app.screen.width&&e==1||this.sprite.x<=15&&e==-1)&&(i=1),this.sprite.x+=i),this.direction=i}}cooldown(){this.shootOnCooldown=!0,setTimeout(()=>{this.shootOnCooldown=!1},this.shootCooldown)}getStats(e){return{1:{texture:"enemy1",health:1,fireRate:750},2:{texture:"enemy2",health:4,fireRate:800},3:{texture:"enemy3",health:6,fireRate:750}}[e]}}const zd=240,Hd=160;class Nd{constructor(){G(this,"app");G(this,"ready",!1);G(this,"width",zd);G(this,"height",Hd);G(this,"difficulty",0);G(this,"playerLives",3);G(this,"playerKills",0);G(this,"playerDamageTaken",0);G(this,"music");G(this,"player");G(this,"ui");G(this,"state","loading");G(this,"enemies",[]);G(this,"framesRendered");this.app=new go,this.music=qe.from({url:"assets/sounds/bgm.wav",preload:!0,loop:!0,volume:.25}),this.ui=new fn(this.difficulty,this),this.framesRendered=0,this.player=new ri(3,this)}listen(){window.addEventListener("message",t=>{switch(t.data.op){case"start":t.data.difficulty!==void 0&&t.data.difficulty!==null&&(this.difficulty=t.data.difficulty),this.restart(),window.parent.postMessage({op:"started",verb:"shoot!"});break;default:console.log(`shoot! - received unknown event: ${t}`);break}}),this.ready=!0,this.music.play(),window.parent.postMessage({op:"ready"})}async preload(){const t=[{alias:"background",src:"/games/sunshoes/assets/sprites/bg.png"},{alias:"player",src:"/games/sunshoes/assets/sprites/player.png"},{alias:"bullet1",src:"/games/sunshoes/assets/sprites/bullet1.png"},{alias:"bullet2",src:"/games/sunshoes/assets/sprites/bullet2.png"},{alias:"bullet3",src:"/games/sunshoes/assets/sprites/bullet3.png"},{alias:"enemy1",src:"/games/sunshoes/assets/sprites/enemy1.png"},{alias:"enemy2",src:"/games/sunshoes/assets/sprites/enemy2.png"},{alias:"enemy3",src:"/games/sunshoes/assets/sprites/enemy3.png"},{alias:"life",src:"/games/sunshoes/assets/sprites/mrgreen.png"},{alias:"wave",src:"/games/sunshoes/assets/sprites/mrred.png"},{alias:"explosion",src:"/games/sunshoes/assets/animations/explosion.json"},{alias:"silkscreen",src:"/games/sunshoes/assets/ui/silkscreen_regular.ttf",data:{family:"silkscreen"}},{alias:"bungeespice",src:"/games/sunshoes/assets/ui/bungeespice.ttf",data:{family:"bungeespice"}}];j.add("bgm","/games/sunshoes/assets/sounds/bgm.wav"),j.add("shoot","/games/sunshoes/assets/sounds/shoot.wav"),j.add("shoot1","/games/sunshoes/assets/sounds/shoot1.wav"),j.add("enemyShoot","/games/sunshoes/assets/sounds/enemyShoot.wav"),j.add("enemyShoot1","/games/sunshoes/assets/sounds/enemyShoot1.wav"),j.add("hit","/games/sunshoes/assets/sounds/hit.wav"),j.add("success","/games/sunshoes/assets/sounds/success.wav"),j.add("failure","/games/sunshoes/assets/sounds/failure.wav"),j.add("explosion2","/games/sunshoes/assets/sounds/explosion2.wav"),j.add("player_hit_01","/games/sunshoes/assets/sounds/pain_jack_01.wav"),j.add("player_hit_02","/games/sunshoes/assets/sounds/pain_jack_02.wav"),j.add("player_hit_03","/games/sunshoes/assets/sounds/pain_jack_03.wav"),j.add("player_death_1","/games/sunshoes/assets/sounds/death_jack_01.wav"),j.add("player_death_2","/games/sunshoes/assets/sounds/death_jack_02.wav"),j.disableAutoPause=!0,await de.load(t)}setup(){(this.player.sprite.texture==null||this.player.sprite.texture.label==="EMPTY")&&(this.player=new ri(this.playerLives,this),this.player.spawn()),this.drawUI(),this.app.stage.onclick=()=>{this.player.sprite.destroyed||this.player.shoot()}}async initialize(){await this.app.init({width:this.width,height:this.height,background:"#1e1e1f"}),document.getElementById("container").appendChild(this.app.canvas);const t=yt.from("background");this.app.stage.addChild(t),this.app.stage.interactive=!0,this.app.renderer.events.cursorStyles.default="none",this.setup(),this.state="playing"}drawUI(){this.ui.outcome!==null&&this.ui.outcome!==void 0&&this.ui.outcome.destroy(),this.ui.render()}removeLife(t){t instanceof ri?this.ui.removeLife():t instanceof pn&&(this.ui.removeEnemyLife(),this.playerKills++)}update(t){if(this.framesRendered+=1,this.ui.update(t),this.player.update(t),this.enemies.length>0)this.enemies.forEach(e=>{e.update(t)});else if(this.playerKills<3){const e=new pn(this.playerKills+1,this);this.enemies.push(e)}this.playerKills===3&&this.state!=="ended"?this.end(!0):this.playerDamageTaken===this.playerLives&&this.state}end(t){this.ready=!1;const e=this.width/2,i=this.height/2,r=t?"YOU WIN!":"YOU LOSE!",n=t?"success":"failure";!j.find(n).isPlaying&&this.state!=="ended"&&(this.ui.outcome=this.ui.renderOutcome(r,e,i),this.app.stage.onclick=null,j.stopAll(),this.music.stop(),this.state="ended",setTimeout(()=>{j.play(n,{volume:.25,complete:()=>{for(;this.playerKills>0;)this.ui.removeEnemyLife(),this.playerKills--;for(;this.playerLives>0;)this.ui.removeLife(),this.playerLives--;this.app.stop(),window.parent.postMessage({op:"done",win:t})}})},500))}restart(){for(this.music.stop(),j.stopAll(),this.state="loading",this.player.bullets.forEach(t=>{t.sprite.destroyed||t.sprite.destroy()}),this.enemies.forEach(t=>{t.sprite.destroyed||t.sprite.destroy()}),this.enemies=[],this.teardown();this.playerKills>0;)this.ui.removeEnemyLife(),this.playerKills--;for(;this.playerLives>0;)this.ui.removeLife(),this.playerLives--;this.playerLives=3,this.playerKills=0,this.playerDamageTaken=0,this.app.stage.removeChild(this.player.sprite),this.player.sprite.destroy(),this.ui=new fn(this.difficulty,this),this.ui.updatePlayerLives=!0,this.setup(),this.listen(),this.app.start()}teardown(){var e,i;this.ui.outcome&&(this.app.stage.removeChild(this.ui.outcome),(e=this.ui.outcome)==null||e.destroy(),(i=this.app.stage.getChildByLabel("outcome"))==null||i.destroy());const t=this.app.stage.getChildByLabel("outcome");t!==null&&t.destroy()}triggerRestart(t=10){window.postMessage({op:"start",difficulty:t})}}(async()=>{const s=new Nd;await s.preload(),await s.initialize(),s.listen();const t=s.app;window.restart=()=>{s.restart()},window.triggerRestart=()=>{s.triggerRestart()},t.ticker.add(e=>{s.update(e)})})();export{fi as $,At as A,je as B,Ot as C,ko as D,ft as E,K as F,Ms as G,Ro as H,be as I,te as J,$ as K,fs as L,Mn as M,W as N,Es as O,Bc as P,Yu as Q,tt as R,Fi as S,U as T,Nc as U,Ln as V,Ft as W,Is as X,Un as Y,z as Z,lo as _,Kn as a,dt as a0,ze as a1,lt as a2,Fa as a3,Ut as a4,Ol as a5,Tr as a6,ps as a7,Bi as a8,oo as a9,gc as aA,yc as aB,Cc as aC,Ac as aD,Tc as aE,Ku as aF,St as aa,to as ab,mc as ac,_c as ad,Sc as ae,wc as af,wa as ag,Pc as ah,Tn as ai,vt as aj,Ts as ak,ar as al,yt as am,Td as an,Za as ao,lr as ap,Hs as aq,cr as ar,th as as,kn as at,co as au,Qe as av,sl as aw,Qh as ax,Ql as ay,Vl as az,ye as b,Mi as c,X as d,q as e,ki as f,ds as g,As as h,Ho as i,No as j,wt as k,Yd as l,md as m,sd as n,nt as o,O as p,wh as q,zl as r,pt as s,J as t,Ih as u,_t as v,Y as w,Po as x,Rn as y,I as z}; diff --git a/2026/games_submissions/sunshoes/assets/logo.svg b/2026/games_submissions/sunshoes/assets/logo.svg new file mode 100644 index 0000000..81b6418 --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/logo.svg @@ -0,0 +1,54 @@ +<svg width="735" height="289" viewBox="0 0 735 289" fill="none" xmlns="http://www.w3.org/2000/svg"> +<g clip-path="url(#clip0_7_84)"> +<path d="M304.17 288.01V89.99H244.97C244.77 89.99 244.56 89.99 244.34 90C233.7 90.37 225.15 99.12 225.05 109.76C225.05 109.82 225.05 109.88 225.05 109.93V268.4C225.05 268.73 225.07 269.1 225.1 269.51C226 279.71 234.54 287.53 244.77 287.97C245.2 287.99 245.61 288 245.99 288H304.17V288.01Z" fill="#E72264"/> +<path d="M548.21 287.91C559.24 287.08 567.97 278 568.05 266.93C568.05 266.86 568.05 266.79 568.05 266.72V110.16C568.05 110.1 568.05 110.03 568.05 109.97C568 99.03 559.1 90.11 548.16 90C548.08 90 548 90 547.92 90H488.93V288.02H545.74C546.51 288.02 547.34 287.98 548.21 287.92V287.91Z" fill="#E72264"/> +<path d="M293.07 90H355.07C361.15 90 369.75 94.92 374.29 101L505.76 277C510.3 283.08 509.05 288 502.98 288H440.98C434.9 288 426.3 283.08 421.76 277L290.28 101C285.74 94.93 286.99 90 293.06 90H293.07Z" fill="#E72264"/> +<path d="M498.07 90H436.07C429.99 90 421.39 94.92 416.85 101L285.38 277C280.84 283.08 282.09 288 288.16 288H350.16C356.24 288 364.84 283.08 369.38 277L500.85 101C505.39 94.93 504.14 90 498.07 90Z" fill="#E72264"/> +<path d="M529.07 0C550.05 0 567.07 17.01 567.07 38C567.07 58.99 550.06 76 529.07 76C508.08 76 491.07 58.99 491.07 38C491.07 17.01 508.08 0 529.07 0Z" fill="#E72264"/> +<path d="M265.07 0C286.05 0 303.07 17.01 303.07 38C303.07 58.99 286.06 76 265.07 76C244.08 76 227.07 58.99 227.07 38C227.07 17.01 244.08 0 265.07 0Z" fill="#E72264"/> +<path d="M695.07 0H635.07C613.53 0 596.07 17.46 596.07 39V99C596.07 120.54 613.53 138 635.07 138H695.07C716.61 138 734.07 120.54 734.07 99V39C734.07 17.46 716.61 0 695.07 0ZM655.44 39.34V79.84C655.44 85.3 654.35 90.04 652.17 94.05C649.99 98.06 646.88 101.17 642.84 103.38C638.8 105.59 634.01 106.7 628.48 106.7C623.78 106.7 619.72 105.85 616.29 104.16C612.86 102.47 609.98 100.1 607.63 97.06C607.63 97.06 601.08 89.99 607.08 85C613.21 79.9 618.52 86.58 618.52 86.58C619.76 88.31 621.23 89.61 622.93 90.47C624.62 91.34 626.54 91.77 628.69 91.77C630.69 91.77 632.46 91.36 633.98 90.53C635.5 89.7 636.71 88.46 637.61 86.8C638.51 85.14 638.96 83.1 638.96 80.68V39.35C638.96 39.35 638.8 31.01 647.08 31.01C655.36 31.01 655.45 39.35 655.45 39.35L655.44 39.34ZM714.35 98.38C709.82 102.86 703.15 105.56 694.35 106.48C688.3 107.12 683.02 106.7 678.52 105.23C674.02 103.76 669.81 101.21 665.88 97.59C665.88 97.59 659.8 92.35 664.7 85.77C668.38 80.82 675.3 85.96 675.3 85.96C677.92 88.4 680.73 90.2 683.74 91.38C686.75 92.56 690.14 92.95 693.93 92.55C697.3 92.2 699.86 91.28 701.62 89.81C703.38 88.34 704.14 86.5 703.91 84.3C703.71 82.38 702.94 80.86 701.61 79.75C700.28 78.64 698.53 77.75 696.37 77.07C694.21 76.39 691.89 75.79 689.4 75.25C686.91 74.71 684.39 74.02 681.83 73.18C679.27 72.34 676.9 71.23 674.7 69.86C672.5 68.49 670.66 66.64 669.16 64.29C667.66 61.94 666.72 58.95 666.34 55.31C665.86 50.77 666.54 46.77 668.36 43.31C670.19 39.85 672.97 37.07 676.71 34.97C680.45 32.87 684.8 31.56 689.75 31.04C694.91 30.5 699.68 30.9 704.06 32.24C708.44 33.59 712.17 35.63 715.24 38.36C715.24 38.36 719.54 41.97 716.05 48.18C713.34 53.01 705.73 50.11 705.73 50.11C703.29 48.07 700.89 46.62 698.55 45.76C696.2 44.9 693.65 44.61 690.9 44.9C688.08 45.2 685.9 45.97 684.36 47.2C682.82 48.44 682.16 50.06 682.37 52.05C682.56 53.84 683.33 55.23 684.69 56.24C686.05 57.24 687.78 58.05 689.9 58.66C692.01 59.27 694.34 59.86 696.86 60.43C699.39 61 701.93 61.69 704.48 62.5C707.03 63.31 709.4 64.47 711.57 65.98C713.74 67.49 715.6 69.45 717.14 71.86C718.68 74.27 719.65 77.4 720.06 81.25C720.79 88.2 718.89 93.91 714.35 98.38Z" fill="#E72264"/> +<path d="M107.17 0.340088C47.98 0.340088 0 48.3201 0 107.51C0 108.67 0.02 109.82 0.06 110.97V213.96C0.06 213.96 0.06 213.97 0.06 213.98V224.45C0.06 224.45 0.06 224.45 0.07 224.44V250.33C0.07 250.53 0.06 250.72 0.06 250.92C0.06 251.12 0.07 251.32 0.08 251.52V252H0.09C0.66 271.89 16.95 287.84 36.98 287.84C57.01 287.84 73.47 271.89 74.04 252V213.98H104.66C105.49 214 106.33 214.01 107.16 214.01C166.35 214.01 214.33 166.7 214.33 107.51C214.33 48.3201 166.36 0.340088 107.17 0.340088ZM107.17 140.01C100.62 140.01 84.02 140.01 77.13 140.01H74.07V107.52C74.07 89.3101 88.96 74.5401 107.17 74.5401C125.38 74.5401 140.15 89.3101 140.15 107.52C140.15 125.73 125.38 140.02 107.17 140.02V140.01Z" fill="#E72264"/> +<path opacity="0.15" d="M36.05 214H73.99V252.01H73.82C73.25 271.9 56.96 287.85 36.93 287.85C16.9 287.85 0.6 271.9 0.03 252.01H0.02V251.53C0.02 251.33 0 251.13 0 250.93C0 250.73 0.01 250.54 0.01 250.34V247.66C1.15 229.87 17.94 214 36.04 214H36.05Z" fill="#1D1D1B"/> +<g opacity="0.05"> +<path opacity="0.5" d="M0.0599976 168.28V213.98C0.0599976 173.72 33.89 140.58 74.05 140.03V125.45C44.2 128.59 17.77 144.66 0.0599976 168.28Z" fill="black"/> +<path d="M0.119995 248.37C8.84 241.97 19.42 238.2 30.84 238.2H74.06V213.98H37.03C17.47 213.98 1.48 229.15 0.119995 248.37Z" fill="black"/> +</g> +<g opacity="0.05"> +<path opacity="0.5" d="M74.05 140.03V126.79C43.95 129.74 17.39 146.16 0.0599976 170.27V213.98C0.0599976 173.72 33.89 140.58 74.05 140.03Z" fill="black"/> +<path d="M37.03 213.98C18 213.98 2.34001 228.35 0.26001 246.83C8.97001 240.03 19.73 236.01 31.4 236.01H74.05V213.99H37.02L37.03 213.98Z" fill="black"/> +</g> +<g opacity="0.05"> +<path opacity="0.5" d="M74.05 140.03V128.12C43.68 130.87 16.95 147.69 0.0599976 172.34V213.97C0.0599976 173.71 33.89 140.57 74.05 140.02V140.03Z" fill="black"/> +<path d="M37.03 213.98C18.53 213.98 3.22002 227.55 0.460022 245.28C9.12002 238.09 20.06 233.8 31.96 233.8H74.05V213.98H37.02H37.03Z" fill="black"/> +</g> +<g opacity="0.05"> +<path opacity="0.5" d="M74.05 140.03V129.46C43.37 132 16.46 149.28 0.0599976 174.53V213.98C0.0599976 173.72 33.89 140.58 74.05 140.03Z" fill="black"/> +<path d="M37.03 213.98C19.06 213.98 4.08998 226.79 0.72998 243.77C9.31998 236.18 20.41 231.6 32.53 231.6H74.06V213.98H37.03Z" fill="black"/> +</g> +<g opacity="0.05"> +<path opacity="0.5" d="M74.05 140.03V130.81C43.01 133.11 15.89 150.93 0.0599976 176.84V213.98C0.0599976 173.72 33.89 140.58 74.05 140.03Z" fill="black"/> +<path d="M37.03 213.98C19.6 213.98 5.00001 226.03 1.07001 242.24C9.54001 234.26 20.77 229.39 33.09 229.39H74.05V213.97H37.02L37.03 213.98Z" fill="black"/> +</g> +<g opacity="0.05"> +<path opacity="0.5" d="M74.05 140.03V132.16C42.6 134.22 15.22 152.65 0.0599976 179.32V213.98C0.0599976 173.72 33.89 140.58 74.05 140.03Z" fill="black"/> +<path d="M37.03 213.98C20.15 213.98 5.92998 225.28 1.47998 240.71C9.79998 232.34 21.14 227.19 33.66 227.19H74.06V213.98H37.03Z" fill="black"/> +</g> +<g opacity="0.05"> +<path opacity="0.5" d="M74.05 140.03V133.52C42.12 135.31 14.43 154.48 0.0599976 182.01V213.98C0.0599976 173.72 33.89 140.58 74.05 140.03Z" fill="black"/> +<path d="M37.03 213.98C20.72 213.98 6.88001 224.54 1.95001 239.19C10.08 230.44 21.53 224.99 34.21 224.99H74.05V213.98H37.02H37.03Z" fill="black"/> +</g> +<g opacity="0.05"> +<path opacity="0.5" d="M74.05 140.03V134.89C41.53 136.39 13.47 156.46 0.0599976 185V213.98C0.0599976 173.72 33.89 140.58 74.05 140.03Z" fill="black"/> +<path d="M37.03 213.98C21.28 213.98 7.83999 223.83 2.48999 237.7C10.4 228.56 21.92 222.79 34.78 222.79H74.06V213.98H37.03Z" fill="black"/> +</g> +<g opacity="0.05"> +<path opacity="0.5" d="M74.05 140.03V136.29C40.78 137.48 12.24 158.68 0.0599976 188.47V213.98C0.0599976 173.72 33.89 140.58 74.05 140.03Z" fill="black"/> +<path d="M37.03 213.98C21.85 213.98 8.80999 223.13 3.10999 236.21C10.74 226.68 22.34 220.59 35.35 220.59H74.06V213.98H37.03Z" fill="black"/> +</g> +</g> +<defs> +<clipPath id="clip0_7_84"> +<rect width="734.07" height="288.01" fill="white"/> +</clipPath> +</defs> +</svg> diff --git a/2026/games_submissions/sunshoes/assets/sounds/bgm.wav b/2026/games_submissions/sunshoes/assets/sounds/bgm.wav Binary files differnew file mode 100644 index 0000000..521c4d3 --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/sounds/bgm.wav diff --git a/2026/games_submissions/sunshoes/assets/sounds/death_jack_01.wav b/2026/games_submissions/sunshoes/assets/sounds/death_jack_01.wav Binary files differnew file mode 100644 index 0000000..87d74e2 --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/sounds/death_jack_01.wav diff --git a/2026/games_submissions/sunshoes/assets/sounds/death_jack_02.wav b/2026/games_submissions/sunshoes/assets/sounds/death_jack_02.wav Binary files differnew file mode 100644 index 0000000..668ee8c --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/sounds/death_jack_02.wav diff --git a/2026/games_submissions/sunshoes/assets/sounds/enemyShoot.wav b/2026/games_submissions/sunshoes/assets/sounds/enemyShoot.wav Binary files differnew file mode 100644 index 0000000..2b1bd9c --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/sounds/enemyShoot.wav diff --git a/2026/games_submissions/sunshoes/assets/sounds/enemyShoot1.wav b/2026/games_submissions/sunshoes/assets/sounds/enemyShoot1.wav Binary files differnew file mode 100644 index 0000000..6da85a0 --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/sounds/enemyShoot1.wav diff --git a/2026/games_submissions/sunshoes/assets/sounds/explode3.wav b/2026/games_submissions/sunshoes/assets/sounds/explode3.wav Binary files differnew file mode 100644 index 0000000..ce351b8 --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/sounds/explode3.wav diff --git a/2026/games_submissions/sunshoes/assets/sounds/explosion.wav b/2026/games_submissions/sunshoes/assets/sounds/explosion.wav Binary files differnew file mode 100644 index 0000000..bb02923 --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/sounds/explosion.wav diff --git a/2026/games_submissions/sunshoes/assets/sounds/explosion2.wav b/2026/games_submissions/sunshoes/assets/sounds/explosion2.wav Binary files differnew file mode 100644 index 0000000..8b55562 --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/sounds/explosion2.wav diff --git a/2026/games_submissions/sunshoes/assets/sounds/failure.wav b/2026/games_submissions/sunshoes/assets/sounds/failure.wav Binary files differnew file mode 100644 index 0000000..f5e6bdf --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/sounds/failure.wav diff --git a/2026/games_submissions/sunshoes/assets/sounds/hit.wav b/2026/games_submissions/sunshoes/assets/sounds/hit.wav Binary files differnew file mode 100644 index 0000000..404f869 --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/sounds/hit.wav diff --git a/2026/games_submissions/sunshoes/assets/sounds/pain_jack_01.wav b/2026/games_submissions/sunshoes/assets/sounds/pain_jack_01.wav Binary files differnew file mode 100644 index 0000000..52ec0f1 --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/sounds/pain_jack_01.wav diff --git a/2026/games_submissions/sunshoes/assets/sounds/pain_jack_02.wav b/2026/games_submissions/sunshoes/assets/sounds/pain_jack_02.wav Binary files differnew file mode 100644 index 0000000..86e796b --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/sounds/pain_jack_02.wav diff --git a/2026/games_submissions/sunshoes/assets/sounds/pain_jack_03.wav b/2026/games_submissions/sunshoes/assets/sounds/pain_jack_03.wav Binary files differnew file mode 100644 index 0000000..7985efa --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/sounds/pain_jack_03.wav diff --git a/2026/games_submissions/sunshoes/assets/sounds/shoot.wav b/2026/games_submissions/sunshoes/assets/sounds/shoot.wav Binary files differnew file mode 100644 index 0000000..1b24753 --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/sounds/shoot.wav diff --git a/2026/games_submissions/sunshoes/assets/sounds/shoot1.wav b/2026/games_submissions/sunshoes/assets/sounds/shoot1.wav Binary files differnew file mode 100644 index 0000000..13bfdf0 --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/sounds/shoot1.wav diff --git a/2026/games_submissions/sunshoes/assets/sounds/success.wav b/2026/games_submissions/sunshoes/assets/sounds/success.wav Binary files differnew file mode 100644 index 0000000..9ec0a03 --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/sounds/success.wav diff --git a/2026/games_submissions/sunshoes/assets/sprites/bg.png b/2026/games_submissions/sunshoes/assets/sprites/bg.png Binary files differnew file mode 100644 index 0000000..0860020 --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/sprites/bg.png diff --git a/2026/games_submissions/sunshoes/assets/sprites/bullet1.png b/2026/games_submissions/sunshoes/assets/sprites/bullet1.png Binary files differnew file mode 100644 index 0000000..1f7a8df --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/sprites/bullet1.png diff --git a/2026/games_submissions/sunshoes/assets/sprites/bullet2.png b/2026/games_submissions/sunshoes/assets/sprites/bullet2.png Binary files differnew file mode 100644 index 0000000..ec08181 --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/sprites/bullet2.png diff --git a/2026/games_submissions/sunshoes/assets/sprites/bullet3.png b/2026/games_submissions/sunshoes/assets/sprites/bullet3.png Binary files differnew file mode 100644 index 0000000..e027ad5 --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/sprites/bullet3.png diff --git a/2026/games_submissions/sunshoes/assets/sprites/enemy1.png b/2026/games_submissions/sunshoes/assets/sprites/enemy1.png Binary files differnew file mode 100644 index 0000000..59b173e --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/sprites/enemy1.png diff --git a/2026/games_submissions/sunshoes/assets/sprites/enemy2.png b/2026/games_submissions/sunshoes/assets/sprites/enemy2.png Binary files differnew file mode 100644 index 0000000..78ce9ad --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/sprites/enemy2.png diff --git a/2026/games_submissions/sunshoes/assets/sprites/enemy3.png b/2026/games_submissions/sunshoes/assets/sprites/enemy3.png Binary files differnew file mode 100644 index 0000000..e4b0214 --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/sprites/enemy3.png diff --git a/2026/games_submissions/sunshoes/assets/sprites/mrgreen.png b/2026/games_submissions/sunshoes/assets/sprites/mrgreen.png Binary files differnew file mode 100644 index 0000000..4245197 --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/sprites/mrgreen.png diff --git a/2026/games_submissions/sunshoes/assets/sprites/mrred.png b/2026/games_submissions/sunshoes/assets/sprites/mrred.png Binary files differnew file mode 100644 index 0000000..3b4324a --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/sprites/mrred.png diff --git a/2026/games_submissions/sunshoes/assets/sprites/player.png b/2026/games_submissions/sunshoes/assets/sprites/player.png Binary files differnew file mode 100644 index 0000000..6327f5e --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/sprites/player.png diff --git a/2026/games_submissions/sunshoes/assets/ui/bungeespice.ttf b/2026/games_submissions/sunshoes/assets/ui/bungeespice.ttf Binary files differnew file mode 100644 index 0000000..8040ccf --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/ui/bungeespice.ttf diff --git a/2026/games_submissions/sunshoes/assets/ui/silkscreen_regular.ttf b/2026/games_submissions/sunshoes/assets/ui/silkscreen_regular.ttf Binary files differnew file mode 100644 index 0000000..8caff81 --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/ui/silkscreen_regular.ttf diff --git a/2026/games_submissions/sunshoes/assets/webworkerAll-3Ebn88U3.js b/2026/games_submissions/sunshoes/assets/webworkerAll-3Ebn88U3.js new file mode 100644 index 0000000..00cf31e --- /dev/null +++ b/2026/games_submissions/sunshoes/assets/webworkerAll-3Ebn88U3.js @@ -0,0 +1,83 @@ +import{N as k,K as O,c as A,aF as M,aj as P,z as b,G as U,a as E,ab as z,a7 as V,ak as _,T as v,ay as Y,$ as X,w as q,F as R}from"./index-DvAPfvr6.js";import{F as L}from"./Filter-BiIvpnZm.js";const y=new k;function G(m,e){e.clear();const t=e.matrix;for(let r=0;r<m.length;r++){const i=m[r];if(i.globalDisplayStatus<7)continue;const n=i.renderGroup??i.parentRenderGroup;n!=null&&n.isCachedAsTexture?e.matrix=y.copyFrom(n.textureOffsetInverseTransform).append(i.worldTransform):n!=null&&n._parentCacheAsTextureRenderGroup?e.matrix=y.copyFrom(n._parentCacheAsTextureRenderGroup.inverseWorldTransform).append(i.groupTransform):e.matrix=i.worldTransform,e.addBounds(i.bounds)}return e.matrix=t,e}function S(m){return typeof m.getCanvasFilterString=="function"}class W{constructor(){this.skip=!1,this.useClip=!1,this.filters=null,this.container=null,this.bounds=new P,this.cssFilterString=""}}class C{constructor(e){this._filterStack=[],this._filterStackIndex=0,this._savedStates=[],this._alphaMultiplier=1,this._warnedFilterTypes=new Set,this.renderer=e}push(e){const t=this._pushFilterFrame(),r=e.filterEffect.filters;if(t.skip=!1,t.useClip=!1,t.filters=r,t.container=e.container,t.cssFilterString="",r.every(o=>!o.enabled)){t.skip=!0;return}const i=[],n=1;for(const o of r){if(!o.enabled)continue;if(!S(o)){this._warnUnsupportedFilter(o);continue}const l=o.getCanvasFilterString();if(l===null){this._warnUnsupportedFilter(o);continue}l&&i.push(l)}if(i.length===0&&n===1){t.skip=!0;return}t.cssFilterString=i.join(" "),this._calculateFilterArea(e,t.bounds),t.useClip=!!e.filterEffect.filterArea;const s=this.renderer.canvasContext.activeContext,a=s.filter||"none";if(this._savedStates.push({filter:a,alphaMultiplier:this._alphaMultiplier}),t.useClip&&Number.isFinite(t.bounds.width)&&Number.isFinite(t.bounds.height)&&t.bounds.width>0&&t.bounds.height>0){const o=this.renderer.canvasContext.activeResolution||1;s.save(),s.setTransform(1,0,0,1,0,0),s.beginPath(),s.rect(t.bounds.x*o,t.bounds.y*o,t.bounds.width*o,t.bounds.height*o),s.clip()}else t.useClip=!1;t.cssFilterString&&(s.filter=a!=="none"?`${a} ${t.cssFilterString}`:t.cssFilterString)}pop(){const e=this._popFilterFrame();if(e.skip)return;const t=this._savedStates.pop();if(!t)return;const r=this.renderer.canvasContext.activeContext;e.useClip?r.restore():r.filter=t.filter,this._alphaMultiplier=t.alphaMultiplier}generateFilteredTexture({texture:e,filters:t}){if(!(t!=null&&t.length)||t.every(d=>!d.enabled))return e;const r=[],i=1;for(const d of t){if(!d.enabled)continue;if(!S(d)){this._warnUnsupportedFilter(d);continue}const F=d.getCanvasFilterString();if(F===null){this._warnUnsupportedFilter(d);continue}F&&r.push(F)}if(r.length===0&&i===1)return e;const n=O.getCanvasSource(e);if(!n)return e;const s=e.frame,a=e.source._resolution??e.source.resolution??1,o=s.width,l=s.height,f=A.getOptimalCanvasAndContext(o,l,a),{canvas:c,context:u}=f;u.setTransform(1,0,0,1,0,0),u.clearRect(0,0,c.width,c.height),r.length&&(u.filter=r.join(" "));const p=s.x*a,h=s.y*a,x=o*a,T=l*a;return u.drawImage(n,p,h,x,T,0,0,x,T),u.filter="none",u.globalAlpha=1,M(c,o,l,a)}_calculateFilterArea(e,t){if(e.renderables?G(e.renderables,t):e.filterEffect.filterArea?(t.clear(),t.addRect(e.filterEffect.filterArea),t.applyMatrix(e.container.worldTransform)):e.container.getFastGlobalBounds(!0,t),e.container){const r=e.container.renderGroup||e.container.parentRenderGroup,i=r==null?void 0:r.cacheToLocalTransform;i&&t.applyMatrix(i)}}_warnUnsupportedFilter(e){var r;const t=((r=e==null?void 0:e.constructor)==null?void 0:r.name)||"Filter";this._warnedFilterTypes.has(t)||(this._warnedFilterTypes.add(t),console.warn(`CanvasRenderer: filter "${t}" is not supported in Canvas2D and will be skipped.`))}get alphaMultiplier(){return this._alphaMultiplier}_pushFilterFrame(){let e=this._filterStack[this._filterStackIndex];return e||(e=this._filterStack[this._filterStackIndex]=new W),this._filterStackIndex++,e}_popFilterFrame(){return this._filterStackIndex<=0?this._filterStack[0]:(this._filterStackIndex--,this._filterStack[this._filterStackIndex])}destroy(){this._filterStack=null,this._savedStates=null,this._warnedFilterTypes=null,this._alphaMultiplier=1}}C.extension={type:[b.CanvasSystem],name:"filter"};var j=`in vec2 aPosition; +out vec2 vTextureCoord; + +uniform vec4 uInputSize; +uniform vec4 uOutputFrame; +uniform vec4 uOutputTexture; + +vec4 filterVertexPosition( void ) +{ + vec2 position = aPosition * uOutputFrame.zw + uOutputFrame.xy; + + position.x = position.x * (2.0 / uOutputTexture.x) - 1.0; + position.y = position.y * (2.0*uOutputTexture.z / uOutputTexture.y) - uOutputTexture.z; + + return vec4(position, 0.0, 1.0); +} + +vec2 filterTextureCoord( void ) +{ + return aPosition * (uOutputFrame.zw * uInputSize.zw); +} + +void main(void) +{ + gl_Position = filterVertexPosition(); + vTextureCoord = filterTextureCoord(); +} +`,N=`in vec2 vTextureCoord; +out vec4 finalColor; +uniform sampler2D uTexture; +void main() { + finalColor = texture(uTexture, vTextureCoord); +} +`,w=`struct GlobalFilterUniforms { + uInputSize: vec4<f32>, + uInputPixel: vec4<f32>, + uInputClamp: vec4<f32>, + uOutputFrame: vec4<f32>, + uGlobalFrame: vec4<f32>, + uOutputTexture: vec4<f32>, +}; + +@group(0) @binding(0) var <uniform> gfu: GlobalFilterUniforms; +@group(0) @binding(1) var uTexture: texture_2d<f32>; +@group(0) @binding(2) var uSampler: sampler; + +struct VSOutput { + @builtin(position) position: vec4<f32>, + @location(0) uv: vec2<f32> +}; + +fn filterVertexPosition(aPosition: vec2<f32>) -> vec4<f32> +{ + var position = aPosition * gfu.uOutputFrame.zw + gfu.uOutputFrame.xy; + + position.x = position.x * (2.0 / gfu.uOutputTexture.x) - 1.0; + position.y = position.y * (2.0 * gfu.uOutputTexture.z / gfu.uOutputTexture.y) - gfu.uOutputTexture.z; + + return vec4(position, 0.0, 1.0); +} + +fn filterTextureCoord(aPosition: vec2<f32>) -> vec2<f32> +{ + return aPosition * (gfu.uOutputFrame.zw * gfu.uInputSize.zw); +} + +@vertex +fn mainVertex( + @location(0) aPosition: vec2<f32>, +) -> VSOutput { + return VSOutput( + filterVertexPosition(aPosition), + filterTextureCoord(aPosition) + ); +} + +@fragment +fn mainFragment( + @location(0) uv: vec2<f32>, +) -> @location(0) vec4<f32> { + return textureSample(uTexture, uSampler, uv); +} +`;class $ extends L{constructor(){const e=U.from({vertex:{source:w,entryPoint:"mainVertex"},fragment:{source:w,entryPoint:"mainFragment"},name:"passthrough-filter"}),t=E.from({vertex:j,fragment:N,name:"passthrough-filter"});super({gpuProgram:e,glProgram:t})}}class I{constructor(e){this._renderer=e}push(e,t,r){this._renderer.renderPipes.batch.break(r),r.add({renderPipeId:"filter",canBundle:!1,action:"pushFilter",container:t,filterEffect:e})}pop(e,t,r){this._renderer.renderPipes.batch.break(r),r.add({renderPipeId:"filter",action:"popFilter",canBundle:!1})}execute(e){e.action==="pushFilter"?this._renderer.filter.push(e):e.action==="popFilter"&&this._renderer.filter.pop()}destroy(){this._renderer=null}}I.extension={type:[b.WebGLPipes,b.WebGPUPipes,b.CanvasPipes],name:"filter"};const H=new Y({attributes:{aPosition:{buffer:new Float32Array([0,0,1,0,1,1,0,1]),format:"float32x2",stride:8,offset:0}},indexBuffer:new Uint32Array([0,1,2,0,2,3])});class K{constructor(){this.skip=!1,this.inputTexture=null,this.backTexture=null,this.filters=null,this.bounds=new P,this.container=null,this.blendRequired=!1,this.outputRenderSurface=null,this.globalFrame={x:0,y:0,width:0,height:0},this.firstEnabledIndex=-1,this.lastEnabledIndex=-1}}class B{constructor(e){this._filterStackIndex=0,this._filterStack=[],this._filterGlobalUniforms=new z({uInputSize:{value:new Float32Array(4),type:"vec4<f32>"},uInputPixel:{value:new Float32Array(4),type:"vec4<f32>"},uInputClamp:{value:new Float32Array(4),type:"vec4<f32>"},uOutputFrame:{value:new Float32Array(4),type:"vec4<f32>"},uGlobalFrame:{value:new Float32Array(4),type:"vec4<f32>"},uOutputTexture:{value:new Float32Array(4),type:"vec4<f32>"}}),this._globalFilterBindGroup=new V({}),this.renderer=e}get activeBackTexture(){var e;return(e=this._activeFilterData)==null?void 0:e.backTexture}push(e){const t=this.renderer,r=e.filterEffect.filters,i=this._pushFilterData();i.skip=!1,i.filters=r,i.container=e.container,i.outputRenderSurface=t.renderTarget.renderSurface;const n=t.renderTarget.renderTarget.colorTexture.source,s=n.resolution,a=n.antialias;if(r.every(p=>!p.enabled)){i.skip=!0;return}const o=i.bounds;if(this._calculateFilterArea(e,o),this._calculateFilterBounds(i,t.renderTarget.rootViewPort,a,s,1),i.skip)return;const l=this._getPreviousFilterData(),f=this._findFilterResolution(s);let c=0,u=0;l&&(c=l.bounds.minX,u=l.bounds.minY),this._calculateGlobalFrame(i,c,u,f,n.width,n.height),this._setupFilterTextures(i,o,t,l)}generateFilteredTexture({texture:e,filters:t}){const r=this._pushFilterData();this._activeFilterData=r,r.skip=!1,r.filters=t;const i=e.source,n=i.resolution,s=i.antialias;if(t.every(p=>!p.enabled))return r.skip=!0,e;const a=r.bounds;if(a.addRect(e.frame),this._calculateFilterBounds(r,a.rectangle,s,n,0),r.skip)return e;const o=n;this._calculateGlobalFrame(r,0,0,o,i.width,i.height),r.outputRenderSurface=_.getOptimalTexture(a.width,a.height,r.resolution,r.antialias),r.backTexture=v.EMPTY,r.inputTexture=e,this.renderer.renderTarget.finishRenderPass(),this._applyFiltersToTexture(r,!0);const u=r.outputRenderSurface;return u.source.alphaMode="premultiplied-alpha",u}pop(){const e=this.renderer,t=this._popFilterData();t.skip||(e.globalUniforms.pop(),e.renderTarget.finishRenderPass(),this._activeFilterData=t,this._applyFiltersToTexture(t,!1),t.blendRequired&&_.returnTexture(t.backTexture),_.returnTexture(t.inputTexture))}getBackTexture(e,t,r){const i=e.colorTexture.source._resolution,n=_.getOptimalTexture(t.width,t.height,i,!1);let s=t.minX,a=t.minY;r&&(s-=r.minX,a-=r.minY),s=Math.floor(s*i),a=Math.floor(a*i);const o=Math.ceil(t.width*i),l=Math.ceil(t.height*i);return this.renderer.renderTarget.copyToTexture(e,n,{x:s,y:a},{width:o,height:l},{x:0,y:0}),n}applyFilter(e,t,r,i){const n=this.renderer,s=this._activeFilterData,o=s.outputRenderSurface===r,l=n.renderTarget.rootRenderTarget.colorTexture.source._resolution,f=this._findFilterResolution(l);let c=0,u=0;if(o){const h=this._findPreviousFilterOffset();c=h.x,u=h.y}this._updateFilterUniforms(t,r,s,c,u,f,o,i);const p=e.enabled?e:this._getPassthroughFilter();this._setupBindGroupsAndRender(p,t,n)}calculateSpriteMatrix(e,t){const r=this._activeFilterData,i=e.set(r.inputTexture._source.width,0,0,r.inputTexture._source.height,r.bounds.minX,r.bounds.minY),n=t.worldTransform.copyTo(k.shared),s=t.renderGroup||t.parentRenderGroup;return s&&s.cacheToLocalTransform&&n.prepend(s.cacheToLocalTransform),n.invert(),i.prepend(n),i.scale(1/t.texture.orig.width,1/t.texture.orig.height),i.translate(t.anchor.x,t.anchor.y),i}destroy(){var e;(e=this._passthroughFilter)==null||e.destroy(!0),this._passthroughFilter=null}_getPassthroughFilter(){return this._passthroughFilter??(this._passthroughFilter=new $),this._passthroughFilter}_setupBindGroupsAndRender(e,t,r){if(r.renderPipes.uniformBatch){const i=r.renderPipes.uniformBatch.getUboResource(this._filterGlobalUniforms);this._globalFilterBindGroup.setResource(i,0)}else this._globalFilterBindGroup.setResource(this._filterGlobalUniforms,0);this._globalFilterBindGroup.setResource(t.source,1),this._globalFilterBindGroup.setResource(t.source.style,2),e.groups[0]=this._globalFilterBindGroup,r.encoder.draw({geometry:H,shader:e,state:e._state,topology:"triangle-list"}),r.type===X.WEBGL&&r.renderTarget.finishRenderPass()}_setupFilterTextures(e,t,r,i){if(e.backTexture=v.EMPTY,e.inputTexture=_.getOptimalTexture(t.width,t.height,e.resolution,e.antialias),e.blendRequired){r.renderTarget.finishRenderPass();const n=r.renderTarget.getRenderTarget(e.outputRenderSurface);e.backTexture=this.getBackTexture(n,t,i==null?void 0:i.bounds)}r.renderTarget.bind(e.inputTexture,!0),r.globalUniforms.push({offset:t})}_calculateGlobalFrame(e,t,r,i,n,s){const a=e.globalFrame;a.x=t*i,a.y=r*i,a.width=n*i,a.height=s*i}_updateFilterUniforms(e,t,r,i,n,s,a,o){const l=this._filterGlobalUniforms.uniforms,f=l.uOutputFrame,c=l.uInputSize,u=l.uInputPixel,p=l.uInputClamp,h=l.uGlobalFrame,x=l.uOutputTexture;a?(f[0]=r.bounds.minX-i,f[1]=r.bounds.minY-n):(f[0]=0,f[1]=0),f[2]=e.frame.width,f[3]=e.frame.height,c[0]=e.source.width,c[1]=e.source.height,c[2]=1/c[0],c[3]=1/c[1],u[0]=e.source.pixelWidth,u[1]=e.source.pixelHeight,u[2]=1/u[0],u[3]=1/u[1],p[0]=.5*u[2],p[1]=.5*u[3],p[2]=e.frame.width*c[2]-.5*u[2],p[3]=e.frame.height*c[3]-.5*u[3];const T=this.renderer.renderTarget.rootRenderTarget.colorTexture;h[0]=i*s,h[1]=n*s,h[2]=T.source.width*s,h[3]=T.source.height*s,t instanceof v&&(t.source.resource=null);const d=this.renderer.renderTarget.getRenderTarget(t);this.renderer.renderTarget.bind(t,!!o),t instanceof v?(x[0]=t.frame.width,x[1]=t.frame.height):(x[0]=d.width,x[1]=d.height),x[2]=d.isRoot?-1:1,this._filterGlobalUniforms.update()}_findFilterResolution(e){let t=this._filterStackIndex-1;for(;t>0&&this._filterStack[t].skip;)--t;return t>0&&this._filterStack[t].inputTexture?this._filterStack[t].inputTexture.source._resolution:e}_findPreviousFilterOffset(){let e=0,t=0,r=this._filterStackIndex;for(;r>0;){r--;const i=this._filterStack[r];if(!i.skip){e=i.bounds.minX,t=i.bounds.minY;break}}return{x:e,y:t}}_calculateFilterArea(e,t){if(e.renderables?G(e.renderables,t):e.filterEffect.filterArea?(t.clear(),t.addRect(e.filterEffect.filterArea),t.applyMatrix(e.container.worldTransform)):e.container.getFastGlobalBounds(!0,t),e.container){const i=(e.container.renderGroup||e.container.parentRenderGroup).cacheToLocalTransform;i&&t.applyMatrix(i)}}_applyFiltersToTexture(e,t){const r=e.inputTexture,i=e.bounds,n=e.filters,s=e.firstEnabledIndex,a=e.lastEnabledIndex;if(this._globalFilterBindGroup.setResource(r.source.style,2),this._globalFilterBindGroup.setResource(e.backTexture.source,3),s===a)n[s].apply(this,r,e.outputRenderSurface,t);else{let o=e.inputTexture;const l=_.getOptimalTexture(i.width,i.height,o.source._resolution,!1);let f=l;for(let c=s;c<a;c++){const u=n[c];if(!u.enabled)continue;u.apply(this,o,f,!0);const p=o;o=f,f=p}n[a].apply(this,o,e.outputRenderSurface,t),_.returnTexture(l)}}_calculateFilterBounds(e,t,r,i,n){var d;const s=this.renderer,a=e.bounds,o=e.filters;let l=1/0,f=0,c=!0,u=!1,p=!1,h=!0,x=-1,T=-1;for(let F=0;F<o.length;F++){const g=o[F];if(!g.enabled)continue;if(x===-1&&(x=F),T=F,l=Math.min(l,g.resolution==="inherit"?i:g.resolution),f+=g.padding,g.antialias==="off"?c=!1:g.antialias==="inherit"&&c&&(c=r),g.clipToViewport||(h=!1),!!!(g.compatibleRenderers&s.type)){p=!1;break}if(g.blendRequired&&!(((d=s.backBuffer)==null?void 0:d.useBackBuffer)??!0)){q("Blend filter requires backBuffer on WebGL renderer to be enabled. Set `useBackBuffer: true` in the renderer options."),p=!1;break}p=!0,u||(u=g.blendRequired)}if(!p){e.skip=!0;return}if(h&&a.fitBounds(0,t.width/i,0,t.height/i),a.scale(l).ceil().scale(1/l).pad((f|0)*n),!a.isPositive){e.skip=!0;return}e.antialias=c,e.resolution=l,e.blendRequired=u,e.firstEnabledIndex=x,e.lastEnabledIndex=T}_popFilterData(){return this._filterStackIndex--,this._filterStack[this._filterStackIndex]}_getPreviousFilterData(){let e,t=this._filterStackIndex-1;for(;t>0&&(t--,e=this._filterStack[t],!!e.skip););return e}_pushFilterData(){let e=this._filterStack[this._filterStackIndex];return e||(e=this._filterStack[this._filterStackIndex]=new K),this._filterStackIndex++,e}}B.extension={type:[b.WebGLSystem,b.WebGPUSystem],name:"filter"};R.add(B,C);R.add(I); diff --git a/2026/games_submissions/sunshoes/favicon.png b/2026/games_submissions/sunshoes/favicon.png Binary files differnew file mode 100644 index 0000000..fdc13bc --- /dev/null +++ b/2026/games_submissions/sunshoes/favicon.png diff --git a/2026/games_submissions/sunshoes/index.html b/2026/games_submissions/sunshoes/index.html new file mode 100644 index 0000000..a48485f --- /dev/null +++ b/2026/games_submissions/sunshoes/index.html @@ -0,0 +1,17 @@ +<!doctype html> +<html lang="en"> +<head> + <meta charset="UTF-8" /> + <link rel="icon" type="image/png" href="/favicon.png" /> + <meta name="viewport" content="width=device-width, initial-scale=1.0" /> + <link rel="stylesheet" href="/style.css"> + <title>SHOOT! - LCOLONQ MICROJAM 2K26-A-PALOOZA</title> + <script type="module" crossorigin src="/games/sunshoes/assets/index-DvAPfvr6.js"></script> +</head> + +<body> + <div id="app"> + <div id="container"></div> + </div> +</body> +</html> diff --git a/2026/games_submissions/sunshoes/style.css b/2026/games_submissions/sunshoes/style.css new file mode 100644 index 0000000..93e65aa --- /dev/null +++ b/2026/games_submissions/sunshoes/style.css @@ -0,0 +1,19 @@ +body { + margin: 0; + padding: 0; + color: rgba(255, 255, 255, 0.87); + background-color: #000000; +} + +#app { + width: 100%; + height: 100vh; + overflow: hidden; + display: flex; + justify-content: center; + align-items: center; +} + +canvas { + cursor: none !important; +} diff --git a/2026/games_submissions/the0x539/data.js b/2026/games_submissions/the0x539/data.js index dba5d6d..977c557 100644 --- a/2026/games_submissions/the0x539/data.js +++ b/2026/games_submissions/the0x539/data.js @@ -7,6 +7,7 @@ const ingredients = { c: 'cobble', C: 'chest', S: 'string', + g: 'gold', } function recipe(...shape) { @@ -77,6 +78,11 @@ export const recipes = { 's S', ' sS', ), + clock: recipe( + ' g ', + 'gdg', + ' g ', + ), }; export const amounts = { diff --git a/2026/games_submissions/the0x539/difficulty.js b/2026/games_submissions/the0x539/difficulty.js new file mode 100644 index 0000000..87a86b9 --- /dev/null +++ b/2026/games_submissions/the0x539/difficulty.js @@ -0,0 +1,100 @@ +export const scenarios = [ + { + level: 0, + items: { + log: 2, + }, + goal: ['chest'], + time: _ => 10, + }, + { + level: 5, + items: { + plank: 7, + cobble: 6, + dust: 8, + ingot: 4, + }, + goal: ['piston'], + time: d => 15 - d, + }, + { + level: 10, + items: { + log: 2, + cobble: 4, + dust: 2, + ingot: 1, + }, + goal: ['piston'], + time: d => 15 - d, + }, + { + level: 13, + items: { + log: 8, + }, + goal: ['pickaxe'], + time: d => 15 - d, + }, + { + level: 18, + items: { + ingot: 8, + plank: 8, + }, + goal: ['hopper'], + time: d => 20 - d, + }, + { + level: 21, + items: { + ingot: 12, + log: 3, + }, + goal: ['hopper'], + time: d => 20 - d, + }, + { + level: 25, + items: { + ingot: 24, + }, + goal: ['helmet', 'chestplate', 'leggings', 'boots'], + time: d => 18 - d, + }, + { + level: 30, + items: { + ingot: 28, + log: 1, + string: 3, + }, + goal: ['helmet', 'chestplate', 'leggings', 'boots', 'bow'], + time: d => 30 - d, + }, + { + level: 35, + items: { + ingot: 24, + log: 1, + string: 3, + gold: 64, + dust: 17, + }, + goal: ['helmet', 'chestplate', 'leggings', 'boots', 'bow'], + time: _ => 15, + }, + { + level: 40, + items: { + ingot: 24, + log: 1, + string: 3, + gold: 63, + dust: 15, + }, + goal: ['helmet', 'chestplate', 'leggings', 'boots', 'bow'], + time: _ => 15, + }, +]; diff --git a/2026/games_submissions/the0x539/interaction.js b/2026/games_submissions/the0x539/interaction.js index 9c3cd37..d45d5c9 100644 --- a/2026/games_submissions/the0x539/interaction.js +++ b/2026/games_submissions/the0x539/interaction.js @@ -347,7 +347,7 @@ export function consumeClock() { if (state === 'split-evenly' && splitTargets.size > 1) { // oh dear. this is a complicated situation // first, let's try to search for uninvolved clocks - const uninvolved = document.querySelector('inventory-cell > item-stack[data-item="clock"]:not([data-original-count])'); + const uninvolved = document.querySelector('inventory-cell > item-stack[data-item="clock"]:not([data-original-count]):not(crafting-output item-stack)'); if (!!uninvolved) { const count = getCount(uninvolved); if (count === 1) { @@ -368,7 +368,7 @@ export function consumeClock() { return; } - const stack = document.querySelector('item-stack[data-item="clock"][data-count]'); + const stack = document.querySelector('item-stack[data-item="clock"][data-count]:not(crafting-output item-stack)') const count = getCount(stack); if (count === 1) { if (stack.parentElement === grabbedStack) { diff --git a/2026/games_submissions/the0x539/items/gold.png b/2026/games_submissions/the0x539/items/gold.png Binary files differnew file mode 100644 index 0000000..99b1a46 --- /dev/null +++ b/2026/games_submissions/the0x539/items/gold.png diff --git a/2026/games_submissions/the0x539/main.js b/2026/games_submissions/the0x539/main.js index b89465e..14a2b45 100644 --- a/2026/games_submissions/the0x539/main.js +++ b/2026/games_submissions/the0x539/main.js @@ -8,6 +8,7 @@ import { consumeClock, resetInventory, } from './interaction.js'; +import { scenarios } from './difficulty.js'; const followCursor = document.querySelector('follow-cursor'); const tooltip = document.querySelector('item-tooltip'); @@ -83,7 +84,7 @@ function giveItem(item, count) { let timerInterval = null; function timer() { - if (!document.querySelector('item-stack[data-item="clock"]')) { + if (!document.querySelector('item-stack[data-item="clock"]:not(crafting-output item-stack)')) { // time's up! endGame(false); } else { @@ -96,11 +97,12 @@ function startGame(difficulty) { resetInventory(); + const scenario = scenarios.toReversed().find(s => difficulty >= s.level); + desiredCrafts.clear(); - desiredCrafts.add('helmet'); - desiredCrafts.add('chestplate'); - desiredCrafts.add('leggings'); - desiredCrafts.add('boots'); + for (const item of scenario.goal) { + desiredCrafts.add(item); + } todoList.replaceChildren(); for (const item of desiredCrafts) { @@ -112,12 +114,11 @@ function startGame(difficulty) { todoList.append(listItem); } - - giveItem('log', 64); - giveItem('ingot', 64); - giveItem('clock', 12); - giveItem('dust', 16); - giveItem('cobble', 16); + + for (const [item, amount] of Object.entries(scenario.items)) { + giveItem(item, amount); + } + giveItem('clock', scenario.time(difficulty - scenario.level)); document.addEventListener('mousemove', onMouseMove); timerInterval = setInterval(timer, 1000); diff --git a/2026/index.html b/2026/index.html index a5ba2b8..34f6504 100644 --- a/2026/index.html +++ b/2026/index.html @@ -62,7 +62,7 @@ let least_ratio = Math.min(Math.floor(window.innerWidth / 480), Math.floor(window.innerHeight / 320)); let factor = Math.max(1, least_ratio); for (let i of iframes) { - i.style["transform"] = `scale(${factor})`; + i.style["transform"] = `scale(${factor * 2})`; } framing.style["transform"] = `scale(${factor})`; } diff --git a/2026/submissions.org b/2026/submissions.org index 2461b39..aa9bb5d 100644 --- a/2026/submissions.org +++ b/2026/submissions.org @@ -1,7 +1,6 @@ * Submissions -- [X] PeetsEater -- [X] MrROBUST -- [X] Bytomancer +- [X] peetseater +- [X] mrrobust - [X] gbjk - [X] lunaticlurker https://lunaticlurker.itch.io/clocktimesetter - [X] pralkarz https://codeberg.org/pralkarz/dzem @@ -18,25 +17,27 @@ - [X] icefoxzettai - [X] novaliminal - [X] talon1024 -- [ ] owlkaline https://github.com/Owlkaline/JobHuntingGame (need event handling fixes) - [X] sleepytealcoder https://codeberg.org/SleepyTealCoder/LcolonqMicrojam2K26APaloozaSconesUpMicrogame - [X] captain_onosa https://github.com/MrOnosa/fast-fall-ball-game-lcolonq -- [ ] jack turps https://github.com/jackturps/cowboy-micro-game (need restart fixes) -- [ ] dreamdeckup (need restart fix) -- [ ] just__jane (need to make sure it's scaled correctly) -- [X] doceys +- [X] steeledshield +- [X] rpc2dot0 (limewire link lmao) +- [X] crm148 http://fishion.org/crm148.tgz +- [X] mankeymaster18 https://github.com/mankeymaster/ratmanity +- [X] asrael https://pub.colonq.computer/~asrael/cj2k26/asrael_io.zip +- [X] bvnanana https://github.com/loremdifr/twetwis/releases/tag/v0.2.0 +- [X] sunshoes https://github.com/sun-shoes/shoot (needs src in repo) +- [X] the0x539 https://github.com/the0x539/microjam-craft +- [X] bytomancer https://github.com/bytomancer/clonq-jam-2026 +- [X] doceys (needs update) - [ ] threecoff https://codeberg.org/threecoff/clennis (needs emscripten build) -- [X] the0x539 -- mankeymaster18 https://github.com/mankeymaster/ratmanity -- steeledshield -- crm148 -- rpc2dot0 -- asrael -- fn_lumi +- [ ] just__jane (need to make sure it's scaled correctly) +- [ ] jack turps https://github.com/jackturps/cowboy-micro-game (need restart fixes) +- [ ] owlkaline https://github.com/Owlkaline/JobHuntingGame (need event handling fixes) +- [ ] dreamdeckup https://codeberg.org/dreamdeckup/lclonq-gamejam-2026 (need restart fix) +- fn_lumi? - captinbaptin? - yurcheeg? - a_tension_span? -- bvnanana? - ctrl_o? - janetacarr? - bigbookofbug? diff --git a/2026/submissions/asrael_io/asrael_io.zip b/2026/submissions/asrael_io/asrael_io.zip Binary files differnew file mode 100644 index 0000000..3310acb --- /dev/null +++ b/2026/submissions/asrael_io/asrael_io.zip diff --git a/2026/submissions/bvnanana/source.zip b/2026/submissions/bvnanana/source.zip Binary files differnew file mode 100644 index 0000000..a4f9263 --- /dev/null +++ b/2026/submissions/bvnanana/source.zip diff --git a/2026/submissions/bvnanana/twetwis_web_build_release.tar.gz b/2026/submissions/bvnanana/twetwis_web_build_release.tar.gz Binary files differnew file mode 100644 index 0000000..4e4b4bd --- /dev/null +++ b/2026/submissions/bvnanana/twetwis_web_build_release.tar.gz diff --git a/2026/submissions/bytomancer/bytomancer-jam.zip b/2026/submissions/bytomancer/bytomancer-jam.zip Binary files differindex 4442755..7f7a672 100644 --- a/2026/submissions/bytomancer/bytomancer-jam.zip +++ b/2026/submissions/bytomancer/bytomancer-jam.zip diff --git a/2026/submissions/bytomancer/clonq-jam-2026-0.9.0.zip b/2026/submissions/bytomancer/source.zip Binary files differindex aebe13b..4ae9548 100644 --- a/2026/submissions/bytomancer/clonq-jam-2026-0.9.0.zip +++ b/2026/submissions/bytomancer/source.zip diff --git a/2026/submissions/crm148/._crm148 b/2026/submissions/crm148/._crm148 Binary files differnew file mode 100755 index 0000000..6ee4edc --- /dev/null +++ b/2026/submissions/crm148/._crm148 diff --git a/2026/submissions/crm148/crm148.tgz b/2026/submissions/crm148/crm148.tgz Binary files differnew file mode 100644 index 0000000..65b14b3 --- /dev/null +++ b/2026/submissions/crm148/crm148.tgz diff --git a/2026/submissions/doceys/doceys.zip b/2026/submissions/doceys/doceys.zip Binary files differindex 116a9ad..a67e6eb 100644 --- a/2026/submissions/doceys/doceys.zip +++ b/2026/submissions/doceys/doceys.zip diff --git a/2026/submissions/doceys/source.zip b/2026/submissions/doceys/source.zip Binary files differindex a0ffc17..c2f2d7b 100644 --- a/2026/submissions/doceys/source.zip +++ b/2026/submissions/doceys/source.zip diff --git a/2026/submissions/dreamdeckup/master.zip b/2026/submissions/dreamdeckup/master.zip Binary files differnew file mode 100644 index 0000000..c8004c5 --- /dev/null +++ b/2026/submissions/dreamdeckup/master.zip diff --git a/2026/submissions/mankeymaster18/ratmanity.zip b/2026/submissions/mankeymaster18/ratmanity.zip Binary files differnew file mode 100644 index 0000000..bfa26f5 --- /dev/null +++ b/2026/submissions/mankeymaster18/ratmanity.zip diff --git a/2026/submissions/mankeymaster18/source.zip b/2026/submissions/mankeymaster18/source.zip Binary files differnew file mode 100644 index 0000000..de81004 --- /dev/null +++ b/2026/submissions/mankeymaster18/source.zip diff --git a/2026/submissions/rpc2dot0/eatyourgreens.zip b/2026/submissions/rpc2dot0/eatyourgreens.zip Binary files differnew file mode 100644 index 0000000..3e8a282 --- /dev/null +++ b/2026/submissions/rpc2dot0/eatyourgreens.zip diff --git a/2026/submissions/steeledshield/submission.zip b/2026/submissions/steeledshield/submission.zip Binary files differnew file mode 100644 index 0000000..d154772 --- /dev/null +++ b/2026/submissions/steeledshield/submission.zip diff --git a/2026/submissions/sunshoes/main.zip b/2026/submissions/sunshoes/main.zip Binary files differnew file mode 100644 index 0000000..70fbb1c --- /dev/null +++ b/2026/submissions/sunshoes/main.zip diff --git a/2026/submissions/the0x539/trunk.zip b/2026/submissions/the0x539/trunk.zip Binary files differindex e0eaaa2..633d749 100644 --- a/2026/submissions/the0x539/trunk.zip +++ b/2026/submissions/the0x539/trunk.zip diff --git a/2026/todo.org b/2026/todo.org index ce2d5f0..5dab9e9 100644 --- a/2026/todo.org +++ b/2026/todo.org @@ -1,8 +1,9 @@ * what remains -- we need "losing" +- [ ] we need "losing" + display streak + prompt to restart -- we need to display verbs -- we need some metadata +- [X] we need to display verbs +- [ ] we need some metadata + credits + sound or no +- [ ] upscale further |
