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

package/esm2022/abstractions/text/text.mjs

@@ -0,0 +1,274 @@
+import { CUSTOM_ELEMENTS_SCHEMA, Component, DestroyRef, EventEmitter, Input, Output, effect, inject, } from '@angular/core';
+import { NgtArgs, injectNgtRef, injectNgtStore, signalStore } from 'angular-three';
+// @ts-expect-error: no type def for troika-three-text
+import { Text, preloadFont } from 'troika-three-text';
+import * as i0 from "@angular/core";
+export class NgtsText {
+    set text(text) {
+        this.inputs.set({ text });
+    }
+    set font(font) {
+        this.inputs.set({ font });
+    }
+    set fontSize(fontSize) {
+        this.inputs.set({ fontSize });
+    }
+    set anchorX(anchorX) {
+        this.inputs.set({ anchorX });
+    }
+    set anchorY(anchorY) {
+        this.inputs.set({ anchorY });
+    }
+    set sdfGlyphSize(sdfGlyphSize) {
+        this.inputs.set({ sdfGlyphSize });
+    }
+    set characters(characters) {
+        this.inputs.set({ characters });
+    }
+    set color(color) {
+        this.inputs.set({ color });
+    }
+    set maxWidth(maxWidth) {
+        this.inputs.set({ maxWidth });
+    }
+    set lineHeight(lineHeight) {
+        this.inputs.set({ lineHeight });
+    }
+    set letterSpacing(letterSpacing) {
+        this.inputs.set({ letterSpacing });
+    }
+    set textAlign(textAlign) {
+        this.inputs.set({ textAlign });
+    }
+    set clipRect(clipRect) {
+        this.inputs.set({ clipRect });
+    }
+    set depthOffset(depthOffset) {
+        this.inputs.set({ depthOffset });
+    }
+    set direction(direction) {
+        this.inputs.set({ direction });
+    }
+    set overflowWrap(overflowWrap) {
+        this.inputs.set({ overflowWrap });
+    }
+    set whiteSpace(whiteSpace) {
+        this.inputs.set({ whiteSpace });
+    }
+    set outlineWidth(outlineWidth) {
+        this.inputs.set({ outlineWidth });
+    }
+    set outlineOffsetX(outlineOffsetX) {
+        this.inputs.set({ outlineOffsetX });
+    }
+    set outlineOffsetY(outlineOffsetY) {
+        this.inputs.set({ outlineOffsetY });
+    }
+    set outlineBlur(outlineBlur) {
+        this.inputs.set({ outlineBlur });
+    }
+    set outlineColor(outlineColor) {
+        this.inputs.set({ outlineColor });
+    }
+    set outlineOpacity(outlineOpacity) {
+        this.inputs.set({ outlineOpacity });
+    }
+    set strokeWidth(strokeWidth) {
+        this.inputs.set({ strokeWidth });
+    }
+    set strokeColor(strokeColor) {
+        this.inputs.set({ strokeColor });
+    }
+    set strokeOpacity(strokeOpacity) {
+        this.inputs.set({ strokeOpacity });
+    }
+    set fillOpacity(fillOpacity) {
+        this.inputs.set({ fillOpacity });
+    }
+    set debugSDF(debugSDF) {
+        this.inputs.set({ debugSDF });
+    }
+    constructor() {
+        this.inputs = signalStore({
+            fontSize: 1,
+            sdfGlyphSize: 64,
+            anchorX: 'center',
+            anchorY: 'middle',
+        });
+        this.textRef = injectNgtRef();
+        this.sync = new EventEmitter();
+        this.troikaText = new Text();
+        this.store = injectNgtStore();
+        inject(DestroyRef).onDestroy(() => {
+            this.troikaText.dispose();
+        });
+        this.preloadFont();
+        this.syncText();
+    }
+    preloadFont() {
+        const _font = this.inputs.select('font');
+        const _characters = this.inputs.select('characters');
+        effect(() => {
+            const [font, characters] = [_font(), _characters()];
+            const invalidate = this.store.get('invalidate');
+            preloadFont({ font, characters }, () => invalidate());
+        });
+    }
+    syncText() {
+        effect(() => {
+            const [invalidate] = [this.store.get('invalidate'), this.inputs.state()];
+            this.troikaText.sync(() => {
+                invalidate();
+                if (this.sync.observed) {
+                    this.sync.emit(this.troikaText);
+                }
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.0", ngImport: i0, type: NgtsText, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.0", type: NgtsText, isStandalone: true, selector: "ngts-text", inputs: { textRef: "textRef", text: "text", font: "font", fontSize: "fontSize", anchorX: "anchorX", anchorY: "anchorY", sdfGlyphSize: "sdfGlyphSize", characters: "characters", color: "color", maxWidth: "maxWidth", lineHeight: "lineHeight", letterSpacing: "letterSpacing", textAlign: "textAlign", clipRect: "clipRect", depthOffset: "depthOffset", direction: "direction", overflowWrap: "overflowWrap", whiteSpace: "whiteSpace", outlineWidth: "outlineWidth", outlineOffsetX: "outlineOffsetX", outlineOffsetY: "outlineOffsetY", outlineBlur: "outlineBlur", outlineColor: "outlineColor", outlineOpacity: "outlineOpacity", strokeWidth: "strokeWidth", strokeColor: "strokeColor", strokeOpacity: "strokeOpacity", fillOpacity: "fillOpacity", debugSDF: "debugSDF" }, outputs: { sync: "sync" }, ngImport: i0, template: `
+		<ngt-primitive
+			ngtCompound
+			*args="[troikaText]"
+			[ref]="textRef"
+			[text]="inputs.state().text"
+			[anchorX]="inputs.state().anchorX"
+			[anchorY]="inputs.state().anchorY"
+			[font]="inputs.state().font"
+			[fontSize]="inputs.state().fontSize"
+			[sdfGlyphSize]="inputs.state().sdfGlyphSize"
+			[characters]="inputs.state().characters"
+			[color]="inputs.state().color"
+			[maxWidth]="inputs.state().maxWidth"
+			[lineHeight]="inputs.state().lineHeight"
+			[letterSpacing]="inputs.state().letterSpacing"
+			[textAlign]="inputs.state().textAlign"
+			[clipRect]="inputs.state().clipRect"
+			[depthOffset]="inputs.state().depthOffset"
+			[direction]="inputs.state().direction"
+			[overflowWrap]="inputs.state().overflowWrap"
+			[whiteSpace]="inputs.state().whiteSpace"
+			[outlineWidth]="inputs.state().outlineWidth"
+			[outlineOffsetX]="inputs.state().outlineOffsetX"
+			[outlineOffsetY]="inputs.state().outlineOffsetY"
+			[outlineBlur]="inputs.state().outlineBlur"
+			[outlineColor]="inputs.state().outlineColor"
+			[outlineOpacity]="inputs.state().outlineOpacity"
+			[strokeWidth]="inputs.state().strokeWidth"
+			[strokeColor]="inputs.state().strokeColor"
+			[strokeOpacity]="inputs.state().strokeOpacity"
+			[fillOpacity]="inputs.state().fillOpacity"
+			[debugSDF]="inputs.state().debugSDF"
+		>
+			<ng-content />
+		</ngt-primitive>
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.0", ngImport: i0, type: NgtsText, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-text',
+                    standalone: true,
+                    template: `
+		<ngt-primitive
+			ngtCompound
+			*args="[troikaText]"
+			[ref]="textRef"
+			[text]="inputs.state().text"
+			[anchorX]="inputs.state().anchorX"
+			[anchorY]="inputs.state().anchorY"
+			[font]="inputs.state().font"
+			[fontSize]="inputs.state().fontSize"
+			[sdfGlyphSize]="inputs.state().sdfGlyphSize"
+			[characters]="inputs.state().characters"
+			[color]="inputs.state().color"
+			[maxWidth]="inputs.state().maxWidth"
+			[lineHeight]="inputs.state().lineHeight"
+			[letterSpacing]="inputs.state().letterSpacing"
+			[textAlign]="inputs.state().textAlign"
+			[clipRect]="inputs.state().clipRect"
+			[depthOffset]="inputs.state().depthOffset"
+			[direction]="inputs.state().direction"
+			[overflowWrap]="inputs.state().overflowWrap"
+			[whiteSpace]="inputs.state().whiteSpace"
+			[outlineWidth]="inputs.state().outlineWidth"
+			[outlineOffsetX]="inputs.state().outlineOffsetX"
+			[outlineOffsetY]="inputs.state().outlineOffsetY"
+			[outlineBlur]="inputs.state().outlineBlur"
+			[outlineColor]="inputs.state().outlineColor"
+			[outlineOpacity]="inputs.state().outlineOpacity"
+			[strokeWidth]="inputs.state().strokeWidth"
+			[strokeColor]="inputs.state().strokeColor"
+			[strokeOpacity]="inputs.state().strokeOpacity"
+			[fillOpacity]="inputs.state().fillOpacity"
+			[debugSDF]="inputs.state().debugSDF"
+		>
+			<ng-content />
+		</ngt-primitive>
+	`,
+                    imports: [NgtArgs],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { textRef: [{
+                type: Input
+            }], text: [{
+                type: Input,
+                args: [{ required: true }]
+            }], font: [{
+                type: Input
+            }], fontSize: [{
+                type: Input
+            }], anchorX: [{
+                type: Input
+            }], anchorY: [{
+                type: Input
+            }], sdfGlyphSize: [{
+                type: Input
+            }], characters: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }], maxWidth: [{
+                type: Input
+            }], lineHeight: [{
+                type: Input
+            }], letterSpacing: [{
+                type: Input
+            }], textAlign: [{
+                type: Input
+            }], clipRect: [{
+                type: Input
+            }], depthOffset: [{
+                type: Input
+            }], direction: [{
+                type: Input
+            }], overflowWrap: [{
+                type: Input
+            }], whiteSpace: [{
+                type: Input
+            }], outlineWidth: [{
+                type: Input
+            }], outlineOffsetX: [{
+                type: Input
+            }], outlineOffsetY: [{
+                type: Input
+            }], outlineBlur: [{
+                type: Input
+            }], outlineColor: [{
+                type: Input
+            }], outlineOpacity: [{
+                type: Input
+            }], strokeWidth: [{
+                type: Input
+            }], strokeColor: [{
+                type: Input
+            }], strokeOpacity: [{
+                type: Input
+            }], fillOpacity: [{
+                type: Input
+            }], debugSDF: [{
+                type: Input
+            }], sync: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"text.js","sourceRoot":"","sources":["../../../../../../libs/soba/abstractions/src/text/text.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n\tCUSTOM_ELEMENTS_SCHEMA,\n\tComponent,\n\tDestroyRef,\n\tEventEmitter,\n\tInput,\n\tOutput,\n\teffect,\n\tinject,\n} from '@angular/core';\nimport { NgtArgs, injectNgtRef, injectNgtStore, signalStore, type NgtMesh } from 'angular-three';\n\n// @ts-expect-error: no type def for troika-three-text\nimport { Text, preloadFont } from 'troika-three-text';\n\nexport type NgtsTextState = {\n\ttext: string;\n\t/** Font size, default: 1 */\n\tfontSize: number;\n\tanchorX: number | 'left' | 'center' | 'right';\n\tanchorY: number | 'top' | 'top-baseline' | 'middle' | 'bottom-baseline' | 'bottom';\n\tsdfGlyphSize: number;\n\tfont?: string;\n\tcharacters?: string;\n\tcolor?: THREE.ColorRepresentation;\n\tmaxWidth?: number;\n\tlineHeight?: number;\n\tletterSpacing?: number;\n\ttextAlign?: 'left' | 'right' | 'center' | 'justify';\n\tclipRect?: [number, number, number, number];\n\tdepthOffset?: number;\n\tdirection?: 'auto' | 'ltr' | 'rtl';\n\toverflowWrap?: 'normal' | 'break-word';\n\twhiteSpace?: 'normal' | 'overflowWrap' | 'nowrap';\n\toutlineWidth?: number | string;\n\toutlineOffsetX?: number | string;\n\toutlineOffsetY?: number | string;\n\toutlineBlur?: number | string;\n\toutlineColor?: THREE.ColorRepresentation;\n\toutlineOpacity?: number;\n\tstrokeWidth?: number | string;\n\tstrokeColor?: THREE.ColorRepresentation;\n\tstrokeOpacity?: number;\n\tfillOpacity?: number;\n\tdebugSDF?: boolean;\n};\n\ndeclare global {\n\tinterface HTMLElementTagNameMap {\n\t\t/**\n\t\t * @extends ngt-mesh\n\t\t */\n\t\t'ngts-text': NgtsTextState & NgtMesh;\n\t}\n}\n\n@Component({\n\tselector: 'ngts-text',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-primitive\n\t\t\tngtCompound\n\t\t\t*args=\"[troikaText]\"\n\t\t\t[ref]=\"textRef\"\n\t\t\t[text]=\"inputs.state().text\"\n\t\t\t[anchorX]=\"inputs.state().anchorX\"\n\t\t\t[anchorY]=\"inputs.state().anchorY\"\n\t\t\t[font]=\"inputs.state().font\"\n\t\t\t[fontSize]=\"inputs.state().fontSize\"\n\t\t\t[sdfGlyphSize]=\"inputs.state().sdfGlyphSize\"\n\t\t\t[characters]=\"inputs.state().characters\"\n\t\t\t[color]=\"inputs.state().color\"\n\t\t\t[maxWidth]=\"inputs.state().maxWidth\"\n\t\t\t[lineHeight]=\"inputs.state().lineHeight\"\n\t\t\t[letterSpacing]=\"inputs.state().letterSpacing\"\n\t\t\t[textAlign]=\"inputs.state().textAlign\"\n\t\t\t[clipRect]=\"inputs.state().clipRect\"\n\t\t\t[depthOffset]=\"inputs.state().depthOffset\"\n\t\t\t[direction]=\"inputs.state().direction\"\n\t\t\t[overflowWrap]=\"inputs.state().overflowWrap\"\n\t\t\t[whiteSpace]=\"inputs.state().whiteSpace\"\n\t\t\t[outlineWidth]=\"inputs.state().outlineWidth\"\n\t\t\t[outlineOffsetX]=\"inputs.state().outlineOffsetX\"\n\t\t\t[outlineOffsetY]=\"inputs.state().outlineOffsetY\"\n\t\t\t[outlineBlur]=\"inputs.state().outlineBlur\"\n\t\t\t[outlineColor]=\"inputs.state().outlineColor\"\n\t\t\t[outlineOpacity]=\"inputs.state().outlineOpacity\"\n\t\t\t[strokeWidth]=\"inputs.state().strokeWidth\"\n\t\t\t[strokeColor]=\"inputs.state().strokeColor\"\n\t\t\t[strokeOpacity]=\"inputs.state().strokeOpacity\"\n\t\t\t[fillOpacity]=\"inputs.state().fillOpacity\"\n\t\t\t[debugSDF]=\"inputs.state().debugSDF\"\n\t\t>\n\t\t\t<ng-content />\n\t\t</ngt-primitive>\n\t`,\n\timports: [NgtArgs],\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsText {\n\tprotected inputs = signalStore<NgtsTextState>({\n\t\tfontSize: 1,\n\t\tsdfGlyphSize: 64,\n\t\tanchorX: 'center',\n\t\tanchorY: 'middle',\n\t});\n\n\t@Input() textRef = injectNgtRef<Text>();\n\n\t@Input({ required: true }) set text(text: string) {\n\t\tthis.inputs.set({ text });\n\t}\n\n\t@Input() set font(font: string) {\n\t\tthis.inputs.set({ font });\n\t}\n\n\t@Input() set fontSize(fontSize: number) {\n\t\tthis.inputs.set({ fontSize });\n\t}\n\n\t@Input() set anchorX(anchorX: number | 'left' | 'center' | 'right') {\n\t\tthis.inputs.set({ anchorX });\n\t}\n\n\t@Input() set anchorY(anchorY: number | 'top' | 'top-baseline' | 'middle' | 'bottom-baseline' | 'bottom') {\n\t\tthis.inputs.set({ anchorY });\n\t}\n\n\t@Input() set sdfGlyphSize(sdfGlyphSize: number) {\n\t\tthis.inputs.set({ sdfGlyphSize });\n\t}\n\n\t@Input() set characters(characters: string) {\n\t\tthis.inputs.set({ characters });\n\t}\n\n\t@Input() set color(color: THREE.ColorRepresentation) {\n\t\tthis.inputs.set({ color });\n\t}\n\n\t@Input() set maxWidth(maxWidth: number) {\n\t\tthis.inputs.set({ maxWidth });\n\t}\n\n\t@Input() set lineHeight(lineHeight: number) {\n\t\tthis.inputs.set({ lineHeight });\n\t}\n\n\t@Input() set letterSpacing(letterSpacing: number) {\n\t\tthis.inputs.set({ letterSpacing });\n\t}\n\n\t@Input() set textAlign(textAlign: 'left' | 'right' | 'center' | 'justify') {\n\t\tthis.inputs.set({ textAlign });\n\t}\n\n\t@Input() set clipRect(clipRect: [number, number, number, number]) {\n\t\tthis.inputs.set({ clipRect });\n\t}\n\n\t@Input() set depthOffset(depthOffset: number) {\n\t\tthis.inputs.set({ depthOffset });\n\t}\n\n\t@Input() set direction(direction: 'auto' | 'ltr' | 'rtl') {\n\t\tthis.inputs.set({ direction });\n\t}\n\n\t@Input() set overflowWrap(overflowWrap: 'normal' | 'break-word') {\n\t\tthis.inputs.set({ overflowWrap });\n\t}\n\n\t@Input() set whiteSpace(whiteSpace: 'normal' | 'overflowWrap' | 'nowrap') {\n\t\tthis.inputs.set({ whiteSpace });\n\t}\n\n\t@Input() set outlineWidth(outlineWidth: number | string) {\n\t\tthis.inputs.set({ outlineWidth });\n\t}\n\n\t@Input() set outlineOffsetX(outlineOffsetX: number | string) {\n\t\tthis.inputs.set({ outlineOffsetX });\n\t}\n\n\t@Input() set outlineOffsetY(outlineOffsetY: number | string) {\n\t\tthis.inputs.set({ outlineOffsetY });\n\t}\n\n\t@Input() set outlineBlur(outlineBlur: number | string) {\n\t\tthis.inputs.set({ outlineBlur });\n\t}\n\n\t@Input() set outlineColor(outlineColor: THREE.ColorRepresentation) {\n\t\tthis.inputs.set({ outlineColor });\n\t}\n\n\t@Input() set outlineOpacity(outlineOpacity: number) {\n\t\tthis.inputs.set({ outlineOpacity });\n\t}\n\n\t@Input() set strokeWidth(strokeWidth: number | string) {\n\t\tthis.inputs.set({ strokeWidth });\n\t}\n\n\t@Input() set strokeColor(strokeColor: THREE.ColorRepresentation) {\n\t\tthis.inputs.set({ strokeColor });\n\t}\n\n\t@Input() set strokeOpacity(strokeOpacity: number) {\n\t\tthis.inputs.set({ strokeOpacity });\n\t}\n\n\t@Input() set fillOpacity(fillOpacity: number) {\n\t\tthis.inputs.set({ fillOpacity });\n\t}\n\n\t@Input() set debugSDF(debugSDF: boolean) {\n\t\tthis.inputs.set({ debugSDF });\n\t}\n\n\t@Output() sync = new EventEmitter<Text>();\n\n\ttroikaText = new Text();\n\n\tprivate store = injectNgtStore();\n\n\tconstructor() {\n\t\tinject(DestroyRef).onDestroy(() => {\n\t\t\tthis.troikaText.dispose();\n\t\t});\n\t\tthis.preloadFont();\n\t\tthis.syncText();\n\t}\n\n\tprivate preloadFont() {\n\t\tconst _font = this.inputs.select('font');\n\t\tconst _characters = this.inputs.select('characters');\n\n\t\teffect(() => {\n\t\t\tconst [font, characters] = [_font(), _characters()];\n\t\t\tconst invalidate = this.store.get('invalidate');\n\t\t\tpreloadFont({ font, characters }, () => invalidate());\n\t\t});\n\t}\n\n\tprivate syncText() {\n\t\teffect(() => {\n\t\t\tconst [invalidate] = [this.store.get('invalidate'), this.inputs.state()];\n\t\t\tthis.troikaText.sync(() => {\n\t\t\t\tinvalidate();\n\t\t\t\tif (this.sync.observed) {\n\t\t\t\t\tthis.sync.emit(this.troikaText);\n\t\t\t\t}\n\t\t\t});\n\t\t});\n\t}\n}\n"]}

package/esm2022/abstractions/text-3d/text-3d.mjs

@@ -0,0 +1,165 @@
+import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, Input } from '@angular/core';
+import { toObservable, toSignal } from '@angular/core/rxjs-interop';
+import { extend, injectNgtRef, NgtArgs, signalStore } from 'angular-three';
+import { map, of, switchMap } from 'rxjs';
+import { Mesh } from 'three';
+import { FontLoader, TextGeometry } from 'three-stdlib';
+import * as i0 from "@angular/core";
+extend({ Mesh, TextGeometry });
+export class NgtsText3D {
+    constructor() {
+        this.inputs = signalStore({
+            lineHeight: 1,
+            letterSpacing: 0,
+            size: 1,
+            height: 0.2,
+            bevelThickness: 0.1,
+            bevelSize: 0.01,
+            bevelEnabled: false,
+            bevelOffset: 0,
+            bevelSegments: 4,
+            curveSegments: 8,
+        });
+        this.textRef = injectNgtRef();
+        this.fontData = toSignal(toObservable(this.inputs.select('font')).pipe(switchMap((font) => {
+            if (typeof font === 'string')
+                return fetch(font).then((res) => res.json());
+            return of(font);
+        }), map((fontData) => new FontLoader().parse(fontData))));
+        this.text = this.inputs.select('text');
+        this.size = this.inputs.select('size');
+        this.height = this.inputs.select('height');
+        this.bevelThickness = this.inputs.select('bevelThickness');
+        this.bevelSize = this.inputs.select('bevelSize');
+        this.bevelEnabled = this.inputs.select('bevelEnabled');
+        this.bevelSegments = this.inputs.select('bevelSegments');
+        this.bevelOffset = this.inputs.select('bevelOffset');
+        this.curveSegments = this.inputs.select('curveSegments');
+        this.letterSpacing = this.inputs.select('letterSpacing');
+        this.lineHeight = this.inputs.select('lineHeight');
+        this.geometryArgs = computed(() => {
+            const fontData = this.fontData();
+            if (!fontData || !fontData.data)
+                return null;
+            return [
+                this.text(),
+                {
+                    font: fontData,
+                    size: this.size(),
+                    height: this.height(),
+                    bevelThickness: this.bevelThickness(),
+                    bevelSize: this.bevelSize(),
+                    bevelSegments: this.bevelSegments(),
+                    bevelEnabled: this.bevelEnabled(),
+                    bevelOffset: this.bevelOffset(),
+                    curveSegments: this.curveSegments(),
+                    letterSpacing: this.letterSpacing(),
+                    lineHeight: this.lineHeight(),
+                },
+            ];
+        });
+    }
+    set _font(font) {
+        this.inputs.set({ font });
+    }
+    set _text(text) {
+        this.inputs.set({ text });
+    }
+    set _bevelEnabled(bevelEnabled) {
+        this.inputs.set({ bevelEnabled });
+    }
+    set _bevelOffset(bevelOffset) {
+        this.inputs.set({ bevelOffset });
+    }
+    set _bevelSize(bevelSize) {
+        this.inputs.set({ bevelSize });
+    }
+    set _bevelThickness(bevelThickness) {
+        this.inputs.set({ bevelThickness });
+    }
+    set _curveSegments(curveSegments) {
+        this.inputs.set({ curveSegments });
+    }
+    set _bevelSegments(bevelSegments) {
+        this.inputs.set({ bevelSegments });
+    }
+    set _height(height) {
+        this.inputs.set({ height });
+    }
+    set _size(size) {
+        this.inputs.set({ size });
+    }
+    set _lineHeight(lineHeight) {
+        this.inputs.set({ lineHeight });
+    }
+    set _letterSpacing(letterSpacing) {
+        this.inputs.set({ letterSpacing });
+    }
+    set _smooth(smooth) {
+        this.inputs.set({ smooth });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.0", ngImport: i0, type: NgtsText3D, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.0", type: NgtsText3D, isStandalone: true, selector: "ngts-text-3d", inputs: { textRef: "textRef", _font: ["font", "_font"], _text: ["text", "_text"], _bevelEnabled: ["bevelEnabled", "_bevelEnabled"], _bevelOffset: ["bevelOffset", "_bevelOffset"], _bevelSize: ["bevelSize", "_bevelSize"], _bevelThickness: ["bevelThickness", "_bevelThickness"], _curveSegments: ["curveSegments", "_curveSegments"], _bevelSegments: ["bevelSegments", "_bevelSegments"], _height: ["height", "_height"], _size: ["size", "_size"], _lineHeight: ["lineHeight", "_lineHeight"], _letterSpacing: ["letterSpacing", "_letterSpacing"], _smooth: ["smooth", "_smooth"] }, ngImport: i0, template: `
+		<ngt-mesh ngtCompound [ref]="textRef">
+			<ngt-text-geometry *args="geometryArgs()" />
+			<ng-content />
+		</ngt-mesh>
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.0", ngImport: i0, type: NgtsText3D, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-text-3d',
+                    standalone: true,
+                    template: `
+		<ngt-mesh ngtCompound [ref]="textRef">
+			<ngt-text-geometry *args="geometryArgs()" />
+			<ng-content />
+		</ngt-mesh>
+	`,
+                    imports: [NgtArgs],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], propDecorators: { textRef: [{
+                type: Input
+            }], _font: [{
+                type: Input,
+                args: [{ required: true, alias: 'font' }]
+            }], _text: [{
+                type: Input,
+                args: [{ required: true, alias: 'text' }]
+            }], _bevelEnabled: [{
+                type: Input,
+                args: [{ alias: 'bevelEnabled' }]
+            }], _bevelOffset: [{
+                type: Input,
+                args: [{ alias: 'bevelOffset' }]
+            }], _bevelSize: [{
+                type: Input,
+                args: [{ alias: 'bevelSize' }]
+            }], _bevelThickness: [{
+                type: Input,
+                args: [{ alias: 'bevelThickness' }]
+            }], _curveSegments: [{
+                type: Input,
+                args: [{ alias: 'curveSegments' }]
+            }], _bevelSegments: [{
+                type: Input,
+                args: [{ alias: 'bevelSegments' }]
+            }], _height: [{
+                type: Input,
+                args: [{ alias: 'height' }]
+            }], _size: [{
+                type: Input,
+                args: [{ alias: 'size' }]
+            }], _lineHeight: [{
+                type: Input,
+                args: [{ alias: 'lineHeight' }]
+            }], _letterSpacing: [{
+                type: Input,
+                args: [{ alias: 'letterSpacing' }]
+            }], _smooth: [{
+                type: Input,
+                args: [{ alias: 'smooth' }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"text-3d.js","sourceRoot":"","sources":["../../../../../../libs/soba/abstractions/src/text-3d/text-3d.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, Input } from '@angular/core';\nimport { toObservable, toSignal } from '@angular/core/rxjs-interop';\nimport { extend, injectNgtRef, NgtArgs, signalStore, type NgtMesh } from 'angular-three';\nimport { map, of, switchMap } from 'rxjs';\nimport { Mesh } from 'three';\nimport { FontLoader, TextGeometry, TextGeometryParameters } from 'three-stdlib';\n\ndeclare type Glyph = { _cachedOutline: string[]; ha: number; o: string };\n\ndeclare type FontData = {\n\tboundingBox: { yMax: number; yMin: number };\n\tfamilyName: string;\n\tglyphs: { [k: string]: Glyph };\n\tresolution: number;\n\tunderlineThickness: number;\n};\n\nextend({ Mesh, TextGeometry });\n\nexport type NgtsText3DState = {\n\tfont: FontData | string;\n\ttext: string;\n\tbevelSegments?: number;\n\tsmooth?: number;\n} & Omit<TextGeometryParameters, 'font'>;\n\ndeclare global {\n\tinterface HTMLElementTagNameMap {\n\t\t/**\n\t\t * @extends ngt-mesh\n\t\t * @extends three-stdlib|TextGeometryParameters\n\t\t */\n\t\t'ngts-text-3d': NgtsText3DState & NgtMesh;\n\t}\n}\n\n@Component({\n\tselector: 'ngts-text-3d',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-mesh ngtCompound [ref]=\"textRef\">\n\t\t\t<ngt-text-geometry *args=\"geometryArgs()\" />\n\t\t\t<ng-content />\n\t\t</ngt-mesh>\n\t`,\n\timports: [NgtArgs],\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsText3D {\n\tprivate inputs = signalStore<NgtsText3DState>({\n\t\tlineHeight: 1,\n\t\tletterSpacing: 0,\n\t\tsize: 1,\n\t\theight: 0.2,\n\t\tbevelThickness: 0.1,\n\t\tbevelSize: 0.01,\n\t\tbevelEnabled: false,\n\t\tbevelOffset: 0,\n\t\tbevelSegments: 4,\n\t\tcurveSegments: 8,\n\t});\n\n\t@Input() textRef = injectNgtRef<Mesh>();\n\n\t@Input({ required: true, alias: 'font' }) set _font(font: FontData | string) {\n\t\tthis.inputs.set({ font });\n\t}\n\n\t@Input({ required: true, alias: 'text' }) set _text(text: string) {\n\t\tthis.inputs.set({ text });\n\t}\n\n\t@Input({ alias: 'bevelEnabled' }) set _bevelEnabled(bevelEnabled: boolean) {\n\t\tthis.inputs.set({ bevelEnabled });\n\t}\n\n\t@Input({ alias: 'bevelOffset' }) set _bevelOffset(bevelOffset: number) {\n\t\tthis.inputs.set({ bevelOffset });\n\t}\n\n\t@Input({ alias: 'bevelSize' }) set _bevelSize(bevelSize: number) {\n\t\tthis.inputs.set({ bevelSize });\n\t}\n\n\t@Input({ alias: 'bevelThickness' }) set _bevelThickness(bevelThickness: number) {\n\t\tthis.inputs.set({ bevelThickness });\n\t}\n\n\t@Input({ alias: 'curveSegments' }) set _curveSegments(curveSegments: number) {\n\t\tthis.inputs.set({ curveSegments });\n\t}\n\n\t@Input({ alias: 'bevelSegments' }) set _bevelSegments(bevelSegments: number) {\n\t\tthis.inputs.set({ bevelSegments });\n\t}\n\n\t@Input({ alias: 'height' }) set _height(height: number) {\n\t\tthis.inputs.set({ height });\n\t}\n\n\t@Input({ alias: 'size' }) set _size(size: number) {\n\t\tthis.inputs.set({ size });\n\t}\n\n\t@Input({ alias: 'lineHeight' }) set _lineHeight(lineHeight: number) {\n\t\tthis.inputs.set({ lineHeight });\n\t}\n\n\t@Input({ alias: 'letterSpacing' }) set _letterSpacing(letterSpacing: number) {\n\t\tthis.inputs.set({ letterSpacing });\n\t}\n\n\t@Input({ alias: 'smooth' }) set _smooth(smooth: number) {\n\t\tthis.inputs.set({ smooth });\n\t}\n\n\tprivate fontData = toSignal(\n\t\ttoObservable(this.inputs.select('font')).pipe(\n\t\t\tswitchMap((font) => {\n\t\t\t\tif (typeof font === 'string') return fetch(font).then((res) => res.json()) as Promise<FontData>;\n\t\t\t\treturn of(font as FontData);\n\t\t\t}),\n\t\t\tmap((fontData) => new FontLoader().parse(fontData)),\n\t\t),\n\t);\n\n\tprivate text = this.inputs.select('text');\n\tprivate size = this.inputs.select('size');\n\tprivate height = this.inputs.select('height');\n\tprivate bevelThickness = this.inputs.select('bevelThickness');\n\tprivate bevelSize = this.inputs.select('bevelSize');\n\tprivate bevelEnabled = this.inputs.select('bevelEnabled');\n\tprivate bevelSegments = this.inputs.select('bevelSegments');\n\tprivate bevelOffset = this.inputs.select('bevelOffset');\n\tprivate curveSegments = this.inputs.select('curveSegments');\n\tprivate letterSpacing = this.inputs.select('letterSpacing');\n\tprivate lineHeight = this.inputs.select('lineHeight');\n\n\tgeometryArgs = computed(() => {\n\t\tconst fontData = this.fontData();\n\t\tif (!fontData || !fontData.data) return null;\n\n\t\treturn [\n\t\t\tthis.text(),\n\t\t\t{\n\t\t\t\tfont: fontData,\n\t\t\t\tsize: this.size(),\n\t\t\t\theight: this.height(),\n\t\t\t\tbevelThickness: this.bevelThickness(),\n\t\t\t\tbevelSize: this.bevelSize(),\n\t\t\t\tbevelSegments: this.bevelSegments(),\n\t\t\t\tbevelEnabled: this.bevelEnabled(),\n\t\t\t\tbevelOffset: this.bevelOffset(),\n\t\t\t\tcurveSegments: this.curveSegments(),\n\t\t\t\tletterSpacing: this.letterSpacing(),\n\t\t\t\tlineHeight: this.lineHeight(),\n\t\t\t},\n\t\t];\n\t});\n}\n"]}

package/esm2022/angular-three-soba.mjs

@@ -2,4 +2,4 @@
  * Generated bundle index. Do not edit.
  */
 export * from './index';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5ndWxhci10aHJlZS1zb2JhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyLXRocmVlLXNvYmEvc3JjL2FuZ3VsYXItdGhyZWUtc29iYS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5ndWxhci10aHJlZS1zb2JhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vbGlicy9zb2JhL3NyYy9hbmd1bGFyLXRocmVlLXNvYmEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=

package/esm2022/cameras/angular-three-soba-cameras.mjs

@@ -2,4 +2,4 @@
  * Generated bundle index. Do not edit.
  */
 export * from './index';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5ndWxhci10aHJlZS1zb2JhLWNhbWVyYXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXItdGhyZWUtc29iYS9jYW1lcmFzL3NyYy9hbmd1bGFyLXRocmVlLXNvYmEtY2FtZXJhcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5ndWxhci10aHJlZS1zb2JhLWNhbWVyYXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvY2FtZXJhcy9zcmMvYW5ndWxhci10aHJlZS1zb2JhLWNhbWVyYXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=

package/esm2022/cameras/camera/camera-content.mjs

@@ -0,0 +1,20 @@
+import { Directive, inject, Input, TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export class NgtsCameraContent {
+    constructor() {
+        this.template = inject(TemplateRef);
+        this.ngtsCameraContent = '';
+    }
+    static ngTemplateContextGuard(_, ctx) {
+        return true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.0", ngImport: i0, type: NgtsCameraContent, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.0", type: NgtsCameraContent, isStandalone: true, selector: "ng-template[ngtsCameraContent]", inputs: { ngtsCameraContent: "ngtsCameraContent" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.0", ngImport: i0, type: NgtsCameraContent, decorators: [{
+            type: Directive,
+            args: [{ selector: 'ng-template[ngtsCameraContent]', standalone: true }]
+        }], propDecorators: { ngtsCameraContent: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FtZXJhLWNvbnRlbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvY2FtZXJhcy9zcmMvY2FtZXJhL2NhbWVyYS1jb250ZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxFQUFFLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBSXRFLE1BQU0sT0FBTyxpQkFBaUI7SUFEOUI7UUFFQyxhQUFRLEdBQUcsTUFBTSxDQUFDLFdBQVcsQ0FBQyxDQUFDO1FBQ3RCLHNCQUFpQixHQUFjLEVBQUUsQ0FBQztLQVEzQztJQU5BLE1BQU0sQ0FBQyxzQkFBc0IsQ0FDNUIsQ0FBb0IsRUFDcEIsR0FBWTtRQUVaLE9BQU8sSUFBSSxDQUFDO0lBQ2IsQ0FBQzs4R0FUVyxpQkFBaUI7a0dBQWpCLGlCQUFpQjs7MkZBQWpCLGlCQUFpQjtrQkFEN0IsU0FBUzttQkFBQyxFQUFFLFFBQVEsRUFBRSxnQ0FBZ0MsRUFBRSxVQUFVLEVBQUUsSUFBSSxFQUFFOzhCQUdqRSxpQkFBaUI7c0JBQXpCLEtBQUsiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIGluamVjdCwgSW5wdXQsIFRlbXBsYXRlUmVmIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgKiBhcyBUSFJFRSBmcm9tICd0aHJlZSc7XG5cbkBEaXJlY3RpdmUoeyBzZWxlY3RvcjogJ25nLXRlbXBsYXRlW25ndHNDYW1lcmFDb250ZW50XScsIHN0YW5kYWxvbmU6IHRydWUgfSlcbmV4cG9ydCBjbGFzcyBOZ3RzQ2FtZXJhQ29udGVudCB7XG5cdHRlbXBsYXRlID0gaW5qZWN0KFRlbXBsYXRlUmVmKTtcblx0QElucHV0KCkgbmd0c0NhbWVyYUNvbnRlbnQ6IHRydWUgfCAnJyA9ICcnO1xuXG5cdHN0YXRpYyBuZ1RlbXBsYXRlQ29udGV4dEd1YXJkKFxuXHRcdF86IE5ndHNDYW1lcmFDb250ZW50LFxuXHRcdGN0eDogdW5rbm93bixcblx0KTogY3R4IGlzIHsgZmJvOiBUSFJFRS5XZWJHTFJlbmRlclRhcmdldDsgZ3JvdXA/OiBUSFJFRS5Hcm91cCB9IHtcblx0XHRyZXR1cm4gdHJ1ZTtcblx0fVxufVxuIl19

package/esm2022/cameras/camera/camera.mjs

@@ -0,0 +1,77 @@
+import { Directive, effect, Input } from '@angular/core';
+import { injectNgtRef, injectNgtStore, signalStore } from 'angular-three';
+import { injectNgtsFBO } from 'angular-three-soba/misc';
+import * as i0 from "@angular/core";
+export class NgtsCamera {
+    set _makeDefault(makeDefault) {
+        this.inputs.set({ makeDefault });
+    }
+    set _manual(manual) {
+        this.inputs.set({ manual });
+    }
+    set _frames(frames) {
+        this.inputs.set({ frames });
+    }
+    set _resolution(resolution) {
+        this.inputs.set({ resolution });
+    }
+    set _envMap(envMap) {
+        this.inputs.set({ envMap });
+    }
+    constructor() {
+        this.inputs = signalStore({
+            resolution: 256,
+            frames: Infinity,
+            makeDefault: false,
+            manual: false,
+        });
+        this.cameraRef = injectNgtRef();
+        this.cameraResolution = this.inputs.select('resolution');
+        this.store = injectNgtStore();
+        this.fboRef = injectNgtsFBO(() => ({ width: this.cameraResolution() }));
+        this.setDefaultCamera();
+        this.updateProjectionMatrix();
+    }
+    setDefaultCamera() {
+        const makeDefault = this.inputs.select('makeDefault');
+        effect((onCleanup) => {
+            const camera = this.cameraRef.nativeElement;
+            if (camera && makeDefault()) {
+                const { camera: oldCamera } = this.store.get();
+                this.store.set({ camera });
+                onCleanup(() => this.store.set({ camera: oldCamera }));
+            }
+        });
+    }
+    updateProjectionMatrix() {
+        const manual = this.inputs.select('manual');
+        effect(() => {
+            const camera = this.cameraRef.nativeElement;
+            if (!manual() && camera)
+                camera.updateProjectionMatrix();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.0", ngImport: i0, type: NgtsCamera, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.0", type: NgtsCamera, inputs: { _makeDefault: ["makeDefault", "_makeDefault"], _manual: ["manual", "_manual"], _frames: ["frames", "_frames"], _resolution: ["resolution", "_resolution"], _envMap: ["envMap", "_envMap"], cameraRef: "cameraRef" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.0", ngImport: i0, type: NgtsCamera, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return []; }, propDecorators: { _makeDefault: [{
+                type: Input,
+                args: [{ alias: 'makeDefault' }]
+            }], _manual: [{
+                type: Input,
+                args: [{ alias: 'manual' }]
+            }], _frames: [{
+                type: Input,
+                args: [{ alias: 'frames' }]
+            }], _resolution: [{
+                type: Input,
+                args: [{ alias: 'resolution' }]
+            }], _envMap: [{
+                type: Input,
+                args: [{ alias: 'envMap' }]
+            }], cameraRef: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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