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.
TypeScript 2d-game-engine3d3d-game-engineandroidcppecsgame-editorgame-enginegamedeviostypescriptwebassemblywebglwebgpuwechat-minigame
// 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;
}