@next2d/builder 0.1.8 → 0.1.11

package/templates/xbox/js/bootstrap.js

@@ -110,6 +110,126 @@
         global.URL.revokeObjectURL = function () {};
     }
 
+    // --- URLSearchParams の最小補完 ----------------------------------------
+    // V8 単体には URLSearchParams が存在しないため補完する。
+    // Next2D アプリがクエリ文字列 (?mode=0 等) を解析する際に使用する。
+    if (typeof global.URLSearchParams === "undefined") {
+        global.URLSearchParams = class URLSearchParams {
+            constructor(init) {
+                this._list = [];
+                if (typeof init === "string") {
+                    let query = init;
+                    if (query.charAt(0) === "?") {
+                        query = query.slice(1);
+                    }
+                    if (query.length) {
+                        const pairs = query.split("&");
+                        for (let i = 0; i < pairs.length; i++) {
+                            const pair = pairs[i];
+                            if (!pair) {
+                                continue;
+                            }
+                            const index = pair.indexOf("=");
+                            const decode = (value) => {
+                                try {
+                                    return decodeURIComponent(value.replace(/\+/g, " "));
+                                } catch {
+                                    return value;
+                                }
+                            };
+                            if (index === -1) {
+                                this._list.push([decode(pair), ""]);
+                            } else {
+                                this._list.push([decode(pair.slice(0, index)), decode(pair.slice(index + 1))]);
+                            }
+                        }
+                    }
+                } else if (init && typeof init === "object") {
+                    if (Array.isArray(init)) {
+                        for (let i = 0; i < init.length; i++) {
+                            this._list.push([String(init[i][0]), String(init[i][1])]);
+                        }
+                    } else if (typeof init.forEach === "function") {
+                        init.forEach((value, key) => this._list.push([String(key), String(value)]));
+                    } else {
+                        for (const key in init) {
+                            if (Object.prototype.hasOwnProperty.call(init, key)) {
+                                this._list.push([key, String(init[key])]);
+                            }
+                        }
+                    }
+                }
+            }
+            get(name) {
+                for (let i = 0; i < this._list.length; i++) {
+                    if (this._list[i][0] === name) {
+                        return this._list[i][1];
+                    }
+                }
+                return null;
+            }
+            getAll(name) {
+                const result = [];
+                for (let i = 0; i < this._list.length; i++) {
+                    if (this._list[i][0] === name) {
+                        result.push(this._list[i][1]);
+                    }
+                }
+                return result;
+            }
+            has(name) {
+                return this.get(name) !== null;
+            }
+            set(name, value) {
+                const text = String(value);
+                let done = false;
+                const next = [];
+                for (let i = 0; i < this._list.length; i++) {
+                    if (this._list[i][0] === name) {
+                        if (!done) {
+                            next.push([name, text]);
+                            done = true;
+                        }
+                    } else {
+                        next.push(this._list[i]);
+                    }
+                }
+                if (!done) {
+                    next.push([name, text]);
+                }
+                this._list = next;
+            }
+            append(name, value) {
+                this._list.push([String(name), String(value)]);
+            }
+            delete(name) {
+                this._list = this._list.filter((pair) => pair[0] !== name);
+            }
+            forEach(callback, thisArg) {
+                for (let i = 0; i < this._list.length; i++) {
+                    callback.call(thisArg, this._list[i][1], this._list[i][0], this);
+                }
+            }
+            keys() {
+                return this._list.map((pair) => pair[0])[Symbol.iterator]();
+            }
+            values() {
+                return this._list.map((pair) => pair[1])[Symbol.iterator]();
+            }
+            entries() {
+                return this._list.map((pair) => [pair[0], pair[1]])[Symbol.iterator]();
+            }
+            toString() {
+                return this._list
+                    .map((pair) => encodeURIComponent(pair[0]) + "=" + encodeURIComponent(pair[1]))
+                    .join("&");
+            }
+            [Symbol.iterator]() {
+                return this.entries();
+            }
+        };
+    }
+
     // --- location (Next2D が参照する場合の最小値) ---------------------------
     if (typeof global.location === "undefined") {
         global.location = {

package/templates/xbox/src/AssetLoader.cpp

@@ -1,4 +1,5 @@
 #include "AssetLoader.h"
+#include "EmbeddedAssets.h"
 
 #include <filesystem>
 #include <fstream>
@@ -14,9 +15,10 @@ AssetLoader::AssetLoader(std::string root)
 {
 }
 
-std::string AssetLoader::Resolve(const std::string& url) const
+std::string AssetLoader::RelativeKey(const std::string& url) const
 {
-    // 先頭の "/" や "./"、絶対 URL のオリジンを剥がして assets/app 基準に寄せる。
+    // 先頭の "/" や "./"、絶対 URL のオリジンを剥がして assets/app 基準の相対パスにする。
+    // 埋め込み pak のキー(フォワードスラッシュ相対)と一致させるためのもの。
     std::string path = url;
 
     // スキーム付き (file://, http://localhost/...) はパス部だけ取り出す
@@ -39,11 +41,101 @@ std::string AssetLoader::Resolve(const std::string& url) const
         path = path.substr(2);
     }
 
-    return (fs::path(root_) / path).string();
+    // バックスラッシュはフォワードスラッシュへ正規化 (pak キーと一致させる)。
+    for (char& c : path) {
+        if (c == '\\') c = '/';
+    }
+    return path;
+}
+
+std::string AssetLoader::Resolve(const std::string& url) const
+{
+    return (fs::path(root_) / RelativeKey(url)).string();
+}
+
+// base64 デコード (data: URI 用)。Image.cpp の同等実装と同じ仕様。
+static bool DecodeBase64(const std::string& in, std::vector<uint8_t>* out)
+{
+    auto val = [](char c) -> int {
+        if (c >= 'A' && c <= 'Z') return c - 'A';
+        if (c >= 'a' && c <= 'z') return c - 'a' + 26;
+        if (c >= '0' && c <= '9') return c - '0' + 52;
+        if (c == '+') return 62;
+        if (c == '/') return 63;
+        return -1;
+    };
+    out->clear();
+    out->reserve(in.size() / 4 * 3);
+    int buf = 0, bits = 0;
+    for (char c : in) {
+        if (c == '=' || c == '\r' || c == '\n' || c == ' ') continue;
+        const int v = val(c);
+        if (v < 0) return false;
+        buf = buf << 6 | v;
+        bits += 6;
+        if (bits >= 8) {
+            bits -= 8;
+            out->push_back(static_cast<uint8_t>(buf >> bits & 0xFF));
+        }
+    }
+    return true;
+}
+
+// data: URI を「%xx」percent-decode する (base64 でない稀なケース用)。
+static std::vector<uint8_t> PercentDecode(const std::string& in)
+{
+    std::vector<uint8_t> out;
+    out.reserve(in.size());
+    auto hex = [](char c) -> int {
+        if (c >= '0' && c <= '9') return c - '0';
+        if (c >= 'a' && c <= 'f') return c - 'a' + 10;
+        if (c >= 'A' && c <= 'F') return c - 'A' + 10;
+        return -1;
+    };
+    for (size_t i = 0; i < in.size(); ++i) {
+        if (in[i] == '%' && i + 2 < in.size()) {
+            const int hi = hex(in[i + 1]);
+            const int lo = hex(in[i + 2]);
+            if (hi >= 0 && lo >= 0) {
+                out.push_back(static_cast<uint8_t>(hi << 4 | lo));
+                i += 2;
+                continue;
+            }
+        }
+        out.push_back(static_cast<uint8_t>(in[i]));
+    }
+    return out;
 }
 
 std::optional<std::vector<uint8_t>> AssetLoader::ReadBinary(const std::string& url) const
 {
+    // data: URI (Vite の ?inline はアセットを data:<mime>;base64,<payload> に埋め込む)。
+    // このゲームは全サウンドを ?inline で取り込むため実体は data URI。画像は Image.cpp が
+    // 対応済みだが、音声 (new Audio / Sound の XHR fetch) もこの ReadBinary を通るので
+    // ここで一括デコードする。未対応だと data: をファイルパス扱いして開けず、全 SFX/BGM が
+    // 無音になる (XAudio2 の可否とは無関係に実機でも無音)。
+    if (url.rfind("data:", 0) == 0) {
+        const auto comma = url.find(',');
+        if (comma == std::string::npos) {
+            return std::nullopt;
+        }
+        const std::string meta = url.substr(5, comma - 5);  // 例: "audio/mpeg;base64"
+        const std::string payload = url.substr(comma + 1);
+        if (meta.find("base64") != std::string::npos) {
+            std::vector<uint8_t> out;
+            if (!DecodeBase64(payload, &out)) {
+                return std::nullopt;
+            }
+            return out;
+        }
+        return PercentDecode(payload);
+    }
+
+    // 埋め込みモード優先: exe 内 pak に同じ相対キーがあれば実ファイルより先に返す。
+    if (const auto* embedded = GetEmbeddedAsset(RelativeKey(url))) {
+        return *embedded;
+    }
+
     const std::string path = Resolve(url);
     std::ifstream ifs(path, std::ios::binary | std::ios::ate);
     if (!ifs) {
@@ -61,6 +153,10 @@ std::optional<std::vector<uint8_t>> AssetLoader::ReadBinary(const std::string& u
 
 std::optional<std::string> AssetLoader::ReadText(const std::string& url) const
 {
+    if (const auto* embedded = GetEmbeddedAsset(RelativeKey(url))) {
+        return std::string(embedded->begin(), embedded->end());
+    }
+
     const std::string path = Resolve(url);
     std::ifstream ifs(path, std::ios::binary);
     if (!ifs) {
@@ -74,22 +170,29 @@ std::optional<std::string> AssetLoader::ReadText(const std::string& url) const
 std::optional<std::string> AssetLoader::ResolveEntryModule() const
 {
     // vite が出力する index.html から <script type="module" src="..."> を抽出する。
-    const fs::path index = fs::path(root_) / "index.html";
-    std::ifstream ifs(index, std::ios::binary);
-    if (!ifs) {
-        return std::nullopt;
+    // 埋め込みモードでは pak から、無ければ実ファイルから読む。
+    std::string html;
+    if (const auto* embedded = GetEmbeddedAsset("index.html")) {
+        html.assign(embedded->begin(), embedded->end());
+    } else {
+        const fs::path index = fs::path(root_) / "index.html";
+        std::ifstream ifs(index, std::ios::binary);
+        if (!ifs) {
+            return std::nullopt;
+        }
+        std::ostringstream oss;
+        oss << ifs.rdbuf();
+        html = oss.str();
     }
-    std::ostringstream oss;
-    oss << ifs.rdbuf();
-    const std::string html = oss.str();
 
     // type="module" を含む <script ... src="..."> を優先して拾う。
+    // 返す値は assets/app 基準の絶対パス。モジュールローダ側で埋め込み/実ファイルを解決する。
     std::regex module_re(
         R"(<script[^>]*type=["']module["'][^>]*src=["']([^"']+)["'])",
         std::regex::icase);
     std::smatch m;
     if (std::regex_search(html, m, module_re)) {
-        return (fs::path(root_) / Resolve(m[1].str()).substr(root_.size() + 1)).string();
+        return Resolve(m[1].str());
     }
 
     // 逆順 (src が先) も試す
@@ -97,7 +200,7 @@ std::optional<std::string> AssetLoader::ResolveEntryModule() const
         R"(<script[^>]*src=["']([^"']+)["'][^>]*type=["']module["'])",
         std::regex::icase);
     if (std::regex_search(html, m, module_re2)) {
-        return (fs::path(root_) / Resolve(m[1].str()).substr(root_.size() + 1)).string();
+        return Resolve(m[1].str());
     }
 
     return std::nullopt;

package/templates/xbox/src/AssetLoader.h

@@ -20,6 +20,10 @@ public:
     // 相対 URL/パスを assets/app 基準の絶対パスへ解決する。
     std::string Resolve(const std::string& url) const;
 
+    // URL を assets/app 基準の相対キー(フォワードスラッシュ)へ正規化する。
+    // 埋め込み pak のキーと一致させるために使う。
+    std::string RelativeKey(const std::string& url) const;
+
     // バイナリ読み込み。存在しなければ nullopt。
     std::optional<std::vector<uint8_t>> ReadBinary(const std::string& url) const;
 

package/templates/xbox/src/EmbeddedAssets.cpp

@@ -0,0 +1,149 @@
+#include "EmbeddedAssets.h"
+
+#include <filesystem>
+#include <map>
+#include <utility>
+
+#ifdef _WIN32
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <Windows.h>
+#endif
+
+namespace fs = std::filesystem;
+
+namespace next2d {
+
+namespace {
+
+std::map<std::string, std::vector<uint8_t>> g_assets;
+std::string g_root;   // assets/app の正規化済み絶対パス
+bool g_loaded = false;
+bool g_has = false;
+
+inline uint32_t Read32LE(const uint8_t* p)
+{
+    return static_cast<uint32_t>(p[0])
+         | static_cast<uint32_t>(p[1]) << 8
+         | static_cast<uint32_t>(p[2]) << 16
+         | static_cast<uint32_t>(p[3]) << 24;
+}
+
+} // namespace
+
+bool ParseEmbeddedPak(const uint8_t* data, std::size_t size,
+                      std::vector<std::pair<std::string, std::vector<uint8_t>>>* out)
+{
+    if (!data || size < 12) {
+        return false;
+    }
+    if (data[0] != 'N' || data[1] != '2' || data[2] != 'D' || data[3] != 'A') {
+        return false;
+    }
+    // data[4..7] = version (現状 1 のみ。将来の互換のため値は検査しない)
+    const uint32_t count = Read32LE(data + 8);
+    std::size_t off = 12;
+    for (uint32_t i = 0; i < count; ++i) {
+        if (off + 4 > size) return false;
+        const uint32_t key_len = Read32LE(data + off);
+        off += 4;
+        if (key_len > size || off + key_len > size) return false;
+        std::string key(reinterpret_cast<const char*>(data + off), key_len);
+        off += key_len;
+
+        if (off + 4 > size) return false;
+        const uint32_t data_len = Read32LE(data + off);
+        off += 4;
+        if (data_len > size || off + data_len > size) return false;
+        std::vector<uint8_t> bytes(data + off, data + off + data_len);
+        off += data_len;
+
+        if (out) {
+            out->emplace_back(std::move(key), std::move(bytes));
+        }
+    }
+    return true;
+}
+
+bool InitEmbeddedAssets()
+{
+    if (g_loaded) {
+        return g_has;
+    }
+    g_loaded = true;
+
+#ifdef _WIN32
+    // 実行ファイル自身のリソースから "N2DASSETS" (RCDATA) を取り出す。
+    HRSRC res = FindResourceW(nullptr, L"N2DASSETS", RT_RCDATA);
+    if (res) {
+        HGLOBAL handle = LoadResource(nullptr, res);
+        const DWORD sz = SizeofResource(nullptr, res);
+        const void* ptr = handle ? LockResource(handle) : nullptr;
+        if (ptr && sz >= 12) {
+            std::vector<std::pair<std::string, std::vector<uint8_t>>> entries;
+            if (ParseEmbeddedPak(static_cast<const uint8_t*>(ptr), sz, &entries)) {
+                for (auto& e : entries) {
+                    g_assets.emplace(std::move(e.first), std::move(e.second));
+                }
+                g_has = true;
+            }
+        }
+    }
+#endif
+
+    return g_has;
+}
+
+bool HasEmbeddedAssets()
+{
+    return g_has;
+}
+
+void SetEmbeddedAssetsRoot(const std::string& abs_root)
+{
+    std::error_code ec;
+    fs::path canon = fs::weakly_canonical(fs::path(abs_root), ec);
+    g_root = ec ? abs_root : canon.string();
+}
+
+const std::vector<uint8_t>* GetEmbeddedAsset(const std::string& key)
+{
+    if (!g_has) {
+        return nullptr;
+    }
+    auto it = g_assets.find(key);
+    return it == g_assets.end() ? nullptr : &it->second;
+}
+
+void ForEachEmbeddedAsset(
+    const std::function<void(const std::string& key,
+                             const std::vector<uint8_t>& data)>& callback)
+{
+    if (!g_has) {
+        return;
+    }
+    for (const auto& [key, data] : g_assets) {
+        callback(key, data);
+    }
+}
+
+const std::vector<uint8_t>* GetEmbeddedAssetByAbsPath(const std::string& abs)
+{
+    if (!g_has || g_root.empty()) {
+        return nullptr;
+    }
+    // 純粋に字句的な相対化 (FS 参照なし)。abs も root も weakly_canonical 済みを前提。
+    const fs::path rel = fs::path(abs).lexically_relative(fs::path(g_root));
+    if (rel.empty()) {
+        return nullptr;
+    }
+    const std::string key = rel.generic_string();
+    // root 外 ("../..") は埋め込み対象外。
+    if (key.rfind("..", 0) == 0) {
+        return nullptr;
+    }
+    return GetEmbeddedAsset(key);
+}
+
+} // namespace next2d

package/templates/xbox/src/EmbeddedAssets.h

@@ -0,0 +1,60 @@
+// EmbeddedAssets: exe に埋め込んだ assets pak (Windows RCDATA) を解析して提供する。
+//
+// 目的: 書き出した *.exe の隣に平文の JS/HTML を置かず、ゲーム資産(assets/app 一式 +
+// js/bootstrap.js)を exe 内リソースへ格納する。埋め込みが無い(開発ビルド等)場合は
+// 全 API が「見つからない」を返し、呼び出し側はファイルシステムへフォールバックする。
+// これにより埋め込みは純粋に加算的で、既存のファイル読み経路を壊さない。
+//
+// pak フォーマット (リトルエンディアン uint32):
+//   [4]  magic "N2DA"
+//   [4]  uint32 version (=1)
+//   [4]  uint32 count
+//   count 回:
+//     [4]         uint32 key_len
+//     [key_len]   key   (UTF-8, フォワードスラッシュ相対パス)
+//     [4]         uint32 data_len
+//     [data_len]  data
+//
+// key は次のいずれか:
+//   - assets/app 基準の相対パス (例 "app.js", "index.html", "assets/xxx.js")
+//   - "js/bootstrap.js" / "js/selftest.js" (exe_dir 基準)
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <string>
+#include <vector>
+
+namespace next2d {
+
+// exe リソースから pak をロードして解析する (プロセスで一度だけ)。
+// 埋め込みが存在し解析に成功したとき true。以後の Has/Get はこの結果に従う。
+bool InitEmbeddedAssets();
+
+// 埋め込みが利用可能か。
+bool HasEmbeddedAssets();
+
+// assets/app のルート絶対パスを登録する。GetEmbeddedAssetByAbsPath の
+// 相対キー算出に使う。main で AssetLoader の root と同じ値を渡す。
+void SetEmbeddedAssetsRoot(const std::string& abs_root);
+
+// 相対キー直接指定で検索する。見つかればバイト列ポインタ(プロセス生存中有効)、無ければ nullptr。
+const std::vector<uint8_t>* GetEmbeddedAsset(const std::string& key);
+
+// 全エントリを列挙する (フォント等、キーが事前に分からない資材の収集用)。
+// callback には key とデータ (プロセス生存中有効) が渡る。
+void ForEachEmbeddedAsset(
+    const std::function<void(const std::string& key,
+                             const std::vector<uint8_t>& data)>& callback);
+
+// モジュールローダ用: assets/app 配下の絶対パスを相対キーへ変換して検索する。
+// root 未登録 / abs が root 配下でない場合は nullptr。
+const std::vector<uint8_t>* GetEmbeddedAssetByAbsPath(const std::string& abs);
+
+// テスト用: 生の pak バッファを解析して (key -> data) を out へ格納する。
+// プラットフォーム非依存で macOS 上でも検証できる。成功時 true。
+bool ParseEmbeddedPak(const uint8_t* data, std::size_t size,
+                      std::vector<std::pair<std::string, std::vector<uint8_t>>>* out);
+
+} // namespace next2d

package/templates/xbox/src/EventLoop.cpp

@@ -64,21 +64,6 @@ uint32_t EventLoop::RequestAnimationFrame(v8::Local<v8::Function> callback)
 {
     const uint32_t id = next_raf_id_++;
 
-    // 診断: 誰が rAF を登録しているか (関数名 + minify 後スクリプト位置)。
-    // 最初の 40 件 + 以後 300 件毎にサンプルし、凍結後も生きている登録元を特定する。
-    static uint64_t reg_count = 0;
-    ++reg_count;
-    if (reg_count <= 40 || reg_count % 300 == 0) {
-        const std::string name =
-            v8util::ToStdString(isolate_, callback->GetDebugName());
-        v8::Local<v8::Value> res = callback->GetScriptOrigin().ResourceName();
-        std::cerr << "[Loop] rAF register #" << reg_count
-                  << " fn=" << (name.empty() ? "(anon)" : name)
-                  << " at " << v8util::ToStdString(isolate_, res)
-                  << ":" << callback->GetScriptLineNumber() + 1
-                  << ":" << callback->GetScriptColumnNumber() + 1 << std::endl;
-    }
-
     v8::Global<v8::Function> global;
     global.Reset(isolate_, callback);
     raf_callbacks_.emplace_back(id, std::move(global));