@next2d/builder 0.1.8 → 0.1.10

package/templates/xbox/src/platform/TextRasterizer.cpp

@@ -1,5 +1,12 @@
 #include "TextRasterizer.h"
 
+// DirectWrite / Direct2D / WIC はコンソール (Game Core OS) に存在しない
+// デスクトップ専用 API。コンソールでは false を返し、呼び出し側
+// (Canvas2D の fillText/measureText) が近似値へフォールバックする
+// (契約は TextRasterizer.h に明記済み)。
+// 実機でのテキスト描画品質は devkit 段階の課題 (stb_truetype + フォント同梱)。
+#if !NEXT2D_XBOX_CONSOLE
+
 #include "../bindings/RasterCore.h"
 
 #include <algorithm>
@@ -181,3 +188,28 @@ bool RasterizeTextWithDWrite(const std::string& css_font, const std::wstring& te
 }
 
 } // namespace next2d
+
+#else // NEXT2D_XBOX_CONSOLE
+
+// コンソール: stb_truetype 実装へ委譲する。フォントは main.cpp が起動時に
+// 埋め込み資材 (*.ttf/*.otf) から登録する。未登録なら false を返し、
+// 呼び出し側 (Canvas2D) が近似値へフォールバックする。
+#include "StbTextRasterizer.h"
+
+namespace next2d {
+
+bool MeasureTextWithDWrite(const std::string& css_font, const std::wstring& text,
+                           TextMetricsInfo& out)
+{
+    return stbtext::MeasureText(css_font, text, out);
+}
+
+bool RasterizeTextWithDWrite(const std::string& css_font, const std::wstring& text,
+                             uint8_t r, uint8_t g, uint8_t b, TextBitmap& out)
+{
+    return stbtext::RasterizeText(css_font, text, r, g, b, out);
+}
+
+} // namespace next2d
+
+#endif // !NEXT2D_XBOX_CONSOLE

package/templates/xbox/src/platform/WicDecoder.cpp

@@ -1,5 +1,10 @@
 #include "WicDecoder.h"
 
+// WIC はコンソール (Game Core OS) に存在しないデスクトップ専用 API。
+// 第一経路は ImageDecoder (stb_image) で、本ファイルはデスクトップの
+// フォールバック (TIFF/HEIF 等 stb 非対応形式) のみを担う。
+#if !NEXT2D_XBOX_CONSOLE
+
 #include <wincodec.h>
 #include <wrl/client.h>
 
@@ -61,3 +66,17 @@ bool DecodeImageWithWIC(const std::vector<uint8_t>& input, DecodedImage& out)
 }
 
 } // namespace next2d
+
+#else // NEXT2D_XBOX_CONSOLE
+
+namespace next2d {
+
+// コンソール: WIC 無し。ImageDecoder (stb_image) が全デコードを担う。
+bool DecodeImageWithWIC(const std::vector<uint8_t>&, DecodedImage&)
+{
+    return false;
+}
+
+} // namespace next2d
+
+#endif // !NEXT2D_XBOX_CONSOLE

package/templates/xbox/src/v8/CodeCache.h

@@ -0,0 +1,223 @@
+// V8 バイトコードキャッシュ。
+//
+// player+framework のバンドル (数 MB) は毎起動フルパースがかかり、jitless
+// (Ignition) では起動時間の主要因になる。初回起動時に eager コンパイルして
+// バイトコードをディスクへ保存し、2 回目以降はそれを消費してパースを省略する。
+// 生成物はデータであり動的コード生成ではないため、コンソール (JIT 禁止) でも使える。
+//
+// - 保存先: %LOCALAPPDATA%\Next2D\codecache\<hash>.v8bc
+//   (DomShims の localStorage バックエンドと同じ配置方針。環境変数が無ければ無効化)
+// - キー: スクリプト名 + ソース内容の FNV-1a。ソースが変われば別ファイルになる。
+// - V8 のバージョン/フラグ不一致は V8 自身が検出して reject する (その場で作り直す)。
+// - すべてのエラーは graceful degrade (キャッシュ無しの通常コンパイルに落ちる)。
+// - 小さいスクリプトはパースが安く I/O の方が高いため対象外 (kMinSourceSize)。
+#pragma once
+
+#include <v8.h>
+
+#include <chrono>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <filesystem>
+#include <fstream>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace next2d::codecache {
+
+// キャッシュ対象の最小ソースサイズ。bootstrap.js (十数 KB) は対象外、
+// ゲーム/player バンドル (数百 KB〜数 MB) が対象になる境界。
+inline constexpr size_t kMinSourceSize = 64 * 1024;
+
+inline const std::filesystem::path& CacheDir()
+{
+    static const std::filesystem::path dir = []() -> std::filesystem::path {
+        const char* base = std::getenv("LOCALAPPDATA");
+        if (!base || !*base) {
+            return {};
+        }
+        std::error_code ec;
+        std::filesystem::path d = std::filesystem::path(base) / "Next2D" / "codecache";
+        std::filesystem::create_directories(d, ec);
+        if (ec) {
+            return {};
+        }
+        // ゲーム更新でソースが変わるとキャッシュはファイル名ごと変わり、旧ファイルは
+        // 参照されない孤児になる。30 日アクセスの無い .v8bc を起動時に掃除する
+        // (Load が使用時に write time を touch するため実質 LRU)。
+        const auto now = std::filesystem::file_time_type::clock::now();
+        std::error_code iter_ec;
+        for (const auto& entry : std::filesystem::directory_iterator(d, iter_ec)) {
+            std::error_code e2;
+            if (entry.path().extension() != ".v8bc") {
+                continue;
+            }
+            const auto t = std::filesystem::last_write_time(entry.path(), e2);
+            if (!e2 && now - t > std::chrono::hours(24 * 30)) {
+                std::filesystem::remove(entry.path(), e2);
+            }
+        }
+        return d;
+    }();
+    return dir;
+}
+
+inline uint64_t Fnv1a(const void* data, size_t size, uint64_t hash = 1469598103934665603ull)
+{
+    const auto* p = static_cast<const unsigned char*>(data);
+    for (size_t i = 0; i < size; ++i) {
+        hash ^= p[i];
+        hash *= 1099511628211ull;
+    }
+    return hash;
+}
+
+inline std::filesystem::path CacheFileFor(const std::string& name, const std::string& source)
+{
+    const std::filesystem::path& dir = CacheDir();
+    if (dir.empty()) {
+        return {};
+    }
+    uint64_t h = Fnv1a(name.data(), name.size());
+    h = Fnv1a(source.data(), source.size(), h);
+    char buf[17] = {};
+    std::snprintf(buf, sizeof(buf), "%016llx", static_cast<unsigned long long>(h));
+    return dir / (std::string(buf) + ".v8bc");
+}
+
+inline bool Eligible(const std::string& source)
+{
+    return source.size() >= kMinSourceSize && !CacheDir().empty();
+}
+
+// キャッシュファイルを読む。戻り値の所有権は ScriptCompiler::Source が取る
+// (BufferOwned なので CachedData 破棄時に delete[] される)。無ければ nullptr。
+inline v8::ScriptCompiler::CachedData* Load(const std::string& name, const std::string& source)
+{
+    const std::filesystem::path file = CacheFileFor(name, source);
+    if (file.empty()) {
+        return nullptr;
+    }
+    std::ifstream ifs(file, std::ios::binary);
+    if (!ifs) {
+        return nullptr;
+    }
+    std::vector<char> buf(
+        (std::istreambuf_iterator<char>(ifs)), std::istreambuf_iterator<char>());
+    if (buf.empty()) {
+        return nullptr;
+    }
+    // 使用時に write time を更新し、CacheDir の 30 日掃除を LRU として機能させる
+    std::error_code ec;
+    std::filesystem::last_write_time(
+        file, std::filesystem::file_time_type::clock::now(), ec);
+
+    auto* data = new uint8_t[buf.size()];
+    std::memcpy(data, buf.data(), buf.size());
+    return new v8::ScriptCompiler::CachedData(
+        data, static_cast<int>(buf.size()),
+        v8::ScriptCompiler::CachedData::BufferOwned);
+}
+
+inline void Store(const std::string& name, const std::string& source,
+                  const v8::ScriptCompiler::CachedData* data)
+{
+    if (!data || !data->data || data->length <= 0) {
+        return;
+    }
+    const std::filesystem::path file = CacheFileFor(name, source);
+    if (file.empty()) {
+        return;
+    }
+    std::ofstream ofs(file, std::ios::binary | std::ios::trunc);
+    if (ofs) {
+        ofs.write(reinterpret_cast<const char*>(data->data), data->length);
+    }
+}
+
+// classic script をキャッシュ込みでコンパイルする。
+// - キャッシュ有り: kConsumeCodeCache で消費 (V8 が reject したら作り直して保存)
+// - キャッシュ無し: kEagerCompile で全関数を一括コンパイルして保存
+//   (初回はその分遅いが、以降の起動は lazy compile も含めて丸ごと省ける)
+// - 対象外サイズ: 従来どおりの lazy コンパイル
+inline v8::MaybeLocal<v8::Script> Compile(v8::Local<v8::Context> ctx,
+                                          v8::Local<v8::String> src,
+                                          v8::ScriptOrigin& origin,
+                                          const std::string& name,
+                                          const std::string& source_str)
+{
+    if (!Eligible(source_str)) {
+        v8::ScriptCompiler::Source source(src, origin);
+        return v8::ScriptCompiler::Compile(ctx, &source);
+    }
+
+    if (v8::ScriptCompiler::CachedData* cached = Load(name, source_str)) {
+        v8::ScriptCompiler::Source source(src, origin, cached);
+        v8::Local<v8::Script> script;
+        if (!v8::ScriptCompiler::Compile(
+                ctx, &source, v8::ScriptCompiler::kConsumeCodeCache).ToLocal(&script)) {
+            return {};
+        }
+        if (source.GetCachedData() && source.GetCachedData()->rejected) {
+            std::unique_ptr<v8::ScriptCompiler::CachedData> fresh(
+                v8::ScriptCompiler::CreateCodeCache(script->GetUnboundScript()));
+            Store(name, source_str, fresh.get());
+        }
+        return script;
+    }
+
+    v8::ScriptCompiler::Source source(src, origin);
+    v8::Local<v8::Script> script;
+    if (!v8::ScriptCompiler::Compile(
+            ctx, &source, v8::ScriptCompiler::kEagerCompile).ToLocal(&script)) {
+        return {};
+    }
+    std::unique_ptr<v8::ScriptCompiler::CachedData> fresh(
+        v8::ScriptCompiler::CreateCodeCache(script->GetUnboundScript()));
+    Store(name, source_str, fresh.get());
+    return script;
+}
+
+// ES module 版。規約は Compile と同じ。
+inline v8::MaybeLocal<v8::Module> CompileModule(v8::Isolate* isolate,
+                                                v8::Local<v8::String> src,
+                                                v8::ScriptOrigin& origin,
+                                                const std::string& name,
+                                                const std::string& source_str)
+{
+    if (!Eligible(source_str)) {
+        v8::ScriptCompiler::Source source(src, origin);
+        return v8::ScriptCompiler::CompileModule(isolate, &source);
+    }
+
+    if (v8::ScriptCompiler::CachedData* cached = Load(name, source_str)) {
+        v8::ScriptCompiler::Source source(src, origin, cached);
+        v8::Local<v8::Module> module;
+        if (!v8::ScriptCompiler::CompileModule(
+                isolate, &source, v8::ScriptCompiler::kConsumeCodeCache).ToLocal(&module)) {
+            return {};
+        }
+        if (source.GetCachedData() && source.GetCachedData()->rejected) {
+            std::unique_ptr<v8::ScriptCompiler::CachedData> fresh(
+                v8::ScriptCompiler::CreateCodeCache(module->GetUnboundModuleScript()));
+            Store(name, source_str, fresh.get());
+        }
+        return module;
+    }
+
+    v8::ScriptCompiler::Source source(src, origin);
+    v8::Local<v8::Module> module;
+    if (!v8::ScriptCompiler::CompileModule(
+            isolate, &source, v8::ScriptCompiler::kEagerCompile).ToLocal(&module)) {
+        return {};
+    }
+    std::unique_ptr<v8::ScriptCompiler::CachedData> fresh(
+        v8::ScriptCompiler::CreateCodeCache(module->GetUnboundModuleScript()));
+    Store(name, source_str, fresh.get());
+    return module;
+}
+
+} // namespace next2d::codecache

package/templates/xbox/src/v8/V8Runtime.cpp

@@ -1,7 +1,9 @@
 #include "V8Runtime.h"
 
 #include "V8Util.h"
+#include "CodeCache.h"
 #include "HostContext.h"
+#include "EmbeddedAssets.h"
 #include "bindings/Bindings.h"
 
 #include <filesystem>
@@ -46,7 +48,14 @@ void V8Runtime::InitializeProcess(const char* exec_path)
     // - JS: --jitless (Ignition インタプリタのみ・RWX ページ無し)
     // - WebAssembly: --wasm-jitless (DrumBrake = V8 の wasm インタープリタ。
     //   prebuilt V8 r2 は v8_enable_drumbrake=true でビルドされている)
-    v8::V8::SetFlagsFromString("--jitless --wasm-jitless");
+    // - --no-flush-bytecode: V8 は既定でしばらく実行されない関数のバイトコードを
+    //   破棄し、次回実行時に再パースする (メモリ最適化)。ゲームでは画面遷移で
+    //   久々に呼ばれる関数の再パースがフレームヒッチになるため無効化する
+    //   (ゲームバンドル数 MB 程度ならバイトコード常駐のメモリ増は許容範囲)。
+    // 注: PC ビルドも意図的に jitless で統一する。コンソール実機の性能を PC 検証で
+    //     忠実に再現するため (PC だけ JIT で速くするとレギュレーション下の実機で
+    //     性能問題が再発する)。
+    v8::V8::SetFlagsFromString("--jitless --wasm-jitless --no-flush-bytecode");
 
     v8::V8::InitializeICUDefaultLocation(exec_path);
     v8::V8::InitializeExternalStartupData(exec_path);
@@ -79,6 +88,14 @@ bool V8Runtime::Initialize(HostContext* host)
     create_params_.array_buffer_allocator =
         v8::ArrayBuffer::Allocator::NewDefaultAllocator();
 
+    // 60fps のゲームはフレーム毎に短命オブジェクト (ディスクリプタ/一時配列) を
+    // 大量生成する。young generation を既定 (十数 MB) から 64MB へ拡大して
+    // scavenge (minor GC) の頻度を下げ、マイクロヒッチを減らす。
+    // scavenge の停止時間は生存オブジェクト量に比例し空間サイズには比例しないため、
+    // 拡大はほぼ純粋に頻度低減として効く。
+    create_params_.constraints.set_max_young_generation_size_in_bytes(
+        64 * 1024 * 1024);
+
     isolate_ = v8::Isolate::New(create_params_);
     isolate_->SetData(kHostContextSlot, host);
     isolate_->SetData(kRuntimeSlot, this);
@@ -162,8 +179,9 @@ bool V8Runtime::RunScript(const std::string& source, const std::string& name)
     v8::ScriptOrigin origin(v8util::Str(isolate_, name));
     v8::Local<v8::String> src = v8util::Str(isolate_, source);
 
+    // バイトコードキャッシュ込みでコンパイル (2回目以降の起動でパースを省略)
     v8::Local<v8::Script> script;
-    if (!v8::Script::Compile(ctx, src, &origin).ToLocal(&script)) {
+    if (!codecache::Compile(ctx, src, origin, name, source).ToLocal(&script)) {
         ReportException(&try_catch);
         return false;
     }
@@ -188,35 +206,17 @@ v8::MaybeLocal<v8::Module> V8Runtime::LoadModule(const std::string& path,
         return cached->second.Get(isolate_);
     }
 
-    std::string source = ReadTextFile(abs);
-    if (source.empty() && !fs::exists(abs)) {
-        v8util::ThrowTypeError(isolate_, "Module not found: " + abs);
-        return v8::MaybeLocal<v8::Module>();
-    }
-
-    // «診断» Tween(Job) の凍結調査: app.js の Job 更新コードへトレースを注入する。
-    // rAF が 2 本 (ticker + 1 Job) のまま描画が止まる現象の currentTime/duration の
-    // 実値を観測する。パターン不一致なら無変更 (ログのみ)。
-    if (source.find("(e.currentTime=(t-e.startTime)/1e3,") != std::string::npos) {
-        const auto patch = [&source](const std::string& from, const std::string& to) {
-            const auto pos = source.find(from);
-            if (pos != std::string::npos) {
-                source.replace(pos, from.size(), to);
-            } else {
-                std::cerr << "[V8] job trace patch not applied: "
-                          << from.substr(0, 40) << std::endl;
-            }
-        };
-        patch("(e.currentTime=(t-e.startTime)/1e3,",
-              "(e.currentTime=(t-e.startTime)/1e3,"
-              "((globalThis.__jt=(globalThis.__jt||0)+1)<=60||globalThis.__jt%600===0)&&"
-              "console.info(\"[jobtrace] #\"+globalThis.__jt,"
-              "\"ct=\"+e.currentTime.toFixed(3),\"dur=\"+e.duration,"
-              "\"t=\"+t.toFixed(1),\"st=\"+e.startTime.toFixed(1)),");
-        patch("e.currentTime>=e.duration?(",
-              "e.currentTime>=e.duration?("
-              "console.info(\"[jobtrace] COMPLETE dur=\"+e.duration),");
-        std::cerr << "[V8] job trace patch applied to " << abs << std::endl;
+    // 埋め込みモード優先: exe 内に格納された assets/app を先に探す (平文 JS を置かない)。
+    // 埋め込みが無い開発ビルドでは nullptr が返り、従来どおりファイルから読む。
+    std::string source;
+    if (const auto* embedded = GetEmbeddedAssetByAbsPath(abs)) {
+        source.assign(embedded->begin(), embedded->end());
+    } else {
+        source = ReadTextFile(abs);
+        if (source.empty() && !fs::exists(abs)) {
+            v8util::ThrowTypeError(isolate_, "Module not found: " + abs);
+            return v8::MaybeLocal<v8::Module>();
+        }
     }
 
     v8::Local<v8::String> src = v8util::Str(isolate_, source);
@@ -227,9 +227,10 @@ v8::MaybeLocal<v8::Module> V8Runtime::LoadModule(const std::string& path,
         false, false, /*is_module*/ true
     );
 
-    v8::ScriptCompiler::Source compiler_source(src, origin);
+    // バイトコードキャッシュ込みでコンパイル。アプリ本体 (数 MB の ESM バンドル) の
+    // 毎起動フルパースを 2 回目以降省略する (起動時間の主要因)。
     v8::Local<v8::Module> module;
-    if (!v8::ScriptCompiler::CompileModule(isolate_, &compiler_source).ToLocal(&module)) {
+    if (!codecache::CompileModule(isolate_, src, origin, abs, source).ToLocal(&module)) {
         return v8::MaybeLocal<v8::Module>();
     }
 

package/templates/xbox/src/v8/V8Util.h

@@ -3,8 +3,10 @@
 
 #include <v8.h>
 #include <iostream>
+#include <fstream>
 #include <string>
 #include <string_view>
+#include <unordered_map>
 
 namespace next2d::v8util {
 
@@ -17,6 +19,32 @@ inline v8::Local<v8::String> Str(v8::Isolate* isolate, std::string_view s)
     ).ToLocalChecked();
 }
 
+// プロパティ名 v8::String のキャッシュ。
+// バインディングのディスクリプタ解析 (webgpu::Prop/HasProp/U32 等) は毎フレーム
+// 数千回呼ばれ、その度に NewFromUtf8 が JS ヒープ確保 + ハッシュ計算をしていた。
+// internalized string (isolate 内で重複排除され、プロパティ検索がポインタ比較で済む)
+// を v8::Eternal で保持し、2 回目以降はハッシュマップ参照のみにする。
+// jitless では JS↔C++ 境界のコストが相対的に重いため、ここの削減が全体に効く。
+// キーは内容比較 (std::string) なので呼び出し元がリテラル以外を渡しても安全。
+// ホストは単一 Isolate 運用 (worker も同一 Isolate の別 Context) だが、
+// 念のため isolate が変わったらキャッシュを破棄する (Eternal は isolate 寿命に紐づく)。
+inline v8::Local<v8::String> PropName(v8::Isolate* isolate, const char* key)
+{
+    static v8::Isolate* cached_isolate = nullptr;
+    static std::unordered_map<std::string, v8::Eternal<v8::String>> cache;
+    if (cached_isolate != isolate) {
+        cache.clear();
+        cached_isolate = isolate;
+    }
+    auto it = cache.find(key);
+    if (it == cache.end()) {
+        v8::Local<v8::String> s = v8::String::NewFromUtf8(
+            isolate, key, v8::NewStringType::kInternalized).ToLocalChecked();
+        it = cache.emplace(key, v8::Eternal<v8::String>(isolate, s)).first;
+    }
+    return it->second.Get(isolate);
+}
+
 // v8::Value -> std::string (UTF-8)
 inline std::string ToStdString(v8::Isolate* isolate, v8::Local<v8::Value> value)
 {
@@ -58,6 +86,23 @@ inline void ThrowTypeError(v8::Isolate* isolate, std::string_view message)
 // rAF / タイマー / onmessage / イベントリスナーのコールバックは TryCatch で
 // 保護されるが、報告しないと例外が無音で消えて原因究明が不可能になる
 // (レンダラ worker が毎フレーム throw していても黒画面にしか見えない)。
+// 例外を stderr に加えてログファイルにも残す。GUI 実行(ダブルクリック)では stderr が
+// 捨てられて例外が見えないため、rAF/タイマー/リスナーで無音死する不具合(例: Tween の
+// rAF チェーンが UPDATE リスナの throw で再登録されず停止)を実行後に追跡できるように
+// する。暴走ログ防止に先頭 200 件までに制限。ファイルは実行ディレクトリの next2d-error.log。
+inline void AppendErrorLog(const std::string& line)
+{
+    static int written = 0;
+    if (written >= 200) {
+        return;
+    }
+    ++written;
+    std::ofstream ofs("next2d-error.log", std::ios::app);
+    if (ofs) {
+        ofs << line << std::endl;
+    }
+}
+
 inline void ReportCaught(v8::Isolate* isolate, v8::TryCatch* tc, const char* where)
 {
     if (!tc->HasCaught()) {
@@ -66,19 +111,24 @@ inline void ReportCaught(v8::Isolate* isolate, v8::TryCatch* tc, const char* whe
     v8::HandleScope hs(isolate);
     v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
     const std::string text = ToStdString(isolate, tc->Exception());
-    std::cerr << "[JS] exception in " << where << ": " << text << std::endl;
+    const std::string head = std::string("[JS] exception in ") + where + ": " + text;
+    std::cerr << head << std::endl;
+    AppendErrorLog(head);
     v8::Local<v8::Value> stack;
     if (!ctx.IsEmpty() && tc->StackTrace(ctx).ToLocal(&stack)) {
         const std::string s = ToStdString(isolate, stack);
         if (!s.empty() && s != text) {
             std::cerr << s << std::endl;
+            AppendErrorLog(s);
         }
     }
     v8::Local<v8::Message> message = tc->Message();
     if (!message.IsEmpty() && !ctx.IsEmpty()) {
-        std::cerr << "  at "
-                  << ToStdString(isolate, message->GetScriptOrigin().ResourceName())
-                  << ":" << message->GetLineNumber(ctx).FromMaybe(0) << std::endl;
+        const std::string loc = std::string("  at ")
+            + ToStdString(isolate, message->GetScriptOrigin().ResourceName())
+            + ":" + std::to_string(message->GetLineNumber(ctx).FromMaybe(0));
+        std::cerr << loc << std::endl;
+        AppendErrorLog(loc);
     }
 }