@eva/plugin-renderer-scene-capture 2.1.0-beta.14

package/dist/plugin-renderer-scene-capture.d.ts

@@ -0,0 +1,152 @@
+import { Component } from '@eva/eva.js';
+import type { ComponentChanged } from '@eva/eva.js';
+import { ContainerManager } from '@eva/plugin-renderer';
+import { Renderer } from '@eva/plugin-renderer';
+import { RendererSystem } from '@eva/plugin-renderer';
+import { Texture } from 'pixi.js';
+import type { UpdateParams } from '@eva/eva.js';
+
+/** Get a live Pixi Texture produced by a SceneCapture `output` key. */
+export declare function getSceneCaptureTexture(output: string): Texture | undefined;
+
+/**
+ * Captures named live Eva renderer containers into an offscreen Pixi RenderTexture.
+ *
+ * Requires SceneCaptureSystem plus RendererSystem from @eva/plugin-renderer. Source
+ * names are resolved at capture time, so late-created reflection proxy entities work
+ * without rebinding. The component only stores serializable configuration; the Pixi
+ * target and presentation lifecycle are owned by SceneCaptureSystem.
+ *
+ * @example
+ * ```ts
+ * reflectionRoot.addComponent(new SceneCapture({
+ *   sourceNames: ['building-reflection', 'actor-reflection'],
+ *   output: 'rain-reflection',
+ *   width: 750,
+ *   height: 420,
+ *   resolutionScale: 0.5,
+ *   updateMode: 'always',
+ *   clearAlpha: 0,
+ * }));
+ * ```
+ */
+export declare class SceneCapture extends Component<SceneCaptureParams> {
+    static componentName: string;
+    sourceNames: string[];
+    output: string;
+    width: number;
+    height: number;
+    resolutionScale: number;
+    updateMode: SceneCaptureUpdateMode;
+    clearColor: number;
+    clearAlpha: number;
+    enabled: boolean;
+    /** Monotonic runtime invalidation sequence consumed by SceneCaptureSystem. */
+    captureRevision: number;
+    init(params?: SceneCaptureParams): void;
+    /** Mark this target dirty; manual targets capture on the next presentation frame. */
+    requestCapture(): void;
+    private normalizeUpdateMode;
+}
+
+/** Serializable configuration for a live SceneCapture target. */
+export declare interface SceneCaptureParams {
+    /** Names of live GameObjects whose renderer containers are captured in order. */
+    sourceNames?: string[];
+    /** Public registry key used to obtain the resulting Pixi Texture. */
+    output?: string;
+    /** Logical target width in Eva design units. */
+    width?: number;
+    /** Logical target height in Eva design units. */
+    height?: number;
+    /** Pixi RenderTexture resolution multiplier. Defaults to 1. */
+    resolutionScale?: number;
+    /** Capture policy. `manual` runs only after requestCapture(). */
+    updateMode?: SceneCaptureUpdateMode;
+    /** RGB clear color expressed as 0xRRGGBB. */
+    clearColor?: number;
+    /** Clear alpha in the inclusive 0..1 range. */
+    clearAlpha?: number;
+    /** Stops writes while preserving the last captured texture. */
+    enabled?: boolean;
+}
+
+/**
+ * Renders named live Eva containers into transparent offscreen Pixi textures.
+ *
+ * The system registers a presentation participant scoped to the root RendererSystem
+ * application. This makes each capture finish before the application performs its
+ * final main-stage render. It never reparents source containers and explicitly
+ * rejects the main Pixi stage as a capture source.
+ */
+export declare class SceneCaptureSystem extends Renderer {
+    static systemName: string;
+    name: string;
+    /** Let a newly-added target become available during a zero-simulation presentation frame. */
+    readonly presentationAddFlushEnabled = true;
+    private readonly records;
+    private readonly outputs;
+    private readonly emptyCaptureRoot;
+    private readonly participantId;
+    private presentationHandle?;
+    private destroyed;
+    renderSystem: RendererSystem;
+    containerManager: ContainerManager;
+    init(): void;
+    update(time?: UpdateParams): void;
+    /** Compatibility fallback for hosts that have not yet exposed presentation participants. */
+    lateUpdate(): void;
+    componentChanged(changed: ComponentChanged): void;
+    /** Return this system's texture for an output key without relying on global state. */
+    getTexture(output: string): Texture | undefined;
+    onDestroy(): void;
+    private addRecord;
+    private createTexture;
+    private widthOf;
+    private heightOf;
+    private resolutionOf;
+    private resizeRecord;
+    private updateOutput;
+    private bindOutput;
+    private unbindOutput;
+    private disposeRecord;
+    private ensurePresentationParticipant;
+    private hasLivePresentationParticipant;
+    /** Executes synchronously inside the renderer's presentation phase. */
+    private captureForApplication;
+    private shouldCapture;
+    private captureRecord;
+    private resolveSourceContainers;
+    private toClearColor;
+}
+
+/** A registry entry is valid until its owning SceneCapture record is disposed. */
+export declare interface SceneCaptureTextureEntry {
+    readonly output: string;
+    readonly owner: object;
+    readonly texture: Texture;
+}
+
+/**
+ * Public, owner-aware lookup table for live SceneCapture outputs.
+ *
+ * A later capture may intentionally replace the same key. Disposal is guarded by
+ * owner identity so removing an older component cannot erase the newer texture.
+ */
+export declare class SceneCaptureTextureRegistry {
+    private readonly entries;
+    get(output: string): Texture | undefined;
+    getEntry(output: string): SceneCaptureTextureEntry | undefined;
+    has(output: string): boolean;
+    set(output: string, owner: object, texture: Texture): void;
+    delete(output: string, owner?: object): boolean;
+    private normalize;
+}
+
+/** Shared lookup table for shader/filter consumers that do not own the capture system. */
+export declare const sceneCaptureTextureRegistry: SceneCaptureTextureRegistry;
+
+/** Controls when a SceneCapture writes its output texture. */
+export declare type SceneCaptureUpdateMode = 'always' | 'onDirty' | 'manual';
+
+export { }

package/dist/plugin-renderer-scene-capture.esm.js

@@ -0,0 +1,542 @@
+import { Component, OBSERVER_TYPE, decorators } from '@eva/eva.js';
+import { type } from '@eva/inspector-decorator';
+import { Renderer, RendererSystem } from '@eva/plugin-renderer';
+import { Container, RenderTexture } from 'pixi.js';
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+const finitePositive$1 = (value, fallback) => {
+    const numberValue = Number(value);
+    return Number.isFinite(numberValue) && numberValue > 0 ? numberValue : fallback;
+};
+const clamp = (value, min, max, fallback) => {
+    const numberValue = Number(value);
+    if (!Number.isFinite(numberValue))
+        return fallback;
+    return Math.min(max, Math.max(min, numberValue));
+};
+/**
+ * Captures named live Eva renderer containers into an offscreen Pixi RenderTexture.
+ *
+ * Requires SceneCaptureSystem plus RendererSystem from @eva/plugin-renderer. Source
+ * names are resolved at capture time, so late-created reflection proxy entities work
+ * without rebinding. The component only stores serializable configuration; the Pixi
+ * target and presentation lifecycle are owned by SceneCaptureSystem.
+ *
+ * @example
+ * ```ts
+ * reflectionRoot.addComponent(new SceneCapture({
+ *   sourceNames: ['building-reflection', 'actor-reflection'],
+ *   output: 'rain-reflection',
+ *   width: 750,
+ *   height: 420,
+ *   resolutionScale: 0.5,
+ *   updateMode: 'always',
+ *   clearAlpha: 0,
+ * }));
+ * ```
+ */
+class SceneCapture extends Component {
+    constructor() {
+        super(...arguments);
+        this.sourceNames = [];
+        this.output = '';
+        this.width = 256;
+        this.height = 256;
+        this.resolutionScale = 1;
+        this.updateMode = 'always';
+        this.clearColor = 0x000000;
+        this.clearAlpha = 0;
+        this.enabled = true;
+        /** Monotonic runtime invalidation sequence consumed by SceneCaptureSystem. */
+        this.captureRevision = 0;
+    }
+    init(params) {
+        if (params)
+            Object.assign(this, params);
+        this.sourceNames = Array.isArray(this.sourceNames)
+            ? this.sourceNames.filter(name => typeof name === 'string' && name.trim().length > 0)
+            : [];
+        this.output = typeof this.output === 'string' ? this.output.trim() : '';
+        this.width = finitePositive$1(this.width, 256);
+        this.height = finitePositive$1(this.height, 256);
+        this.resolutionScale = finitePositive$1(this.resolutionScale, 1);
+        this.updateMode = this.normalizeUpdateMode(this.updateMode);
+        this.clearColor = Math.max(0, Math.min(0xffffff, Number(this.clearColor) || 0)) >>> 0;
+        this.clearAlpha = clamp(this.clearAlpha, 0, 1, 0);
+        this.enabled = this.enabled !== false;
+    }
+    /** Mark this target dirty; manual targets capture on the next presentation frame. */
+    requestCapture() {
+        this.captureRevision++;
+        this.emit('captureRequested', { revision: this.captureRevision });
+    }
+    normalizeUpdateMode(value) {
+        return value === 'onDirty' || value === 'manual' ? value : 'always';
+    }
+}
+SceneCapture.componentName = 'SceneCapture';
+__decorate([
+    type('array'),
+    __metadata("design:type", Array)
+], SceneCapture.prototype, "sourceNames", void 0);
+__decorate([
+    type('string'),
+    __metadata("design:type", String)
+], SceneCapture.prototype, "output", void 0);
+__decorate([
+    type('number'),
+    __metadata("design:type", Number)
+], SceneCapture.prototype, "width", void 0);
+__decorate([
+    type('number'),
+    __metadata("design:type", Number)
+], SceneCapture.prototype, "height", void 0);
+__decorate([
+    type('number'),
+    __metadata("design:type", Number)
+], SceneCapture.prototype, "resolutionScale", void 0);
+__decorate([
+    type('string'),
+    __metadata("design:type", String)
+], SceneCapture.prototype, "updateMode", void 0);
+__decorate([
+    type('number'),
+    __metadata("design:type", Number)
+], SceneCapture.prototype, "clearColor", void 0);
+__decorate([
+    type('number'),
+    __metadata("design:type", Number)
+], SceneCapture.prototype, "clearAlpha", void 0);
+__decorate([
+    type('boolean'),
+    __metadata("design:type", Boolean)
+], SceneCapture.prototype, "enabled", void 0);
+__decorate([
+    type('number'),
+    __metadata("design:type", Number)
+], SceneCapture.prototype, "captureRevision", void 0);
+
+/**
+ * Public, owner-aware lookup table for live SceneCapture outputs.
+ *
+ * A later capture may intentionally replace the same key. Disposal is guarded by
+ * owner identity so removing an older component cannot erase the newer texture.
+ */
+class SceneCaptureTextureRegistry {
+    constructor() {
+        this.entries = new Map();
+    }
+    get(output) {
+        var _a;
+        return (_a = this.entries.get(this.normalize(output))) === null || _a === void 0 ? void 0 : _a.texture;
+    }
+    getEntry(output) {
+        return this.entries.get(this.normalize(output));
+    }
+    has(output) {
+        return this.entries.has(this.normalize(output));
+    }
+    set(output, owner, texture) {
+        const key = this.normalize(output);
+        if (!key || !owner || !texture)
+            return;
+        this.entries.set(key, Object.freeze({ output: key, owner, texture }));
+    }
+    delete(output, owner) {
+        const key = this.normalize(output);
+        const entry = this.entries.get(key);
+        if (!entry || (owner && entry.owner !== owner))
+            return false;
+        return this.entries.delete(key);
+    }
+    normalize(output) {
+        return typeof output === 'string' ? output.trim() : '';
+    }
+}
+/** Shared lookup table for shader/filter consumers that do not own the capture system. */
+const sceneCaptureTextureRegistry = new SceneCaptureTextureRegistry();
+/** Get a live Pixi Texture produced by a SceneCapture `output` key. */
+function getSceneCaptureTexture(output) {
+    return sceneCaptureTextureRegistry.get(output);
+}
+
+let nextSystemId = 0;
+const finitePositive = (value, fallback) => {
+    const numberValue = Number(value);
+    return Number.isFinite(numberValue) && numberValue > 0 ? numberValue : fallback;
+};
+const clampAlpha = (value) => {
+    const numberValue = Number(value);
+    if (!Number.isFinite(numberValue))
+        return 0;
+    return Math.max(0, Math.min(1, numberValue));
+};
+const normalizedOutput = (value) => (typeof value === 'string' ? value.trim() : '');
+/**
+ * Renders named live Eva containers into transparent offscreen Pixi textures.
+ *
+ * The system registers a presentation participant scoped to the root RendererSystem
+ * application. This makes each capture finish before the application performs its
+ * final main-stage render. It never reparents source containers and explicitly
+ * rejects the main Pixi stage as a capture source.
+ */
+let SceneCaptureSystem = class SceneCaptureSystem extends Renderer {
+    constructor() {
+        super(...arguments);
+        this.name = 'SceneCapture';
+        /** Let a newly-added target become available during a zero-simulation presentation frame. */
+        this.presentationAddFlushEnabled = true;
+        this.records = new Map();
+        this.outputs = new Map();
+        this.emptyCaptureRoot = new Container();
+        this.participantId = `scene-capture:${++nextSystemId}`;
+        this.destroyed = false;
+    }
+    init() {
+        this.renderSystem = this.game.getSystem(RendererSystem);
+        if (!this.renderSystem) {
+            throw new Error('[SceneCapture] RendererSystem must be registered before SceneCaptureSystem.');
+        }
+        this.renderSystem.rendererManager.register(this);
+        this.ensurePresentationParticipant();
+    }
+    update(time) {
+        super.update(time);
+        this.ensurePresentationParticipant();
+    }
+    /** Compatibility fallback for hosts that have not yet exposed presentation participants. */
+    lateUpdate() {
+        var _a;
+        if (this.hasLivePresentationParticipant())
+            return;
+        const application = (_a = this.renderSystem) === null || _a === void 0 ? void 0 : _a.application;
+        if (application)
+            this.captureForApplication(application);
+    }
+    componentChanged(changed) {
+        if (changed.componentName !== 'SceneCapture')
+            return;
+        const component = changed.component;
+        const gameObjectId = changed.gameObject.id;
+        if (changed.type === OBSERVER_TYPE.ADD) {
+            this.addRecord(gameObjectId, component);
+            return;
+        }
+        if (changed.type === OBSERVER_TYPE.REMOVE) {
+            const record = this.records.get(gameObjectId);
+            if (record)
+                this.disposeRecord(record);
+            return;
+        }
+        const record = this.records.get(gameObjectId);
+        if (!record)
+            return;
+        record.component = component;
+        this.resizeRecord(record);
+        this.updateOutput(record);
+        // `manual` remains explicitly controlled by requestCapture(). `onDirty`
+        // invalidates for every declarative configuration/source change.
+        if (component.updateMode !== 'manual')
+            record.dirty = true;
+        if (component.captureRevision !== record.lastCaptureRevision)
+            record.dirty = true;
+    }
+    /** Return this system's texture for an output key without relying on global state. */
+    getTexture(output) {
+        var _a;
+        return (_a = this.outputs.get(normalizedOutput(output))) === null || _a === void 0 ? void 0 : _a.texture;
+    }
+    onDestroy() {
+        var _a;
+        this.destroyed = true;
+        (_a = this.presentationHandle) === null || _a === void 0 ? void 0 : _a.dispose();
+        this.presentationHandle = undefined;
+        for (const record of Array.from(this.records.values()))
+            this.disposeRecord(record);
+        try {
+            this.emptyCaptureRoot.destroy({ children: false });
+        }
+        catch (_b) {
+            // Renderer-adapter mocks and already-destroyed Pixi roots can reject cleanup.
+        }
+    }
+    addRecord(gameObjectId, component) {
+        const existing = this.records.get(gameObjectId);
+        if (existing)
+            this.disposeRecord(existing);
+        const record = {};
+        const owner = record;
+        Object.assign(record, {
+            owner,
+            gameObjectId,
+            component,
+            texture: this.createTexture(component),
+            output: normalizedOutput(component.output),
+            width: this.widthOf(component),
+            height: this.heightOf(component),
+            resolutionScale: this.resolutionOf(component),
+            dirty: component.updateMode !== 'manual' || component.captureRevision > 0,
+            lastCaptureRevision: 0,
+            disposed: false,
+            onCaptureRequested: () => {
+                if (!record.disposed)
+                    record.dirty = true;
+            },
+        });
+        component.on('captureRequested', record.onCaptureRequested);
+        this.records.set(gameObjectId, record);
+        this.bindOutput(record);
+    }
+    createTexture(component) {
+        return RenderTexture.create({
+            width: this.widthOf(component),
+            height: this.heightOf(component),
+            resolution: this.resolutionOf(component),
+        });
+    }
+    widthOf(component) {
+        return finitePositive(component.width, 256);
+    }
+    heightOf(component) {
+        return finitePositive(component.height, 256);
+    }
+    resolutionOf(component) {
+        return finitePositive(component.resolutionScale, 1);
+    }
+    resizeRecord(record) {
+        const width = this.widthOf(record.component);
+        const height = this.heightOf(record.component);
+        const resolutionScale = this.resolutionOf(record.component);
+        if (record.width === width && record.height === height && record.resolutionScale === resolutionScale)
+            return;
+        record.width = width;
+        record.height = height;
+        record.resolutionScale = resolutionScale;
+        const texture = record.texture;
+        if (typeof texture.resize === 'function') {
+            texture.resize(width, height, resolutionScale);
+            return;
+        }
+        const previous = record.texture;
+        record.texture = this.createTexture(record.component);
+        this.bindOutput(record);
+        try {
+            previous.destroy(true);
+        }
+        catch (_a) {
+            // The old output is already detached from registry ownership.
+        }
+    }
+    updateOutput(record) {
+        const nextOutput = normalizedOutput(record.component.output);
+        if (record.output === nextOutput)
+            return;
+        this.unbindOutput(record);
+        record.output = nextOutput;
+        this.bindOutput(record);
+    }
+    bindOutput(record) {
+        if (!record.output)
+            return;
+        this.outputs.set(record.output, record);
+        sceneCaptureTextureRegistry.set(record.output, record.owner, record.texture);
+    }
+    unbindOutput(record) {
+        if (!record.output)
+            return;
+        if (this.outputs.get(record.output) === record)
+            this.outputs.delete(record.output);
+        sceneCaptureTextureRegistry.delete(record.output, record.owner);
+    }
+    disposeRecord(record) {
+        if (record.disposed)
+            return;
+        record.disposed = true;
+        this.records.delete(record.gameObjectId);
+        this.unbindOutput(record);
+        try {
+            record.component.off('captureRequested', record.onCaptureRequested);
+        }
+        catch (_a) {
+            // Component could have been fully torn down by a synchronous game destroy.
+        }
+        try {
+            record.texture.destroy(true);
+        }
+        catch (_b) {
+            // A renderer teardown may have destroyed its GPU texture first.
+        }
+    }
+    ensurePresentationParticipant() {
+        var _a;
+        if (this.destroyed || this.hasLivePresentationParticipant())
+            return;
+        const renderer = this.renderSystem;
+        if (!(renderer === null || renderer === void 0 ? void 0 : renderer.application) || typeof renderer.registerPresentationParticipant !== 'function')
+            return;
+        const applicationId = (_a = renderer.getPresentationApplicationId) === null || _a === void 0 ? void 0 : _a.call(renderer, renderer.application);
+        let handle;
+        handle = renderer.registerPresentationParticipant({
+            id: this.participantId,
+            applicationId,
+            build: () => ({
+                writes: Array.from(this.outputs.keys(), output => `scene-capture:${output}`),
+            }),
+            submit: (context) => {
+                this.captureForApplication(context.application);
+            },
+            dispose: () => {
+                if (this.presentationHandle === handle)
+                    this.presentationHandle = undefined;
+            },
+        });
+        this.presentationHandle = handle;
+    }
+    hasLivePresentationParticipant() {
+        return Boolean(this.presentationHandle && !this.presentationHandle.disposed);
+    }
+    /** Executes synchronously inside the renderer's presentation phase. */
+    captureForApplication(application) {
+        const renderer = application === null || application === void 0 ? void 0 : application.renderer;
+        if (!(renderer === null || renderer === void 0 ? void 0 : renderer.render))
+            return;
+        for (const record of this.records.values()) {
+            if (!this.shouldCapture(record))
+                continue;
+            if (!this.captureRecord(renderer, application, record))
+                continue;
+            record.dirty = false;
+            record.lastCaptureRevision = record.component.captureRevision;
+        }
+    }
+    shouldCapture(record) {
+        const component = record.component;
+        if (record.disposed || component.enabled === false)
+            return false;
+        if (component.updateMode === 'always')
+            return true;
+        if (component.captureRevision !== record.lastCaptureRevision)
+            record.dirty = true;
+        return record.dirty;
+    }
+    captureRecord(renderer, application, record) {
+        const sources = this.resolveSourceContainers(record.component, application);
+        const clearColor = this.toClearColor(record.component);
+        try {
+            if (sources.length === 0) {
+                renderer.render({
+                    container: this.emptyCaptureRoot,
+                    target: record.texture,
+                    clear: true,
+                    clearColor,
+                });
+                return true;
+            }
+            for (let index = 0; index < sources.length; index++) {
+                const source = sources[index];
+                const options = {
+                    container: source,
+                    target: record.texture,
+                    clear: index === 0,
+                };
+                if (index === 0)
+                    options.clearColor = clearColor;
+                // Passing the current world transform preserves root/parent placement
+                // without reparenting a live container out of the main stage.
+                if (source.worldTransform)
+                    options.transform = source.worldTransform;
+                renderer.render(options);
+            }
+            return true;
+        }
+        catch (_a) {
+            // Keep the record dirty so a transient WebGL/WebGPU target error retries
+            // during a later presentation frame instead of freezing a stale reflection.
+            return false;
+        }
+    }
+    resolveSourceContainers(component, application) {
+        var _a;
+        const sources = [];
+        const sourceNames = Array.isArray(component.sourceNames) ? component.sourceNames : [];
+        const game = this.game;
+        for (const sourceName of sourceNames) {
+            if (!sourceName || typeof (game === null || game === void 0 ? void 0 : game.findAllByName) !== 'function')
+                continue;
+            const gameObjects = game.findAllByName(sourceName);
+            for (const gameObject of gameObjects || []) {
+                if (!gameObject || gameObject.destroyed)
+                    continue;
+                const container = (_a = this.containerManager) === null || _a === void 0 ? void 0 : _a.getContainer(gameObject.id);
+                if (!container ||
+                    container.destroyed ||
+                    container === application.stage ||
+                    container === this.emptyCaptureRoot) {
+                    continue;
+                }
+                if (!sources.includes(container))
+                    sources.push(container);
+            }
+        }
+        return sources;
+    }
+    toClearColor(component) {
+        const color = (Number(component.clearColor) || 0) >>> 0;
+        return [
+            ((color >>> 16) & 0xff) / 255,
+            ((color >>> 8) & 0xff) / 255,
+            (color & 0xff) / 255,
+            clampAlpha(component.clearAlpha),
+        ];
+    }
+};
+SceneCaptureSystem.systemName = 'SceneCapture';
+SceneCaptureSystem = __decorate([
+    decorators.componentObserver({
+        SceneCapture: [
+            { prop: ['sourceNames'], deep: true },
+            { prop: ['output'], deep: false },
+            { prop: ['width'], deep: false },
+            { prop: ['height'], deep: false },
+            { prop: ['resolutionScale'], deep: false },
+            { prop: ['updateMode'], deep: false },
+            { prop: ['clearColor'], deep: false },
+            { prop: ['clearAlpha'], deep: false },
+            { prop: ['enabled'], deep: false },
+            { prop: ['captureRevision'], deep: false },
+        ],
+    })
+], SceneCaptureSystem);
+var SceneCaptureSystem$1 = SceneCaptureSystem;
+
+export { SceneCapture, SceneCaptureSystem$1 as SceneCaptureSystem, SceneCaptureTextureRegistry, getSceneCaptureTexture, sceneCaptureTextureRegistry };

package/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./dist/plugin-renderer-scene-capture.cjs.prod.js')
+} else {
+  module.exports = require('./dist/plugin-renderer-scene-capture.cjs.js')
+}