@next2d/builder 0.1.5 → 0.1.7

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

@@ -0,0 +1,221 @@
+#include "Bindings.h"
+
+#include "HostContext.h"
+#include "EventTarget.h"
+#include "v8/V8Util.h"
+
+#include <Windows.h>
+
+namespace next2d {
+
+using v8util::Str;
+using v8util::SetMethod;
+using v8util::SetValue;
+
+namespace {
+
+// document.createElement(tag)
+void CreateElement(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    HostContext* host = HostContext::From(isolate);
+    const std::string tag = args.Length() > 0 ? v8util::ToStdString(isolate, args[0]) : "";
+
+    if (tag == "canvas") {
+        args.GetReturnValue().Set(CreateCanvasElement(isolate, host, 0, 0));
+        return;
+    }
+    if (tag == "video") {
+        args.GetReturnValue().Set(CreateVideoElement(isolate, host));
+        return;
+    }
+
+    // その他の要素は最小スタブ (style/子要素操作/イベントを no-op で備える)
+    v8::Local<v8::Object> el = v8::Object::New(isolate);
+    SetValue(isolate, el, "style", v8::Object::New(isolate));
+    SetValue(isolate, el, "tagName", Str(isolate, tag));
+    SetMethod(isolate, el, "appendChild", [](const v8::FunctionCallbackInfo<v8::Value>& a) {
+        if (a.Length() > 0) a.GetReturnValue().Set(a[0]);
+    });
+    SetMethod(isolate, el, "removeChild", [](const v8::FunctionCallbackInfo<v8::Value>&) {});
+    SetMethod(isolate, el, "setAttribute", [](const v8::FunctionCallbackInfo<v8::Value>&) {});
+    SetMethod(isolate, el, "addEventListener", [](const v8::FunctionCallbackInfo<v8::Value>&) {});
+    SetMethod(isolate, el, "removeEventListener", [](const v8::FunctionCallbackInfo<v8::Value>&) {});
+    args.GetReturnValue().Set(el);
+}
+
+// window/document/body 用の EventTarget を設置する (実ディスパッチ対応)。
+void NoopEventTarget(v8::Isolate* isolate, v8::Local<v8::Object> obj)
+{
+    InstallEventTarget(isolate, obj);
+}
+
+} // namespace
+
+namespace {
+
+// navigator.clipboard.readText() -> Promise<string> (Win32 クリップボード)
+void ClipboardReadText(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
+    auto resolver = v8::Promise::Resolver::New(ctx).ToLocalChecked();
+    args.GetReturnValue().Set(resolver->GetPromise());
+
+    std::string text;
+    if (OpenClipboard(nullptr)) {
+        HANDLE h = GetClipboardData(CF_UNICODETEXT);
+        if (h) {
+            auto* w = static_cast<const wchar_t*>(GlobalLock(h));
+            if (w) {
+                int n = WideCharToMultiByte(CP_UTF8, 0, w, -1, nullptr, 0, nullptr, nullptr);
+                if (n > 0) {
+                    text.resize(n - 1);
+                    WideCharToMultiByte(CP_UTF8, 0, w, -1, text.data(), n, nullptr, nullptr);
+                }
+                GlobalUnlock(h);
+            }
+        }
+        CloseClipboard();
+    }
+    resolver->Resolve(ctx, Str(isolate, text)).Check();
+}
+
+// navigator.clipboard.writeText(text) -> Promise
+void ClipboardWriteText(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
+    auto resolver = v8::Promise::Resolver::New(ctx).ToLocalChecked();
+    args.GetReturnValue().Set(resolver->GetPromise());
+
+    if (args.Length() > 0 && OpenClipboard(nullptr)) {
+        const std::string s = v8util::ToStdString(isolate, args[0]);
+        int n = MultiByteToWideChar(CP_UTF8, 0, s.c_str(), -1, nullptr, 0);
+        if (n > 0) {
+            HGLOBAL h = GlobalAlloc(GMEM_MOVEABLE, static_cast<size_t>(n) * sizeof(wchar_t));
+            if (h) {
+                auto* w = static_cast<wchar_t*>(GlobalLock(h));
+                MultiByteToWideChar(CP_UTF8, 0, s.c_str(), -1, w, n);
+                GlobalUnlock(h);
+                EmptyClipboard();
+                SetClipboardData(CF_UNICODETEXT, h);
+            }
+        }
+        CloseClipboard();
+    }
+    resolver->Resolve(ctx, v8::Undefined(isolate)).Check();
+}
+
+// new OffscreenCanvas(width, height)
+void OffscreenCanvasConstructor(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    if (!args.IsConstructCall()) {
+        v8util::ThrowTypeError(isolate, "OffscreenCanvas must be called with new");
+        return;
+    }
+    HostContext* host = HostContext::From(isolate);
+    int w = args.Length() > 0 && args[0]->IsNumber()
+        ? static_cast<int>(args[0].As<v8::Number>()->Value()) : host->viewport_width;
+    int h = args.Length() > 1 && args[1]->IsNumber()
+        ? static_cast<int>(args[1].As<v8::Number>()->Value()) : host->viewport_height;
+    args.GetReturnValue().Set(CreateOffscreenCanvas(isolate, host, w, h));
+}
+
+} // namespace
+
+void InstallDomShims(v8::Isolate* isolate, v8::Local<v8::Object> global, HostContext* host)
+{
+    v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
+
+    // OffscreenCanvas コンストラクタ (メッシュ生成/テキスト/点内包判定で使用)
+    {
+        v8::Local<v8::FunctionTemplate> oc =
+            v8::FunctionTemplate::New(isolate, OffscreenCanvasConstructor);
+        oc->SetClassName(Str(isolate, "OffscreenCanvas"));
+        global->Set(ctx, Str(isolate, "OffscreenCanvas"),
+                    oc->GetFunction(ctx).ToLocalChecked()).Check();
+    }
+
+    // globalThis / window / self は同一オブジェクトを指す
+    SetValue(isolate, global, "globalThis", global);
+    SetValue(isolate, global, "window", global);
+    SetValue(isolate, global, "self", global);
+    NoopEventTarget(isolate, global);
+
+    // devicePixelRatio
+    SetValue(isolate, global, "devicePixelRatio",
+             v8::Number::New(isolate, host->device_pixel_ratio));
+
+    // screen
+    v8::Local<v8::Object> screen = v8::Object::New(isolate);
+    SetValue(isolate, screen, "width", v8::Integer::New(isolate, host->viewport_width));
+    SetValue(isolate, screen, "height", v8::Integer::New(isolate, host->viewport_height));
+    SetValue(isolate, global, "screen", screen);
+
+    // innerWidth / innerHeight
+    SetValue(isolate, global, "innerWidth", v8::Integer::New(isolate, host->viewport_width));
+    SetValue(isolate, global, "innerHeight", v8::Integer::New(isolate, host->viewport_height));
+
+    // navigator (gpu/getGamepads は後段のバインディングが付与)
+    v8::Local<v8::Object> navigator = v8::Object::New(isolate);
+    SetValue(isolate, navigator, "userAgent",
+             Str(isolate, "Next2D/Xbox (GDK; V8; Dawn/WebGPU)"));
+    SetValue(isolate, navigator, "language", Str(isolate, "en-US"));
+    SetValue(isolate, navigator, "platform", Str(isolate, "Xbox"));
+
+    // navigator.clipboard (テキスト貼付/コピー、Win32 クリップボード)
+    v8::Local<v8::Object> clipboard = v8::Object::New(isolate);
+    SetMethod(isolate, clipboard, "readText", ClipboardReadText);
+    SetMethod(isolate, clipboard, "writeText", ClipboardWriteText);
+    SetValue(isolate, navigator, "clipboard", clipboard);
+
+    SetValue(isolate, global, "navigator", navigator);
+
+    // document
+    v8::Local<v8::Object> document = v8::Object::New(isolate);
+    SetMethod(isolate, document, "createElement", CreateElement);
+    SetMethod(isolate, document, "getElementById",
+        [](const v8::FunctionCallbackInfo<v8::Value>& a) { a.GetReturnValue().SetNull(); });
+    SetMethod(isolate, document, "querySelector",
+        [](const v8::FunctionCallbackInfo<v8::Value>& a) { a.GetReturnValue().SetNull(); });
+    SetMethod(isolate, document, "getElementsByTagName",
+        [](const v8::FunctionCallbackInfo<v8::Value>& a) {
+            a.GetReturnValue().Set(v8::Array::New(a.GetIsolate(), 0));
+        });
+    NoopEventTarget(isolate, document);
+
+    // document.body / documentElement は canvas を格納できる最小要素
+    v8::Local<v8::Object> body = v8::Object::New(isolate);
+    SetValue(isolate, body, "style", v8::Object::New(isolate));
+    SetMethod(isolate, body, "appendChild", [](const v8::FunctionCallbackInfo<v8::Value>& a) {
+        if (a.Length() > 0) a.GetReturnValue().Set(a[0]);
+    });
+    NoopEventTarget(isolate, body);
+    SetValue(isolate, document, "body", body);
+    SetValue(isolate, document, "documentElement", body);
+
+    // メインの canvas をあらかじめ 1 枚用意し document.__mainCanvas として公開する。
+    // bootstrap.js はこれを既定キャンバスとして Next2D に渡す。
+    v8::Local<v8::Object> canvas = CreateCanvasElement(isolate, host, 0, 0);
+    SetValue(isolate, document, "__mainCanvas", canvas);
+
+    global->Set(ctx, Str(isolate, "document"), document).Check();
+}
+
+void InstallGlobalBindings(v8::Isolate* isolate, v8::Local<v8::Object> global, HostContext* host)
+{
+    // 依存順: console -> DOM -> timers -> fetch -> image -> audio -> webgpu -> gamepad
+    InstallConsole(isolate, global);
+    InstallDomShims(isolate, global, host);
+    InstallTimers(isolate, global, host);
+    InstallFetch(isolate, global, host);
+    InstallNetwork(isolate, global, host);  // XMLHttpRequest/Blob/URL/ImageData
+    InstallImage(isolate, global, host);
+    InstallAudio(isolate, global, host);
+    InstallWebGPU(isolate, global, host);   // navigator.gpu
+    InstallGamepad(isolate, global, host);  // navigator.getGamepads
+}
+
+} // namespace next2d

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

@@ -0,0 +1,127 @@
+#include "EventTarget.h"
+
+#include "v8/V8Util.h"
+
+#include <string>
+
+namespace next2d {
+
+using v8util::Str;
+using v8util::SetMethod;
+using v8util::SetValue;
+using v8util::ToStdString;
+
+namespace {
+
+void AddEventListener(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
+    if (args.Length() < 2 || !args[1]->IsFunction()) {
+        return;
+    }
+    const std::string type = ToStdString(isolate, args[0]);
+    v8::Local<v8::Object> self = args.This();
+
+    v8::Local<v8::Value> lv;
+    v8::Local<v8::Object> listeners;
+    if (self->Get(ctx, Str(isolate, "__listeners")).ToLocal(&lv) && lv->IsObject()) {
+        listeners = lv.As<v8::Object>();
+    } else {
+        listeners = v8::Object::New(isolate);
+        SetValue(isolate, self, "__listeners", listeners);
+    }
+
+    v8::Local<v8::Value> arrv;
+    v8::Local<v8::Array> arr;
+    if (listeners->Get(ctx, Str(isolate, type.c_str())).ToLocal(&arrv) && arrv->IsArray()) {
+        arr = arrv.As<v8::Array>();
+    } else {
+        arr = v8::Array::New(isolate, 0);
+        listeners->Set(ctx, Str(isolate, type.c_str()), arr).Check();
+    }
+    arr->Set(ctx, arr->Length(), args[1]).Check();
+}
+
+void RemoveEventListener(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
+    if (args.Length() < 2) {
+        return;
+    }
+    const std::string type = ToStdString(isolate, args[0]);
+    v8::Local<v8::Value> lv;
+    if (!args.This()->Get(ctx, Str(isolate, "__listeners")).ToLocal(&lv) || !lv->IsObject()) {
+        return;
+    }
+    v8::Local<v8::Value> arrv;
+    if (!lv.As<v8::Object>()->Get(ctx, Str(isolate, type.c_str())).ToLocal(&arrv) || !arrv->IsArray()) {
+        return;
+    }
+    // 一致する関数を null 化 (簡易)
+    auto arr = arrv.As<v8::Array>();
+    for (uint32_t i = 0; i < arr->Length(); ++i) {
+        v8::Local<v8::Value> fn;
+        if (arr->Get(ctx, i).ToLocal(&fn) && fn->StrictEquals(args[1])) {
+            arr->Set(ctx, i, v8::Null(isolate)).Check();
+        }
+    }
+}
+
+void DispatchEventJS(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    if (args.Length() >= 1 && args[0]->IsObject()) {
+        DispatchEvent(isolate, args.This(), args[0].As<v8::Object>());
+    }
+    args.GetReturnValue().Set(true);
+}
+
+} // namespace
+
+void InstallEventTarget(v8::Isolate* isolate, v8::Local<v8::Object> target)
+{
+    SetMethod(isolate, target, "addEventListener", AddEventListener);
+    SetMethod(isolate, target, "removeEventListener", RemoveEventListener);
+    SetMethod(isolate, target, "dispatchEvent", DispatchEventJS);
+}
+
+void DispatchEvent(v8::Isolate* isolate, v8::Local<v8::Object> target,
+                   v8::Local<v8::Object> event)
+{
+    v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
+    v8::Local<v8::Value> type_val;
+    if (!event->Get(ctx, Str(isolate, "type")).ToLocal(&type_val)) {
+        return;
+    }
+    const std::string type = ToStdString(isolate, type_val);
+    v8::Local<v8::Value> args1[1] = { event };
+
+    // on<type> プロパティ
+    v8::Local<v8::Value> on;
+    const std::string onname = "on" + type;
+    if (target->Get(ctx, Str(isolate, onname.c_str())).ToLocal(&on) && on->IsFunction()) {
+        v8::TryCatch tc(isolate);
+        (void) on.As<v8::Function>()->Call(ctx, target, 1, args1);
+    }
+
+    // __listeners[type]
+    v8::Local<v8::Value> lv;
+    if (target->Get(ctx, Str(isolate, "__listeners")).ToLocal(&lv) && lv->IsObject()) {
+        v8::Local<v8::Value> arrv;
+        if (lv.As<v8::Object>()->Get(ctx, Str(isolate, type.c_str())).ToLocal(&arrv) &&
+            arrv->IsArray()) {
+            auto arr = arrv.As<v8::Array>();
+            for (uint32_t i = 0; i < arr->Length(); ++i) {
+                v8::Local<v8::Value> fn;
+                if (arr->Get(ctx, i).ToLocal(&fn) && fn->IsFunction()) {
+                    v8::TryCatch tc(isolate);
+                    (void) fn.As<v8::Function>()->Call(ctx, target, 1, args1);
+                }
+            }
+        }
+    }
+}
+
+} // namespace next2d

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

@@ -0,0 +1,17 @@
+// DOM EventTarget 相当の最小実装。
+// addEventListener で登録した関数を __listeners[type] に保持し、C++ から DispatchEvent で発火する。
+// main.cpp の WndProc が Win32 入力を PointerEvent/KeyboardEvent/WheelEvent へ変換して使う。
+#pragma once
+
+#include <v8.h>
+
+namespace next2d {
+
+// target に addEventListener / removeEventListener / dispatchEvent を設置する。
+void InstallEventTarget(v8::Isolate* isolate, v8::Local<v8::Object> target);
+
+// target の on<type> と __listeners[type] を発火する。event は {type, ...} を持つ JS オブジェクト。
+void DispatchEvent(v8::Isolate* isolate, v8::Local<v8::Object> target,
+                   v8::Local<v8::Object> event);
+
+} // namespace next2d

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

@@ -0,0 +1,149 @@
+#include "Bindings.h"
+
+#include "HostContext.h"
+#include "AssetLoader.h"
+#include "v8/V8Util.h"
+
+#include <cstring>
+#include <vector>
+
+namespace next2d {
+
+using v8util::Str;
+using v8util::ToStdString;
+
+namespace {
+
+// Response.arrayBuffer(): 内部データ(External の std::vector) から ArrayBuffer を作る。
+void ResponseArrayBuffer(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
+
+    v8::Local<v8::Object> self = args.This();
+    v8::Local<v8::Value> ext =
+        self->GetInternalField(0).As<v8::Value>();
+    auto* data = static_cast<std::vector<uint8_t>*>(ext.As<v8::External>()->Value());
+
+    std::unique_ptr<v8::BackingStore> store =
+        v8::ArrayBuffer::NewBackingStore(isolate, data->size());
+    if (!data->empty()) {
+        std::memcpy(store->Data(), data->data(), data->size());
+    }
+    v8::Local<v8::ArrayBuffer> buffer =
+        v8::ArrayBuffer::New(isolate, std::move(store));
+
+    v8::Local<v8::Promise::Resolver> resolver =
+        v8::Promise::Resolver::New(ctx).ToLocalChecked();
+    resolver->Resolve(ctx, buffer).Check();
+    args.GetReturnValue().Set(resolver->GetPromise());
+}
+
+void ResponseText(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
+
+    v8::Local<v8::Object> self = args.This();
+    auto* data = static_cast<std::vector<uint8_t>*>(
+        self->GetInternalField(0).As<v8::External>()->Value());
+
+    v8::Local<v8::String> text = v8::String::NewFromUtf8(
+        isolate, reinterpret_cast<const char*>(data->data()),
+        v8::NewStringType::kNormal, static_cast<int>(data->size())
+    ).ToLocalChecked();
+
+    v8::Local<v8::Promise::Resolver> resolver =
+        v8::Promise::Resolver::New(ctx).ToLocalChecked();
+    resolver->Resolve(ctx, text).Check();
+    args.GetReturnValue().Set(resolver->GetPromise());
+}
+
+void ResponseJson(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
+
+    v8::Local<v8::Object> self = args.This();
+    auto* data = static_cast<std::vector<uint8_t>*>(
+        self->GetInternalField(0).As<v8::External>()->Value());
+
+    v8::Local<v8::String> text = v8::String::NewFromUtf8(
+        isolate, reinterpret_cast<const char*>(data->data()),
+        v8::NewStringType::kNormal, static_cast<int>(data->size())
+    ).ToLocalChecked();
+
+    v8::Local<v8::Promise::Resolver> resolver =
+        v8::Promise::Resolver::New(ctx).ToLocalChecked();
+    v8::Local<v8::Value> parsed;
+    if (v8::JSON::Parse(ctx, text).ToLocal(&parsed)) {
+        resolver->Resolve(ctx, parsed).Check();
+    } else {
+        resolver->Reject(ctx, v8::Exception::SyntaxError(Str(isolate, "Invalid JSON"))).Check();
+    }
+    args.GetReturnValue().Set(resolver->GetPromise());
+}
+
+// External に持たせた vector を解放するための弱参照コールバック
+void ReleaseResponseData(const v8::WeakCallbackInfo<std::vector<uint8_t>>& info)
+{
+    delete info.GetParameter();
+}
+
+v8::Local<v8::Object> MakeResponse(v8::Isolate* isolate, v8::Local<v8::Context> ctx,
+                                   std::vector<uint8_t>&& bytes, bool ok, int status)
+{
+    v8::Local<v8::ObjectTemplate> tmpl = v8::ObjectTemplate::New(isolate);
+    tmpl->SetInternalFieldCount(1);
+    v8::Local<v8::Object> response = tmpl->NewInstance(ctx).ToLocalChecked();
+
+    auto* data = new std::vector<uint8_t>(std::move(bytes));
+    response->SetInternalField(0, v8::External::New(isolate, data));
+
+    // GC 時に解放
+    auto* handle = new v8::Global<v8::Object>(isolate, response);
+    handle->SetWeak(data, ReleaseResponseData, v8::WeakCallbackType::kParameter);
+
+    v8util::SetValue(isolate, response, "ok", v8::Boolean::New(isolate, ok));
+    v8util::SetValue(isolate, response, "status", v8::Integer::New(isolate, status));
+    v8util::SetMethod(isolate, response, "arrayBuffer", ResponseArrayBuffer);
+    v8util::SetMethod(isolate, response, "text", ResponseText);
+    v8util::SetMethod(isolate, response, "json", ResponseJson);
+    return response;
+}
+
+// fetch(url) -> Promise<Response>
+void Fetch(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
+    AssetLoader* assets = HostContext::From(isolate)->assets;
+
+    v8::Local<v8::Promise::Resolver> resolver =
+        v8::Promise::Resolver::New(ctx).ToLocalChecked();
+    args.GetReturnValue().Set(resolver->GetPromise());
+
+    if (args.Length() < 1) {
+        resolver->Reject(ctx, v8::Exception::TypeError(Str(isolate, "url required"))).Check();
+        return;
+    }
+
+    const std::string url = ToStdString(isolate, args[0]);
+    auto bytes = assets->ReadBinary(url);
+    if (!bytes) {
+        // 404 相当の Response を返す (fetch は存在しないリソースでも reject しない)
+        resolver->Resolve(ctx, MakeResponse(isolate, ctx, {}, false, 404)).Check();
+        return;
+    }
+
+    resolver->Resolve(ctx, MakeResponse(isolate, ctx, std::move(*bytes), true, 200)).Check();
+}
+
+} // namespace
+
+void InstallFetch(v8::Isolate* isolate, v8::Local<v8::Object> global, HostContext* /*host*/)
+{
+    v8util::SetMethod(isolate, global, "fetch", Fetch);
+}
+
+} // namespace next2d

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

@@ -0,0 +1,79 @@
+#include "Bindings.h"
+
+#include "HostContext.h"
+#include "platform/GamepadManager.h"
+#include "v8/V8Util.h"
+
+namespace next2d {
+
+using v8util::Str;
+
+namespace {
+
+v8::Local<v8::Object> BuildGamepad(v8::Isolate* isolate, v8::Local<v8::Context> ctx,
+                                   const GamepadSnapshot& snap, int index)
+{
+    v8::Local<v8::Object> pad = v8::Object::New(isolate);
+
+    v8util::SetValue(isolate, pad, "index", v8::Integer::New(isolate, index));
+    v8util::SetValue(isolate, pad, "id", Str(isolate, "Xbox Wireless Controller (STANDARD GAMEPAD)"));
+    v8util::SetValue(isolate, pad, "mapping", Str(isolate, "standard"));
+    v8util::SetValue(isolate, pad, "connected", v8::Boolean::New(isolate, snap.connected));
+    v8util::SetValue(isolate, pad, "timestamp", v8::Number::New(isolate, snap.timestamp));
+
+    // axes
+    v8::Local<v8::Array> axes = v8::Array::New(isolate, static_cast<int>(snap.axes.size()));
+    for (size_t i = 0; i < snap.axes.size(); ++i) {
+        axes->Set(ctx, static_cast<uint32_t>(i), v8::Number::New(isolate, snap.axes[i])).Check();
+    }
+    v8util::SetValue(isolate, pad, "axes", axes);
+
+    // buttons: { pressed, touched, value }
+    v8::Local<v8::Array> buttons = v8::Array::New(isolate, static_cast<int>(snap.buttons.size()));
+    for (size_t i = 0; i < snap.buttons.size(); ++i) {
+        v8::Local<v8::Object> b = v8::Object::New(isolate);
+        v8util::SetValue(isolate, b, "pressed", v8::Boolean::New(isolate, snap.pressed[i]));
+        v8util::SetValue(isolate, b, "touched", v8::Boolean::New(isolate, snap.pressed[i]));
+        v8util::SetValue(isolate, b, "value", v8::Number::New(isolate, snap.buttons[i]));
+        buttons->Set(ctx, static_cast<uint32_t>(i), b).Check();
+    }
+    v8util::SetValue(isolate, pad, "buttons", buttons);
+
+    return pad;
+}
+
+// navigator.getGamepads()
+void GetGamepads(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
+    GamepadManager* mgr = HostContext::From(isolate)->gamepad;
+
+    const auto& snaps = mgr ? mgr->snapshots() : std::vector<GamepadSnapshot>{};
+    v8::Local<v8::Array> result = v8::Array::New(isolate, static_cast<int>(snaps.size()));
+    for (size_t i = 0; i < snaps.size(); ++i) {
+        if (snaps[i].connected) {
+            result->Set(ctx, static_cast<uint32_t>(i),
+                        BuildGamepad(isolate, ctx, snaps[i], static_cast<int>(i))).Check();
+        } else {
+            result->Set(ctx, static_cast<uint32_t>(i), v8::Null(isolate)).Check();
+        }
+    }
+    args.GetReturnValue().Set(result);
+}
+
+} // namespace
+
+// navigator は DomShims が生成するため、ここでは navigator.getGamepads を後付けする。
+void InstallGamepad(v8::Isolate* isolate, v8::Local<v8::Object> global, HostContext* /*host*/)
+{
+    v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
+    v8::Local<v8::Value> nav_val;
+    if (!global->Get(ctx, Str(isolate, "navigator")).ToLocal(&nav_val) || !nav_val->IsObject()) {
+        return;
+    }
+    v8::Local<v8::Object> navigator = nav_val.As<v8::Object>();
+    v8util::SetMethod(isolate, navigator, "getGamepads", GetGamepads);
+}
+
+} // namespace next2d