@next2d/builder 0.1.4 → 0.1.6

package/templates/xbox/src/bindings/webgpu/WebGPUCommon.h

@@ -0,0 +1,119 @@
+// WebGPU バインディング共通基盤。
+//
+// wgpu:: (Dawn C++) ハンドルを V8 オブジェクトへラップする汎用機構と、
+// JS ディスクリプタ(プレーンオブジェクト)を wgpu 構造体へ変換するヘルパーを提供する。
+//
+// 【重要・実装範囲について】
+// WebGPU の IDL 全面(約40型・数百メソッド・全ディスクリプタ)を手書きするのは膨大なため、
+// 本バインディングは Next2D の WebGPU レンダラが使用するコア経路
+// (adapter/device/queue/buffer/texture/sampler/shader/bindGroup(Layout)/
+//  pipelineLayout/renderPipeline/commandEncoder/renderPass/canvasContext) を実装する。
+// 追加のメソッド/ディスクリプタ項目は各 Create* 付近の «EXTEND» コメントに沿って拡張する。
+#pragma once
+
+#include <webgpu/webgpu_cpp.h>
+#include <v8.h>
+
+#include "v8/V8Util.h"
+
+#include <memory>
+#include <string>
+
+namespace next2d::webgpu {
+
+// wgpu ハンドルの寿命を JS オブジェクトに紐づけるためのホルダ。
+template <typename T>
+struct Holder {
+    T handle;
+};
+
+template <typename T>
+void ReleaseHolder(const v8::WeakCallbackInfo<Holder<T>>& info)
+{
+    delete info.GetParameter();
+}
+
+// wgpu ハンドル T を、指定 ObjectTemplate から生成したオブジェクトにラップする。
+template <typename T>
+v8::Local<v8::Object> Wrap(v8::Isolate* isolate,
+                           v8::Local<v8::ObjectTemplate> tmpl,
+                           T handle)
+{
+    v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
+    v8::Local<v8::Object> obj = tmpl->NewInstance(ctx).ToLocalChecked();
+    auto* holder = new Holder<T>{std::move(handle)};
+    obj->SetInternalField(0, v8::External::New(isolate, holder));
+    auto* global = new v8::Global<v8::Object>(isolate, obj);
+    global->SetWeak(holder, ReleaseHolder<T>, v8::WeakCallbackType::kParameter);
+    return obj;
+}
+
+// ラップされたオブジェクトから wgpu ハンドルを取り出す。
+template <typename T>
+T& Unwrap(v8::Local<v8::Object> obj)
+{
+    auto* holder = static_cast<Holder<T>*>(
+        obj->GetInternalField(0).As<v8::External>()->Value());
+    return holder->handle;
+}
+
+// 内部フィールド 1 個の ObjectTemplate を作る。
+inline v8::Local<v8::ObjectTemplate> HandleTemplate(v8::Isolate* isolate)
+{
+    v8::Local<v8::ObjectTemplate> tmpl = v8::ObjectTemplate::New(isolate);
+    tmpl->SetInternalFieldCount(1);
+    return tmpl;
+}
+
+// --- JS オブジェクト読み取りヘルパー ------------------------------------
+inline v8::Local<v8::Value> Prop(v8::Isolate* isolate, v8::Local<v8::Object> obj,
+                                 const char* key)
+{
+    v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
+    v8::Local<v8::Value> v;
+    if (obj->Get(ctx, v8util::Str(isolate, key)).ToLocal(&v)) {
+        return v;
+    }
+    return v8::Undefined(isolate);
+}
+
+inline bool HasProp(v8::Isolate* isolate, v8::Local<v8::Object> obj, const char* key)
+{
+    v8::Local<v8::Value> v = Prop(isolate, obj, key);
+    return !v->IsUndefined() && !v->IsNull();
+}
+
+inline uint32_t U32(v8::Isolate* isolate, v8::Local<v8::Object> obj,
+                    const char* key, uint32_t fallback = 0)
+{
+    v8::Local<v8::Value> v = Prop(isolate, obj, key);
+    return v->IsNumber() ? static_cast<uint32_t>(v.As<v8::Number>()->Value()) : fallback;
+}
+
+inline uint64_t U64(v8::Isolate* isolate, v8::Local<v8::Object> obj,
+                    const char* key, uint64_t fallback = 0)
+{
+    v8::Local<v8::Value> v = Prop(isolate, obj, key);
+    return v->IsNumber() ? static_cast<uint64_t>(v.As<v8::Number>()->Value()) : fallback;
+}
+
+inline double F64(v8::Isolate* isolate, v8::Local<v8::Object> obj,
+                  const char* key, double fallback = 0.0)
+{
+    v8::Local<v8::Value> v = Prop(isolate, obj, key);
+    return v->IsNumber() ? v.As<v8::Number>()->Value() : fallback;
+}
+
+inline bool Bool(v8::Isolate* isolate, v8::Local<v8::Object> obj,
+                 const char* key, bool fallback = false)
+{
+    v8::Local<v8::Value> v = Prop(isolate, obj, key);
+    return v->IsBoolean() ? v.As<v8::Boolean>()->Value() : fallback;
+}
+
+inline std::string Str(v8::Isolate* isolate, v8::Local<v8::Object> obj, const char* key)
+{
+    return v8util::ToStdString(isolate, Prop(isolate, obj, key));
+}
+
+} // namespace next2d::webgpu

package/templates/xbox/src/bindings/webgpu/WebGPUEnums.h

@@ -0,0 +1,245 @@
+// WebGPU の文字列 enum を wgpu:: enum へ変換するヘルパー。
+// 2D レンダラ(Next2D)が使用する頻出値を網羅する。未知値は既定へフォールバックする。
+// «EXTEND» 追加フォーマット/enum が必要な場合はここに追記する。
+#pragma once
+
+#include <webgpu/webgpu_cpp.h>
+#include <string>
+#include <string_view>
+
+namespace next2d::webgpu {
+
+inline wgpu::TextureFormat ToTextureFormat(std::string_view s)
+{
+    using F = wgpu::TextureFormat;
+    if (s == "rgba8unorm")            return F::RGBA8Unorm;
+    if (s == "rgba8unorm-srgb")       return F::RGBA8UnormSrgb;
+    if (s == "bgra8unorm")            return F::BGRA8Unorm;
+    if (s == "bgra8unorm-srgb")       return F::BGRA8UnormSrgb;
+    if (s == "rgba8snorm")            return F::RGBA8Snorm;
+    if (s == "r8unorm")               return F::R8Unorm;
+    if (s == "rg8unorm")              return F::RG8Unorm;
+    if (s == "r16float")              return F::R16Float;
+    if (s == "rg16float")             return F::RG16Float;
+    if (s == "rgba16float")           return F::RGBA16Float;
+    if (s == "r32float")              return F::R32Float;
+    if (s == "rg32float")             return F::RG32Float;
+    if (s == "rgba32float")           return F::RGBA32Float;
+    if (s == "depth16unorm")          return F::Depth16Unorm;
+    if (s == "depth24plus")           return F::Depth24Plus;
+    if (s == "depth24plus-stencil8")  return F::Depth24PlusStencil8;
+    if (s == "depth32float")          return F::Depth32Float;
+    if (s == "stencil8")              return F::Stencil8;
+    return F::RGBA8Unorm;
+}
+
+inline wgpu::VertexFormat ToVertexFormat(std::string_view s)
+{
+    using V = wgpu::VertexFormat;
+    if (s == "float32")    return V::Float32;
+    if (s == "float32x2")  return V::Float32x2;
+    if (s == "float32x3")  return V::Float32x3;
+    if (s == "float32x4")  return V::Float32x4;
+    if (s == "uint32")     return V::Uint32;
+    if (s == "uint32x2")   return V::Uint32x2;
+    if (s == "uint32x3")   return V::Uint32x3;
+    if (s == "uint32x4")   return V::Uint32x4;
+    if (s == "sint32")     return V::Sint32;
+    if (s == "sint32x2")   return V::Sint32x2;
+    if (s == "uint8x2")    return V::Uint8x2;
+    if (s == "uint8x4")    return V::Uint8x4;
+    if (s == "unorm8x2")   return V::Unorm8x2;
+    if (s == "unorm8x4")   return V::Unorm8x4;
+    if (s == "uint16x2")   return V::Uint16x2;
+    if (s == "uint16x4")   return V::Uint16x4;
+    if (s == "unorm16x2")  return V::Unorm16x2;
+    if (s == "unorm16x4")  return V::Unorm16x4;
+    if (s == "float16x2")  return V::Float16x2;
+    if (s == "float16x4")  return V::Float16x4;
+    return V::Float32;
+}
+
+inline wgpu::PrimitiveTopology ToTopology(std::string_view s)
+{
+    using T = wgpu::PrimitiveTopology;
+    if (s == "point-list")     return T::PointList;
+    if (s == "line-list")      return T::LineList;
+    if (s == "line-strip")     return T::LineStrip;
+    if (s == "triangle-list")  return T::TriangleList;
+    if (s == "triangle-strip") return T::TriangleStrip;
+    return T::TriangleList;
+}
+
+inline wgpu::IndexFormat ToIndexFormat(std::string_view s)
+{
+    if (s == "uint16") return wgpu::IndexFormat::Uint16;
+    if (s == "uint32") return wgpu::IndexFormat::Uint32;
+    return wgpu::IndexFormat::Undefined;
+}
+
+inline wgpu::BlendFactor ToBlendFactor(std::string_view s)
+{
+    using B = wgpu::BlendFactor;
+    if (s == "zero")                return B::Zero;
+    if (s == "one")                 return B::One;
+    if (s == "src")                 return B::Src;
+    if (s == "one-minus-src")       return B::OneMinusSrc;
+    if (s == "src-alpha")           return B::SrcAlpha;
+    if (s == "one-minus-src-alpha") return B::OneMinusSrcAlpha;
+    if (s == "dst")                 return B::Dst;
+    if (s == "one-minus-dst")       return B::OneMinusDst;
+    if (s == "dst-alpha")           return B::DstAlpha;
+    if (s == "one-minus-dst-alpha") return B::OneMinusDstAlpha;
+    if (s == "src-alpha-saturated") return B::SrcAlphaSaturated;
+    if (s == "constant")            return B::Constant;
+    if (s == "one-minus-constant")  return B::OneMinusConstant;
+    return B::One;
+}
+
+inline wgpu::BlendOperation ToBlendOperation(std::string_view s)
+{
+    using O = wgpu::BlendOperation;
+    if (s == "add")              return O::Add;
+    if (s == "subtract")         return O::Subtract;
+    if (s == "reverse-subtract") return O::ReverseSubtract;
+    if (s == "min")              return O::Min;
+    if (s == "max")              return O::Max;
+    return O::Add;
+}
+
+inline wgpu::LoadOp ToLoadOp(std::string_view s)
+{
+    if (s == "load")  return wgpu::LoadOp::Load;
+    if (s == "clear") return wgpu::LoadOp::Clear;
+    return wgpu::LoadOp::Clear;
+}
+
+inline wgpu::StoreOp ToStoreOp(std::string_view s)
+{
+    if (s == "store")   return wgpu::StoreOp::Store;
+    if (s == "discard") return wgpu::StoreOp::Discard;
+    return wgpu::StoreOp::Store;
+}
+
+inline wgpu::CompareFunction ToCompareFunction(std::string_view s)
+{
+    using C = wgpu::CompareFunction;
+    if (s == "never")         return C::Never;
+    if (s == "less")          return C::Less;
+    if (s == "equal")         return C::Equal;
+    if (s == "less-equal")    return C::LessEqual;
+    if (s == "greater")       return C::Greater;
+    if (s == "not-equal")     return C::NotEqual;
+    if (s == "greater-equal") return C::GreaterEqual;
+    if (s == "always")        return C::Always;
+    return C::Always;
+}
+
+inline wgpu::StencilOperation ToStencilOperation(std::string_view s)
+{
+    using O = wgpu::StencilOperation;
+    if (s == "keep")            return O::Keep;
+    if (s == "zero")            return O::Zero;
+    if (s == "replace")         return O::Replace;
+    if (s == "invert")          return O::Invert;
+    if (s == "increment-clamp") return O::IncrementClamp;
+    if (s == "decrement-clamp") return O::DecrementClamp;
+    if (s == "increment-wrap")  return O::IncrementWrap;
+    if (s == "decrement-wrap")  return O::DecrementWrap;
+    return O::Keep;
+}
+
+inline wgpu::CullMode ToCullMode(std::string_view s)
+{
+    if (s == "none")  return wgpu::CullMode::None;
+    if (s == "front") return wgpu::CullMode::Front;
+    if (s == "back")  return wgpu::CullMode::Back;
+    return wgpu::CullMode::None;
+}
+
+inline wgpu::FrontFace ToFrontFace(std::string_view s)
+{
+    if (s == "ccw") return wgpu::FrontFace::CCW;
+    if (s == "cw")  return wgpu::FrontFace::CW;
+    return wgpu::FrontFace::CCW;
+}
+
+inline wgpu::AddressMode ToAddressMode(std::string_view s)
+{
+    if (s == "clamp-to-edge") return wgpu::AddressMode::ClampToEdge;
+    if (s == "repeat")        return wgpu::AddressMode::Repeat;
+    if (s == "mirror-repeat") return wgpu::AddressMode::MirrorRepeat;
+    return wgpu::AddressMode::ClampToEdge;
+}
+
+inline wgpu::FilterMode ToFilterMode(std::string_view s)
+{
+    if (s == "nearest") return wgpu::FilterMode::Nearest;
+    if (s == "linear")  return wgpu::FilterMode::Linear;
+    return wgpu::FilterMode::Nearest;
+}
+
+inline wgpu::MipmapFilterMode ToMipmapFilterMode(std::string_view s)
+{
+    if (s == "nearest") return wgpu::MipmapFilterMode::Nearest;
+    if (s == "linear")  return wgpu::MipmapFilterMode::Linear;
+    return wgpu::MipmapFilterMode::Nearest;
+}
+
+inline wgpu::VertexStepMode ToStepMode(std::string_view s)
+{
+    if (s == "vertex")   return wgpu::VertexStepMode::Vertex;
+    if (s == "instance") return wgpu::VertexStepMode::Instance;
+    return wgpu::VertexStepMode::Vertex;
+}
+
+inline wgpu::TextureDimension ToTextureDimension(std::string_view s)
+{
+    if (s == "1d") return wgpu::TextureDimension::e1D;
+    if (s == "2d") return wgpu::TextureDimension::e2D;
+    if (s == "3d") return wgpu::TextureDimension::e3D;
+    return wgpu::TextureDimension::e2D;
+}
+
+inline wgpu::TextureViewDimension ToTextureViewDimension(std::string_view s)
+{
+    using D = wgpu::TextureViewDimension;
+    if (s == "1d")         return D::e1D;
+    if (s == "2d")         return D::e2D;
+    if (s == "2d-array")   return D::e2DArray;
+    if (s == "cube")       return D::Cube;
+    if (s == "cube-array") return D::CubeArray;
+    if (s == "3d")         return D::e3D;
+    return D::Undefined;
+}
+
+inline wgpu::BufferBindingType ToBufferBindingType(std::string_view s)
+{
+    using B = wgpu::BufferBindingType;
+    if (s == "uniform")           return B::Uniform;
+    if (s == "storage")           return B::Storage;
+    if (s == "read-only-storage") return B::ReadOnlyStorage;
+    return B::Uniform;
+}
+
+inline wgpu::SamplerBindingType ToSamplerBindingType(std::string_view s)
+{
+    using S = wgpu::SamplerBindingType;
+    if (s == "filtering")     return S::Filtering;
+    if (s == "non-filtering") return S::NonFiltering;
+    if (s == "comparison")    return S::Comparison;
+    return S::Filtering;
+}
+
+inline wgpu::TextureSampleType ToTextureSampleType(std::string_view s)
+{
+    using T = wgpu::TextureSampleType;
+    if (s == "float")               return T::Float;
+    if (s == "unfilterable-float")  return T::UnfilterableFloat;
+    if (s == "depth")               return T::Depth;
+    if (s == "sint")                return T::Sint;
+    if (s == "uint")                return T::Uint;
+    return T::Float;
+}
+
+} // namespace next2d::webgpu

package/templates/xbox/src/gpu/DawnContext.cpp

@@ -0,0 +1,170 @@
+#include "DawnContext.h"
+
+#include <Windows.h>
+#include <dawn/native/DawnNative.h>
+#include <iostream>
+
+namespace next2d {
+
+namespace {
+
+void HandleDeviceLost(const wgpu::Device&, wgpu::DeviceLostReason reason, wgpu::StringView message)
+{
+    std::cerr << "[Dawn] Device lost (" << static_cast<int>(reason) << "): "
+              << std::string(message.data, message.length) << std::endl;
+}
+
+void HandleUncapturedError(const wgpu::Device&, wgpu::ErrorType type, wgpu::StringView message)
+{
+    std::cerr << "[Dawn] Uncaptured error (" << static_cast<int>(type) << "): "
+              << std::string(message.data, message.length) << std::endl;
+}
+
+} // namespace
+
+DawnContext::~DawnContext() = default;
+
+bool DawnContext::Initialize(HWND hwnd, uint32_t width, uint32_t height)
+{
+    hwnd_   = hwnd;
+    width_  = width;
+    height_ = height;
+
+    // タイムドウェイト非依存のコールバックを扱えるよう ProcessEvents を有効化
+    wgpu::InstanceDescriptor instance_desc = {};
+    static const wgpu::InstanceFeatureName kFeatures[] = {
+        wgpu::InstanceFeatureName::TimedWaitAny,
+    };
+    instance_desc.requiredFeatureCount = 1;
+    instance_desc.requiredFeatures = kFeatures;
+
+    instance_ = wgpu::CreateInstance(&instance_desc);
+    if (!instance_) {
+        std::cerr << "[Dawn] Failed to create instance" << std::endl;
+        return false;
+    }
+
+    // HWND から surface を生成 (D3D12)
+    wgpu::SurfaceSourceWindowsHWND hwnd_source = {};
+    hwnd_source.hinstance = GetModuleHandle(nullptr);
+    hwnd_source.hwnd = hwnd_;
+
+    wgpu::SurfaceDescriptor surface_desc = {};
+    surface_desc.nextInChain = &hwnd_source;
+
+    surface_ = instance_.CreateSurface(&surface_desc);
+    if (!surface_) {
+        std::cerr << "[Dawn] Failed to create surface" << std::endl;
+        return false;
+    }
+
+    return true;
+}
+
+bool DawnContext::AcquireDevice()
+{
+    if (device_) {
+        return true;
+    }
+
+    // Adapter を要求 (D3D12 / HighPerformance)
+    wgpu::RequestAdapterOptions adapter_opts = {};
+    adapter_opts.backendType = wgpu::BackendType::D3D12;
+    adapter_opts.powerPreference = wgpu::PowerPreference::HighPerformance;
+    adapter_opts.compatibleSurface = surface_;
+
+    wgpu::Future adapter_future = instance_.RequestAdapter(
+        &adapter_opts,
+        wgpu::CallbackMode::AllowProcessEvents,
+        [this](wgpu::RequestAdapterStatus status, wgpu::Adapter adapter,
+               wgpu::StringView message) {
+            if (status != wgpu::RequestAdapterStatus::Success) {
+                std::cerr << "[Dawn] RequestAdapter failed: "
+                          << std::string(message.data, message.length) << std::endl;
+                return;
+            }
+            adapter_ = std::move(adapter);
+        });
+
+    instance_.WaitAny(adapter_future, UINT64_MAX);
+    if (!adapter_) {
+        return false;
+    }
+
+    // Device を要求
+    wgpu::DeviceDescriptor device_desc = {};
+    device_desc.SetDeviceLostCallback(wgpu::CallbackMode::AllowProcessEvents, HandleDeviceLost);
+    device_desc.SetUncapturedErrorCallback(HandleUncapturedError);
+
+    wgpu::Future device_future = adapter_.RequestDevice(
+        &device_desc,
+        wgpu::CallbackMode::AllowProcessEvents,
+        [this](wgpu::RequestDeviceStatus status, wgpu::Device device,
+               wgpu::StringView message) {
+            if (status != wgpu::RequestDeviceStatus::Success) {
+                std::cerr << "[Dawn] RequestDevice failed: "
+                          << std::string(message.data, message.length) << std::endl;
+                return;
+            }
+            device_ = std::move(device);
+        });
+
+    instance_.WaitAny(device_future, UINT64_MAX);
+    if (!device_) {
+        return false;
+    }
+
+    // surface の優先フォーマットを取得
+    wgpu::SurfaceCapabilities caps = {};
+    surface_.GetCapabilities(adapter_, &caps);
+    if (caps.formatCount > 0) {
+        format_ = caps.formats[0];
+    }
+
+    Configure(width_, height_);
+    return true;
+}
+
+void DawnContext::Configure(uint32_t width, uint32_t height)
+{
+    if (!device_ || width == 0 || height == 0) {
+        return;
+    }
+
+    width_  = width;
+    height_ = height;
+
+    wgpu::SurfaceConfiguration config = {};
+    config.device      = device_;
+    config.format      = format_;
+    config.usage       = wgpu::TextureUsage::RenderAttachment;
+    config.width       = width_;
+    config.height      = height_;
+    config.presentMode = wgpu::PresentMode::Fifo;
+    config.alphaMode   = wgpu::CompositeAlphaMode::Opaque;
+
+    surface_.Configure(&config);
+}
+
+wgpu::Texture DawnContext::GetCurrentTexture()
+{
+    wgpu::SurfaceTexture surface_texture = {};
+    surface_.GetCurrentTexture(&surface_texture);
+    return surface_texture.texture;
+}
+
+void DawnContext::Present()
+{
+    if (surface_) {
+        surface_.Present();
+    }
+}
+
+void DawnContext::Tick()
+{
+    if (instance_) {
+        instance_.ProcessEvents();
+    }
+}
+
+} // namespace next2d

package/templates/xbox/src/gpu/DawnContext.h

@@ -0,0 +1,64 @@
+// DawnContext: Dawn(WebGPU) の Instance / Adapter / Device / Surface を管理する。
+//
+// GDK ウィンドウ(HWND) から D3D12 バックエンドの surface を生成し、
+// スワップチェーンとして提示する。JS 側の navigator.gpu / canvas.getContext('webgpu')
+// はこのコンテキストが保持する Device / Surface を参照する。
+#pragma once
+
+#include <webgpu/webgpu_cpp.h>
+
+#include <cstdint>
+#include <functional>
+
+struct HWND__;
+using HWND = HWND__*;
+
+namespace next2d {
+
+class DawnContext {
+public:
+    DawnContext() = default;
+    ~DawnContext();
+
+    // Instance と HWND 由来 surface を生成する。
+    bool Initialize(HWND hwnd, uint32_t width, uint32_t height);
+
+    // Adapter/Device を同期的に取得する (内部で ProcessEvents をポンプして待つ)。
+    // navigator.gpu.requestAdapter/requestDevice からも利用する。
+    bool AcquireDevice();
+
+    // surface をデバイスに紐付けて構成する (canvas サイズ変更時に再呼び出し)。
+    void Configure(uint32_t width, uint32_t height);
+
+    // 今フレームのバックバッファテクスチャを取得する。
+    wgpu::Texture GetCurrentTexture();
+
+    // 提示する。
+    void Present();
+
+    // Dawn の非同期イベント(コールバック)を進める。毎フレーム呼ぶ。
+    void Tick();
+
+    const wgpu::Instance& instance() const { return instance_; }
+    const wgpu::Adapter&  adapter()  const { return adapter_; }
+    const wgpu::Device&   device()   const { return device_; }
+    const wgpu::Surface&  surface()  const { return surface_; }
+    wgpu::TextureFormat   format()   const { return format_; }
+
+    uint32_t width()  const { return width_; }
+    uint32_t height() const { return height_; }
+    bool ready() const { return device_ != nullptr; }
+
+private:
+    wgpu::Instance instance_ = nullptr;
+    wgpu::Adapter  adapter_  = nullptr;
+    wgpu::Device   device_   = nullptr;
+    wgpu::Surface  surface_  = nullptr;
+    wgpu::TextureFormat format_ = wgpu::TextureFormat::BGRA8Unorm;
+
+    HWND     hwnd_   = nullptr;
+    uint32_t width_  = 0;
+    uint32_t height_ = 0;
+};
+
+} // namespace next2d