Skip to content

A fast 2D and 3D game engine — TypeScript SDK, C++/WebAssembly core, visual editor. Ship one project to web, desktop, WeChat MiniGames, playable ads, and native Android / iOS.

53.7 KB
Raw Blame
// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: Copyright (c) 2024-present ESEngine Team
/**
 * @file    WebSDKEntry.cpp
 * @brief   ESEngine Web SDK entry point with rendering support
 *
 * @author  ESEngine Team
 * @date    2026
 *
 * @copyright Copyright (c) 2026 ESEngine Team
 *            Licensed under the Apache License, Version 2.0.
 */


#include <emscripten.h>
#include <emscripten/bind.h>
#include <emscripten/html5.h>

#include "EngineContext.hpp"
#include "ActiveContext.hpp"
#include "ResourceManagerBindings.hpp"
#include "RendererBindings.hpp"
#include "TestProbeBindings.hpp"
#include "UIBindings.hpp"
#include "BoundarySpan.hpp"
#include "ImmediateDrawBindings.hpp"
#include "GeometryBindings.hpp"
#include "AnimationBindings.hpp"
#include "MaterialBindings.hpp"
#ifdef ES_ENABLE_POSTPROCESS
#include "PostProcessBindings.hpp"
#endif
#ifdef ES_ENABLE_TILEMAP
#include "TilemapBindings.hpp"
#endif

#include "../ui/UILayoutSystem.hpp"
#include "../ui/UIHitTestSystem.hpp"
#include "../ui/UIRenderOrderSystem.hpp"
#include "../ui/UISystem.hpp"

#include "../renderer/rhi/OpenGLHeaders.hpp"
#include "../renderer/rhi/GfxDevice.hpp"
#ifdef ES_ENABLE_WEBGPU
#include "../renderer/webgpu/WebGPUDevice.hpp"
#endif
#include "../renderer/frame/RenderContext.hpp"
#include "../renderer/frame/RenderFrame.hpp"
#include "../renderer/draw/ImmediateDraw.hpp"
#include "../renderer/draw/CustomGeometry.hpp"
#include "../resource/ResourceManager.hpp"
#include "../resource/ShaderParser.hpp"
#ifdef ES_ENABLE_BITMAP_TEXT
#include "../text/SdfGenerator.hpp"
#endif
#include "../ecs/TransformSystem.hpp"
#include "../core/World.hpp"
#include "../ecs/components/Velocity.hpp"
#include "../ecs/components/Camera.hpp"
#include "../ecs/components/UINode.hpp"
#include "../ecs/components/UIVisual.hpp"
#include "../ecs/components/RigidBody2D.hpp"
#include "../ecs/components/Collider2D.hpp"
#include "../ecs/components/ShapeRenderer.hpp"
#include "../animation/TweenSystem.hpp"
#ifdef ES_ENABLE_PARTICLES
#include "../particle/ParticleSystem.hpp"
#endif
#include "../core/Log.hpp"

#include <glm/glm.hpp>
#include <cstdlib>
#include <cstring>
#include <cstddef>
#include <malloc.h>

static_assert(sizeof(void*) == 4, "EM_JS pointer passing assumes wasm32 (4-byte pointers)");

namespace esengine {

static EngineContext& legacyCtx() { return EngineContext::instance(); }
// Single source of truth for the active context lives in activeCtx()
// (ActiveContext.hpp), which now carries the headless fallback uniformly — so
// this is just the file-local short alias, identical to every other binding's.
static EstellaContext& ctx() { return activeCtx(); }

#define g_initialized (ctx().state().initialized)
#define g_resourceManager (ctx().tryGet<resource::ResourceManager>())
#define g_renderContext (ctx().tryGet<RenderContext>())
#ifdef ES_ENABLE_PARTICLES
#define g_particleSystem (ctx().tryGet<particle::ParticleSystem>())
#endif

// Bytes malloc has handed out and not got back, for the resource census. The
// reserved heap size cannot answer this: emscripten's heap only grows, so a leak
// hides until it crosses a growth step. This is exact, and it falls on free.
f64 es_getMallocBytes() {
    const struct mallinfo mi = mallinfo();
    return static_cast<f64>(static_cast<u32>(mi.uordblks));
}

// Cook-time introspection: assembles both GLSL stages exactly as the runtime would
// (same parser + injected headers), plus the reflection a GLSL→WGSL converter needs
// (texture params → sampler units). The export cook feeds the assembled stages through
// glslang+naga and appends the result as `#pragma vertex|fragment wgsl full` twins,
// so twin-less user .esshader assets run on WebGPU (REARCH_WGSL Phase 4). Runs under
// plain Node (the web glue loads there), so the cook needs no browser context.
emscripten::val esshader_cookInfo(const std::string& source, const std::string& featuresCsv) {
    emscripten::val out = emscripten::val::object();
    resource::ParsedShader parsed = resource::ShaderParser::parse(source);
    out.set("valid", parsed.valid);
    if (!parsed.valid) {
        out.set("error", parsed.errorMessage);
        return out;
    }
    const std::vector<std::string> features = resource::ShaderParser::splitFeatures(featuresCsv);
    const std::string vert = resource::ShaderParser::assembleStage(
        parsed, resource::ShaderStage::Vertex, "", features,
        resource::ShaderTargetLanguage::GLSL_ES300);
    const std::string frag = resource::ShaderParser::assembleStage(
        parsed, resource::ShaderStage::Fragment, "", features,
        resource::ShaderTargetLanguage::GLSL_ES300);
    out.set("name", parsed.name);
    out.set("domain", parsed.domain);
    out.set("hasWgslVertex", parsed.wgslStages.count(resource::ShaderStage::Vertex) != 0);
    out.set("hasWgslFragment", parsed.wgslStages.count(resource::ShaderStage::Fragment) != 0);
    out.set("hasSwitches", !parsed.switches.empty());
    out.set("canonicalVaryings", resource::ShaderParser::canonicalVaryingsWGSL(parsed));
    // The switch/feature NAMES, so a cook can enumerate the permutations it has
    // to emit a twin for — WGSL resolves them at assembly time (preprocessConditionals),
    // which needs every branch present in the body.
    emscripten::val switches = emscripten::val::array();
    u32 switchCount = 0;
    for (const auto& s : parsed.switches) switches.set(switchCount++, s.name);
    out.set("switches", switches);
    emscripten::val featureNames = emscripten::val::array();
    u32 featureCount = 0;
    for (const auto& f : parsed.features) featureNames.set(featureCount++, f);
    out.set("features", featureNames);
    out.set("vertGlsl", vert);
    out.set("fragGlsl", frag);
    emscripten::val textures = emscripten::val::array();
    u32 count = 0;
    for (const auto& p : parsed.properties) {
        if (p.fromParam && p.type == resource::ShaderPropertyType::Texture && p.textureUnit >= 0) {
            emscripten::val tex = emscripten::val::object();
            tex.set("name", p.name);
            tex.set("unit", p.textureUnit);
            textures.set(count++, tex);
        }
    }
    out.set("textures", textures);
    return out;
}

// Build provenance signature — kept self-contained (not via the umbrella
// header) so the literal is guaranteed to land in this translation unit and
// survive in the shipped binary. Emitted once at init as an origin marker.
static constexpr const char* kEstellaBuildProvenance =
    "estella-build:9abbd5b4-06f3-47df-b968-826763c6879a";

bool initRendererInternal(const char* canvasSelector) {
    if (g_initialized) return true;

    EmscriptenWebGLContextAttributes attrs;
    emscripten_webgl_init_context_attributes(&attrs);
    attrs.majorVersion = 2;
    attrs.minorVersion = 0;
    attrs.alpha = true;
    attrs.depth = true;
    attrs.stencil = true;
    attrs.antialias = true;
    attrs.premultipliedAlpha = true;
    attrs.preserveDrawingBuffer = false;
    attrs.powerPreference = EM_WEBGL_POWER_PREFERENCE_DEFAULT;
    attrs.failIfMajorPerformanceCaveat = false;

    EMSCRIPTEN_WEBGL_CONTEXT_HANDLE webglCtx = emscripten_webgl_create_context(canvasSelector, &attrs);
    if (webglCtx <= 0) {
        ES_LOG_ERROR("Failed to create WebGL2 context for '{}': {}", canvasSelector, webglCtx);
        return false;
    }

    ES_LOG_INFO("WebGL2 context created for '{}'", canvasSelector);
    ES_LOG_INFO("Estella runtime provenance {}", kEstellaBuildProvenance);

    g_activeContext = &legacyCtx().context();
    if (!g_activeContext->init(static_cast<int>(webglCtx), true)) {
        // This path creates the context; an externally supplied handle is borrowed.
        emscripten_webgl_destroy_context(webglCtx);
        return false;
    }
    return true;
}

// The WebGPU mirror of initRendererInternal — the same platform boundary,
// injecting the backend instead of a GL context handle. The page acquires the
// GPUDevice asynchronously (navigator.gpu) BEFORE instantiating the module and
// hands it over via Module.preinitializedWebGPUDevice; the wasm side stays
// fully synchronous. @p width/@p height size the canvas swapchain (the SDK
// passes the canvas backing size it already manages).
bool initRendererWebGPU(const std::string& canvasSelector, u32 width, u32 height,
                        bool readback, bool preferBGRA) {
#ifdef ES_ENABLE_WEBGPU
    if (g_initialized) return true;

    WGPUDevice raw = emscripten_webgpu_get_device();
    if (!raw) {
        ES_LOG_ERROR("initRendererWebGPU: no Module.preinitializedWebGPUDevice — the host "
                     "must acquire a GPUDevice before instantiating the module");
        return false;
    }
    auto device = makeUnique<WebGPUDevice>(raw);
    // Before the surface is configured, because the usage is fixed there: a host
    // that will ask what was drawn (the editor's viewport capture, a pixel gate)
    // has to say so now.
    device->setSurfaceReadback(readback);
    // navigator.gpu.getPreferredCanvasFormat(), as the page reported it: any other
    // format makes the browser copy the whole frame on every present.
    device->setPreferredSurfaceBGRA(preferBGRA);
    if (!device->configureSurface(canvasSelector.c_str(), width, height)) {
        ES_LOG_ERROR("initRendererWebGPU: surface configuration failed for '{}'", canvasSelector);
        return false;
    }

    ES_LOG_INFO("WebGPU device injected for '{}' ({}x{})", canvasSelector, width, height);
    ES_LOG_INFO("Estella runtime provenance {}", kEstellaBuildProvenance);

    g_activeContext = &legacyCtx().context();
    return g_activeContext->init(std::move(device));
#else
    (void)canvasSelector; (void)width; (void)height; (void)readback; (void)preferBGRA;
    ES_LOG_ERROR("initRendererWebGPU: this build carries no WebGPU backend (ES_ENABLE_WEBGPU off)");
    return false;
#endif
}

bool initRenderer() {
    return initRendererInternal("#canvas");
}

bool initRendererWithContext(int contextHandle) {
    if (g_initialized) return true;
    if (contextHandle <= 0) {
        ES_LOG_ERROR("Invalid WebGL context handle: {}", contextHandle);
        return false;
    }

    g_activeContext = &legacyCtx().context();
    return g_activeContext->init(contextHandle);
}

void shutdownRenderer() {
    if (g_activeContext) {
        g_activeContext->shutdown();
        g_activeContext = nullptr;
    }
}

resource::ResourceManager* getResourceManager() {
    return g_resourceManager;
}

// =============================================================================
// Device Loss
// =============================================================================

namespace {
GfxDevice* activeGfxDevice() {
    return g_activeContext ? g_activeContext->tryGet<GfxDevice>() : nullptr;
}
}  // namespace

/** @brief The device's status (see GfxDeviceStatus). Live when no device exists yet. */
u32 deviceStatus() {
    GfxDevice* device = activeGfxDevice();
    return static_cast<u32>(device ? device->deviceStatus() : GfxDeviceStatus::Live);
}

/** @brief The formatted loss report; empty while the device is live. */
std::string deviceLostReport() {
    GfxDevice* device = activeGfxDevice();
    if (!device) return {};
    const GfxDeviceLostInfo* info = device->deviceLostInfo();
    return info ? gfxFormatDeviceLost(*info) : std::string();
}

/**
 * @brief Who the device is, as `backend|vendor|renderer|version`.
 * @details Readable while the device is LIVE, which the loss report is not — a
 *          crash report needs the GPU it ran on, and by then the backend cannot
 *          be asked. Pipe-joined: one crossing, and these are driver strings
 *          rather than a schema.
 */
std::string deviceIdentity() {
    GfxDevice* device = activeGfxDevice();
    if (!device) return {};
    const GfxDeviceIdentity& id = device->deviceIdentity();
    if (!id.known()) return {};
    return id.backend + "|" + id.vendor + "|" + id.renderer + "|" + id.version;
}

#ifdef ES_ENABLE_WEBGPU
EM_JS_DEPS(estella_webgpu_replacement, "$WebGPU");

// The page's replacement GPUDevice, as a WGPUDevice. Imported rather than read
// through emscripten_webgpu_get_device, which caches the FIRST device and would
// hand back the dead one forever.
EM_JS(uintptr_t, es_takePendingWebGPUDevice, (), {
    var device = Module['pendingWebGPUDevice'];
    if (!device) return 0;
    Module['pendingWebGPUDevice'] = null;
    return WebGPU.importJsDevice(device);
});
#endif

/**
 * @brief Hands the backend a replacement device the page acquired.
 * @details WebGPU only: a device belongs to whoever created it, so a lost one
 *          can only be replaced from the page. Taken up by the next recovery
 *          attempt, which keeps one order of operations for both backends.
 */
bool provideReplacementDevice() {
#ifdef ES_ENABLE_WEBGPU
    GfxDevice* device = activeGfxDevice();
    if (!device) return false;
    const uintptr_t raw = es_takePendingWebGPUDevice();
    if (!raw) return false;
    return device->provideReplacementDevice(reinterpret_cast<void*>(raw));
#else
    return false;
#endif
}

/**
 * @brief Rebuilds the device and everything it issued; see GfxDevice::recoverDevice.
 * @details The device stays Recovering, drawing, until the content it is owed
 *          has been refilled or given up on, then turns Live by itself.
 */
bool recoverDevice() {
    GfxDevice* device = activeGfxDevice();
    if (!device || !device->recoverDevice()) return false;
    // What the render context built from code it builds again; everything else owed has a provider on the other side.
    if (auto* context = g_renderContext) context->restoreBuiltinContent();
    return true;
}

/**
 * @brief Reports a loss the page observed.
 * @details The browser tells JS, not wasm: `webglcontextlost` fires on the
 *          canvas element and a GPUDevice resolves its `lost` promise. Both
 *          arrive here so the C++ device stops submitting on the same frame
 *          rather than after its own next poll.
 */
void notifyDeviceLost(u32 reason, const std::string& message) {
    if (GfxDevice* device = activeGfxDevice()) {
        device->notifyDeviceLost(static_cast<GfxDeviceLostReason>(reason), message, "host");
    }
}

// Runtime glyph atlas: a Canvas2D-rasterized alpha bitmap to a signed distance
// field. Both buffers are caller-allocated in WASM linear memory and are
// width*height. Under the text flag, because the generator it calls is.
#ifdef ES_ENABLE_BITMAP_TEXT
void web_sdfFromAlpha(uintptr_t alphaPtr, uintptr_t outPtr, u32 width, u32 height, f32 spread) {
    const u64 pixels = static_cast<u64>(width) * height;
    const u8* alpha = boundarySpan<u8>(alphaPtr, pixels, "sdfFromAlpha.alpha");
    u8* out = boundarySpanMut<u8>(outPtr, pixels, "sdfFromAlpha.out");
    if (!alpha || !out) return;
    text::sdfFromAlpha(alpha, out, width, height, spread);
}
#endif

// =============================================================================
// Pointer-based Component Access
// =============================================================================

// NOTE: Per-field component layout offsets are asserted for ALL components in
// WebBindings.generated.cpp (generated by EHT's PtrLayoutGenerator), which is
// the single source of truth for the pointer ABI. Do not hand-maintain
// static_assert(offsetof(...)) here — they drifted and only covered 8 of N
// components.

int getTransformPtr(ecs::Registry& r, u32 e) {
    auto* t = r.tryGet<ecs::Transform>(Entity::fromRaw(e));
    if (!t) return 0;
    t->ensureDecomposed();
    return static_cast<int>(reinterpret_cast<uintptr_t>(t));
}

// Every pool's version in one number: what a holder of raw component addresses
// asks before trusting them for another frame (Registry::layoutEpoch).
double registryLayoutEpoch(ecs::Registry& r) {
    return r.layoutEpoch();
}

int getSpritePtr(ecs::Registry& r, u32 e) {
    auto* s = r.tryGet<ecs::Sprite>(Entity::fromRaw(e));
    if (!s) return 0;
    return static_cast<int>(reinterpret_cast<uintptr_t>(s));
}

int getUINodePtr(ecs::Registry& r, u32 e) {
    auto* node = r.tryGet<ecs::UINode>(Entity::fromRaw(e));
    if (!node) return 0;
    return static_cast<int>(reinterpret_cast<uintptr_t>(node));
}

int getVelocityPtr(ecs::Registry& r, u32 e) {
    auto* v = r.tryGet<ecs::Velocity>(Entity::fromRaw(e));
    if (!v) return 0;
    return static_cast<int>(reinterpret_cast<uintptr_t>(v));
}

int getCameraPtr(ecs::Registry& r, u32 e) {
    auto* c = r.tryGet<ecs::Camera>(Entity::fromRaw(e));
    if (!c) return 0;
    return static_cast<int>(reinterpret_cast<uintptr_t>(c));
}

int getRigidBody2DPtr(ecs::Registry& r, u32 e) {
    auto* rb = r.tryGet<ecs::RigidBody2D>(Entity::fromRaw(e));
    if (!rb) return 0;
    return static_cast<int>(reinterpret_cast<uintptr_t>(rb));
}

int getBoxCollider2DPtr(ecs::Registry& r, u32 e) {
    auto* bc = r.tryGet<ecs::BoxCollider2D>(Entity::fromRaw(e));
    if (!bc) return 0;
    return static_cast<int>(reinterpret_cast<uintptr_t>(bc));
}

int getCircleCollider2DPtr(ecs::Registry& r, u32 e) {
    auto* cc = r.tryGet<ecs::CircleCollider2D>(Entity::fromRaw(e));
    if (!cc) return 0;
    return static_cast<int>(reinterpret_cast<uintptr_t>(cc));
}

}  // namespace esengine

EMSCRIPTEN_BINDINGS(esengine_ptr_access) {
    emscripten::function("getTransformPtr", &esengine::getTransformPtr);
    emscripten::function("registryLayoutEpoch", &esengine::registryLayoutEpoch);
    emscripten::function("getSpritePtr", &esengine::getSpritePtr);
    emscripten::function("getUINodePtr", &esengine::getUINodePtr);
    emscripten::function("getVelocityPtr", &esengine::getVelocityPtr);
    emscripten::function("getCameraPtr", &esengine::getCameraPtr);
    emscripten::function("getRigidBody2DPtr", &esengine::getRigidBody2DPtr);
    emscripten::function("getBoxCollider2DPtr", &esengine::getBoxCollider2DPtr);
    emscripten::function("getCircleCollider2DPtr", &esengine::getCircleCollider2DPtr);
}

// Engine instancing: expose EstellaContext as
// a JS-newable instance + an explicit active-context setter, so the editor can
// own / create / destroy isolated engine contexts rather than every App being
// hard-bound to the process singleton (EngineContext::instance()). PURE ADDITION
// — the existing initRenderer paths are untouched until N3 routes through these.
// JS owns the instance (new module.EstellaContext() ... ctx.delete()), exactly
// like new module.Registry().
EMSCRIPTEN_BINDINGS(esengine_context) {
    emscripten::class_<esengine::EstellaContext>("EstellaContext")
        .constructor<>()
        // The WebGL overload — JS hands over a context handle. The
        // device-injection overload is C++-side only (harnesses/backends).
        .function("init", emscripten::select_overload<bool(int)>(&esengine::EstellaContext::init))
        .function("shutdown", &esengine::EstellaContext::shutdown)
        .function("isInitialized", &esengine::EstellaContext::isInitialized);
    // Pointer (not reference) so JS can pass null to clear the active context.
    emscripten::function(
        "setActiveContext",
        +[](esengine::EstellaContext* c) { esengine::g_activeContext = c; },
        emscripten::allow_raw_pointers());
}

EMSCRIPTEN_BINDINGS(esengine_renderer) {
    emscripten::function("initRenderer", &esengine::initRenderer);
    emscripten::function("initRendererWithContext", &esengine::initRendererWithContext);
    // Registered in every build variant; without ES_ENABLE_WEBGPU it reports
    // and returns false, so the JS surface never drifts across variants.
    emscripten::function("initRendererWebGPU", &esengine::initRendererWebGPU);
    emscripten::function("shutdownRenderer", &esengine::shutdownRenderer);
    emscripten::function("getResourceManager", &esengine::getResourceManager, emscripten::allow_raw_pointers());
#ifdef ES_ENABLE_BITMAP_TEXT
    emscripten::function("sdfFromAlpha", &esengine::web_sdfFromAlpha);
#endif
    emscripten::function("deviceStatus", &esengine::deviceStatus);
    emscripten::function("deviceLostReport", &esengine::deviceLostReport);
    emscripten::function("deviceIdentity", &esengine::deviceIdentity);
    emscripten::function("notifyDeviceLost", &esengine::notifyDeviceLost);
    emscripten::function("recoverDevice", &esengine::recoverDevice);
    emscripten::function("provideReplacementDevice", &esengine::provideReplacementDevice);

    emscripten::class_<esengine::resource::ResourceManager>("ResourceManager")
        .function("createTexture", &esengine::rm_createTexture)
        .function("createTextureEx", &esengine::rm_createTextureEx)
        .function("createTextureArray", &esengine::rm_createTextureArray)
        .function("createShader", &esengine::rm_createShader)
        .function("supportsCompressedFormat", &esengine::rm_supportsCompressedFormat)
        .function("createCompressedTexture", &esengine::rm_createCompressedTexture)
        .function("registerExternalTexture", &esengine::rm_registerExternalTexture)
        .function("registerExternalTextureSized", &esengine::rm_registerExternalTextureSized)
        .function("wrapDeviceTexture", &esengine::rm_wrapDeviceTexture)
        .function("texturesAwaitingReupload", &esengine::rm_texturesAwaitingReupload)
        .function("forgoTextureContent", &esengine::rm_forgoTextureContent)
        .function("restoreTextureContent", &esengine::rm_restoreTextureContent)
        .function("getTextureNativeId", &esengine::rm_getTextureNativeId)
        .function("meshesAwaitingRemat", &esengine::rm_meshesAwaitingRemat)
        .function("meshRealizations", &esengine::rm_meshRealizations)
        .function("adoptTextureContent", &esengine::rm_adoptTextureContent)
        .function("releaseTexture", &esengine::rm_releaseTexture)
        .function("getTextureRefCount", &esengine::rm_getTextureRefCount)
        .function("releaseShader", &esengine::rm_releaseShader)
        .function("getShaderRefCount", &esengine::rm_getShaderRefCount)
        .function("getTextureGLId", &esengine::rm_getTextureGLId)
        .function("getTextureDimensions", &esengine::rm_getTextureDimensions)
        .function("setTextureMetadata", &esengine::rm_setTextureMetadata)
        .function("updateTextureSubregion", &esengine::rm_updateTextureSubregion)
        .function("registerTextureWithPath", &esengine::rm_registerTextureWithPath)
        .function("setTextureBudget", &esengine::rm_setTextureBudget)
        .function("setRetainedBudget", &esengine::rm_setRetainedBudget)
        .function("acquireTextureByPath", &esengine::rm_acquireTextureByPath)
        .function("invalidateTexturePath", &esengine::rm_invalidateTexturePath)
        .function("trimTextureCache", &esengine::rm_trimTextureCache)
        .function("getResourceStats", &esengine::rm_getResourceStats)
#ifdef ES_ENABLE_BITMAP_TEXT
        .function("loadBitmapFont", &esengine::rm_loadBitmapFont)
        .function("createLabelAtlasFont", &esengine::rm_createLabelAtlasFont)
        .function("releaseBitmapFont", &esengine::rm_releaseBitmapFont)
        .function("getBitmapFontRefCount", &esengine::rm_getBitmapFontRefCount)
        .function("measureBitmapText", &esengine::rm_measureBitmapText)
#endif
        ;

    // Every skeletal runtime is a side module; this is the one door their posed
    // geometry comes through, so it belongs to neither of their build flags.
    emscripten::function("renderer_submitSkeletalBatchByEntity", &esengine::renderer_submitSkeletalBatchByEntity);
    emscripten::function("renderer_submitSkeletalBatchByEntityEx", &esengine::renderer_submitSkeletalBatchByEntityEx);
    emscripten::function("renderer_entityVisibleToCamera", &esengine::renderer_entityVisibleToCamera);
    emscripten::function("renderer_submitTextBatch", &esengine::renderer_submitTextBatch);
    emscripten::function("renderer_retainedTextBegin", &esengine::renderer_retainedTextBegin);
    emscripten::function("renderer_retainedTextBatch", &esengine::renderer_retainedTextBatch);
    emscripten::function("renderer_retainedTextClear", &esengine::renderer_retainedTextClear);
    emscripten::function("renderer_retainedTextStale", &esengine::renderer_retainedTextStale);
    emscripten::function("renderer_retainedTextSubmit", &esengine::renderer_retainedTextSubmit);
    emscripten::function("meshRenderer_setGeometry", &esengine::meshRenderer_setGeometry);
    emscripten::function("meshInstances_set", &esengine::meshInstances_set);
    emscripten::function("mesh_createFromChannels", &esengine::mesh_createFromChannels);
    emscripten::function("mesh_rematerializeFromChannels", &esengine::mesh_rematerializeFromChannels);
    emscripten::function("mesh_release", &esengine::mesh_release);
    emscripten::function("environment_create", &esengine::environment_create);
    emscripten::function("environment_setSky", &esengine::environment_setSky);
    emscripten::function("environment_setSun", &esengine::environment_setSun);
    emscripten::function("environment_release", &esengine::environment_release);
    emscripten::function("renderer_setSkyEnvironment", &esengine::renderer_setSkyEnvironment);
    emscripten::function("probe_volume_create", &esengine::probe_volume_create);
    emscripten::function("probe_volume_release", &esengine::probe_volume_release);
    emscripten::function("probe_volume_setSkyVisibility", &esengine::probe_volume_setSkyVisibility);
    emscripten::function("meshRenderer_localBounds", &esengine::meshRenderer_localBounds);
    emscripten::function("meshRenderer_makeAllResident", &esengine::meshRenderer_makeAllResident);
    emscripten::function("meshRenderer_setMeshAll", &esengine::meshRenderer_setMeshAll);
    emscripten::function("meshRenderer_setMaterialAll", &esengine::meshRenderer_setMaterialAll);

    emscripten::function("material_compileEsshader", &esengine::material_compileEsshader);
    emscripten::function("esshader_cookInfo", &esengine::esshader_cookInfo);
    emscripten::function("es_getMallocBytes", &esengine::es_getMallocBytes);
    emscripten::function("material_define", &esengine::material_define);
    emscripten::function("material_setUniform", &esengine::material_setUniform);
    emscripten::function("material_setTexture", &esengine::material_setTexture);
    emscripten::function("material_undefine", &esengine::material_undefine);

    emscripten::function("draw_begin", &esengine::draw_begin);
    emscripten::function("draw_end", &esengine::draw_end);
    emscripten::function("draw_deferEnd", &esengine::draw_deferEnd);
    emscripten::function("draw_line", &esengine::draw_line);
    emscripten::function("draw_line3D", &esengine::draw_line3D);
    emscripten::function("draw_line3DScreen", &esengine::draw_line3DScreen);
    emscripten::function("draw_line3DScreenOffset", &esengine::draw_line3DScreenOffset);
    emscripten::function("draw_rect", &esengine::draw_rect);
    emscripten::function("draw_rectOutline", &esengine::draw_rectOutline);
    emscripten::function("draw_circle", &esengine::draw_circle);
    emscripten::function("draw_circleOutline", &esengine::draw_circleOutline);
    emscripten::function("draw_texture", &esengine::draw_texture);
    emscripten::function("draw_textureRotated", &esengine::draw_textureRotated);
    emscripten::function("draw_setLayer", &esengine::draw_setLayer);
    emscripten::function("draw_setDepth", &esengine::draw_setDepth);
    emscripten::function("draw_getDrawCallCount", &esengine::draw_getDrawCallCount);
    emscripten::function("draw_getPrimitiveCount", &esengine::draw_getPrimitiveCount);
    emscripten::function("draw_setBlendMode", &esengine::draw_setBlendMode);
    emscripten::function("draw_setDepthTest", &esengine::draw_setDepthTest);
    emscripten::function("draw_getDepthState", &esengine::draw_getDepthState);
    emscripten::function("draw_setDepthState", &esengine::draw_setDepthState);
    emscripten::function("draw_deferBegin", &esengine::draw_deferBegin);
    emscripten::function("draw_mesh", &esengine::draw_mesh);
    emscripten::function("draw_meshWithUniforms", &esengine::draw_meshWithUniforms);
    emscripten::function("draw_meshWithMaterial", &esengine::draw_meshWithMaterial);

    emscripten::function("geometry_create", &esengine::geometry_create);
    emscripten::function("geometry_init", &esengine::geometry_init);
    emscripten::function("geometry_setIndices16", &esengine::geometry_setIndices16);
    emscripten::function("geometry_setIndices32", &esengine::geometry_setIndices32);
    emscripten::function("geometry_updateVertices", &esengine::geometry_updateVertices);
    emscripten::function("geometry_release", &esengine::geometry_release);
    emscripten::function("geometry_isValid", &esengine::geometry_isValid);

#ifdef ES_ENABLE_POSTPROCESS
    emscripten::function("postprocess_init", &esengine::postprocess_init);
    emscripten::function("postprocess_shutdown", &esengine::postprocess_shutdown);
    emscripten::function("postprocess_resize", &esengine::postprocess_resize);
    emscripten::function("postprocess_addPass", &esengine::postprocess_addPass);
    emscripten::function("postprocess_addComputePass", &esengine::postprocess_addComputePass);
    emscripten::function("postprocess_supportsCompute", &esengine::postprocess_supportsCompute);
    emscripten::function("postprocess_addNativePass", &esengine::postprocess_addNativePass);
    emscripten::function("postprocess_setGIScene", &esengine::postprocess_setGIScene);
    emscripten::function("postprocess_updateGIField", &esengine::postprocess_updateGIField);
    emscripten::function("postprocess_setPassScale", &esengine::postprocess_setPassScale);
    emscripten::function("postprocess_setPassContinuesEffect", &esengine::postprocess_setPassContinuesEffect);
    emscripten::function("postprocess_requestSkyCapture", &esengine::postprocess_requestSkyCapture);
    emscripten::function("postprocess_pollSkyCapture", &esengine::postprocess_pollSkyCapture);
    emscripten::function("postprocess_takeSkyCapture", &esengine::postprocess_takeSkyCapture);
    emscripten::function("postprocess_giStats", &esengine::postprocess_giStats);
    emscripten::function("postprocess_setMsaaSamples", &esengine::postprocess_setMsaaSamples);
    emscripten::function("postprocess_effectiveMsaaSamples", &esengine::postprocess_effectiveMsaaSamples);
    emscripten::function("postprocess_maxMsaaSamples", &esengine::postprocess_maxMsaaSamples);
    emscripten::function("postprocess_hdrFormat", &esengine::postprocess_hdrFormat);
    emscripten::function("postprocess_hdrFormatNames", &esengine::postprocess_hdrFormatNames);
    emscripten::function("postprocess_setUniformFloat", &esengine::postprocess_setUniformFloat);
    emscripten::function("postprocess_setUniformVec4", &esengine::postprocess_setUniformVec4);
    emscripten::function("postprocess_setPassTexture", &esengine::postprocess_setPassTexture);
    emscripten::function("postprocess_begin", &esengine::postprocess_begin);
    emscripten::function("postprocess_end", &esengine::postprocess_end);
    emscripten::function("postprocess_isInitialized", &esengine::postprocess_isInitialized);
    emscripten::function("postprocess_setBypass", &esengine::postprocess_setBypass);
    emscripten::function("postprocess_setOutputTransform", &esengine::postprocess_setOutputTransform);
    emscripten::function("postprocess_setDisplayLut", &esengine::postprocess_setDisplayLut);
    emscripten::function("postprocess_setViewExposure", &esengine::postprocess_setViewExposure);
    emscripten::function("postprocess_clearPasses", &esengine::postprocess_clearPasses);
    emscripten::function("postprocess_setOutputViewport", &esengine::postprocess_setOutputViewport);
    emscripten::function("postprocess_setPresentRequired", &esengine::postprocess_setPresentRequired);
    emscripten::function("postprocess_beginScreenCapture", &esengine::postprocess_beginScreenCapture);
    emscripten::function("postprocess_endScreenCapture", &esengine::postprocess_endScreenCapture);
    emscripten::function("postprocess_executeScreenPasses", &esengine::postprocess_executeScreenPasses);
    emscripten::function("postprocess_addScreenPass", &esengine::postprocess_addScreenPass);
    emscripten::function("postprocess_clearScreenPasses", &esengine::postprocess_clearScreenPasses);
    emscripten::function("postprocess_setScreenUniformFloat", &esengine::postprocess_setScreenUniformFloat);
    emscripten::function("postprocess_setScreenUniformVec4", &esengine::postprocess_setScreenUniformVec4);
#endif

#ifdef ES_ENABLE_TILEMAP
    // Tilemaps registered here with every other binding, from the same
    // TilemapBindings.hpp declarations the native wrappers are generated from.
    emscripten::function("tilemap_initLayer", &esengine::tilemap_initLayer);
    emscripten::function("tilemap_initInfinite", &esengine::tilemap_initInfinite);
    emscripten::function("tilemap_destroyLayer", &esengine::tilemap_destroyLayer);
    emscripten::function("tilemap_setTile", &esengine::tilemap_setTile);
    emscripten::function("tilemap_getTile", &esengine::tilemap_getTile);
    emscripten::function("tilemap_fillRect", &esengine::tilemap_fillRect);
    emscripten::function("tilemap_setTiles", &esengine::tilemap_setTiles);
    emscripten::function("tilemap_setTilesets", &esengine::tilemap_setTilesets);
    emscripten::function("tilemap_hasLayer", &esengine::tilemap_hasLayer);
    emscripten::function("tilemap_getEditRevision", &esengine::tilemap_getEditRevision);
    emscripten::function("tilemap_getGeneration", &esengine::tilemap_getGeneration);
    emscripten::function("tilemap_readChunkIndex", &esengine::tilemap_readChunkIndex);
    emscripten::function("tilemap_readChunkTiles", &esengine::tilemap_readChunkTiles);
    emscripten::function("tilemap_setRenderProps", &esengine::tilemap_setRenderProps);
    emscripten::function("tilemap_setTint", &esengine::tilemap_setTint);
    emscripten::function("tilemap_setVisible", &esengine::tilemap_setVisible);
    emscripten::function("tilemap_setOriginEntity", &esengine::tilemap_setOriginEntity);
    emscripten::function("tilemap_exportChunks", &esengine::tilemap_exportChunks);
    emscripten::function("tilemap_importChunks", &esengine::tilemap_importChunks);
    emscripten::function("tilemap_initInfiniteLayer", &esengine::tilemap_initInfiniteLayer);
    emscripten::function("tilemap_setChunkTiles", &esengine::tilemap_setChunkTiles);
    emscripten::function("tilemap_removeChunk", &esengine::tilemap_removeChunk);
    emscripten::function("tilemap_setTileAnimation", &esengine::tilemap_setTileAnimation);
    emscripten::function("tilemap_clearTileAnimations", &esengine::tilemap_clearTileAnimations);
    emscripten::function("tilemap_advanceAnimations", &esengine::tilemap_advanceAnimations);
    emscripten::function("tilemap_setTileProperty", &esengine::tilemap_setTileProperty);
    emscripten::function("tilemap_getTileProperty", &esengine::tilemap_getTileProperty);
    emscripten::function("tilemap_flipTile", &esengine::tilemap_flipTile);
    emscripten::function("tilemap_rotateTile", &esengine::tilemap_rotateTile);
    emscripten::function("tilemap_setGridType", &esengine::tilemap_setGridType);
    emscripten::function("tilemap_setHexParams", &esengine::tilemap_setHexParams);
    emscripten::function("tilemap_tileToWorld", &esengine::tilemap_tileToWorld);
    emscripten::function("tilemap_worldToTile", &esengine::tilemap_worldToTile);
#endif

    emscripten::function("renderer_init", &esengine::renderer_init);
    emscripten::function("renderer_resize", &esengine::renderer_resize);
    emscripten::function("renderer_beginFrame", &esengine::renderer_beginFrame);
    emscripten::function("renderer_setOrigin", &esengine::renderer_setOrigin);
    emscripten::function("renderer_begin", &esengine::renderer_begin);
    emscripten::function("renderer_flush", &esengine::renderer_flush);
    emscripten::function("renderer_end", &esengine::renderer_end);
    emscripten::function("renderer_endFrame", &esengine::renderer_endFrame);
    emscripten::function("renderer_beginScreenOverlay", &esengine::renderer_beginScreenOverlay);
    emscripten::function("renderer_submitScreenOverlay", &esengine::renderer_submitScreenOverlay);
    emscripten::function("renderer_endScreenOverlay", &esengine::renderer_endScreenOverlay);
#ifdef ES_ENABLE_BITMAP_TEXT
#endif

#ifdef ES_ENABLE_PARTICLES
#endif
    emscripten::function("renderer_updateTransforms", &esengine::renderer_updateTransforms);
    // The address of the composition's staleness counter, so a producer on the
    // JS side stores into linear memory instead of calling across it. Measured:
    // the store is below noise, the call nearly doubles a Transform write.
    emscripten::function("transform_epochAddress", emscripten::optional_override([]() -> uintptr_t {
        return reinterpret_cast<uintptr_t>(&esengine::ecs::transformMutationEpoch());
    }));
    emscripten::function("transform_ensureComposed", emscripten::optional_override(
        [](esengine::ecs::Registry& registry) {
            if (auto* ts = esengine::ctx().tryGet<esengine::ecs::TransformSystem>()) {
                ts->ensureComposed(registry);
            }
        }), emscripten::allow_raw_pointers());
    // Whether composition also records WHICH entities' output moved. Off by
    // default: only a consumer maintaining an incremental structure needs it.
    emscripten::function("transform_setChangeTracking", emscripten::optional_override(
        [](bool on) {
            if (auto* ts = esengine::ctx().tryGet<esengine::ecs::TransformSystem>()) {
                ts->setChangeTracking(on);
            }
        }));
    // What every composition since the last acknowledgement changed: the entities
    // as an address into linear memory, because a JS array of a hundred thousand
    // handles would cost more than the walk that found them.
    emscripten::function("transform_compositionChanges", emscripten::optional_override(
        []() -> emscripten::val {
            static_assert(sizeof(esengine::Entity) == sizeof(esengine::u32),
                          "the changed set is read as a Uint32Array of raw ids");
            auto out = emscripten::val::object();
            auto* ts = esengine::ctx().tryGet<esengine::ecs::TransformSystem>();
            out.set("serial", ts ? ts->compositionSerial() : 0u);
            out.set("tracking", ts && ts->changeTracking());
            out.set("overflowed", ts && ts->changesOverflowed());
            out.set("count", ts ? static_cast<esengine::u32>(ts->pendingChanges().size()) : 0u);
            out.set("visited", ts ? ts->visited() : 0u);
            out.set("ptr", ts ? static_cast<esengine::u32>(
                reinterpret_cast<uintptr_t>(ts->pendingChanges().data())) : 0u);
            return out;
        }));
    // Applied: the set starts again. Separate from the read so a consumer that
    // throws half way through has not acknowledged, and gets it again.
    emscripten::function("transform_takeChanges", emscripten::optional_override([]() {
        if (auto* ts = esengine::ctx().tryGet<esengine::ecs::TransformSystem>()) ts->takeChanges();
    }));
    emscripten::function("renderer_setEntityDrawOrder", &esengine::renderer_setEntityDrawOrder);
    emscripten::function("renderer_submitAll", &esengine::renderer_submitAll);
#ifdef ES_ENABLE_PARTICLES
    emscripten::function("particle_update", &esengine::particle_update);
    emscripten::function("particle_collisionQueryCount", &esengine::particle_collisionQueryCount);
    emscripten::function("particle_collisionQueries", &esengine::particle_collisionQueries);
    emscripten::function("particle_collisionEventCount", &esengine::particle_collisionEventCount);
    emscripten::function("particle_collisionEvents", &esengine::particle_collisionEvents);
    emscripten::function("particle_collisionStatsCount", &esengine::particle_collisionStatsCount);
    emscripten::function("particle_collisionStats", &esengine::particle_collisionStats);
    emscripten::function("particle_collisionResolve", &esengine::particle_collisionResolve);
    emscripten::function("particle_collisionSetBudget", &esengine::particle_collisionSetBudget);
    emscripten::function("particle_play", &esengine::particle_play);
    emscripten::function("particle_stop", &esengine::particle_stop);
    emscripten::function("particle_reset", &esengine::particle_reset);
    emscripten::function("particle_emitAt", &esengine::particle_emitAt);
    emscripten::function("particle_getAliveCount", &esengine::particle_getAliveCount);
    emscripten::function("particle_set_color_lut", &esengine::particle_set_color_lut);
    emscripten::function("particle_set_size_lut", &esengine::particle_set_size_lut);
    emscripten::function("particle_set_speed_lut", &esengine::particle_set_speed_lut);
    emscripten::function("particle_set_bursts", &esengine::particle_set_bursts);
#endif
    emscripten::function("trail_update", &esengine::trail_update);
    emscripten::function("trail_clear", &esengine::trail_clear);
    emscripten::function("springbone_update", &esengine::springbone_update);
    emscripten::function("springbone_reset", &esengine::springbone_reset);
    emscripten::function("springbone_release", &esengine::springbone_release);
    emscripten::function("springbone_snapshot", &esengine::springbone_snapshot);
    emscripten::function("springbone_snapshotCount", &esengine::springbone_snapshotCount);
    emscripten::function("springbone_snapshotData", &esengine::springbone_snapshotData);
    emscripten::function("renderer_setStage", &esengine::renderer_setStage);
    emscripten::function("renderer_createTarget", &esengine::renderer_createTarget);
    emscripten::function("renderer_releaseTarget", &esengine::renderer_releaseTarget);
    emscripten::function("renderer_getTargetTexture", &esengine::renderer_getTargetTexture);
    emscripten::function("renderer_queueMaterialBake", &esengine::renderer_queueMaterialBake);
    emscripten::function("renderer_materialBakeState", &esengine::renderer_materialBakeState);
    emscripten::function("renderer_getTargetDepthTexture", &esengine::renderer_getTargetDepthTexture);
    emscripten::function("renderer_getDrawCalls", &esengine::renderer_getDrawCalls);
    emscripten::function("renderer_getGpuDrawCalls", &esengine::renderer_getGpuDrawCalls);
    emscripten::function("renderer_getLiveObjects", &esengine::renderer_getLiveObjects);
    emscripten::function("renderer_getTriangles", &esengine::renderer_getTriangles);
    emscripten::function("renderer_getSprites", &esengine::renderer_getSprites);
    emscripten::function("renderer_getSkeletal", &esengine::renderer_getSkeletal);
    emscripten::function("renderer_getText", &esengine::renderer_getText);
    emscripten::function("renderer_getMeshes", &esengine::renderer_getMeshes);
    emscripten::function("renderer_getCulled", &esengine::renderer_getCulled);
    emscripten::function("renderer_getGpuTimeMs", &esengine::renderer_getGpuTimeMs);
    emscripten::function("engine_setCpuProfiling", &esengine::engine_setCpuProfiling);
    emscripten::function("engine_setRandomSeed", &esengine::engine_setRandomSeed);
    emscripten::function("engine_getCpuScopes", &esengine::engine_getCpuScopes);
#ifdef ES_ENABLE_TEST_PROBES
    emscripten::function("engine_prewarmMeshVariants", &esengine::engine_prewarmMeshVariants);
#endif
    emscripten::function("engine_getCounters", &esengine::engine_getCounters);
    emscripten::function("engine_getGpuScopes", &esengine::engine_getGpuScopes);
    emscripten::function("renderer_getTextureBytes", &esengine::renderer_getTextureBytes);
    emscripten::function("renderer_getEstimatedGpuBytes", &esengine::renderer_getEstimatedGpuBytes);
    emscripten::function("renderer_programEpoch", &esengine::renderer_programEpoch);
    emscripten::function("renderer_deviceGeneration", &esengine::renderer_deviceGeneration);
    emscripten::function("engine_prepareMeshPrograms", &esengine::engine_prepareMeshPrograms);
    emscripten::function("renderer_setClearColor", &esengine::renderer_setClearColor);
    emscripten::function("renderer_setViewport", &esengine::renderer_setViewport);
    emscripten::function("renderer_setYSortLayers", &esengine::renderer_setYSortLayers);
    emscripten::function("renderer_setTreeSortLayers", &esengine::renderer_setTreeSortLayers);
    emscripten::function("renderer_setDepthLayers", &esengine::renderer_setDepthLayers);
    emscripten::function("renderer_setQualityBudgets", &esengine::renderer_setQualityBudgets);
    emscripten::function("renderer_setShadowDistance", &esengine::renderer_setShadowDistance);
    emscripten::function("renderer_setShadow2DSoftSamples", &esengine::renderer_setShadow2DSoftSamples);
    emscripten::function("renderer_setDepthPrepass", &esengine::renderer_setDepthPrepass);
    emscripten::function("renderer_setLightingDirect", &esengine::renderer_setLightingDirect);
    emscripten::function("renderer_setAsyncShaderCompile", &esengine::renderer_setAsyncShaderCompile);
    emscripten::function("renderer_getPendingShaders", &esengine::renderer_getPendingShaders);
    emscripten::function("renderer_setPlanarReflectionQuality", &esengine::renderer_setPlanarReflectionQuality);
    emscripten::function("renderer_getPlanarReflectionStatus", &esengine::renderer_getPlanarReflectionStatus);
    emscripten::function("renderer_setViewLighting", &esengine::renderer_setViewLighting);
    emscripten::function("renderer_setCullingMask", &esengine::renderer_setCullingMask);
    emscripten::function("renderer_setViewId", &esengine::renderer_setViewId);
    emscripten::function("renderer_lodInspect", &esengine::renderer_lodInspect);
    emscripten::function("renderer_setLodPreview", &esengine::renderer_setLodPreview);
    emscripten::function("renderer_setImpostorAtlas", &esengine::renderer_setImpostorAtlas);
    emscripten::function("renderer_takeTextureWants", &esengine::renderer_takeTextureWants);
    emscripten::function("renderer_setViewShading", &esengine::renderer_setViewShading);
    emscripten::function("renderer_setWorldUnitsPerMeter", &esengine::renderer_setWorldUnitsPerMeter);
    emscripten::function("renderer_requestProbeCapture", &esengine::renderer_requestProbeCapture);
    emscripten::function("renderer_pollProbeCapture", &esengine::renderer_pollProbeCapture);
    emscripten::function("renderer_takeProbeCapture", &esengine::renderer_takeProbeCapture);
    emscripten::function("renderer_setProbeVolumeOverride", &esengine::renderer_setProbeVolumeOverride);
    emscripten::function("renderer_setProbeVolumeReflection", &esengine::renderer_setProbeVolumeReflection);
    emscripten::function("renderer_setMeshEdgeBuffers", &esengine::renderer_setMeshEdgeBuffers);
    emscripten::function("renderer_setViewSkinWeights", &esengine::renderer_setViewSkinWeights);
    emscripten::function("renderer_lightStatus", &esengine::renderer_lightStatus);
    emscripten::function("renderer_shadowStatus", &esengine::renderer_shadowStatus);
    emscripten::function("renderer_setColorSpace", &esengine::renderer_setColorSpace);


    emscripten::function("registry_getCanvasEntity", &esengine::registry_getCanvasEntity);
    emscripten::function("registry_getCanvasEntities", &esengine::registry_getCanvasEntities);
    emscripten::function("registry_getCameraEntities", &esengine::registry_getCameraEntities);
    emscripten::function("getChildEntities", &esengine::getChildEntities);
    emscripten::function("registry_getGeneration", &esengine::registry_getGeneration);
    emscripten::function("registry_batchSyncPhysicsTransforms", &esengine::registry_batchSyncPhysicsTransforms);
    emscripten::function("registry_readWorldPoses2D", &esengine::registry_readWorldPoses2D);
    emscripten::function("registry_watchEntityChanges", &esengine::registry_watchEntityChanges);
    emscripten::function("registry_unwatchEntityChanges", &esengine::registry_unwatchEntityChanges);
    emscripten::function("registry_entityChangeSequence", &esengine::registry_entityChangeSequence);
    emscripten::function("registry_entityChangeResetEpoch", &esengine::registry_entityChangeResetEpoch);
    emscripten::function("registry_componentMutationRevision", &esengine::registry_componentMutationRevision);
    emscripten::function("registry_readEntityChanges", &esengine::registry_readEntityChanges);
    emscripten::function("registry_markComponentsChanged", &esengine::registry_markComponentsChanged);

    emscripten::function("gl_enableErrorCheck", &esengine::gl_enableErrorCheck);
    emscripten::function("gl_checkErrors", &esengine::gl_checkErrors);
    emscripten::function("renderer_diagnose", &esengine::renderer_diagnose);

    emscripten::function("renderer_captureNextFrame", &esengine::renderer_captureNextFrame);
    emscripten::function("renderer_captureFrame", &esengine::renderer_captureFrame);
    emscripten::function("renderer_pollFrameCapture", &esengine::renderer_pollFrameCapture);
    emscripten::function("renderer_takeFrameCapture", &esengine::renderer_takeFrameCapture);
    emscripten::function("renderer_getCapturedFrameSize", &esengine::renderer_getCapturedFrameSize);
    emscripten::function("renderer_getCapturedFrameData", &esengine::renderer_getCapturedFrameData);
    emscripten::function("renderer_getCapturedEntities", &esengine::renderer_getCapturedEntities);
    emscripten::function("renderer_getCapturedEntityCount", &esengine::renderer_getCapturedEntityCount);
    emscripten::function("renderer_getCapturedTextures", &esengine::renderer_getCapturedTextures);
    emscripten::function("renderer_getCapturedTextureCount", &esengine::renderer_getCapturedTextureCount);
    emscripten::function("renderer_getCapturedPassCount", &esengine::renderer_getCapturedPassCount);
    emscripten::function("renderer_hasCapturedData", &esengine::renderer_hasCapturedData);
    emscripten::function("renderer_replayToDrawCall", &esengine::renderer_replayToDrawCall);
    emscripten::function("renderer_snapshotMatchesCapture", &esengine::renderer_snapshotMatchesCapture);
    emscripten::function("renderer_pollSnapshotReadback", &esengine::renderer_pollSnapshotReadback);
    emscripten::function("renderer_getSnapshotPtr", &esengine::renderer_getSnapshotPtr);
    emscripten::function("renderer_getSnapshotSize", &esengine::renderer_getSnapshotSize);
    emscripten::function("renderer_getSnapshotWidth", &esengine::renderer_getSnapshotWidth);
    emscripten::function("renderer_getSnapshotHeight", &esengine::renderer_getSnapshotHeight);
    emscripten::function("renderer_renderMaterialPreview", &esengine::renderer_renderMaterialPreview);
    // Skeletal previews. Every one names its handle — there is no current preview
    // and no begin/end pair, so two of them cannot reach each other.
    emscripten::function("renderer_createSkeletalPreview", &esengine::renderer_createSkeletalPreview);
    emscripten::function("renderer_submitSkeletalPreviewBatch", &esengine::renderer_submitSkeletalPreviewBatch);
    emscripten::function("renderer_submitSkeletalPreviewBatchEx", &esengine::renderer_submitSkeletalPreviewBatchEx);
    emscripten::function("renderer_renderSkeletalPreview", &esengine::renderer_renderSkeletalPreview);
    emscripten::function("renderer_pollSkeletalPreview", &esengine::renderer_pollSkeletalPreview);
    emscripten::function("renderer_getSkeletalPreviewPtr", &esengine::renderer_getSkeletalPreviewPtr);
    emscripten::function("renderer_getSkeletalPreviewSize", &esengine::renderer_getSkeletalPreviewSize);
    emscripten::function("renderer_getSkeletalPreviewWidth", &esengine::renderer_getSkeletalPreviewWidth);
    emscripten::function("renderer_getSkeletalPreviewHeight", &esengine::renderer_getSkeletalPreviewHeight);
    emscripten::function("renderer_destroySkeletalPreview", &esengine::renderer_destroySkeletalPreview);
    emscripten::function("renderer_renderMeshPreview", &esengine::renderer_renderMeshPreview);
    emscripten::function("renderer_pollPreviewReadback", &esengine::renderer_pollPreviewReadback);
    emscripten::function("renderer_getPreviewPtr", &esengine::renderer_getPreviewPtr);
    emscripten::function("renderer_getPreviewSize", &esengine::renderer_getPreviewSize);
    emscripten::function("renderer_getPreviewWidth", &esengine::renderer_getPreviewWidth);
    emscripten::function("renderer_getPreviewHeight", &esengine::renderer_getPreviewHeight);
    emscripten::function("renderer_setTextureParams", &esengine::renderer_setTextureParams);
}

EMSCRIPTEN_BINDINGS(esengine_ui_systems) {
    emscripten::function("uiLayout_update", &esengine::uiLayout_update);
    emscripten::function("uiHitTest_update", &esengine::uiHitTest_update);
    emscripten::function("uiHitTest_updateDomains", &esengine::uiHitTest_updateDomains);
    emscripten::function("uiHitTest_getHitEntity", &esengine::uiHitTest_getHitEntity);
    emscripten::function("uiHitTest_pick", &esengine::uiHitTest_pick);
    emscripten::function("uiHitTest_pickAll", &esengine::uiHitTest_pickAll);
    emscripten::function("uiHitTest_pickResult", &esengine::uiHitTest_pickResult);
    emscripten::function("uiNode_computedWidth", &esengine::uiNode_computedWidth);
    emscripten::function("uiNode_computedHeight", &esengine::uiNode_computedHeight);
    emscripten::function("uiRenderOrder_update", &esengine::uiRenderOrder_update);
    emscripten::function("ui_getRenderOrder", &esengine::ui_getRenderOrder);
    emscripten::function("ui_getCullBit", &esengine::ui_getCullBit);
    emscripten::function("ui_isScreenDomain", &esengine::ui_isScreenDomain);
    emscripten::function("getUINodeHiddenInTree", &esengine::getUINodeHiddenInTree);
    emscripten::function("getUINodeAlphaInTree", &esengine::getUINodeAlphaInTree);
    emscripten::function("getUINodeComputedWidth", &esengine::getUINodeComputedWidth);
    emscripten::function("getUINodeComputedHeight", &esengine::getUINodeComputedHeight);
    emscripten::function("transform_update", &esengine::transform_update);
    emscripten::function("transform_copyFlatRenderMatrix", &esengine::transform_copyFlatRenderMatrix);

    // Tweens (AnimationBindings.hpp) — the same declarations the native
    // wrappers are generated from.
    emscripten::function("anim_createTween", &esengine::anim_createTween);
    emscripten::function("anim_cancelTween", &esengine::anim_cancelTween);
    emscripten::function("anim_cancelAllTweens", &esengine::anim_cancelAllTweens);
    emscripten::function("anim_pauseTween", &esengine::anim_pauseTween);
    emscripten::function("anim_resumeTween", &esengine::anim_resumeTween);
    emscripten::function("anim_setTweenBezier", &esengine::anim_setTweenBezier);
    emscripten::function("anim_setSequenceNext", &esengine::anim_setSequenceNext);
    emscripten::function("anim_updateTweens", &esengine::anim_updateTweens);
    emscripten::function("anim_getTweenState", &esengine::anim_getTweenState);
}


int main() {
    return 0;
}