angular-three-soba 1.14.1 → 2.0.0-beta.10

package/esm2022/misc/decal/decal.mjs

@@ -0,0 +1,187 @@
+import { NgIf } from '@angular/common';
+import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, effect, Input } from '@angular/core';
+import { applyProps, extend, injectNgtRef, is, signalStore, } from 'angular-three';
+import * as THREE from 'three';
+import { AxesHelper, BoxGeometry, Mesh, MeshNormalMaterial } from 'three';
+import { DecalGeometry } from 'three-stdlib';
+import * as i0 from "@angular/core";
+extend({ Mesh, BoxGeometry, MeshNormalMaterial, AxesHelper });
+function vecToArray(vec = [0, 0, 0]) {
+    if (Array.isArray(vec)) {
+        return vec;
+    }
+    if (vec instanceof THREE.Vector3 || vec instanceof THREE.Euler) {
+        return [vec.x, vec.y, vec.z];
+    }
+    return [vec, vec, vec];
+}
+export class NgtsDecal {
+    set _debug(debug) {
+        this.inputs.set({ debug });
+    }
+    set _mesh(mesh) {
+        this.inputs.set({ mesh });
+    }
+    set _position(position) {
+        this.inputs.set({ position });
+    }
+    set _rotation(rotation) {
+        this.inputs.set({ rotation });
+    }
+    set _scale(scale) {
+        this.inputs.set({ scale });
+    }
+    set _map(map) {
+        this.inputs.set({ map });
+    }
+    set _polygonOffsetFactor(polygonOffsetFactor) {
+        this.inputs.set({ polygonOffsetFactor });
+    }
+    set _depthTest(depthTest) {
+        this.inputs.set({ depthTest });
+    }
+    constructor() {
+        this.inputs = signalStore({
+            debug: false,
+            depthTest: false,
+            polygonOffsetFactor: -10,
+            position: [0, 0, 0],
+            rotation: [0, 0, 0],
+            scale: 1,
+        });
+        this.decalRef = injectNgtRef();
+        this.mesh = this.inputs.select('mesh');
+        this.__position = this.inputs.select('position');
+        this.__rotation = this.inputs.select('rotation');
+        this.__scale = this.inputs.select('scale');
+        this.position = computed(() => vecToArray(this.__position()));
+        this.rotation = computed(() => vecToArray(this.__rotation()));
+        this.scale = computed(() => vecToArray(this.__scale()));
+        this.helperRef = injectNgtRef();
+        this.debug = this.inputs.select('debug');
+        this.depthTest = this.inputs.select('depthTest');
+        this.polygonOffsetFactor = this.inputs.select('polygonOffsetFactor');
+        this.map = this.inputs.select('map');
+        this.processDecal();
+    }
+    processDecal() {
+        effect((onCleanup) => {
+            const decal = this.decalRef.nativeElement;
+            if (!decal)
+                return;
+            const [mesh, position, rotation, scale, helper] = [
+                this.mesh(),
+                this.position(),
+                this.rotation(),
+                this.scale(),
+                this.helperRef.nativeElement,
+            ];
+            const parent = mesh ? (is.ref(mesh) ? mesh.nativeElement : mesh) : decal.parent;
+            if (!(parent instanceof Mesh)) {
+                throw new Error('[NGT] ngts-decal must have a ngt-mesh as parent or specify its "mesh" input');
+            }
+            const state = {
+                position: new THREE.Vector3(),
+                rotation: new THREE.Euler(),
+                scale: new THREE.Vector3(1, 1, 1),
+            };
+            if (parent) {
+                applyProps(state, { position, scale });
+                // Zero out the parents matrix world for this operation
+                const matrixWorld = parent.matrixWorld.clone();
+                parent.matrixWorld.identity();
+                if (!rotation || typeof rotation === 'number') {
+                    const o = new THREE.Object3D();
+                    o.position.copy(state.position);
+                    o.lookAt(parent.position);
+                    if (typeof rotation === 'number')
+                        o.rotateZ(rotation);
+                    applyProps(state, { rotation: o.rotation });
+                }
+                else {
+                    applyProps(state, { rotation });
+                }
+                decal.geometry = new DecalGeometry(parent, state.position, state.rotation, state.scale);
+                if (helper) {
+                    applyProps(helper, state);
+                    // Prevent the helpers from blocking rays
+                    helper.traverse((child) => (child.raycast = () => null));
+                }
+                // Reset parents matix-world
+                parent.matrixWorld = matrixWorld;
+                onCleanup(() => {
+                    decal.geometry.dispose();
+                });
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsDecal, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.7", type: NgtsDecal, isStandalone: true, selector: "ngts-decal", inputs: { decalRef: "decalRef", _debug: ["debug", "_debug"], _mesh: ["mesh", "_mesh"], _position: ["position", "_position"], _rotation: ["rotation", "_rotation"], _scale: ["scale", "_scale"], _map: ["map", "_map"], _polygonOffsetFactor: ["polygonOffsetFactor", "_polygonOffsetFactor"], _depthTest: ["depthTest", "_depthTest"] }, ngImport: i0, template: `
+		<ngt-mesh [ref]="decalRef" ngtCompound>
+			<ngt-value [rawValue]="true" attach="material.transparent" />
+			<ngt-value [rawValue]="true" attach="material.polygonOffset" />
+			<ngt-value [rawValue]="polygonOffsetFactor()" attach="material.polygonOffsetFactor" />
+			<ngt-value [rawValue]="depthTest()" attach="material.depthTest" />
+			<ngt-value [rawValue]="map()" attach="material.map" />
+			<ng-content />
+
+			<ngt-mesh *ngIf="debug()" [ref]="helperRef">
+				<ngt-box-geometry />
+				<ngt-mesh-normal-material [wireframe]="true" />
+				<ngt-axes-helper />
+			</ngt-mesh>
+		</ngt-mesh>
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsDecal, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-decal',
+                    standalone: true,
+                    template: `
+		<ngt-mesh [ref]="decalRef" ngtCompound>
+			<ngt-value [rawValue]="true" attach="material.transparent" />
+			<ngt-value [rawValue]="true" attach="material.polygonOffset" />
+			<ngt-value [rawValue]="polygonOffsetFactor()" attach="material.polygonOffsetFactor" />
+			<ngt-value [rawValue]="depthTest()" attach="material.depthTest" />
+			<ngt-value [rawValue]="map()" attach="material.map" />
+			<ng-content />
+
+			<ngt-mesh *ngIf="debug()" [ref]="helperRef">
+				<ngt-box-geometry />
+				<ngt-mesh-normal-material [wireframe]="true" />
+				<ngt-axes-helper />
+			</ngt-mesh>
+		</ngt-mesh>
+	`,
+                    imports: [NgIf],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { decalRef: [{
+                type: Input
+            }], _debug: [{
+                type: Input,
+                args: [{ alias: 'debug' }]
+            }], _mesh: [{
+                type: Input,
+                args: [{ alias: 'mesh' }]
+            }], _position: [{
+                type: Input,
+                args: [{ alias: 'position' }]
+            }], _rotation: [{
+                type: Input,
+                args: [{ alias: 'rotation' }]
+            }], _scale: [{
+                type: Input,
+                args: [{ alias: 'scale' }]
+            }], _map: [{
+                type: Input,
+                args: [{ alias: 'map' }]
+            }], _polygonOffsetFactor: [{
+                type: Input,
+                args: [{ alias: 'polygonOffsetFactor' }]
+            }], _depthTest: [{
+                type: Input,
+                args: [{ alias: 'depthTest' }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decal.js","sourceRoot":"","sources":["../../../../../../libs/soba/misc/src/decal/decal.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgIf } from '@angular/common';\nimport { Component, computed, CUSTOM_ELEMENTS_SCHEMA, effect, Input } from '@angular/core';\nimport {\n\tapplyProps,\n\textend,\n\tinjectNgtRef,\n\tis,\n\tsignalStore,\n\ttype NgtEuler,\n\ttype NgtMesh,\n\ttype NgtRef,\n\ttype NgtVector3,\n} from 'angular-three';\nimport * as THREE from 'three';\nimport { AxesHelper, BoxGeometry, Mesh, MeshNormalMaterial } from 'three';\nimport { DecalGeometry } from 'three-stdlib';\n\nextend({ Mesh, BoxGeometry, MeshNormalMaterial, AxesHelper });\n\nexport type NgtsDecalState = {\n\tdebug: boolean;\n\tmesh?: NgtRef<THREE.Mesh>;\n\tposition: NgtVector3;\n\trotation: NgtEuler | number;\n\tscale: NgtVector3;\n\tmap?: THREE.Texture;\n\tpolygonOffsetFactor: number;\n\tdepthTest: boolean;\n};\n\ndeclare global {\n\tinterface HTMLElementTagNameMap {\n\t\t/**\n\t\t * @extends ngt-mesh\n\t\t */\n\t\t'ngts-decal': NgtsDecalState & NgtMesh;\n\t}\n}\n\nfunction vecToArray(vec: number[] | NgtVector3 | NgtEuler | number = [0, 0, 0]) {\n\tif (Array.isArray(vec)) {\n\t\treturn vec;\n\t}\n\n\tif (vec instanceof THREE.Vector3 || vec instanceof THREE.Euler) {\n\t\treturn [vec.x, vec.y, vec.z];\n\t}\n\n\treturn [vec, vec, vec];\n}\n\n@Component({\n\tselector: 'ngts-decal',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-mesh [ref]=\"decalRef\" ngtCompound>\n\t\t\t<ngt-value [rawValue]=\"true\" attach=\"material.transparent\" />\n\t\t\t<ngt-value [rawValue]=\"true\" attach=\"material.polygonOffset\" />\n\t\t\t<ngt-value [rawValue]=\"polygonOffsetFactor()\" attach=\"material.polygonOffsetFactor\" />\n\t\t\t<ngt-value [rawValue]=\"depthTest()\" attach=\"material.depthTest\" />\n\t\t\t<ngt-value [rawValue]=\"map()\" attach=\"material.map\" />\n\t\t\t<ng-content />\n\n\t\t\t<ngt-mesh *ngIf=\"debug()\" [ref]=\"helperRef\">\n\t\t\t\t<ngt-box-geometry />\n\t\t\t\t<ngt-mesh-normal-material [wireframe]=\"true\" />\n\t\t\t\t<ngt-axes-helper />\n\t\t\t</ngt-mesh>\n\t\t</ngt-mesh>\n\t`,\n\timports: [NgIf],\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsDecal {\n\tprivate inputs = signalStore<NgtsDecalState>({\n\t\tdebug: false,\n\t\tdepthTest: false,\n\t\tpolygonOffsetFactor: -10,\n\t\tposition: [0, 0, 0],\n\t\trotation: [0, 0, 0],\n\t\tscale: 1,\n\t});\n\n\t@Input() decalRef = injectNgtRef<Mesh>();\n\n\t@Input({ alias: 'debug' }) set _debug(debug: boolean) {\n\t\tthis.inputs.set({ debug });\n\t}\n\n\t@Input({ alias: 'mesh' }) set _mesh(mesh: NgtRef<THREE.Mesh>) {\n\t\tthis.inputs.set({ mesh });\n\t}\n\n\t@Input({ alias: 'position' }) set _position(position: NgtVector3) {\n\t\tthis.inputs.set({ position });\n\t}\n\n\t@Input({ alias: 'rotation' }) set _rotation(rotation: NgtEuler | number) {\n\t\tthis.inputs.set({ rotation });\n\t}\n\n\t@Input({ alias: 'scale' }) set _scale(scale: NgtVector3) {\n\t\tthis.inputs.set({ scale });\n\t}\n\n\t@Input({ alias: 'map' }) set _map(map: THREE.Texture) {\n\t\tthis.inputs.set({ map });\n\t}\n\n\t@Input({ alias: 'polygonOffsetFactor' }) set _polygonOffsetFactor(polygonOffsetFactor: number) {\n\t\tthis.inputs.set({ polygonOffsetFactor });\n\t}\n\n\t@Input({ alias: 'depthTest' }) set _depthTest(depthTest: boolean) {\n\t\tthis.inputs.set({ depthTest });\n\t}\n\n\tprivate mesh = this.inputs.select('mesh');\n\tprivate __position = this.inputs.select('position');\n\tprivate __rotation = this.inputs.select('rotation');\n\tprivate __scale = this.inputs.select('scale');\n\tprivate position = computed(() => vecToArray(this.__position()));\n\tprivate rotation = computed(() => vecToArray(this.__rotation()));\n\tprivate scale = computed(() => vecToArray(this.__scale()));\n\n\thelperRef = injectNgtRef<Mesh>();\n\n\tdebug = this.inputs.select('debug');\n\tdepthTest = this.inputs.select('depthTest');\n\tpolygonOffsetFactor = this.inputs.select('polygonOffsetFactor');\n\tmap = this.inputs.select('map');\n\n\tconstructor() {\n\t\tthis.processDecal();\n\t}\n\n\tprivate processDecal() {\n\t\teffect((onCleanup) => {\n\t\t\tconst decal = this.decalRef.nativeElement;\n\t\t\tif (!decal) return;\n\n\t\t\tconst [mesh, position, rotation, scale, helper] = [\n\t\t\t\tthis.mesh(),\n\t\t\t\tthis.position(),\n\t\t\t\tthis.rotation(),\n\t\t\t\tthis.scale(),\n\t\t\t\tthis.helperRef.nativeElement,\n\t\t\t];\n\n\t\t\tconst parent = mesh ? (is.ref(mesh) ? mesh.nativeElement : mesh) : decal.parent;\n\t\t\tif (!(parent instanceof Mesh)) {\n\t\t\t\tthrow new Error('[NGT] ngts-decal must have a ngt-mesh as parent or specify its \"mesh\" input');\n\t\t\t}\n\n\t\t\tconst state = {\n\t\t\t\tposition: new THREE.Vector3(),\n\t\t\t\trotation: new THREE.Euler(),\n\t\t\t\tscale: new THREE.Vector3(1, 1, 1),\n\t\t\t};\n\n\t\t\tif (parent) {\n\t\t\t\tapplyProps(state, { position, scale });\n\n\t\t\t\t// Zero out the parents matrix world for this operation\n\t\t\t\tconst matrixWorld = parent.matrixWorld.clone();\n\t\t\t\tparent.matrixWorld.identity();\n\n\t\t\t\tif (!rotation || typeof rotation === 'number') {\n\t\t\t\t\tconst o = new THREE.Object3D();\n\n\t\t\t\t\to.position.copy(state.position);\n\t\t\t\t\to.lookAt(parent.position);\n\t\t\t\t\tif (typeof rotation === 'number') o.rotateZ(rotation);\n\t\t\t\t\tapplyProps(state, { rotation: o.rotation });\n\t\t\t\t} else {\n\t\t\t\t\tapplyProps(state, { rotation });\n\t\t\t\t}\n\n\t\t\t\tdecal.geometry = new DecalGeometry(parent, state.position, state.rotation, state.scale);\n\t\t\t\tif (helper) {\n\t\t\t\t\tapplyProps(helper, state);\n\t\t\t\t\t// Prevent the helpers from blocking rays\n\t\t\t\t\thelper.traverse((child) => (child.raycast = () => null));\n\t\t\t\t}\n\t\t\t\t// Reset parents matix-world\n\t\t\t\tparent.matrixWorld = matrixWorld;\n\n\t\t\t\tonCleanup(() => {\n\t\t\t\t\tdecal.geometry.dispose();\n\t\t\t\t});\n\t\t\t}\n\t\t});\n\t}\n}\n"]}

package/esm2022/misc/depth-buffer/depth-buffer.mjs

@@ -0,0 +1,44 @@
+import { ChangeDetectorRef, computed, effect, inject, runInInjectionContext } from '@angular/core';
+import { assertInjectionContext, injectBeforeRender, injectNgtRef, injectNgtStore, safeDetectChanges, } from 'angular-three';
+import * as THREE from 'three';
+import { injectNgtsFBO } from '../fbo/fbo';
+export function injectNgtsDepthBuffer(paramsFactory = () => ({}), { injector } = {}) {
+    injector = assertInjectionContext(injectNgtsDepthBuffer, injector);
+    return runInInjectionContext(injector, () => {
+        const depthBufferRef = injectNgtRef(null);
+        const store = injectNgtStore();
+        const cdr = inject(ChangeDetectorRef);
+        const size = store.select('size');
+        const dpr = store.select('viewport', 'dpr');
+        const fboParams = computed(() => {
+            const params = { size: 256, frames: Infinity, ...paramsFactory() };
+            const width = params.size || size().width * dpr();
+            const height = params.size || size().height * dpr();
+            const depthTexture = new THREE.DepthTexture(width, height);
+            depthTexture.format = THREE.DepthFormat;
+            depthTexture.type = THREE.UnsignedShortType;
+            return { width, height, settings: { depthTexture } };
+        });
+        const fboRef = injectNgtsFBO(fboParams, { injector });
+        effect(() => {
+            const fbo = fboRef.nativeElement;
+            if (fbo) {
+                depthBufferRef.nativeElement = fbo.depthTexture;
+                safeDetectChanges(cdr);
+            }
+        });
+        let count = 0;
+        injectBeforeRender(({ gl, scene, camera }) => {
+            const params = { size: 256, frames: Infinity, ...paramsFactory() };
+            const fbo = fboRef.untracked;
+            if ((params.frames === Infinity || count < params.frames) && fbo) {
+                gl.setRenderTarget(fbo);
+                gl.render(scene, camera);
+                gl.setRenderTarget(null);
+                count++;
+            }
+        }, { injector });
+        return depthBufferRef;
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/misc/example/example.mjs

@@ -0,0 +1,160 @@
+import { NgIf } from '@angular/common';
+import { CUSTOM_ELEMENTS_SCHEMA, Component, Input, computed, forwardRef, signal } from '@angular/core';
+import { createInjectionToken, extend, injectNgtRef, signalStore } from 'angular-three';
+import { NgtsText3D } from 'angular-three-soba/abstractions';
+import { NgtsCenter } from 'angular-three-soba/staging';
+import { Group, MeshNormalMaterial, MeshStandardMaterial } from 'three';
+import * as i0 from "@angular/core";
+/**
+ * augment HTMLElementTagNameMap with the selector of the component.
+ * the type is usually the Inputs' state and the root THREE element
+
+declare global {
+    interface HTMLElementTagNameMap {
+        \/**
+         * @extends ngt-group
+         *\/
+        'ngts-example': NgtsExampleState & NgtGroup;
+    }
+}
+
+*/
+/**
+ * make sure soba's component extends all regular THREE entities that it needs
+ */
+extend({ Group, MeshNormalMaterial, MeshStandardMaterial });
+/**
+ * We can setup public API for this soba component with createInjectionToken + forwardRef
+ * the `example.api` is **usually** a computed property in the component class
+ *
+ * @see Bounds for example
+ */
+export const [injectNgtsExampleApi, provideNgtsExampleApi] = createInjectionToken((example) => example.api, { isRoot: false, deps: [forwardRef(() => NgtsExample)] });
+/**
+ * @description this component is only for documentation purposes.
+ */
+export class NgtsExample {
+    constructor() {
+        /**
+         * use signalStore to store inputs with default inputs
+         */
+        this.inputs = signalStore({ color: '#cbcbcb', bevelSize: 0.04, debug: false });
+        /**
+         * a soba component usually has a Input for the component ref and this Input always has a default value with injectNgtRef
+         */
+        this.exampleRef = injectNgtRef();
+        /**
+         * exposes signals from inputs
+         */
+        this.bevelSize = this.inputs.select('bevelSize');
+        this.font = this.inputs.select('font');
+        this.debug = this.inputs.select('debug');
+        this.color = this.inputs.select('color');
+        /**
+         * can have internal state
+         */
+        this.count = signal(0);
+        /**
+         * Expose the public API for this soba component
+         */
+        this.api = computed(() => ({
+            bevelSize: this.bevelSize(),
+            increment: () => this.count.update((v) => v + 1),
+            decrement: () => this.count.update((v) => v - 1),
+        }));
+    }
+    /**
+     * setup Input for the Inputs state. Use alias to have an easier time to setup computed
+     *
+     * @example: this way "private font" and "set _font" won't conflict
+     * private font = this.inputs.select('font');
+     */
+    set _font(font) {
+        this.inputs.set({ font });
+    }
+    set _color(color) {
+        this.inputs.set({ color });
+    }
+    set _debug(debug) {
+        this.inputs.set({ debug });
+    }
+    set _bevelSize(bevelSize) {
+        this.inputs.set({ bevelSize });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsExample, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.7", type: NgtsExample, isStandalone: true, selector: "ngts-example", inputs: { exampleRef: "exampleRef", _font: ["font", "_font"], _color: ["color", "_color"], _debug: ["debug", "_debug"], _bevelSize: ["bevelSize", "_bevelSize"] }, providers: [provideNgtsExampleApi()], ngImport: i0, template: `
+		<!-- ngtCompound is used by the Renderer to spread props from ngts-example down to ngt-group -->
+		<!-- i.e: <ngts-example [position]="[1, 1, 1]" />, [1, 1, 1] will be passed down to ngt-group -->
+		<!-- [ref] is used with the Input so that the consumer can pass an external ref and control this internal ngt-group -->
+		<ngt-group ngtCompound [ref]="exampleRef">
+			<ngts-center [top]="true">
+				<ngts-text-3d
+					[bevelEnabled]="true"
+					[bevelSize]="bevelSize()"
+					[font]="font()"
+					[text]="count().toString()"
+				>
+					<ngt-mesh-standard-material *ngIf="!debug(); else withDebug" [color]="color()" />
+					<ng-template #withDebug>
+						<ngt-mesh-normal-material [wireframe]="true" />
+					</ng-template>
+				</ngts-text-3d>
+			</ngts-center>
+			<!-- use Content Projection here so consumers can pass in children for ngt-group -->
+			<ng-content />
+		</ngt-group>
+	`, isInline: true, dependencies: [{ kind: "component", type: NgtsCenter, selector: "ngts-center", inputs: ["centerRef", "top", "right", "bottom", "left", "front", "back", "disableX", "disableY", "disableZ", "disable", "precise", "cacheKey"], outputs: ["centered"] }, { kind: "component", type: NgtsText3D, selector: "ngts-text-3d", inputs: ["textRef", "font", "text", "bevelEnabled", "bevelOffset", "bevelSize", "bevelThickness", "curveSegments", "bevelSegments", "height", "size", "lineHeight", "letterSpacing", "smooth"] }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsExample, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-example',
+                    standalone: true,
+                    template: `
+		<!-- ngtCompound is used by the Renderer to spread props from ngts-example down to ngt-group -->
+		<!-- i.e: <ngts-example [position]="[1, 1, 1]" />, [1, 1, 1] will be passed down to ngt-group -->
+		<!-- [ref] is used with the Input so that the consumer can pass an external ref and control this internal ngt-group -->
+		<ngt-group ngtCompound [ref]="exampleRef">
+			<ngts-center [top]="true">
+				<ngts-text-3d
+					[bevelEnabled]="true"
+					[bevelSize]="bevelSize()"
+					[font]="font()"
+					[text]="count().toString()"
+				>
+					<ngt-mesh-standard-material *ngIf="!debug(); else withDebug" [color]="color()" />
+					<ng-template #withDebug>
+						<ngt-mesh-normal-material [wireframe]="true" />
+					</ng-template>
+				</ngts-text-3d>
+			</ngts-center>
+			<!-- use Content Projection here so consumers can pass in children for ngt-group -->
+			<ng-content />
+		</ngt-group>
+	`,
+                    /**
+                     * can definitely use other Soba components
+                     */
+                    imports: [NgtsCenter, NgtsText3D, NgIf],
+                    /**
+                     * call the API provider here to actually provide the API for the component's children
+                     */
+                    providers: [provideNgtsExampleApi()],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], propDecorators: { exampleRef: [{
+                type: Input
+            }], _font: [{
+                type: Input,
+                args: [{ alias: 'font', required: true }]
+            }], _color: [{
+                type: Input,
+                args: [{ alias: 'color' }]
+            }], _debug: [{
+                type: Input,
+                args: [{ alias: 'debug' }]
+            }], _bevelSize: [{
+                type: Input,
+                args: [{ alias: 'bevelSize' }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"example.js","sourceRoot":"","sources":["../../../../../../libs/soba/misc/src/example/example.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgIf } from '@angular/common';\nimport { CUSTOM_ELEMENTS_SCHEMA, Component, Input, computed, forwardRef, signal } from '@angular/core';\nimport { createInjectionToken, extend, injectNgtRef, signalStore } from 'angular-three';\nimport { NgtsText3D } from 'angular-three-soba/abstractions';\nimport { NgtsCenter } from 'angular-three-soba/staging';\nimport { Group, MeshNormalMaterial, MeshStandardMaterial } from 'three';\n\n/**\n * define states of a component. usually acts for inputs signalStore\n */\nexport type NgtsExampleState = {\n\tfont: string;\n\tcolor: THREE.ColorRepresentation;\n\tdebug: boolean;\n\tbevelSize: number;\n};\n\n/**\n * augment HTMLElementTagNameMap with the selector of the component.\n * the type is usually the Inputs' state and the root THREE element\n\ndeclare global {\n\tinterface HTMLElementTagNameMap {\n\t\t\\/**\n\t\t * @extends ngt-group\n\t\t *\\/\n\t\t'ngts-example': NgtsExampleState & NgtGroup;\n\t}\n}\n\n*/\n\n/**\n * make sure soba's component extends all regular THREE entities that it needs\n */\nextend({ Group, MeshNormalMaterial, MeshStandardMaterial });\n\n/**\n * We can setup public API for this soba component with createInjectionToken + forwardRef\n * the `example.api` is **usually** a computed property in the component class\n *\n * @see Bounds for example\n */\nexport const [injectNgtsExampleApi, provideNgtsExampleApi] = createInjectionToken(\n\t(example: NgtsExample) => example.api,\n\t{ isRoot: false, deps: [forwardRef(() => NgtsExample)] },\n);\n\n@Component({\n\tselector: 'ngts-example',\n\tstandalone: true,\n\ttemplate: `\n\t\t<!-- ngtCompound is used by the Renderer to spread props from ngts-example down to ngt-group -->\n\t\t<!-- i.e: <ngts-example [position]=\"[1, 1, 1]\" />, [1, 1, 1] will be passed down to ngt-group -->\n\t\t<!-- [ref] is used with the Input so that the consumer can pass an external ref and control this internal ngt-group -->\n\t\t<ngt-group ngtCompound [ref]=\"exampleRef\">\n\t\t\t<ngts-center [top]=\"true\">\n\t\t\t\t<ngts-text-3d\n\t\t\t\t\t[bevelEnabled]=\"true\"\n\t\t\t\t\t[bevelSize]=\"bevelSize()\"\n\t\t\t\t\t[font]=\"font()\"\n\t\t\t\t\t[text]=\"count().toString()\"\n\t\t\t\t>\n\t\t\t\t\t<ngt-mesh-standard-material *ngIf=\"!debug(); else withDebug\" [color]=\"color()\" />\n\t\t\t\t\t<ng-template #withDebug>\n\t\t\t\t\t\t<ngt-mesh-normal-material [wireframe]=\"true\" />\n\t\t\t\t\t</ng-template>\n\t\t\t\t</ngts-text-3d>\n\t\t\t</ngts-center>\n\t\t\t<!-- use Content Projection here so consumers can pass in children for ngt-group -->\n\t\t\t<ng-content />\n\t\t</ngt-group>\n\t`,\n\t/**\n\t * can definitely use other Soba components\n\t */\n\timports: [NgtsCenter, NgtsText3D, NgIf],\n\t/**\n\t * call the API provider here to actually provide the API for the component's children\n\t */\n\tproviders: [provideNgtsExampleApi()],\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\n/**\n * @description this component is only for documentation purposes.\n */\nexport class NgtsExample {\n\t/**\n\t * use signalStore to store inputs with default inputs\n\t */\n\tprivate inputs = signalStore<NgtsExampleState>({ color: '#cbcbcb', bevelSize: 0.04, debug: false });\n\n\t/**\n\t * a soba component usually has a Input for the component ref and this Input always has a default value with injectNgtRef\n\t */\n\t@Input() exampleRef = injectNgtRef<Group>();\n\n\t/**\n\t * setup Input for the Inputs state. Use alias to have an easier time to setup computed\n\t *\n\t * @example: this way \"private font\" and \"set _font\" won't conflict\n\t * private font = this.inputs.select('font');\n\t */\n\t@Input({ alias: 'font', required: true }) set _font(font: string) {\n\t\tthis.inputs.set({ font });\n\t}\n\n\t@Input({ alias: 'color' }) set _color(color: THREE.ColorRepresentation) {\n\t\tthis.inputs.set({ color });\n\t}\n\n\t@Input({ alias: 'debug' }) set _debug(debug: boolean) {\n\t\tthis.inputs.set({ debug });\n\t}\n\n\t@Input({ alias: 'bevelSize' }) set _bevelSize(bevelSize: number) {\n\t\tthis.inputs.set({ bevelSize });\n\t}\n\n\t/**\n\t * exposes signals from inputs\n\t */\n\tbevelSize = this.inputs.select('bevelSize');\n\tfont = this.inputs.select('font');\n\tdebug = this.inputs.select('debug');\n\tcolor = this.inputs.select('color');\n\n\t/**\n\t * can have internal state\n\t */\n\tcount = signal(0);\n\n\t/**\n\t * Expose the public API for this soba component\n\t */\n\tapi = computed(() => ({\n\t\tbevelSize: this.bevelSize(),\n\t\tincrement: () => this.count.update((v) => v + 1),\n\t\tdecrement: () => this.count.update((v) => v - 1),\n\t}));\n}\n"]}

package/esm2022/misc/fbo/fbo.mjs

@@ -0,0 +1,47 @@
+import { ChangeDetectorRef, DestroyRef, computed, effect, inject, runInInjectionContext, } from '@angular/core';
+import { assertInjectionContext, injectNgtRef, injectNgtStore, safeDetectChanges } from 'angular-three';
+import * as THREE from 'three';
+export function injectNgtsFBO(fboParams, { injector } = {}) {
+    injector = assertInjectionContext(injectNgtsFBO, injector);
+    return runInInjectionContext(injector, () => {
+        const store = injectNgtStore();
+        const cdr = inject(ChangeDetectorRef);
+        const targetRef = injectNgtRef(null);
+        inject(DestroyRef).onDestroy(() => targetRef.nativeElement?.dispose());
+        const size = store.select('size');
+        const dpr = store.select('viewport', 'dpr');
+        const fboSettings = computed(() => {
+            const { width, height, settings } = fboParams();
+            const _width = typeof width === 'number' ? width : size().width * dpr();
+            const _height = typeof height === 'number' ? height : size().height * dpr();
+            const _settings = (typeof width === 'number' ? settings : width) || {};
+            return { width: _width, height: _height, settings: _settings };
+        });
+        effect(() => {
+            const { width, height, settings } = fboSettings();
+            const { samples = 0, depth, ...targetSettings } = settings;
+            let untrackedTarget = targetRef.untracked;
+            if (!untrackedTarget) {
+                const target = new THREE.WebGLRenderTarget(width, height, {
+                    minFilter: THREE.LinearFilter,
+                    magFilter: THREE.LinearFilter,
+                    type: THREE.HalfFloatType,
+                    ...targetSettings,
+                });
+                if (depth)
+                    target.depthTexture = new THREE.DepthTexture(width, height, THREE.FloatType);
+                target.samples = samples;
+                targetRef.nativeElement = target;
+                untrackedTarget = targetRef.untracked;
+            }
+            if (untrackedTarget) {
+                untrackedTarget.setSize(width, height);
+                if (samples)
+                    untrackedTarget.samples = samples;
+                safeDetectChanges(cdr);
+            }
+        });
+        return targetRef;
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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