@next2d/builder 0.1.7 → 0.1.10

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

@@ -7,6 +7,7 @@
 #include <cctype>
 #include <cmath>
 #include <cstdint>
+#include <memory>
 #include <string>
 #include <utility>
 #include <vector>
@@ -26,10 +27,18 @@ struct SubPath {
 
 struct RGBA { uint8_t r=0,g=0,b=0,a=255; };
 
-// クリップ矩形 (デバイス座標, [x0,x1) x [y0,y1))。active=false なら無制限。
+// クリップ領域 (デバイス座標)。
+//   active=false          … 無制限
+//   active=true, mask=null … 矩形クリップ [x0,x1) x [y0,y1) (厳密)
+//   mask!=null            … 任意形状クリップ。x0..y1 は外接矩形 (高速リジェクト用)、
+//                            mask は surface と同寸のカバレッジ (1=内側/0=外側)。
+// mask は shared_ptr のため save()/restore() の state コピーで安価に共有される
+// (clip() は既存 mask を破壊せず新しい mask を割り当てるので復元が壊れない)。
 struct ClipRect {
     bool   active = false;
     double x0 = 0, y0 = 0, x1 = 0, y1 = 0;
+    std::shared_ptr<const std::vector<uint8_t>> mask;
+    int mask_w = 0, mask_h = 0;
 };
 
 // RGBA8 のピクセルバッファ。
@@ -101,6 +110,9 @@ inline void Blend(Surface& s, const ClipRect& clip, int x, int y, const RGBA& co
 {
     if (x < 0 || y < 0 || x >= s.width || y >= s.height) return;
     if (clip.active && (x < clip.x0 || x >= clip.x1 || y < clip.y0 || y >= clip.y1)) return;
+    // 任意形状クリップ: マスクの外なら書き込まない。
+    if (clip.mask && (x >= clip.mask_w || y >= clip.mask_h ||
+                      (*clip.mask)[static_cast<size_t>(y) * clip.mask_w + x] == 0)) return;
     size_t i = (static_cast<size_t>(y) * s.width + x) * 4;
     double a = (col.a / 255.0) * alpha;
     s.pixels[i+0] = static_cast<uint8_t>(col.r * a + s.pixels[i+0] * (1 - a));
@@ -215,6 +227,98 @@ inline void IntersectClip(ClipRect& clip, double nx0, double ny0, double nx1, do
     }
 }
 
+// パスが単一の軸並行矩形か判定する (矩形なら外接矩形クリップで厳密に足りる)。
+// beginPath→rect() は 4 or 5 点 (閉路点重複) の矩形サブパスになる。
+inline bool IsAxisAlignedRect(const std::vector<SubPath>& path)
+{
+    if (path.size() != 1) return false;
+    const std::vector<Point>& p = path[0].pts;
+    // 末尾が始点と重複する 5 点表現も許容する
+    size_t n = p.size();
+    if (n == 5 && std::abs(p[4].x - p[0].x) < 1e-6 && std::abs(p[4].y - p[0].y) < 1e-6) {
+        n = 4;
+    }
+    if (n != 4) return false;
+    // 各辺が水平または垂直であること
+    for (size_t i = 0; i < 4; ++i) {
+        const Point& a = p[i];
+        const Point& b = p[(i + 1) % 4];
+        const bool horizontal = std::abs(a.y - b.y) < 1e-6;
+        const bool vertical   = std::abs(a.x - b.x) < 1e-6;
+        if (!horizontal && !vertical) return false;
+    }
+    return true;
+}
+
+// パスを nonzero winding でカバレッジマスク (surface 同寸, 1=内側) にラスタライズする。
+// スキャンライン規約は FillPath と一致させる (塗りと同じ形にクリップされる)。
+inline std::shared_ptr<std::vector<uint8_t>> RasterizePathMask(
+    const std::vector<SubPath>& path, int width, int height)
+{
+    auto mask = std::make_shared<std::vector<uint8_t>>(
+        static_cast<size_t>(width) * height, 0);
+    if (width <= 0 || height <= 0) return mask;
+
+    double miny = 1e18, maxy = -1e18;
+    for (auto& sp : path) for (auto& p : sp.pts) { miny = std::min(miny,p.y); maxy = std::max(maxy,p.y); }
+    if (maxy < miny) return mask;
+    int y0 = std::max(0, static_cast<int>(std::floor(miny)));
+    int y1 = std::min(height - 1, static_cast<int>(std::ceil(maxy)));
+    for (int y = y0; y <= y1; ++y) {
+        double sy = y + 0.5;
+        std::vector<std::pair<double,int>> xs;
+        for (auto& sp : path) {
+            size_t n = sp.pts.size();
+            if (n < 2) continue;
+            for (size_t i = 0; i < n; ++i) {
+                Point a = sp.pts[i];
+                Point b = sp.pts[(i+1) % n];
+                if ((a.y <= sy && b.y > sy) || (b.y <= sy && a.y > sy)) {
+                    double t = (sy - a.y) / (b.y - a.y);
+                    xs.push_back({a.x + t * (b.x - a.x), a.y < b.y ? 1 : -1});
+                }
+            }
+        }
+        std::sort(xs.begin(), xs.end());
+        int wind = 0;
+        for (size_t i = 0; i + 1 < xs.size(); ++i) {
+            wind += xs[i].second;
+            if (wind != 0) {
+                int xa = std::max(0, static_cast<int>(std::floor(xs[i].first)));
+                int xb = std::min(width - 1, static_cast<int>(std::ceil(xs[i+1].first)));
+                for (int x = xa; x <= xb; ++x) {
+                    (*mask)[static_cast<size_t>(y) * width + x] = 1;
+                }
+            }
+        }
+    }
+    return mask;
+}
+
+// 任意形状パスをクリップへ積集合で反映する (非矩形 clip() の実体)。
+// 外接矩形 (高速リジェクト) も同時に反映し、既存 mask があれば AND を取って
+// 新しい mask を割り当てる (save/restore 安全)。
+inline void IntersectClipMask(ClipRect& clip, const std::vector<SubPath>& path,
+                              int width, int height)
+{
+    double minx, miny, maxx, maxy;
+    if (PathBounds(path, &minx, &miny, &maxx, &maxy)) {
+        IntersectClip(clip, std::floor(minx), std::floor(miny),
+                      std::ceil(maxx), std::ceil(maxy));
+    }
+    auto next = RasterizePathMask(path, width, height);
+    if (clip.mask) {
+        const std::vector<uint8_t>& prev = *clip.mask;
+        const size_t n = std::min(next->size(), prev.size());
+        for (size_t i = 0; i < n; ++i) {
+            if (prev[i] == 0) { (*next)[i] = 0; }
+        }
+    }
+    clip.mask = next;
+    clip.mask_w = width;
+    clip.mask_h = height;
+}
+
 // 3次ベジェを現在サブパスへフラット化して追記する。p0 は変換済みの直前点。
 inline void FlattenCubic(std::vector<Point>& out,
                          Point p0, Point p1, Point p2, Point p3, int steps = 16)

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

@@ -13,6 +13,15 @@
 #include "ImageSource.h"
 #include "EventTarget.h"
 #include "v8/V8Util.h"
+#include "v8/WeakHandle.h"
+
+#include <string>
+#include <vector>
+
+// Media Foundation はコンソール (Game Core OS) に無いデスクトップ専用 API。
+// コンソールでは動画デコード未対応 (末尾の «CONSOLE» スタブ)。
+// 実機での動画対応は devkit 段階の課題。
+#if !NEXT2D_XBOX_CONSOLE
 
 #include <mfapi.h>
 #include <mfidl.h>
@@ -20,9 +29,6 @@
 #include <shlwapi.h>
 #include <wrl/client.h>
 
-#include <string>
-#include <vector>
-
 #pragma comment(lib, "mfplat.lib")
 #pragma comment(lib, "mfreadwrite.lib")
 #pragma comment(lib, "mfuuid.lib")
@@ -47,6 +53,24 @@ struct VideoDecoder {
     bool playing = false;
     bool ended = false;
     double duration = 0.0;
+    double position = 0.0;        // 現在位置 (秒, サンプルタイムスタンプ由来)
+
+    // 先頭 (または指定秒) へシークする。loop 再生と currentTime 設定で使用。
+    bool Seek(double seconds)
+    {
+        if (!reader) return false;
+        PROPVARIANT var;
+        PropVariantInit(&var);
+        var.vt = VT_I8;
+        var.hVal.QuadPart = static_cast<LONGLONG>(seconds * 1e7);   // s -> 100ns
+        const bool ok = SUCCEEDED(reader->SetCurrentPosition(GUID_NULL, var));
+        PropVariantClear(&var);
+        if (ok) {
+            ended = false;
+            position = seconds;
+        }
+        return ok;
+    }
 
     bool Open(const std::vector<uint8_t>& bytes)
     {
@@ -87,13 +111,15 @@ struct VideoDecoder {
     {
         if (!reader) return false;
         DWORD flags = 0;
+        LONGLONG timestamp = 0;
         ComPtr<IMFSample> sample;
         if (FAILED(reader->ReadSample(MF_SOURCE_READER_FIRST_VIDEO_STREAM, 0,
-                                      nullptr, &flags, nullptr, &sample))) {
+                                      nullptr, &flags, &timestamp, &sample))) {
             return false;
         }
         if (flags & MF_SOURCE_READERF_ENDOFSTREAM) { ended = true; return false; }
         if (!sample) return false;
+        position = static_cast<double>(timestamp) / 1e7;   // 100ns -> s
 
         ComPtr<IMFMediaBuffer> buffer;
         sample->ConvertToContiguousBuffer(&buffer);
@@ -112,8 +138,6 @@ struct VideoDecoder {
     }
 };
 
-void ReleaseVideo(const v8::WeakCallbackInfo<VideoDecoder>& info) { delete info.GetParameter(); }
-
 VideoDecoder* Decoder(v8::Local<v8::Object> obj)
 {
     return static_cast<VideoDecoder*>(obj->GetInternalField(0).As<v8::External>()->Value());
@@ -144,7 +168,10 @@ void LoadVideo(v8::Isolate* isolate, v8::Local<v8::Object> self, const std::stri
         SetValue(isolate, self, "videoHeight", v8::Integer::NewFromUnsigned(isolate, dec->height));
         SetValue(isolate, self, "duration", v8::Number::New(isolate, dec->duration));
         SetValue(isolate, self, "readyState", v8::Integer::New(isolate, 4));
+        // player は loadedmetadata / progress / canplaythrough を購読する
+        // (VideoRegisterEventUseCase)。ローカル読み込みは即完了のため順に発火する。
         FireVideoEvent(isolate, self, "loadedmetadata");
+        FireVideoEvent(isolate, self, "progress");
         FireVideoEvent(isolate, self, "canplaythrough");
     } else {
         FireVideoEvent(isolate, self, "error");
@@ -162,7 +189,20 @@ bool GetVideoFramePixels(v8::Isolate* isolate, v8::Local<v8::Object> obj,
     if (dec->playing && !dec->ended) {
         dec->ReadNextFrame();  // 描画のたびに次フレームへ進める(簡易フレーム進行)
         if (dec->ended) {
-            FireVideoEvent(isolate, obj, "ended");
+            // loop 指定時は先頭へ戻して継続、そうでなければ ended を通知
+            v8::Local<v8::Value> loop_v;
+            const bool loop =
+                obj->Get(isolate->GetCurrentContext(),
+                         v8util::Str(isolate, "loop")).ToLocal(&loop_v) &&
+                loop_v->BooleanValue(isolate);
+            if (loop && dec->Seek(0.0)) {
+                dec->ReadNextFrame();
+            } else {
+                dec->playing = false;
+                SetValue(isolate, obj, "ended", v8::Boolean::New(isolate, true));
+                SetValue(isolate, obj, "paused", v8::Boolean::New(isolate, true));
+                FireVideoEvent(isolate, obj, "ended");
+            }
         }
     }
     *out_rgba = dec->frame.data();
@@ -180,19 +220,69 @@ v8::Local<v8::Object> CreateVideoElement(v8::Isolate* isolate, HostContext* /*ho
 
     auto* dec = new VideoDecoder();
     self->SetInternalField(0, v8::External::New(isolate, dec));
-    auto* handle = new v8::Global<v8::Object>(isolate, self);
-    handle->SetWeak(dec, ReleaseVideo, v8::WeakCallbackType::kParameter);
+    v8util::AttachWeak(isolate, self, dec);
 
     SetValue(isolate, self, "__isVideoElement", v8::Boolean::New(isolate, true));
     SetValue(isolate, self, "tagName", Str(isolate, "VIDEO"));
     SetValue(isolate, self, "videoWidth", v8::Integer::New(isolate, 0));
     SetValue(isolate, self, "videoHeight", v8::Integer::New(isolate, 0));
-    SetValue(isolate, self, "currentTime", v8::Number::New(isolate, 0));
     SetValue(isolate, self, "readyState", v8::Integer::New(isolate, 0));
     SetValue(isolate, self, "loop", v8::Boolean::New(isolate, false));
+    SetValue(isolate, self, "paused", v8::Boolean::New(isolate, true));
+    SetValue(isolate, self, "ended", v8::Boolean::New(isolate, false));
+    SetValue(isolate, self, "muted", v8::Boolean::New(isolate, false));
+    SetValue(isolate, self, "volume", v8::Number::New(isolate, 1.0));
+    SetValue(isolate, self, "autoplay", v8::Boolean::New(isolate, false));
     SetValue(isolate, self, "style", v8::Object::New(isolate));
     InstallEventTarget(isolate, self);
 
+    // currentTime: 取得はデコーダの現在位置、設定はシーク
+    self->SetNativeDataProperty(ctx, Str(isolate, "currentTime"),
+        [](v8::Local<v8::Name>, const v8::PropertyCallbackInfo<v8::Value>& info) {
+            VideoDecoder* d = Decoder(info.This());
+            info.GetReturnValue().Set(
+                v8::Number::New(info.GetIsolate(), d ? d->position : 0.0));
+        },
+        [](v8::Local<v8::Name>, v8::Local<v8::Value> value,
+           const v8::PropertyCallbackInfo<void>& info) {
+            if (!value->IsNumber()) return;
+            VideoDecoder* d = Decoder(info.This());
+            if (d) {
+                d->Seek(value.As<v8::Number>()->Value());
+            }
+        }).Check();
+
+    // setAttribute / getAttribute (player は playsinline を設定する)
+    SetMethod(isolate, self, "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);
+                SetValue(iso, a.This(), "__attrs", store);
+            }
+            store->Set(c, a[0], a[1]).Check();
+        });
+    SetMethod(isolate, self, "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);
+                }
+            }
+        });
+
     // src セッター: 代入で読み込み開始
     self->SetNativeDataProperty(ctx, Str(isolate, "src"),
         [](v8::Local<v8::Name>, const v8::PropertyCallbackInfo<v8::Value>& info) {
@@ -218,12 +308,16 @@ v8::Local<v8::Object> CreateVideoElement(v8::Isolate* isolate, HostContext* /*ho
     SetMethod(isolate, self, "play", [](const v8::FunctionCallbackInfo<v8::Value>& a) {
         v8::Isolate* iso = a.GetIsolate();
         Decoder(a.This())->playing = true;
+        SetValue(iso, a.This(), "paused", v8::Boolean::New(iso, false));
+        SetValue(iso, a.This(), "ended", v8::Boolean::New(iso, false));
         auto r = v8::Promise::Resolver::New(iso->GetCurrentContext()).ToLocalChecked();
         r->Resolve(iso->GetCurrentContext(), v8::Undefined(iso)).Check();
         a.GetReturnValue().Set(r->GetPromise());
     });
     SetMethod(isolate, self, "pause", [](const v8::FunctionCallbackInfo<v8::Value>& a) {
+        v8::Isolate* iso = a.GetIsolate();
         Decoder(a.This())->playing = false;
+        SetValue(iso, a.This(), "paused", v8::Boolean::New(iso, true));
     });
     SetMethod(isolate, self, "canPlayType", [](const v8::FunctionCallbackInfo<v8::Value>& a) {
         a.GetReturnValue().Set(Str(a.GetIsolate(), "maybe"));
@@ -233,3 +327,52 @@ v8::Local<v8::Object> CreateVideoElement(v8::Isolate* isolate, HostContext* /*ho
 }
 
 } // namespace next2d
+
+#else // NEXT2D_XBOX_CONSOLE
+
+// «CONSOLE» 動画デコード未対応スタブ。
+// createElement('video') がクラッシュしないよう API 形状だけ提供する
+// (フレーム取得は常に false、canPlayType は空 = 非対応を正しく通知)。
+namespace next2d {
+
+using v8util::Str;
+using v8util::SetMethod;
+using v8util::SetValue;
+
+bool GetVideoFramePixels(v8::Isolate*, v8::Local<v8::Object>,
+                         const uint8_t** out_rgba, uint32_t* out_width, uint32_t* out_height)
+{
+    *out_rgba = nullptr;
+    *out_width = 0;
+    *out_height = 0;
+    return false;
+}
+
+v8::Local<v8::Object> CreateVideoElement(v8::Isolate* isolate, HostContext* /*host*/)
+{
+    v8::Local<v8::Object> self = v8::Object::New(isolate);
+    SetValue(isolate, self, "__isVideoElement", v8::Boolean::New(isolate, true));
+    SetValue(isolate, self, "tagName", Str(isolate, "VIDEO"));
+    SetValue(isolate, self, "localName", Str(isolate, "video"));
+    SetValue(isolate, self, "videoWidth", v8::Integer::New(isolate, 0));
+    SetValue(isolate, self, "videoHeight", v8::Integer::New(isolate, 0));
+    SetValue(isolate, self, "paused", v8::Boolean::New(isolate, true));
+    SetValue(isolate, self, "ended", v8::Boolean::New(isolate, false));
+    InstallEventTarget(isolate, self);
+    SetMethod(isolate, self, "load", [](const v8::FunctionCallbackInfo<v8::Value>&) {});
+    SetMethod(isolate, self, "play", [](const v8::FunctionCallbackInfo<v8::Value>& a) {
+        v8::Isolate* iso = a.GetIsolate();
+        auto r = v8::Promise::Resolver::New(iso->GetCurrentContext()).ToLocalChecked();
+        r->Resolve(iso->GetCurrentContext(), v8::Undefined(iso)).Check();
+        a.GetReturnValue().Set(r->GetPromise());
+    });
+    SetMethod(isolate, self, "pause", [](const v8::FunctionCallbackInfo<v8::Value>&) {});
+    SetMethod(isolate, self, "canPlayType", [](const v8::FunctionCallbackInfo<v8::Value>& a) {
+        a.GetReturnValue().Set(Str(a.GetIsolate(), ""));
+    });
+    return self;
+}
+
+} // namespace next2d
+
+#endif // !NEXT2D_XBOX_CONSOLE