@next2d/builder 0.1.5 → 0.1.7

package/templates/xbox/src/EventLoop.cpp

@@ -0,0 +1,162 @@
+#include "EventLoop.h"
+
+#include "HostContext.h"
+#include "v8/V8Util.h"
+
+#include <algorithm>
+
+namespace next2d {
+
+EventLoop* CurrentEventLoop(v8::Isolate* isolate)
+{
+    v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
+    if (!ctx.IsEmpty() &&
+        ctx->GetNumberOfEmbedderDataFields() > kEventLoopEmbedderSlot) {
+        void* p = ctx->GetAlignedPointerFromEmbedderData(kEventLoopEmbedderSlot);
+        if (p) {
+            return static_cast<EventLoop*>(p);
+        }
+    }
+    HostContext* host = HostContext::From(isolate);
+    return host ? host->event_loop : nullptr;
+}
+
+EventLoop::EventLoop(v8::Isolate* isolate)
+    : isolate_(isolate), start_(Clock::now())
+{
+}
+
+EventLoop::~EventLoop() = default;
+
+double EventLoop::Now() const
+{
+    const auto elapsed = Clock::now() - start_;
+    return std::chrono::duration<double, std::milli>(elapsed).count();
+}
+
+uint32_t EventLoop::SetTimer(v8::Local<v8::Function> callback, double delay_ms, bool repeat)
+{
+    if (delay_ms < 0.0) {
+        delay_ms = 0.0;
+    }
+
+    const uint32_t id = next_timer_id_++;
+    TimerEntry entry;
+    entry.callback.Reset(isolate_, callback);
+    entry.due_ms = Now() + delay_ms;
+    entry.interval_ms = delay_ms;
+    entry.repeat = repeat;
+    entry.cancelled = false;
+    timers_.emplace(id, std::move(entry));
+    return id;
+}
+
+void EventLoop::ClearTimer(uint32_t id)
+{
+    auto it = timers_.find(id);
+    if (it != timers_.end()) {
+        // 実行ループ中の削除に備え cancelled フラグで無効化
+        it->second.cancelled = true;
+    }
+}
+
+uint32_t EventLoop::RequestAnimationFrame(v8::Local<v8::Function> callback)
+{
+    const uint32_t id = next_raf_id_++;
+    v8::Global<v8::Function> global;
+    global.Reset(isolate_, callback);
+    raf_callbacks_.emplace_back(id, std::move(global));
+    return id;
+}
+
+void EventLoop::CancelAnimationFrame(uint32_t id)
+{
+    raf_cancelled_.push_back(id);
+}
+
+void EventLoop::PumpTimers()
+{
+    const double now = Now();
+
+    v8::HandleScope handle_scope(isolate_);
+    v8::Local<v8::Context> ctx = isolate_->GetCurrentContext();
+    v8::Local<v8::Object> global = ctx->Global();
+
+    // 期限到来分を収集 (map の走査中の変更を避けるため id を先に集める)
+    std::vector<uint32_t> due;
+    for (auto& [id, entry] : timers_) {
+        if (!entry.cancelled && entry.due_ms <= now) {
+            due.push_back(id);
+        }
+    }
+
+    for (uint32_t id : due) {
+        auto it = timers_.find(id);
+        if (it == timers_.end() || it->second.cancelled) {
+            continue;
+        }
+
+        v8::Local<v8::Function> fn = it->second.callback.Get(isolate_);
+
+        if (it->second.repeat) {
+            it->second.due_ms = now + it->second.interval_ms;
+        }
+
+        v8::TryCatch try_catch(isolate_);
+        (void) fn->Call(ctx, global, 0, nullptr);
+        // 例外はコンソールに委譲 (V8Runtime のメッセージハンドラが拾う)
+
+        if (!it->second.repeat) {
+            // 単発は実行後に破棄
+            auto erase_it = timers_.find(id);
+            if (erase_it != timers_.end()) {
+                timers_.erase(erase_it);
+            }
+        }
+    }
+
+    // cancelled を掃除
+    for (auto it = timers_.begin(); it != timers_.end();) {
+        if (it->second.cancelled) {
+            it = timers_.erase(it);
+        } else {
+            ++it;
+        }
+    }
+}
+
+void EventLoop::RunAnimationFrame(double timestamp_ms)
+{
+    if (raf_callbacks_.empty()) {
+        return;
+    }
+
+    // ブラウザ同様、今フレームで実行するのは「現時点で登録済み」のコールバックのみ。
+    // コールバック内で再登録された rAF は次フレームに回す。
+    auto current = std::move(raf_callbacks_);
+    raf_callbacks_.clear();
+
+    v8::HandleScope handle_scope(isolate_);
+    v8::Local<v8::Context> ctx = isolate_->GetCurrentContext();
+    v8::Local<v8::Object> global = ctx->Global();
+    v8::Local<v8::Value> arg = v8::Number::New(isolate_, timestamp_ms);
+
+    for (auto& [id, cb] : current) {
+        if (std::find(raf_cancelled_.begin(), raf_cancelled_.end(), id) != raf_cancelled_.end()) {
+            continue;
+        }
+        v8::Local<v8::Function> fn = cb.Get(isolate_);
+        v8::TryCatch try_catch(isolate_);
+        v8::Local<v8::Value> args[1] = { arg };
+        (void) fn->Call(ctx, global, 1, args);
+    }
+
+    raf_cancelled_.clear();
+}
+
+bool EventLoop::HasPendingWork() const
+{
+    return !timers_.empty() || !raf_callbacks_.empty();
+}
+
+} // namespace next2d

package/templates/xbox/src/EventLoop.h

@@ -0,0 +1,73 @@
+// EventLoop: setTimeout / setInterval / requestAnimationFrame を実装する非同期タスクキュー。
+//
+// ブラウザのイベントループを単一スレッドで模倣する。main.cpp のゲームループが毎フレーム
+// PumpTimers() と RunAnimationFrame() を呼び出す。V8 のマイクロタスク(Promise)は
+// V8Runtime 側で各タスク実行後にチェックポイントされる。
+#pragma once
+
+#include <v8.h>
+#include <chrono>
+#include <cstdint>
+#include <map>
+#include <vector>
+
+namespace next2d {
+
+// Context の embedder data slot に EventLoop* を格納するインデックス。
+// main / 各 worker の Context がそれぞれ自分の EventLoop を登録し、
+// Timers/rAF バインディングは実行中の Context の EventLoop を参照する。
+constexpr int kEventLoopEmbedderSlot = 1;
+
+class EventLoop;
+
+// 現在の Context に紐づく EventLoop を返す (未登録なら HostContext の既定)。
+EventLoop* CurrentEventLoop(v8::Isolate* isolate);
+
+class EventLoop {
+public:
+    explicit EventLoop(v8::Isolate* isolate);
+    ~EventLoop();
+
+    using Clock = std::chrono::steady_clock;
+
+    // performance.now() 相当 (起動からの経過ミリ秒)
+    double Now() const;
+
+    // setTimeout / setInterval
+    uint32_t SetTimer(v8::Local<v8::Function> callback, double delay_ms, bool repeat);
+    void ClearTimer(uint32_t id);
+
+    // requestAnimationFrame / cancelAnimationFrame
+    uint32_t RequestAnimationFrame(v8::Local<v8::Function> callback);
+    void CancelAnimationFrame(uint32_t id);
+
+    // 期限の来たタイマーを実行する (毎フレーム冒頭)
+    void PumpTimers();
+
+    // 登録済み rAF コールバックをタイムスタンプ付きで実行する (毎フレーム)
+    void RunAnimationFrame(double timestamp_ms);
+
+    // 保留タスクが残っているか (終了判定用)
+    bool HasPendingWork() const;
+
+private:
+    struct TimerEntry {
+        v8::Global<v8::Function> callback;
+        double due_ms;
+        double interval_ms;
+        bool repeat;
+        bool cancelled;
+    };
+
+    v8::Isolate* isolate_;
+    Clock::time_point start_;
+
+    uint32_t next_timer_id_ = 1;
+    std::map<uint32_t, TimerEntry> timers_;
+
+    uint32_t next_raf_id_ = 1;
+    std::vector<std::pair<uint32_t, v8::Global<v8::Function>>> raf_callbacks_;
+    std::vector<uint32_t> raf_cancelled_;
+};
+
+} // namespace next2d

package/templates/xbox/src/HostContext.h

@@ -0,0 +1,58 @@
+// HostContext: C++ 側のサブシステムを束ね、V8 バインディングから参照できるようにする。
+//
+// Isolate の data slot 0 に本ポインタを格納し、任意のバインディングコールバックから
+// HostContext::From(isolate) で取り出す。これにより各バインディングは EventLoop /
+// DawnContext / AssetLoader / GamepadManager 等へアクセスできる。
+#pragma once
+
+#include <v8.h>
+
+namespace next2d {
+
+class EventLoop;
+class DawnContext;
+class AssetLoader;
+class GamepadManager;
+class AudioEngine;
+class WorkerRuntime;
+
+// Isolate data slot index (V8Runtime が SetData で登録)
+constexpr uint32_t kHostContextSlot = 0;
+
+// グラフィックスバックエンド種別。
+// Xbox は WebGPU(Dawn/D3D12)。Nintendo Switch 移植時は WebGL2(GL) を選ぶ。
+// player は navigator.gpu の有無で自動的に webgpu / webgl2 経路を切り替える。
+enum class GraphicsBackend {
+    WebGPU,
+    WebGL2,
+};
+
+class HostContext {
+public:
+    HostContext() = default;
+
+    EventLoop*       event_loop = nullptr;
+    DawnContext*     gpu        = nullptr;
+    AssetLoader*     assets     = nullptr;
+    GamepadManager*  gamepad    = nullptr;
+    AudioEngine*     audio      = nullptr;
+    WorkerRuntime*   workers    = nullptr;
+
+    // 使用するグラフィックスバックエンド (既定は Xbox=WebGPU)
+    GraphicsBackend  backend    = GraphicsBackend::WebGPU;
+
+    // 入力イベント配送先の主要 canvas (Canvas.cpp が最後に生成したものを記録)
+    v8::Global<v8::Object> main_canvas;
+
+    // アプリのビューポート論理サイズ (canvas.width/height の初期値)
+    int viewport_width  = 1920;
+    int viewport_height = 1080;
+    double device_pixel_ratio = 1.0;
+
+    static HostContext* From(v8::Isolate* isolate)
+    {
+        return static_cast<HostContext*>(isolate->GetData(kHostContextSlot));
+    }
+};
+
+} // namespace next2d

package/templates/xbox/src/bindings/Audio.cpp

@@ -0,0 +1,320 @@
+#include "Bindings.h"
+
+#include "HostContext.h"
+#include "AssetLoader.h"
+#include "EventTarget.h"
+#include "platform/AudioEngine.h"
+#include "v8/V8Util.h"
+
+#include <memory>
+#include <vector>
+
+namespace next2d {
+
+using v8util::Str;
+using v8util::ToStdString;
+
+namespace {
+
+// GainNode.gain.value を保持し、接続済みボイスへ音量を反映する。
+struct GainParam {
+    float value = 1.0f;
+    std::shared_ptr<AudioVoice> voice;  // source.connect(gain) 時にリンクされる
+};
+
+void ReleaseGainParam(const v8::WeakCallbackInfo<GainParam>& info)
+{
+    delete info.GetParameter();
+}
+
+// 再生中(非ループ)の source ノード。毎フレーム IsFinished を見て "ended" を発火する。
+std::vector<v8::Global<v8::Object>>& PlayingSources()
+{
+    static std::vector<v8::Global<v8::Object>> sources;
+    return sources;
+}
+
+// JS オブジェクトに shared_ptr を保持させるためのホルダ。GC で解放する。
+template <typename T>
+struct Holder {
+    std::shared_ptr<T> ptr;
+};
+
+template <typename T>
+void ReleaseHolder(const v8::WeakCallbackInfo<Holder<T>>& info)
+{
+    delete info.GetParameter();
+}
+
+template <typename T>
+void Attach(v8::Isolate* isolate, v8::Local<v8::Object> obj, std::shared_ptr<T> ptr)
+{
+    auto* holder = new Holder<T>{std::move(ptr)};
+    obj->SetInternalField(0, v8::External::New(isolate, holder));
+    auto* handle = new v8::Global<v8::Object>(isolate, obj);
+    handle->SetWeak(holder, ReleaseHolder<T>, v8::WeakCallbackType::kParameter);
+}
+
+template <typename T>
+std::shared_ptr<T> Get(v8::Local<v8::Object> obj)
+{
+    auto* holder = static_cast<Holder<T>*>(
+        obj->GetInternalField(0).As<v8::External>()->Value());
+    return holder->ptr;
+}
+
+v8::Local<v8::ObjectTemplate> InternalTemplate(v8::Isolate* isolate)
+{
+    v8::Local<v8::ObjectTemplate> tmpl = v8::ObjectTemplate::New(isolate);
+    tmpl->SetInternalFieldCount(1);
+    return tmpl;
+}
+
+// --- AudioBufferSourceNode ------------------------------------------------
+void SourceStart(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    auto voice = Get<AudioVoice>(args.This());
+    bool loop = false;
+    v8::Local<v8::Value> loop_val;
+    if (args.This()->Get(args.GetIsolate()->GetCurrentContext(),
+                         Str(args.GetIsolate(), "loop")).ToLocal(&loop_val)) {
+        loop = loop_val->BooleanValue(args.GetIsolate());
+    }
+    if (voice) {
+        voice->Start(loop);
+        // 非ループ再生は終了時に "ended" を発火するため登録する。
+        if (!loop) {
+            PlayingSources().emplace_back(args.GetIsolate(), args.This());
+        }
+    }
+}
+
+void SourceStop(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    auto voice = Get<AudioVoice>(args.This());
+    if (voice) {
+        voice->Stop();
+    }
+}
+
+// GainNode の connect: 実際に音量を反映するのは source.connect(gain) 側。ここは no-op。
+void GainConnect(const v8::FunctionCallbackInfo<v8::Value>& /*args*/) {}
+
+// source.disconnect(): player は stop() でこれを呼ぶ。ボイスを停止し登録からも外す
+// (PlayingSources の強参照 Global がノードを固定し続けるのを防ぐ)。
+void SourceDisconnect(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    auto voice = Get<AudioVoice>(args.This());
+    if (voice) {
+        voice->Stop();
+    }
+    auto& sources = PlayingSources();
+    v8::Local<v8::Object> node = args.This();
+    for (size_t i = 0; i < sources.size();) {
+        if (sources[i].Get(isolate) == node) {
+            sources.erase(sources.begin() + i);
+        } else {
+            ++i;
+        }
+    }
+}
+
+// source.connect(destination): destination が GainNode なら voice をリンクして音量を反映する。
+void SourceConnect(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
+    auto voice = Get<AudioVoice>(args.This());
+    if (!voice || args.Length() < 1 || !args[0]->IsObject()) {
+        return;
+    }
+    // 接続先(GainNode)の gain オブジェクトから GainParam を取り出しリンクする。
+    v8::Local<v8::Object> dest = args[0].As<v8::Object>();
+    v8::Local<v8::Value> gain_val;
+    if (!dest->Get(ctx, Str(isolate, "gain")).ToLocal(&gain_val) || !gain_val->IsObject()) {
+        return;
+    }
+    v8::Local<v8::Object> gain = gain_val.As<v8::Object>();
+    if (gain->InternalFieldCount() < 1) {
+        return;
+    }
+    auto* param = static_cast<GainParam*>(
+        gain->GetInternalField(0).As<v8::External>()->Value());
+    if (param) {
+        param->voice = voice;
+        voice->SetVolume(param->value);  // 接続時点の音量を即時反映
+    }
+}
+
+// createBufferSource() -> AudioBufferSourceNode
+void CreateBufferSource(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
+    AudioEngine* engine = HostContext::From(isolate)->audio;
+
+    v8::Local<v8::Object> node = InternalTemplate(isolate)->NewInstance(ctx).ToLocalChecked();
+    // buffer は後から setter 経由で設定する想定 (ここでは空ボイス)。
+    Attach<AudioVoice>(isolate, node, nullptr);
+
+    v8util::SetValue(isolate, node, "loop", v8::Boolean::New(isolate, false));
+    v8util::SetMethod(isolate, node, "start", SourceStart);
+    v8util::SetMethod(isolate, node, "stop", SourceStop);
+    v8util::SetMethod(isolate, node, "connect", SourceConnect);
+    // source.addEventListener("ended", ...) を player が使うため EventTarget を設置する。
+    InstallEventTarget(isolate, node);
+    v8util::SetMethod(isolate, node, "disconnect", SourceDisconnect);
+
+    // buffer プロパティ設定時に AudioVoice を生成するアクセサ
+    // (SetAccessor は V8 12.9 で削除。SetNativeDataProperty を使う)
+    node->SetNativeDataProperty(ctx, Str(isolate, "buffer"),
+        nullptr,
+        [](v8::Local<v8::Name>, v8::Local<v8::Value> value,
+           const v8::PropertyCallbackInfo<void>& info) {
+            v8::Isolate* iso = info.GetIsolate();
+            if (!value->IsObject()) {
+                return;
+            }
+            auto pcm = Get<PcmBuffer>(value.As<v8::Object>());
+            AudioEngine* eng = HostContext::From(iso)->audio;
+            auto voice = eng->CreateVoice(pcm);
+            Attach<AudioVoice>(iso, info.This(), voice);
+        }).Check();
+
+    args.GetReturnValue().Set(node);
+}
+
+// --- GainNode -------------------------------------------------------------
+void CreateGain(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
+
+    v8::Local<v8::Object> node = v8::Object::New(isolate);
+
+    // gain オブジェクトは内部フィールドに GainParam を持ち、value アクセサで
+    // リンク済みボイスへ音量を即時反映する (再生中のミュート/音量変更に対応)。
+    v8::Local<v8::Object> gain = InternalTemplate(isolate)->NewInstance(ctx).ToLocalChecked();
+    auto* param = new GainParam();
+    gain->SetInternalField(0, v8::External::New(isolate, param));
+    auto* handle = new v8::Global<v8::Object>(isolate, gain);
+    handle->SetWeak(param, ReleaseGainParam, v8::WeakCallbackType::kParameter);
+
+    gain->SetNativeDataProperty(ctx, Str(isolate, "value"),
+        [](v8::Local<v8::Name>, const v8::PropertyCallbackInfo<v8::Value>& info) {
+            auto* p = static_cast<GainParam*>(
+                info.This()->GetInternalField(0).As<v8::External>()->Value());
+            info.GetReturnValue().Set(v8::Number::New(info.GetIsolate(), p ? p->value : 1.0));
+        },
+        [](v8::Local<v8::Name>, v8::Local<v8::Value> value,
+           const v8::PropertyCallbackInfo<void>& info) {
+            auto* p = static_cast<GainParam*>(
+                info.This()->GetInternalField(0).As<v8::External>()->Value());
+            if (!p || !value->IsNumber()) return;
+            p->value = static_cast<float>(value.As<v8::Number>()->Value());
+            if (p->voice) p->voice->SetVolume(p->value);  // 再生中も反映
+        }).Check();
+
+    v8util::SetValue(isolate, node, "gain", gain);
+    v8util::SetMethod(isolate, node, "connect", GainConnect);
+    v8util::SetMethod(isolate, node, "disconnect",
+        [](const v8::FunctionCallbackInfo<v8::Value>&) {});
+    args.GetReturnValue().Set(node);
+}
+
+// 毎フレーム呼ばれ、再生終了した source ノードへ "ended" を発火する (main.cpp のループから)。
+} // namespace
+
+void PumpAudioEvents(v8::Isolate* isolate)
+{
+    auto& sources = PlayingSources();
+    if (sources.empty()) return;
+    v8::HandleScope scope(isolate);
+    v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
+    for (size_t i = 0; i < sources.size();) {
+        v8::Local<v8::Object> node = sources[i].Get(isolate);
+        auto voice = Get<AudioVoice>(node);
+        if (!voice || voice->IsFinished()) {
+            if (voice) {
+                v8::Local<v8::Object> ev = v8::Object::New(isolate);
+                ev->Set(ctx, Str(isolate, "type"), Str(isolate, "ended")).Check();
+                DispatchEvent(isolate, node, ev);
+            }
+            sources.erase(sources.begin() + i);
+        } else {
+            ++i;
+        }
+    }
+}
+
+namespace {
+
+// --- decodeAudioData ------------------------------------------------------
+void DecodeAudioData(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
+
+    v8::Local<v8::Promise::Resolver> resolver =
+        v8::Promise::Resolver::New(ctx).ToLocalChecked();
+    args.GetReturnValue().Set(resolver->GetPromise());
+
+    std::vector<uint8_t> input;
+    if (args.Length() >= 1 && args[0]->IsArrayBuffer()) {
+        auto ab = args[0].As<v8::ArrayBuffer>();
+        auto store = ab->GetBackingStore();
+        input.assign(static_cast<uint8_t*>(store->Data()),
+                     static_cast<uint8_t*>(store->Data()) + store->ByteLength());
+    }
+
+    auto pcm = std::make_shared<PcmBuffer>();
+    if (input.empty() || !AudioEngine::Decode(input, *pcm)) {
+        resolver->Reject(ctx, v8::Exception::Error(Str(isolate, "audio decode failed"))).Check();
+        return;
+    }
+
+    v8::Local<v8::Object> buffer = InternalTemplate(isolate)->NewInstance(ctx).ToLocalChecked();
+    Attach<PcmBuffer>(isolate, buffer, pcm);
+    v8util::SetValue(isolate, buffer, "sampleRate", v8::Number::New(isolate, pcm->sample_rate));
+    v8util::SetValue(isolate, buffer, "numberOfChannels", v8::Integer::New(isolate, pcm->channels));
+    v8util::SetValue(isolate, buffer, "duration",
+        v8::Number::New(isolate, pcm->channels
+            ? static_cast<double>(pcm->samples.size()) / pcm->channels / pcm->sample_rate
+            : 0.0));
+    resolver->Resolve(ctx, buffer).Check();
+}
+
+// AudioContext コンストラクタ
+void AudioContextConstructor(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    if (!args.IsConstructCall()) {
+        v8util::ThrowTypeError(isolate, "AudioContext must be called with new");
+        return;
+    }
+    v8::Local<v8::Object> self = args.This();
+    v8util::SetValue(isolate, self, "sampleRate", v8::Number::New(isolate, 48000));
+    v8util::SetValue(isolate, self, "destination", v8::Object::New(isolate));
+    v8util::SetMethod(isolate, self, "createBufferSource", CreateBufferSource);
+    v8util::SetMethod(isolate, self, "createGain", CreateGain);
+    v8util::SetMethod(isolate, self, "decodeAudioData", DecodeAudioData);
+    args.GetReturnValue().Set(self);
+}
+
+} // namespace
+
+void InstallAudio(v8::Isolate* isolate, v8::Local<v8::Object> global, HostContext* /*host*/)
+{
+    v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
+
+    v8::Local<v8::FunctionTemplate> tmpl =
+        v8::FunctionTemplate::New(isolate, AudioContextConstructor);
+    tmpl->SetClassName(Str(isolate, "AudioContext"));
+    v8::Local<v8::Function> fn = tmpl->GetFunction(ctx).ToLocalChecked();
+
+    global->Set(ctx, Str(isolate, "AudioContext"), fn).Check();
+    global->Set(ctx, Str(isolate, "webkitAudioContext"), fn).Check();
+}
+
+} // namespace next2d

package/templates/xbox/src/bindings/Bindings.h

@@ -0,0 +1,75 @@
+// 各ブラウザ相当バインディングのインストール宣言。
+// V8Runtime::Initialize から Context 生成後に InstallGlobalBindings が呼ばれる。
+#pragma once
+
+#include <v8.h>
+#include <string>
+
+namespace next2d {
+
+class HostContext;
+
+// console.* (log/info/warn/error/debug)
+void InstallConsole(v8::Isolate* isolate, v8::Local<v8::Object> global);
+
+// setTimeout / setInterval / clearTimeout / clearInterval /
+// requestAnimationFrame / cancelAnimationFrame / performance.now
+void InstallTimers(v8::Isolate* isolate, v8::Local<v8::Object> global, HostContext* host);
+
+// fetch / XMLHttpRequest 最小実装 (assets/app からのローカル読み込み)
+void InstallFetch(v8::Isolate* isolate, v8::Local<v8::Object> global, HostContext* host);
+
+// Image / createImageBitmap (WIC デコード)
+void InstallImage(v8::Isolate* isolate, v8::Local<v8::Object> global, HostContext* host);
+
+// navigator.gpu (WebGPU -> Dawn)。backend==WebGPU のときのみ navigator.gpu を公開する。
+void InstallWebGPU(v8::Isolate* isolate, v8::Local<v8::Object> global, HostContext* host);
+
+// canvas.getContext('webgpu') が返す GPUCanvasContext を生成する (WebGPU.cpp)。
+v8::Local<v8::Object> CreateWebGPUCanvasContext(v8::Isolate* isolate, HostContext* host);
+
+// canvas.getContext('2d') / OffscreenCanvas.getContext('2d') を生成する (Canvas2D.cpp)。
+v8::Local<v8::Object> CreateCanvas2DContext(v8::Isolate* isolate, HostContext* host,
+                                            int width, int height);
+
+// navigator.getGamepads / gamepad イベント基盤 (GameInput)
+void InstallGamepad(v8::Isolate* isolate, v8::Local<v8::Object> global, HostContext* host);
+
+// AudioContext 最小実装 (XAudio2)
+void InstallAudio(v8::Isolate* isolate, v8::Local<v8::Object> global, HostContext* host);
+
+// 再生終了した AudioBufferSourceNode へ "ended" を発火する。main.cpp のループから毎フレーム呼ぶ。
+void PumpAudioEvents(v8::Isolate* isolate);
+
+// window / document / navigator / screen 等の DOM 相当スタブと canvas 生成
+void InstallDomShims(v8::Isolate* isolate, v8::Local<v8::Object> global, HostContext* host);
+
+// HTMLCanvasElement 相当を生成する。getContext は '2d'/'webgpu'/'webgl2' を
+// backend に応じてディスパッチし、transferControlToOffscreen も備える (Canvas.cpp)。
+v8::Local<v8::Object> CreateCanvasElement(v8::Isolate* isolate, HostContext* host,
+                                          int width, int height);
+
+// OffscreenCanvas を生成する (Canvas.cpp)。worker/メッシュ生成/テキストで使用。
+v8::Local<v8::Object> CreateOffscreenCanvas(v8::Isolate* isolate, HostContext* host,
+                                            int width, int height);
+
+// window/worker グローバルへ Worker コンストラクタ等を設置する (Worker/WorkerRuntime)。
+void InstallWorker(v8::Isolate* isolate, v8::Local<v8::Object> global, HostContext* host);
+
+// XMLHttpRequest / Blob / URL.createObjectURL / ImageData (Network.cpp)
+void InstallNetwork(v8::Isolate* isolate, v8::Local<v8::Object> global, HostContext* host);
+
+// HTMLVideoElement を生成する (Video.cpp)。document.createElement("video") から使用。
+v8::Local<v8::Object> CreateVideoElement(v8::Isolate* isolate, HostContext* host);
+
+// video 要素の現在フレーム RGBA を取得する (Video.cpp)。GetImageSourcePixels から使用。
+bool GetVideoFramePixels(v8::Isolate* isolate, v8::Local<v8::Object> obj,
+                         const uint8_t** out_rgba, uint32_t* out_w, uint32_t* out_h);
+
+// blob: URL のバイト列をテキストとして取得する (Network.cpp)。
+bool ResolveObjectURL(const std::string& url, std::string* out_text);
+
+// 上記をまとめてインストールする
+void InstallGlobalBindings(v8::Isolate* isolate, v8::Local<v8::Object> global, HostContext* host);
+
+} // namespace next2d