@next2d/builder 0.1.7 → 0.1.10

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

@@ -4,9 +4,12 @@
 #include "AssetLoader.h"
 #include "EventTarget.h"
 #include "platform/AudioEngine.h"
+#include "platform/DecodeQueue.h"
 #include "v8/V8Util.h"
+#include "v8/WeakHandle.h"
 
 #include <memory>
+#include <utility>
 #include <vector>
 
 namespace next2d {
@@ -22,11 +25,6 @@ struct GainParam {
     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()
 {
@@ -40,19 +38,12 @@ 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);
+    v8util::AttachWeak(isolate, obj, holder);
 }
 
 template <typename T>
@@ -198,8 +189,7 @@ void CreateGain(const v8::FunctionCallbackInfo<v8::Value>& args)
     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);
+    v8util::AttachWeak(isolate, gain, param);
 
     gain->SetNativeDataProperty(ctx, Str(isolate, "value"),
         [](v8::Local<v8::Name>, const v8::PropertyCallbackInfo<v8::Value>& info) {
@@ -226,26 +216,53 @@ void CreateGain(const v8::FunctionCallbackInfo<v8::Value>& args)
 // 毎フレーム呼ばれ、再生終了した source ノードへ "ended" を発火する (main.cpp のループから)。
 } // namespace
 
+// V8 破棄前に呼ぶ。再生追跡リストの v8::Global を解放する。
+// (放置すると static デストラクタが V8 破棄後に走りアクセス違反になる)
+void ShutdownAudioEvents()
+{
+    for (auto& g : PlayingSources()) {
+        g.Reset();
+    }
+    PlayingSources().clear();
+}
+
 void PumpAudioEvents(v8::Isolate* isolate)
 {
     auto& sources = PlayingSources();
     if (sources.empty()) return;
     v8::HandleScope scope(isolate);
     v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
+
+    // 1) 終了した source を集めて先に登録リストから外す。ここでは JS を呼ばない。
+    //    (この時点の erase による v8::Global の move は他の再入が無いので安全)
+    std::vector<v8::Global<v8::Object>> finished;
     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);
-            }
+            finished.push_back(std::move(sources[i]));
             sources.erase(sources.begin() + i);
         } else {
             ++i;
         }
     }
+
+    // 2) リストが安定した状態で "ended" を配送する。
+    //    "ended" ハンドラは source.disconnect() や新規再生で PlayingSources を
+    //    再入的に変更しうる。以前は配送と erase を同一ループで行っていたため、
+    //    配送中にベクタが変更されると直後の erase 中の v8::Global move が壊れ
+    //    GlobalHandles::MoveGlobal でアクセス違反していた。独立した finished を
+    //    走査することで再入変更から隔離する。
+    for (auto& g : finished) {
+        v8::Local<v8::Object> node = g.Get(isolate);
+        auto voice = Get<AudioVoice>(node);
+        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);
+        }
+        g.Reset();
+    }
 }
 
 namespace {
@@ -268,21 +285,158 @@ void DecodeAudioData(const v8::FunctionCallbackInfo<v8::Value>& args)
                      static_cast<uint8_t*>(store->Data()) + store->ByteLength());
     }
 
+    // Media Foundation デコードはバックグラウンドスレッドへ (Promise なので元々
+    // 非同期契約)。BGM の同期デコードは画面遷移時の数百 ms ヒッチになっていた。
+    auto resolver_ref =
+        std::make_shared<v8::Global<v8::Promise::Resolver>>(isolate, resolver);
     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();
+    auto decoded = std::make_shared<bool>(false);
+
+    decodequeue::Submit(
+        [input = std::move(input), pcm, decoded]() {
+            *decoded = !input.empty() && AudioEngine::Decode(input, *pcm);
+        },
+        [isolate, resolver_ref, pcm, decoded]() {
+            v8::HandleScope hs(isolate);
+            v8::Local<v8::Promise::Resolver> r = resolver_ref->Get(isolate);
+            v8::Local<v8::Context> c = r->GetCreationContextChecked();
+            v8::Context::Scope cs(c);
+
+            // 重要: デコード失敗でも Reject しない。@next2d/media の SoundDecodeService は
+            // decodeAudioData の reject を catch して先頭バイトをスキップし再帰リトライするが、
+            // そのループ条件 (`idx > byteLength`) が常に false のため同一バッファで無限再帰し、
+            // マイクロタスクが枯渇してフレームワークのローディング画面ごとフリーズする。
+            // ここで無音の空バッファを resolve すれば、そのサウンドは無音になるだけでアプリは
+            // 進行できる (graceful degradation)。実データが壊れているか MF 非対応かは上のログで判別。
+            if (!*decoded) {
+                pcm->samples.clear();      // 0 サンプル = 無音
+                pcm->channels = pcm->channels ? pcm->channels : 2;
+                pcm->sample_rate = pcm->sample_rate ? pcm->sample_rate : 48000;
+            }
+
+            v8::Local<v8::Object> buffer =
+                InternalTemplate(isolate)->NewInstance(c).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));
+            r->Resolve(c, buffer).Check();
+            resolver_ref->Reset();
+        });
+}
+
+// --- Audio (HTMLAudioElement 最小実装) -------------------------------------
+// ゲームコードが `new Audio(url)` で効果音/BGM を再生する経路。
+// play/pause/paused/loop/volume/currentTime/preload をサポートする。
+// pause→play は先頭からの再生になる (位置レジュームは未対応の近似)。
+
+void AudioElementPlay(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 resolver = v8::Promise::Resolver::New(ctx).ToLocalChecked();
+    args.GetReturnValue().Set(resolver->GetPromise());
+
+    auto voice = Get<AudioVoice>(self);
+    if (voice) {
+        bool loop = false;
+        double volume = 1.0;
+        v8::Local<v8::Value> v;
+        if (self->Get(ctx, Str(isolate, "loop")).ToLocal(&v)) {
+            loop = v->BooleanValue(isolate);
+        }
+        if (self->Get(ctx, Str(isolate, "volume")).ToLocal(&v) && v->IsNumber()) {
+            volume = v.As<v8::Number>()->Value();
+        }
+        voice->SetVolume(static_cast<float>(volume));
+        voice->Start(loop);
+    }
+    v8util::SetValue(isolate, self, "paused", v8::Boolean::New(isolate, false));
+    resolver->Resolve(ctx, v8::Undefined(isolate)).Check();
+}
+
+void AudioElementPause(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    auto voice = Get<AudioVoice>(args.This());
+    if (voice) {
+        voice->Stop();
+    }
+    v8util::SetValue(isolate, args.This(), "paused", v8::Boolean::New(isolate, true));
+}
+
+void AudioElementConstructor(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    if (!args.IsConstructCall()) {
+        v8util::ThrowTypeError(isolate, "Audio must be called with new");
         return;
     }
+    v8::Local<v8::Object> self = args.This();
+    Attach<AudioVoice>(isolate, self, nullptr);
+
+    // URL 指定があればロードし、デコードはバックグラウンドスレッドへ (失敗時は
+    // 無音の no-op)。デコード完了前に play() が呼ばれていた場合 (paused=false) は
+    // 完了時に再生を開始する (同期デコード時代の「即時再生」挙動を維持)。
+    if (args.Length() > 0 && args[0]->IsString()) {
+        const std::string src = ToStdString(isolate, args[0]);
+        v8util::SetValue(isolate, self, "src", args[0]);
+        HostContext* host = HostContext::From(isolate);
+        auto bytes = host->assets->ReadBinary(src);
+        if (bytes) {
+            auto self_ref = std::make_shared<v8::Global<v8::Object>>(isolate, self);
+            auto pcm = std::make_shared<PcmBuffer>();
+            auto decoded = std::make_shared<bool>(false);
+            decodequeue::Submit(
+                [input = std::move(*bytes), pcm, decoded]() {
+                    *decoded = AudioEngine::Decode(input, *pcm);
+                },
+                [isolate, self_ref, pcm, decoded, host]() {
+                    v8::HandleScope hs(isolate);
+                    v8::Local<v8::Object> el = self_ref->Get(isolate);
+                    v8::Local<v8::Context> c = el->GetCreationContextChecked();
+                    v8::Context::Scope cs(c);
+                    if (*decoded) {
+                        auto voice = host->audio->CreateVoice(pcm);
+                        Attach<AudioVoice>(isolate, el, voice);
+                        // デコード中に play() 済みなら開始する
+                        v8::Local<v8::Value> paused_v, loop_v, vol_v;
+                        const bool paused =
+                            !el->Get(c, Str(isolate, "paused")).ToLocal(&paused_v) ||
+                            paused_v->BooleanValue(isolate);
+                        if (!paused && voice) {
+                            if (el->Get(c, Str(isolate, "volume")).ToLocal(&vol_v) &&
+                                vol_v->IsNumber()) {
+                                voice->SetVolume(static_cast<float>(
+                                    vol_v.As<v8::Number>()->Value()));
+                            }
+                            const bool loop =
+                                el->Get(c, Str(isolate, "loop")).ToLocal(&loop_v) &&
+                                loop_v->BooleanValue(isolate);
+                            voice->Start(loop);
+                        }
+                    }
+                    self_ref->Reset();
+                });
+        }
+    }
 
-    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();
+    v8util::SetValue(isolate, self, "loop", v8::Boolean::New(isolate, false));
+    v8util::SetValue(isolate, self, "volume", v8::Number::New(isolate, 1.0));
+    v8util::SetValue(isolate, self, "paused", v8::Boolean::New(isolate, true));
+    v8util::SetValue(isolate, self, "preload", Str(isolate, "auto"));
+    v8util::SetValue(isolate, self, "currentTime", v8::Number::New(isolate, 0));
+    v8util::SetMethod(isolate, self, "play", AudioElementPlay);
+    v8util::SetMethod(isolate, self, "pause", AudioElementPause);
+    InstallEventTarget(isolate, self);
+    args.GetReturnValue().Set(self);
 }
 
 // AudioContext コンストラクタ
@@ -299,6 +453,23 @@ void AudioContextConstructor(const v8::FunctionCallbackInfo<v8::Value>& args)
     v8util::SetMethod(isolate, self, "createBufferSource", CreateBufferSource);
     v8util::SetMethod(isolate, self, "createGain", CreateGain);
     v8util::SetMethod(isolate, self, "decodeAudioData", DecodeAudioData);
+
+    // state / resume / suspend / close: ブラウザの AudioContext はユーザージェスチャまで
+    // suspended だが、ホストの XAudio2 は常に有効なので "running" 固定。player の音声
+    // アンロック (初回 pointerup で ctx.resume()) が未実装だと TypeError で throw し、
+    // そのハンドラ(ミュート解除等)以降が中断する。解決済み Promise を返す no-op にする。
+    v8util::SetValue(isolate, self, "state", v8util::Str(isolate, "running"));
+    auto resolvedPromise = [](const v8::FunctionCallbackInfo<v8::Value>& a) {
+        v8::Isolate* iso = a.GetIsolate();
+        v8::Local<v8::Context> c = iso->GetCurrentContext();
+        auto r = v8::Promise::Resolver::New(c).ToLocalChecked();
+        (void) r->Resolve(c, v8::Undefined(iso));
+        a.GetReturnValue().Set(r->GetPromise());
+    };
+    v8util::SetMethod(isolate, self, "resume", resolvedPromise);
+    v8util::SetMethod(isolate, self, "suspend", resolvedPromise);
+    v8util::SetMethod(isolate, self, "close", resolvedPromise);
+
     args.GetReturnValue().Set(self);
 }
 
@@ -315,6 +486,15 @@ void InstallAudio(v8::Isolate* isolate, v8::Local<v8::Object> global, HostContex
 
     global->Set(ctx, Str(isolate, "AudioContext"), fn).Check();
     global->Set(ctx, Str(isolate, "webkitAudioContext"), fn).Check();
+
+    // Audio (HTMLAudioElement 最小): ゲームコードの `new Audio(url)` 用。
+    // インスタンスは内部フィールドに AudioVoice ホルダを持つ。
+    v8::Local<v8::FunctionTemplate> audio_tmpl =
+        v8::FunctionTemplate::New(isolate, AudioElementConstructor);
+    audio_tmpl->SetClassName(Str(isolate, "Audio"));
+    audio_tmpl->InstanceTemplate()->SetInternalFieldCount(1);
+    global->Set(ctx, Str(isolate, "Audio"),
+                audio_tmpl->GetFunction(ctx).ToLocalChecked()).Check();
 }
 
 } // namespace next2d

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

@@ -41,6 +41,12 @@ void InstallAudio(v8::Isolate* isolate, v8::Local<v8::Object> global, HostContex
 // 再生終了した AudioBufferSourceNode へ "ended" を発火する。main.cpp のループから毎フレーム呼ぶ。
 void PumpAudioEvents(v8::Isolate* isolate);
 
+// V8 破棄前に呼ぶ。音声の再生追跡リスト (v8::Global) を解放する。
+void ShutdownAudioEvents();
+
+// V8 破棄前に呼ぶ。WebGPU テンプレートの v8::Global (static) を解放する。
+void ShutdownWebGPU();
+
 // window / document / navigator / screen 等の DOM 相当スタブと canvas 生成
 void InstallDomShims(v8::Isolate* isolate, v8::Local<v8::Object> global, HostContext* host);
 
@@ -69,6 +75,10 @@ bool GetVideoFramePixels(v8::Isolate* isolate, v8::Local<v8::Object> obj,
 // blob: URL のバイト列をテキストとして取得する (Network.cpp)。
 bool ResolveObjectURL(const std::string& url, std::string* out_text);
 
+// TextEncoder/TextDecoder/queueMicrotask 等の JS ポリフィルを評価する (Polyfills.cpp)。
+// bootstrap.js はメインのみのため、worker を含む全コンテキストにはこちらで注入する。
+void InstallPolyfills(v8::Isolate* isolate, v8::Local<v8::Context> context);
+
 // 上記をまとめてインストールする
 void InstallGlobalBindings(v8::Isolate* isolate, v8::Local<v8::Object> global, HostContext* host);
 

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

@@ -105,6 +105,16 @@ void TransferControlToOffscreen(const v8::FunctionCallbackInfo<v8::Value>& args)
     if (args.This()->Get(ctx, Str(isolate, "height")).ToLocal(&hv) && hv->IsNumber()) {
         height = static_cast<int>(hv.As<v8::Number>()->Value());
     }
+
+    // このソース canvas (args.This()) こそがプレイヤーの主表示 canvas。
+    // player は「document.createElement('canvas') → pointer リスナ登録 → その canvas を
+    // transferControlToOffscreen()」の順で主 canvas を作る (input と描画で同一要素)。
+    // 一方 createElement は毎回 main_canvas を上書きするため、後続のヒットテスト用
+    // Canvas2D 生成 (getContext('2d') 用に 7 個も作る) で main_canvas が別要素に化け、
+    // WndProc の入力配送先とリスナ登録先がズレて「ボタンが全く反応しない」状態になる。
+    // transferControlToOffscreen が呼ばれる唯一の canvas = 正しい入力要素なので確定させる。
+    host->main_canvas.Reset(isolate, args.This());
+
     args.GetReturnValue().Set(CreateOffscreenCanvas(isolate, host, width, height));
 }
 
@@ -135,6 +145,9 @@ v8::Local<v8::Object> CreateCanvasElement(v8::Isolate* isolate, HostContext* hos
                                           int width, int height)
 {
     v8::Local<v8::Object> canvas = v8::Object::New(isolate);
+    // player の canvasSetPositionService は children[0].localName === "canvas" を確認する
+    SetValue(isolate, canvas, "tagName", Str(isolate, "CANVAS"));
+    SetValue(isolate, canvas, "localName", Str(isolate, "canvas"));
     SetValue(isolate, canvas, "width",
              v8::Integer::New(isolate, width ? width : host->viewport_width));
     SetValue(isolate, canvas, "height",
@@ -144,10 +157,72 @@ v8::Local<v8::Object> CreateCanvasElement(v8::Isolate* isolate, HostContext* hos
     SetValue(isolate, canvas, "style", v8::Object::New(isolate));
     SetMethod(isolate, canvas, "getContext", Canvas_GetContext);
     SetMethod(isolate, canvas, "transferControlToOffscreen", TransferControlToOffscreen);
+    // Pointer capture: player の pointerdown ハンドラは t.setPointerCapture(pointerId) を
+    // 呼ぶ。未実装だと TypeError で DispatchEvent の TryCatch に飲まれ、以降の座標解決
+    // (dl) に到達せずボタンが反応しない。no-op として実装する (単一ウィンドウでは
+    // capture の有無で挙動は変わらない)。hasPointerCapture は false を返す。
+    SetMethod(isolate, canvas, "setPointerCapture",
+        [](const v8::FunctionCallbackInfo<v8::Value>&) {});
+    SetMethod(isolate, canvas, "releasePointerCapture",
+        [](const v8::FunctionCallbackInfo<v8::Value>&) {});
+    SetMethod(isolate, canvas, "hasPointerCapture",
+        [](const v8::FunctionCallbackInfo<v8::Value>& a) {
+            a.GetReturnValue().Set(false);
+        });
     InstallEventTarget(isolate, canvas);   // pointer/wheel リスナを保持
     SetMethod(isolate, canvas, "getBoundingClientRect", GetBoundingClientRect);
-    // 主要 canvas を HostContext から参照できるよう記録 (WndProc の入力配送先)
-    HostContext::From(isolate)->main_canvas.Reset(isolate, canvas);
+
+    // player の CanvasInitializeService が canvas.setAttribute("style", ...) を呼ぶ。
+    // 属性は __attrs に保存する (見た目の CSS はネイティブ描画では不要)。
+    SetMethod(isolate, canvas, "setAttribute",
+        [](const v8::FunctionCallbackInfo<v8::Value>& a) {
+            if (a.Length() < 2) return;
+            v8::Isolate* iso = a.GetIsolate();
+            v8::Local<v8::Context> c = iso->GetCurrentContext();
+            v8::Local<v8::Value> attrs;
+            v8::Local<v8::Object> store;
+            if (a.This()->Get(c, v8util::Str(iso, "__attrs")).ToLocal(&attrs) && attrs->IsObject()) {
+                store = attrs.As<v8::Object>();
+            } else {
+                store = v8::Object::New(iso);
+                v8util::SetValue(iso, a.This(), "__attrs", store);
+            }
+            store->Set(c, a[0], a[1]).Check();
+        });
+    SetMethod(isolate, canvas, "getAttribute",
+        [](const v8::FunctionCallbackInfo<v8::Value>& a) {
+            a.GetReturnValue().SetNull();
+            if (a.Length() < 1) return;
+            v8::Isolate* iso = a.GetIsolate();
+            v8::Local<v8::Context> c = iso->GetCurrentContext();
+            v8::Local<v8::Value> attrs;
+            if (a.This()->Get(c, v8util::Str(iso, "__attrs")).ToLocal(&attrs) && attrs->IsObject()) {
+                v8::Local<v8::Value> v;
+                if (attrs.As<v8::Object>()->Get(c, a[0]).ToLocal(&v) && !v->IsUndefined()) {
+                    a.GetReturnValue().Set(v);
+                }
+            }
+        });
+    SetMethod(isolate, canvas, "removeAttribute",
+        [](const v8::FunctionCallbackInfo<v8::Value>& a) {
+            if (a.Length() < 1) return;
+            v8::Isolate* iso = a.GetIsolate();
+            v8::Local<v8::Context> c = iso->GetCurrentContext();
+            v8::Local<v8::Value> attrs;
+            if (a.This()->Get(c, v8util::Str(iso, "__attrs")).ToLocal(&attrs) && attrs->IsObject()) {
+                (void) attrs.As<v8::Object>()->Delete(c, a[0]);
+            }
+        });
+    // 主要 canvas の記録 (WndProc の入力配送先)。
+    // 確定は transferControlToOffscreen 側で行う (player が input を張る主 canvas はそちら)。
+    // ここでは「まだ未設定なら暫定で最初の canvas を採用」するフォールバックに留め、
+    // 後続の Canvas2D 生成で上書きしない (上書きすると入力配送先がヒットテスト用 canvas に化ける)。
+    {
+        HostContext* host = HostContext::From(isolate);
+        if (host->main_canvas.IsEmpty()) {
+            host->main_canvas.Reset(isolate, canvas);
+        }
+    }
     return canvas;
 }