angular-three-soba 2.0.0-beta.4 → 2.0.0-beta.40

package/esm2022/misc/html/html.mjs

@@ -0,0 +1,305 @@
+import { NgIf } from '@angular/common';
+import { CUSTOM_ELEMENTS_SCHEMA, Component, ContentChild, EventEmitter, Input, Output, TemplateRef, computed, forwardRef, } from '@angular/core';
+import { extend, injectNgtRef, is, signalStore } from 'angular-three';
+import { NgtsSobaContent } from 'angular-three-soba/utils';
+import { createInjectionToken } from 'ngxtension/create-injection-token';
+import * as THREE from 'three';
+import { Group, Mesh, PlaneGeometry, ShaderMaterial } from 'three';
+import { NgtsHtmlWrapper, defaultCalculatePosition } from './html-wrapper';
+import * as i0 from "@angular/core";
+extend({ Group, PlaneGeometry, Mesh, ShaderMaterial });
+export const [injectNgtsHtmlInputs, provideNgtsHtmlInputs] = createInjectionToken((html) => ({ state: html.inputs.state, ...html.state }), { isRoot: false, deps: [forwardRef(() => NgtsHtml)] });
+export class NgtsHtml {
+    constructor() {
+        this.DoubleSide = THREE.DoubleSide;
+        this.inputs = signalStore({
+            as: 'div',
+            prepend: false,
+            transform: false,
+            fullscreen: false,
+            center: false,
+            sprite: false,
+            zIndexRange: [16777271, 0],
+            eps: 0.001,
+            scale: 1,
+            calculatePosition: defaultCalculatePosition,
+            pointerEvents: 'auto',
+            occlude: false,
+            castShadow: false,
+            receiveShadow: false,
+        });
+        this.groupRef = injectNgtRef();
+        this.occluded = new EventEmitter();
+        this.occlusionMeshRef = injectNgtRef();
+        this.transform = this.inputs.select('transform');
+        this.isRayCastOcclusion = computed(() => {
+            const occlude = this.occlude();
+            return ((occlude && occlude !== 'blending') || (Array.isArray(occlude) && !!occlude.length && is.ref(occlude[0])));
+        });
+        this.occlude = this.inputs.select('occlude');
+        this.castShadow = this.inputs.select('castShadow');
+        this.receiveShadow = this.inputs.select('receiveShadow');
+        this.geometry = this.inputs.select('geometry');
+        this.material = this.inputs.select('material');
+        this.scale = this.inputs.select('scale');
+        this.shaders = computed(() => {
+            const transform = this.transform();
+            return {
+                vertexShader: !transform
+                    ? /* glsl */ `
+          /*
+            This shader is from the THREE's SpriteMaterial.
+            We need to turn the backing plane into a Sprite
+            (make it always face the camera) if "transfrom"
+            is false.
+          */
+          #include <common>
+
+          void main() {
+            vec2 center = vec2(0., 1.);
+            float rotation = 0.0;
+
+            // This is somewhat arbitrary, but it seems to work well
+            // Need to figure out how to derive this dynamically if it even matters
+            float size = 0.03;
+
+            vec4 mvPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );
+            vec2 scale;
+            scale.x = length( vec3( modelMatrix[ 0 ].x, modelMatrix[ 0 ].y, modelMatrix[ 0 ].z ) );
+            scale.y = length( vec3( modelMatrix[ 1 ].x, modelMatrix[ 1 ].y, modelMatrix[ 1 ].z ) );
+
+            bool isPerspective = isPerspectiveMatrix( projectionMatrix );
+            if ( isPerspective ) scale *= - mvPosition.z;
+
+            vec2 alignedPosition = ( position.xy - ( center - vec2( 0.5 ) ) ) * scale * size;
+            vec2 rotatedPosition;
+            rotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;
+            rotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;
+            mvPosition.xy += rotatedPosition;
+
+            gl_Position = projectionMatrix * mvPosition;
+          }
+      `
+                    : undefined,
+                fragmentShader: /* glsl */ `
+        void main() {
+          gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
+        }
+      `,
+            };
+        });
+        this.state = {
+            zIndexRange: this.inputs.select('zIndexRange'),
+            prepend: this.inputs.select('prepend'),
+            transform: this.transform,
+            center: this.inputs.select('center'),
+            fullscreen: this.inputs.select('fullscreen'),
+            calculatePosition: this.inputs.select('calculatePosition'),
+            wrapperClass: this.inputs.select('wrapperClass'),
+            renderedDivClass: this.inputs.select('renderedDivClass'),
+            style: this.inputs.select('style'),
+            pointerEvents: this.inputs.select('pointerEvents'),
+            eps: this.inputs.select('eps'),
+            distanceFactor: this.inputs.select('distanceFactor'),
+            sprite: this.inputs.select('sprite'),
+            as: this.inputs.select('as'),
+            portal: this.inputs.select('portal'),
+            content: this.inputs.select('content'),
+            occlude: this.occlude,
+            isRayCastOcclusion: this.isRayCastOcclusion,
+            occlusionMeshRef: this.occlusionMeshRef,
+            occluded: this.occluded,
+            geometry: this.geometry,
+            scale: this.scale,
+            groupRef: this.groupRef,
+        };
+    }
+    set content(content) {
+        this.inputs.set({ content });
+    }
+    set _as(as) {
+        this.inputs.set({ as });
+    }
+    set _zIndexRange(zIndexRange) {
+        this.inputs.set({ zIndexRange });
+    }
+    set _portal(portal) {
+        this.inputs.set({ portal });
+    }
+    set _occlude(occlude) {
+        this.inputs.set({ occlude });
+    }
+    set _castShadow(castShadow) {
+        this.inputs.set({ castShadow });
+    }
+    set _receiveShadow(receiveShadow) {
+        this.inputs.set({ receiveShadow });
+    }
+    set _material(material) {
+        this.inputs.set({ material });
+    }
+    set _geometry(geometry) {
+        this.inputs.set({ geometry });
+    }
+    set _scale(scale) {
+        this.inputs.set({ scale });
+    }
+    set _prepend(prepend) {
+        this.inputs.set({ prepend });
+    }
+    set _transform(transform) {
+        this.inputs.set({ transform });
+    }
+    set _center(center) {
+        this.inputs.set({ center });
+    }
+    set _sprite(sprite) {
+        this.inputs.set({ sprite });
+    }
+    set _fullscreen(fullscreen) {
+        this.inputs.set({ fullscreen });
+    }
+    set _eps(eps) {
+        this.inputs.set({ eps });
+    }
+    set _distanceFactor(distanceFactor) {
+        this.inputs.set({ distanceFactor });
+    }
+    set _wrapperClass(wrapperClass) {
+        this.inputs.set({ wrapperClass });
+    }
+    set _renderedDivClass(renderedDivClass) {
+        this.inputs.set({ renderedDivClass });
+    }
+    set _style(style) {
+        this.inputs.set({ style });
+    }
+    set _pointerEvents(pointerEvents) {
+        this.inputs.set({ pointerEvents });
+    }
+    set _calculatePosition(calculatePosition) {
+        this.inputs.set({ calculatePosition });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.3", ngImport: i0, type: NgtsHtml, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.3", type: NgtsHtml, isStandalone: true, selector: "ngts-html", inputs: { groupRef: "groupRef", _as: ["as", "_as"], _zIndexRange: ["zIndexRange", "_zIndexRange"], _portal: ["portal", "_portal"], _occlude: ["occlude", "_occlude"], _castShadow: ["castShadow", "_castShadow"], _receiveShadow: ["receiveShadow", "_receiveShadow"], _material: ["material", "_material"], _geometry: ["geometry", "_geometry"], _scale: ["scale", "_scale"], _prepend: ["prepend", "_prepend"], _transform: ["transform", "_transform"], _center: ["center", "_center"], _sprite: ["sprite", "_sprite"], _fullscreen: ["fullscreen", "_fullscreen"], _eps: ["eps", "_eps"], _distanceFactor: ["distanceFactor", "_distanceFactor"], _wrapperClass: ["wrapperClass", "_wrapperClass"], _renderedDivClass: ["renderedDivClass", "_renderedDivClass"], _style: ["style", "_style"], _pointerEvents: ["pointerEvents", "_pointerEvents"], _calculatePosition: ["calculatePosition", "_calculatePosition"] }, outputs: { occluded: "occluded" }, providers: [provideNgtsHtmlInputs()], queries: [{ propertyName: "content", first: true, predicate: NgtsSobaContent, descendants: true, read: TemplateRef }], ngImport: i0, template: `
+		<ngt-group ngtCompound [ref]="groupRef" [scale]="scale()">
+			<ngt-mesh
+				*ngIf="occlude() && !isRayCastOcclusion()"
+				[castShadow]="castShadow()"
+				[receiveShadow]="receiveShadow()"
+				[ref]="occlusionMeshRef"
+			>
+				<ngt-plane-geometry *ngIf="geometry()" />
+				<ngt-shader-material
+					*ngIf="material()"
+					[side]="DoubleSide"
+					[vertexShader]="shaders().vertexShader"
+					[fragmentShader]="shaders().fragmentShader"
+				/>
+			</ngt-mesh>
+		</ngt-group>
+
+		<ngts-html-wrapper />
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: NgtsHtmlWrapper, selector: "ngts-html-wrapper" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.3", ngImport: i0, type: NgtsHtml, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-html',
+                    standalone: true,
+                    template: `
+		<ngt-group ngtCompound [ref]="groupRef" [scale]="scale()">
+			<ngt-mesh
+				*ngIf="occlude() && !isRayCastOcclusion()"
+				[castShadow]="castShadow()"
+				[receiveShadow]="receiveShadow()"
+				[ref]="occlusionMeshRef"
+			>
+				<ngt-plane-geometry *ngIf="geometry()" />
+				<ngt-shader-material
+					*ngIf="material()"
+					[side]="DoubleSide"
+					[vertexShader]="shaders().vertexShader"
+					[fragmentShader]="shaders().fragmentShader"
+				/>
+			</ngt-mesh>
+		</ngt-group>
+
+		<ngts-html-wrapper />
+	`,
+                    imports: [NgIf, NgtsHtmlWrapper],
+                    providers: [provideNgtsHtmlInputs()],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], propDecorators: { content: [{
+                type: ContentChild,
+                args: [NgtsSobaContent, { read: TemplateRef }]
+            }], groupRef: [{
+                type: Input
+            }], _as: [{
+                type: Input,
+                args: [{ alias: 'as' }]
+            }], _zIndexRange: [{
+                type: Input,
+                args: [{ alias: 'zIndexRange' }]
+            }], _portal: [{
+                type: Input,
+                args: [{ alias: 'portal' }]
+            }], _occlude: [{
+                type: Input,
+                args: [{ alias: 'occlude' }]
+            }], _castShadow: [{
+                type: Input,
+                args: [{ alias: 'castShadow' }]
+            }], _receiveShadow: [{
+                type: Input,
+                args: [{ alias: 'receiveShadow' }]
+            }], _material: [{
+                type: Input,
+                args: [{ alias: 'material' }]
+            }], _geometry: [{
+                type: Input,
+                args: [{ alias: 'geometry' }]
+            }], _scale: [{
+                type: Input,
+                args: [{ alias: 'scale' }]
+            }], _prepend: [{
+                type: Input,
+                args: [{ alias: 'prepend' }]
+            }], _transform: [{
+                type: Input,
+                args: [{ alias: 'transform' }]
+            }], _center: [{
+                type: Input,
+                args: [{ alias: 'center' }]
+            }], _sprite: [{
+                type: Input,
+                args: [{ alias: 'sprite' }]
+            }], _fullscreen: [{
+                type: Input,
+                args: [{ alias: 'fullscreen' }]
+            }], _eps: [{
+                type: Input,
+                args: [{ alias: 'eps' }]
+            }], _distanceFactor: [{
+                type: Input,
+                args: [{ alias: 'distanceFactor' }]
+            }], _wrapperClass: [{
+                type: Input,
+                args: [{ alias: 'wrapperClass' }]
+            }], _renderedDivClass: [{
+                type: Input,
+                args: [{ alias: 'renderedDivClass' }]
+            }], _style: [{
+                type: Input,
+                args: [{ alias: 'style' }]
+            }], _pointerEvents: [{
+                type: Input,
+                args: [{ alias: 'pointerEvents' }]
+            }], _calculatePosition: [{
+                type: Input,
+                args: [{ alias: 'calculatePosition' }]
+            }], occluded: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"html.js","sourceRoot":"","sources":["../../../../../../libs/soba/misc/src/html/html.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgIf } from '@angular/common';\nimport {\n\tCUSTOM_ELEMENTS_SCHEMA,\n\tComponent,\n\tContentChild,\n\tEventEmitter,\n\tInput,\n\tOutput,\n\tTemplateRef,\n\tcomputed,\n\tforwardRef,\n} from '@angular/core';\nimport { extend, injectNgtRef, is, signalStore, type NgtGroup, type NgtRef, type NgtVector3 } from 'angular-three';\nimport { NgtsSobaContent } from 'angular-three-soba/utils';\nimport { createInjectionToken } from 'ngxtension/create-injection-token';\nimport * as THREE from 'three';\nimport { Group, Mesh, PlaneGeometry, ShaderMaterial } from 'three';\nimport { NgtsHtmlWrapper, defaultCalculatePosition } from './html-wrapper';\n\nextend({ Group, PlaneGeometry, Mesh, ShaderMaterial });\n\ntype PointerEventsProperties =\n\t| 'auto'\n\t| 'none'\n\t| 'visiblePainted'\n\t| 'visibleFill'\n\t| 'visibleStroke'\n\t| 'visible'\n\t| 'painted'\n\t| 'fill'\n\t| 'stroke'\n\t| 'all'\n\t| 'inherit';\n\nexport type NgtsHtmlState = {\n\tas: keyof HTMLElementTagNameMap;\n\tprepend: boolean;\n\ttransform: boolean;\n\tzIndexRange: Array<number>;\n\tcalculatePosition: typeof defaultCalculatePosition;\n\tfullscreen: boolean;\n\tcenter: boolean;\n\tsprite: boolean;\n\tpointerEvents: PointerEventsProperties;\n\teps: number;\n\tscale: NgtVector3;\n\tcontent?: TemplateRef<unknown>;\n\tdistanceFactor?: number;\n\tstyle?: CSSStyleDeclaration;\n\trenderedDivClass?: string;\n\twrapperClass?: string;\n\tportal?: NgtRef<HTMLElement>;\n\tocclude: NgtRef<THREE.Object3D>[] | boolean | 'raycast' | 'blending';\n\tmaterial?: NgtRef<THREE.Material>;\n\tgeometry?: NgtRef<THREE.BufferGeometry>;\n\tcastShadow: boolean; // Cast shadow for occlusion plane\n\treceiveShadow: boolean; // Receive shadow for occlusion plane\n};\n\nexport const [injectNgtsHtmlInputs, provideNgtsHtmlInputs] = createInjectionToken(\n\t(html: NgtsHtml) => ({ state: html.inputs.state, ...html.state }),\n\t{ isRoot: false, deps: [forwardRef(() => NgtsHtml)] },\n);\n\ndeclare global {\n\tinterface HTMLElementTagNameMap {\n\t\t/**\n\t\t * @extends ngt-group\n\t\t */\n\t\t'ngts-html': NgtsHtmlState & NgtGroup;\n\t}\n}\n\n@Component({\n\tselector: 'ngts-html',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-group ngtCompound [ref]=\"groupRef\" [scale]=\"scale()\">\n\t\t\t<ngt-mesh\n\t\t\t\t*ngIf=\"occlude() && !isRayCastOcclusion()\"\n\t\t\t\t[castShadow]=\"castShadow()\"\n\t\t\t\t[receiveShadow]=\"receiveShadow()\"\n\t\t\t\t[ref]=\"occlusionMeshRef\"\n\t\t\t>\n\t\t\t\t<ngt-plane-geometry *ngIf=\"geometry()\" />\n\t\t\t\t<ngt-shader-material\n\t\t\t\t\t*ngIf=\"material()\"\n\t\t\t\t\t[side]=\"DoubleSide\"\n\t\t\t\t\t[vertexShader]=\"shaders().vertexShader\"\n\t\t\t\t\t[fragmentShader]=\"shaders().fragmentShader\"\n\t\t\t\t/>\n\t\t\t</ngt-mesh>\n\t\t</ngt-group>\n\n\t\t<ngts-html-wrapper />\n\t`,\n\timports: [NgIf, NgtsHtmlWrapper],\n\tproviders: [provideNgtsHtmlInputs()],\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsHtml {\n\tDoubleSide = THREE.DoubleSide;\n\n\tinputs = signalStore<NgtsHtmlState>({\n\t\tas: 'div',\n\t\tprepend: false,\n\t\ttransform: false,\n\t\tfullscreen: false,\n\t\tcenter: false,\n\t\tsprite: false,\n\t\tzIndexRange: [16777271, 0],\n\t\teps: 0.001,\n\t\tscale: 1,\n\t\tcalculatePosition: defaultCalculatePosition,\n\t\tpointerEvents: 'auto',\n\t\tocclude: false,\n\t\tcastShadow: false,\n\t\treceiveShadow: false,\n\t});\n\n\t@ContentChild(NgtsSobaContent, { read: TemplateRef }) set content(content: TemplateRef<unknown>) {\n\t\tthis.inputs.set({ content });\n\t}\n\n\t@Input() groupRef = injectNgtRef<Group>();\n\n\t@Input({ alias: 'as' }) set _as(as: keyof HTMLElementTagNameMap) {\n\t\tthis.inputs.set({ as });\n\t}\n\n\t@Input({ alias: 'zIndexRange' }) set _zIndexRange(zIndexRange: Array<number>) {\n\t\tthis.inputs.set({ zIndexRange });\n\t}\n\n\t@Input({ alias: 'portal' }) set _portal(portal: NgtRef<HTMLElement>) {\n\t\tthis.inputs.set({ portal });\n\t}\n\n\t@Input({ alias: 'occlude' }) set _occlude(occlude: NgtsHtmlState['occlude']) {\n\t\tthis.inputs.set({ occlude });\n\t}\n\n\t@Input({ alias: 'castShadow' }) set _castShadow(castShadow: NgtsHtmlState['castShadow']) {\n\t\tthis.inputs.set({ castShadow });\n\t}\n\n\t@Input({ alias: 'receiveShadow' }) set _receiveShadow(receiveShadow: NgtsHtmlState['receiveShadow']) {\n\t\tthis.inputs.set({ receiveShadow });\n\t}\n\n\t@Input({ alias: 'material' }) set _material(material: NgtsHtmlState['material']) {\n\t\tthis.inputs.set({ material });\n\t}\n\n\t@Input({ alias: 'geometry' }) set _geometry(geometry: NgtsHtmlState['geometry']) {\n\t\tthis.inputs.set({ geometry });\n\t}\n\n\t@Input({ alias: 'scale' }) set _scale(scale: NgtsHtmlState['scale']) {\n\t\tthis.inputs.set({ scale });\n\t}\n\n\t@Input({ alias: 'prepend' }) set _prepend(prepend: boolean) {\n\t\tthis.inputs.set({ prepend });\n\t}\n\n\t@Input({ alias: 'transform' }) set _transform(transform: boolean) {\n\t\tthis.inputs.set({ transform });\n\t}\n\n\t@Input({ alias: 'center' }) set _center(center: boolean) {\n\t\tthis.inputs.set({ center });\n\t}\n\n\t@Input({ alias: 'sprite' }) set _sprite(sprite: boolean) {\n\t\tthis.inputs.set({ sprite });\n\t}\n\n\t@Input({ alias: 'fullscreen' }) set _fullscreen(fullscreen: boolean) {\n\t\tthis.inputs.set({ fullscreen });\n\t}\n\n\t@Input({ alias: 'eps' }) set _eps(eps: number) {\n\t\tthis.inputs.set({ eps });\n\t}\n\n\t@Input({ alias: 'distanceFactor' }) set _distanceFactor(distanceFactor: number) {\n\t\tthis.inputs.set({ distanceFactor });\n\t}\n\n\t@Input({ alias: 'wrapperClass' }) set _wrapperClass(wrapperClass: string) {\n\t\tthis.inputs.set({ wrapperClass });\n\t}\n\n\t@Input({ alias: 'renderedDivClass' }) set _renderedDivClass(renderedDivClass: string) {\n\t\tthis.inputs.set({ renderedDivClass });\n\t}\n\n\t@Input({ alias: 'style' }) set _style(style: CSSStyleDeclaration) {\n\t\tthis.inputs.set({ style });\n\t}\n\n\t@Input({ alias: 'pointerEvents' }) set _pointerEvents(pointerEvents: PointerEventsProperties) {\n\t\tthis.inputs.set({ pointerEvents });\n\t}\n\n\t@Input({ alias: 'calculatePosition' }) set _calculatePosition(\n\t\tcalculatePosition: NgtsHtmlState['calculatePosition'],\n\t) {\n\t\tthis.inputs.set({ calculatePosition });\n\t}\n\n\t@Output() occluded = new EventEmitter<boolean>();\n\n\tocclusionMeshRef = injectNgtRef<Mesh>();\n\n\tprivate transform = this.inputs.select('transform');\n\n\tisRayCastOcclusion = computed(() => {\n\t\tconst occlude = this.occlude();\n\t\treturn (\n\t\t\t(occlude && occlude !== 'blending') || (Array.isArray(occlude) && !!occlude.length && is.ref(occlude[0]))\n\t\t);\n\t});\n\n\tocclude = this.inputs.select('occlude');\n\tcastShadow = this.inputs.select('castShadow');\n\treceiveShadow = this.inputs.select('receiveShadow');\n\tgeometry = this.inputs.select('geometry');\n\tmaterial = this.inputs.select('material');\n\tscale = this.inputs.select('scale');\n\n\tshaders = computed(() => {\n\t\tconst transform = this.transform();\n\t\treturn {\n\t\t\tvertexShader: !transform\n\t\t\t\t? /* glsl */ `\n          /*\n            This shader is from the THREE's SpriteMaterial.\n            We need to turn the backing plane into a Sprite\n            (make it always face the camera) if \"transfrom\"\n            is false.\n          */\n          #include <common>\n\n          void main() {\n            vec2 center = vec2(0., 1.);\n            float rotation = 0.0;\n\n            // This is somewhat arbitrary, but it seems to work well\n            // Need to figure out how to derive this dynamically if it even matters\n            float size = 0.03;\n\n            vec4 mvPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );\n            vec2 scale;\n            scale.x = length( vec3( modelMatrix[ 0 ].x, modelMatrix[ 0 ].y, modelMatrix[ 0 ].z ) );\n            scale.y = length( vec3( modelMatrix[ 1 ].x, modelMatrix[ 1 ].y, modelMatrix[ 1 ].z ) );\n\n            bool isPerspective = isPerspectiveMatrix( projectionMatrix );\n            if ( isPerspective ) scale *= - mvPosition.z;\n\n            vec2 alignedPosition = ( position.xy - ( center - vec2( 0.5 ) ) ) * scale * size;\n            vec2 rotatedPosition;\n            rotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;\n            rotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;\n            mvPosition.xy += rotatedPosition;\n\n            gl_Position = projectionMatrix * mvPosition;\n          }\n      `\n\t\t\t\t: undefined,\n\t\t\tfragmentShader: /* glsl */ `\n        void main() {\n          gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);\n        }\n      `,\n\t\t};\n\t});\n\n\tstate = {\n\t\tzIndexRange: this.inputs.select('zIndexRange'),\n\t\tprepend: this.inputs.select('prepend'),\n\t\ttransform: this.transform,\n\t\tcenter: this.inputs.select('center'),\n\t\tfullscreen: this.inputs.select('fullscreen'),\n\t\tcalculatePosition: this.inputs.select('calculatePosition'),\n\t\twrapperClass: this.inputs.select('wrapperClass'),\n\t\trenderedDivClass: this.inputs.select('renderedDivClass'),\n\t\tstyle: this.inputs.select('style'),\n\t\tpointerEvents: this.inputs.select('pointerEvents'),\n\t\teps: this.inputs.select('eps'),\n\t\tdistanceFactor: this.inputs.select('distanceFactor'),\n\t\tsprite: this.inputs.select('sprite'),\n\t\tas: this.inputs.select('as'),\n\t\tportal: this.inputs.select('portal'),\n\t\tcontent: this.inputs.select('content'),\n\t\tocclude: this.occlude,\n\t\tisRayCastOcclusion: this.isRayCastOcclusion,\n\t\tocclusionMeshRef: this.occlusionMeshRef,\n\t\toccluded: this.occluded,\n\t\tgeometry: this.geometry,\n\t\tscale: this.scale,\n\t\tgroupRef: this.groupRef,\n\t};\n}\n"]}

package/esm2022/misc/index.mjs

@@ -1,5 +1,14 @@
 export * from './animations/animations';
 export * from './bake-shadows/bake-shadows';
+export * from './caustics/caustics';
+export * from './decal/decal';
 export * from './depth-buffer/depth-buffer';
+export * from './example/example';
 export * from './fbo/fbo';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvbWlzYy9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyxXQUFXLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2FuaW1hdGlvbnMvYW5pbWF0aW9ucyc7XG5leHBvcnQgKiBmcm9tICcuL2Jha2Utc2hhZG93cy9iYWtlLXNoYWRvd3MnO1xuZXhwb3J0ICogZnJvbSAnLi9kZXB0aC1idWZmZXIvZGVwdGgtYnVmZmVyJztcbmV4cG9ydCAqIGZyb20gJy4vZmJvL2Zibyc7XG4iXX0=
+export * from './html/html';
+export * from './sampler/sampler';
+export * from './shadow/shadow';
+export * from './stats-gl/stats-gl';
+export * from './trail-texture/inject-trail-texture';
+export * from './trail/trail';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvbWlzYy9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsc0NBQXNDLENBQUM7QUFDckQsY0FBYyxlQUFlLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2FuaW1hdGlvbnMvYW5pbWF0aW9ucyc7XG5leHBvcnQgKiBmcm9tICcuL2Jha2Utc2hhZG93cy9iYWtlLXNoYWRvd3MnO1xuZXhwb3J0ICogZnJvbSAnLi9jYXVzdGljcy9jYXVzdGljcyc7XG5leHBvcnQgKiBmcm9tICcuL2RlY2FsL2RlY2FsJztcbmV4cG9ydCAqIGZyb20gJy4vZGVwdGgtYnVmZmVyL2RlcHRoLWJ1ZmZlcic7XG5leHBvcnQgKiBmcm9tICcuL2V4YW1wbGUvZXhhbXBsZSc7XG5leHBvcnQgKiBmcm9tICcuL2Ziby9mYm8nO1xuZXhwb3J0ICogZnJvbSAnLi9odG1sL2h0bWwnO1xuZXhwb3J0ICogZnJvbSAnLi9zYW1wbGVyL3NhbXBsZXInO1xuZXhwb3J0ICogZnJvbSAnLi9zaGFkb3cvc2hhZG93JztcbmV4cG9ydCAqIGZyb20gJy4vc3RhdHMtZ2wvc3RhdHMtZ2wnO1xuZXhwb3J0ICogZnJvbSAnLi90cmFpbC10ZXh0dXJlL2luamVjdC10cmFpbC10ZXh0dXJlJztcbmV4cG9ydCAqIGZyb20gJy4vdHJhaWwvdHJhaWwnO1xuIl19

package/esm2022/misc/sampler/sampler.mjs

@@ -0,0 +1,132 @@
+import { CUSTOM_ELEMENTS_SCHEMA, Component, Injector, Input, computed, effect, runInInjectionContext, signal, untracked, } from '@angular/core';
+import { checkUpdate, extend, injectNgtRef, is, signalStore } from 'angular-three';
+import { assertInjector } from 'ngxtension/assert-injector';
+import * as THREE from 'three';
+import { Group } from 'three';
+import { MeshSurfaceSampler } from 'three-stdlib';
+import * as i0 from "@angular/core";
+const defaultState = {
+    count: 16,
+};
+export function injectNgtsSurfaceSampler(surfaceSamplerState, { injector } = {}) {
+    injector = assertInjector(injectNgtsSurfaceSampler, injector);
+    return runInInjectionContext(injector, () => {
+        const state = computed(() => ({ ...defaultState, ...(surfaceSamplerState() || {}) }));
+        const _buffer = signal((() => {
+            const arr = Array.from({ length: state().count }, () => [
+                1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1,
+            ]).flat();
+            return new THREE.InstancedBufferAttribute(Float32Array.from(arr), 16);
+        })());
+        effect(() => {
+            const { mesh, count, transform, instancedMesh, weight } = state();
+            const meshObj = is.ref(mesh) ? mesh.nativeElement : mesh;
+            if (!meshObj)
+                return;
+            const instancedMeshObj = is.ref(instancedMesh) ? instancedMesh.nativeElement : instancedMesh;
+            const buffer = untracked(_buffer);
+            const sampler = new MeshSurfaceSampler(meshObj);
+            if (weight) {
+                sampler.setWeightAttribute(weight);
+            }
+            sampler.build();
+            const position = new THREE.Vector3();
+            const normal = new THREE.Vector3();
+            const color = new THREE.Color();
+            const dummy = new THREE.Object3D();
+            meshObj.updateMatrixWorld(true);
+            for (let i = 0; i < count; i++) {
+                sampler.sample(position, normal, color);
+                if (typeof transform === 'function') {
+                    transform({ dummy, sampledMesh: meshObj, position, normal, color }, i);
+                }
+                else {
+                    dummy.position.copy(position);
+                }
+                dummy.updateMatrix();
+                if (instancedMeshObj) {
+                    instancedMeshObj.setMatrixAt(i, dummy.matrix);
+                }
+                dummy.matrix.toArray(buffer.array, i * 16);
+            }
+            if (instancedMeshObj) {
+                checkUpdate(instancedMeshObj.instanceMatrix);
+            }
+            checkUpdate(buffer);
+            untracked(() => {
+                _buffer.set(buffer.clone());
+            });
+        });
+        return _buffer.asReadonly();
+    });
+}
+extend({ Group });
+export class NgtsSampler {
+    set _count(count) {
+        this.inputs.set({ count });
+    }
+    set _mesh(mesh) {
+        this.inputs.set({ mesh });
+    }
+    set _transform(transform) {
+        this.inputs.set({ transform });
+    }
+    set _weight(weight) {
+        this.inputs.set({ weight });
+    }
+    set _instancedMesh(instancedMesh) {
+        this.inputs.set({ instancedMesh });
+    }
+    constructor() {
+        this.inputs = signalStore({ count: 16 });
+        this.samplerRef = injectNgtRef();
+        this.surfaceSamplerState = computed(() => {
+            const sampler = this.samplerRef.nativeElement;
+            if (!sampler)
+                return null;
+            const { count, weight, transform, mesh, instancedMesh } = this.inputs.state();
+            const instancedMeshRef = instancedMesh ??
+                sampler.children.find((child) => child.hasOwnProperty('instanceMatrix'));
+            const meshRef = mesh ?? sampler.children.find((child) => child.type === 'Mesh');
+            return { count, weight, transform, mesh: meshRef, instancedMesh: instancedMeshRef };
+        });
+        injectNgtsSurfaceSampler(this.surfaceSamplerState);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.3", ngImport: i0, type: NgtsSampler, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.3", type: NgtsSampler, isStandalone: true, selector: "ngts-sampler", inputs: { samplerRef: "samplerRef", _count: ["count", "_count"], _mesh: ["mesh", "_mesh"], _transform: ["transform", "_transform"], _weight: ["weight", "_weight"], _instancedMesh: ["instancedMesh", "_instancedMesh"] }, ngImport: i0, template: `
+		<ngt-group ngtCompound [ref]="samplerRef">
+			<ng-content />
+		</ngt-group>
+	`, isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.3", ngImport: i0, type: NgtsSampler, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-sampler',
+                    standalone: true,
+                    template: `
+		<ngt-group ngtCompound [ref]="samplerRef">
+			<ng-content />
+		</ngt-group>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { samplerRef: [{
+                type: Input
+            }], _count: [{
+                type: Input,
+                args: [{ alias: 'count' }]
+            }], _mesh: [{
+                type: Input,
+                args: [{ alias: 'mesh' }]
+            }], _transform: [{
+                type: Input,
+                args: [{ alias: 'transform' }]
+            }], _weight: [{
+                type: Input,
+                args: [{ alias: 'weight' }]
+            }], _instancedMesh: [{
+                type: Input,
+                args: [{ alias: 'instancedMesh' }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sampler.js","sourceRoot":"","sources":["../../../../../../libs/soba/misc/src/sampler/sampler.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,sBAAsB,EACtB,SAAS,EACT,QAAQ,EACR,KAAK,EACL,QAAQ,EACR,MAAM,EACN,qBAAqB,EACrB,MAAM,EACN,SAAS,GACT,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,EAAE,EAAE,WAAW,EAA8B,MAAM,eAAe,CAAC;AAC/G,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAC9B,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;;AA0ClD,MAAM,YAAY,GAA0C;IAC3D,KAAK,EAAE,EAAE;CACT,CAAC;AAEF,MAAM,UAAU,wBAAwB,CACvC,mBAAiH,EACjH,EAAE,QAAQ,KAA8B,EAAE;IAE1C,QAAQ,GAAG,cAAc,CAAC,wBAAwB,EAAE,QAAQ,CAAC,CAAC;IAC9D,OAAO,qBAAqB,CAAC,QAAQ,EAAE,GAAG,EAAE;QAC3C,MAAM,KAAK,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,YAAY,EAAE,GAAG,CAAC,mBAAmB,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QACtF,MAAM,OAAO,GAAG,MAAM,CACrB,CAAC,GAAG,EAAE;YACL,MAAM,GAAG,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE,GAAG,EAAE,CAAC;gBACvD,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;aAC9C,CAAC,CAAC,IAAI,EAAE,CAAC;YACV,OAAO,IAAI,KAAK,CAAC,wBAAwB,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC;QACvE,CAAC,CAAC,EAAE,CACJ,CAAC;QAEF,MAAM,CAAC,GAAG,EAAE;YACX,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,EAAE,GAAG,KAAK,EAAE,CAAC;YAClE,MAAM,OAAO,GAAG,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC;YACzD,IAAI,CAAC,OAAO;gBAAE,OAAO;YACrB,MAAM,gBAAgB,GAAG,EAAE,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC,CAAC,aAAa,CAAC;YAC7F,MAAM,MAAM,GAAG,SAAS,CAAC,OAAO,CAAC,CAAC;YAElC,MAAM,OAAO,GAAG,IAAI,kBAAkB,CAAC,OAAO,CAAC,CAAC;YAEhD,IAAI,MAAM,EAAE;gBACX,OAAO,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC;aACnC;YAED,OAAO,CAAC,KAAK,EAAE,CAAC;YAEhB,MAAM,QAAQ,GAAG,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;YACrC,MAAM,MAAM,GAAG,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;YACnC,MAAM,KAAK,GAAG,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;YAChC,MAAM,KAAK,GAAG,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;YAEnC,OAAO,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;YAEhC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE;gBAC/B,OAAO,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;gBAExC,IAAI,OAAO,SAAS,KAAK,UAAU,EAAE;oBACpC,SAAS,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC,CAAC;iBACvE;qBAAM;oBACN,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;iBAC9B;gBAED,KAAK,CAAC,YAAY,EAAE,CAAC;gBAErB,IAAI,gBAAgB,EAAE;oBACrB,gBAAgB,CAAC,WAAW,CAAC,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;iBAC9C;gBAED,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;aAC3C;YAED,IAAI,gBAAgB,EAAE;gBACrB,WAAW,CAAC,gBAAgB,CAAC,cAAc,CAAC,CAAC;aAC7C;YAED,WAAW,CAAC,MAAM,CAAC,CAAC;YAEpB,SAAS,CAAC,GAAG,EAAE;gBACd,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,EAAoC,CAAC,CAAC;YAC/D,CAAC,CAAC,CAAC;QACJ,CAAC,CAAC,CAAC;QAEH,OAAO,OAAO,CAAC,UAAU,EAAE,CAAC;IAC7B,CAAC,CAAC,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;AAqBlB,MAAM,OAAO,WAAW;IAKvB,IAA+B,MAAM,CAAC,KAAa;QAClD,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;IAC5B,CAAC;IAED,IAA8B,KAAK,CAAC,IAAwB;QAC3D,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;IAC3B,CAAC;IAED,IAAmC,UAAU,CAAC,SAAwC;QACrF,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC;IAChC,CAAC;IAED,IAAgC,OAAO,CAAC,MAAc;QACrD,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;IAC7B,CAAC;IAED,IAAuC,cAAc,CAAC,aAA0C;QAC/F,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,aAAa,EAAE,CAAC,CAAC;IACpC,CAAC;IAgBD;QAtCQ,WAAM,GAAG,WAAW,CAA0B,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,CAAC;QAE5D,eAAU,GAAG,YAAY,EAAS,CAAC;QAsBpC,wBAAmB,GAAG,QAAQ,CAAC,GAAG,EAAE;YAC3C,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC;YAC9C,IAAI,CAAC,OAAO;gBAAE,OAAO,IAAI,CAAC;YAC1B,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,aAAa,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;YAE9E,MAAM,gBAAgB,GACrB,aAAa;gBACZ,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,cAAc,CAAC,gBAAgB,CAAC,CAAyB,CAAC;YAEnG,MAAM,OAAO,GAAG,IAAI,IAAK,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,CAAgB,CAAC;YAEhG,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,CAAC;QACrF,CAAC,CAAC,CAAC;QAGF,wBAAwB,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;IACpD,CAAC;8GAzCW,WAAW;kGAAX,WAAW,mSAPb;;;;EAIT;;2FAGW,WAAW;kBAVvB,SAAS;mBAAC;oBACV,QAAQ,EAAE,cAAc;oBACxB,UAAU,EAAE,IAAI;oBAChB,QAAQ,EAAE;;;;EAIT;oBACD,OAAO,EAAE,CAAC,sBAAsB,CAAC;iBACjC;0EAIS,UAAU;sBAAlB,KAAK;gBAEyB,MAAM;sBAApC,KAAK;uBAAC,EAAE,KAAK,EAAE,OAAO,EAAE;gBAIK,KAAK;sBAAlC,KAAK;uBAAC,EAAE,KAAK,EAAE,MAAM,EAAE;gBAIW,UAAU;sBAA5C,KAAK;uBAAC,EAAE,KAAK,EAAE,WAAW,EAAE;gBAIG,OAAO;sBAAtC,KAAK;uBAAC,EAAE,KAAK,EAAE,QAAQ,EAAE;gBAIa,cAAc;sBAApD,KAAK;uBAAC,EAAE,KAAK,EAAE,eAAe,EAAE","sourcesContent":["import {\n\tCUSTOM_ELEMENTS_SCHEMA,\n\tComponent,\n\tInjector,\n\tInput,\n\tcomputed,\n\teffect,\n\trunInInjectionContext,\n\tsignal,\n\tuntracked,\n} from '@angular/core';\nimport { checkUpdate, extend, injectNgtRef, is, signalStore, type NgtGroup, type NgtRef } from 'angular-three';\nimport { assertInjector } from 'ngxtension/assert-injector';\nimport * as THREE from 'three';\nimport { Group } from 'three';\nimport { MeshSurfaceSampler } from 'three-stdlib';\n\ntype SamplePayload = {\n\t/**\n\t * The position of the sample.\n\t */\n\tposition: THREE.Vector3;\n\t/**\n\t * The normal of the mesh at the sampled position.\n\t */\n\tnormal: THREE.Vector3;\n\t/**\n\t * The vertex color of the mesh at the sampled position.\n\t */\n\tcolor: THREE.Color;\n};\n\ntype TransformPayload = SamplePayload & {\n\t/**\n\t * The dummy object used to transform each instance.\n\t * This object's matrix will be updated after transforming & it will be used\n\t * to set the instance's matrix.\n\t */\n\tdummy: THREE.Object3D;\n\t/**\n\t * The mesh that's initially passed to the sampler.\n\t * Use this if you need to apply transforms from your mesh to your instances\n\t * or if you need to grab attributes from the geometry.\n\t */\n\tsampledMesh: THREE.Mesh;\n};\n\nexport type NgtsSurfaceSamplerTransformFn = (payload: TransformPayload, i: number) => void;\n\nexport type NgtsSurfaceSamplerState = {\n\tcount: number;\n\tmesh: NgtRef<THREE.Mesh>;\n\ttransform?: NgtsSurfaceSamplerTransformFn;\n\tweight?: string;\n\tinstancedMesh?: NgtRef<THREE.InstancedMesh>;\n};\n\nconst defaultState: Omit<NgtsSurfaceSamplerState, 'mesh'> = {\n\tcount: 16,\n};\n\nexport function injectNgtsSurfaceSampler(\n\tsurfaceSamplerState: () => (Partial<Omit<NgtsSurfaceSamplerState, 'mesh'>> & { mesh: NgtRef<THREE.Mesh> }) | null,\n\t{ injector }: { injector?: Injector } = {},\n) {\n\tinjector = assertInjector(injectNgtsSurfaceSampler, injector);\n\treturn runInInjectionContext(injector, () => {\n\t\tconst state = computed(() => ({ ...defaultState, ...(surfaceSamplerState() || {}) }));\n\t\tconst _buffer = signal(\n\t\t\t(() => {\n\t\t\t\tconst arr = Array.from({ length: state().count }, () => [\n\t\t\t\t\t1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1,\n\t\t\t\t]).flat();\n\t\t\t\treturn new THREE.InstancedBufferAttribute(Float32Array.from(arr), 16);\n\t\t\t})(),\n\t\t);\n\n\t\teffect(() => {\n\t\t\tconst { mesh, count, transform, instancedMesh, weight } = state();\n\t\t\tconst meshObj = is.ref(mesh) ? mesh.nativeElement : mesh;\n\t\t\tif (!meshObj) return;\n\t\t\tconst instancedMeshObj = is.ref(instancedMesh) ? instancedMesh.nativeElement : instancedMesh;\n\t\t\tconst buffer = untracked(_buffer);\n\n\t\t\tconst sampler = new MeshSurfaceSampler(meshObj);\n\n\t\t\tif (weight) {\n\t\t\t\tsampler.setWeightAttribute(weight);\n\t\t\t}\n\n\t\t\tsampler.build();\n\n\t\t\tconst position = new THREE.Vector3();\n\t\t\tconst normal = new THREE.Vector3();\n\t\t\tconst color = new THREE.Color();\n\t\t\tconst dummy = new THREE.Object3D();\n\n\t\t\tmeshObj.updateMatrixWorld(true);\n\n\t\t\tfor (let i = 0; i < count; i++) {\n\t\t\t\tsampler.sample(position, normal, color);\n\n\t\t\t\tif (typeof transform === 'function') {\n\t\t\t\t\ttransform({ dummy, sampledMesh: meshObj, position, normal, color }, i);\n\t\t\t\t} else {\n\t\t\t\t\tdummy.position.copy(position);\n\t\t\t\t}\n\n\t\t\t\tdummy.updateMatrix();\n\n\t\t\t\tif (instancedMeshObj) {\n\t\t\t\t\tinstancedMeshObj.setMatrixAt(i, dummy.matrix);\n\t\t\t\t}\n\n\t\t\t\tdummy.matrix.toArray(buffer.array, i * 16);\n\t\t\t}\n\n\t\t\tif (instancedMeshObj) {\n\t\t\t\tcheckUpdate(instancedMeshObj.instanceMatrix);\n\t\t\t}\n\n\t\t\tcheckUpdate(buffer);\n\n\t\t\tuntracked(() => {\n\t\t\t\t_buffer.set(buffer.clone() as THREE.InstancedBufferAttribute);\n\t\t\t});\n\t\t});\n\n\t\treturn _buffer.asReadonly();\n\t});\n}\n\nextend({ Group });\n\ndeclare global {\n\tinterface HTMLElementTagNameMap {\n\t\t/**\n\t\t * @extends ngt-group\n\t\t */\n\t\t'ngts-sampler': NgtsSurfaceSamplerState & NgtGroup;\n\t}\n}\n\n@Component({\n\tselector: 'ngts-sampler',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-group ngtCompound [ref]=\"samplerRef\">\n\t\t\t<ng-content />\n\t\t</ngt-group>\n\t`,\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsSampler {\n\tprivate inputs = signalStore<NgtsSurfaceSamplerState>({ count: 16 });\n\n\t@Input() samplerRef = injectNgtRef<Group>();\n\n\t@Input({ alias: 'count' }) set _count(count: number) {\n\t\tthis.inputs.set({ count });\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: 'transform' }) set _transform(transform: NgtsSurfaceSamplerTransformFn) {\n\t\tthis.inputs.set({ transform });\n\t}\n\n\t@Input({ alias: 'weight' }) set _weight(weight: string) {\n\t\tthis.inputs.set({ weight });\n\t}\n\n\t@Input({ alias: 'instancedMesh' }) set _instancedMesh(instancedMesh: NgtRef<THREE.InstancedMesh>) {\n\t\tthis.inputs.set({ instancedMesh });\n\t}\n\n\tprivate surfaceSamplerState = computed(() => {\n\t\tconst sampler = this.samplerRef.nativeElement;\n\t\tif (!sampler) return null;\n\t\tconst { count, weight, transform, mesh, instancedMesh } = this.inputs.state();\n\n\t\tconst instancedMeshRef =\n\t\t\tinstancedMesh ??\n\t\t\t(sampler.children.find((child) => child.hasOwnProperty('instanceMatrix')) as THREE.InstancedMesh);\n\n\t\tconst meshRef = mesh ?? (sampler.children.find((child) => child.type === 'Mesh') as THREE.Mesh);\n\n\t\treturn { count, weight, transform, mesh: meshRef, instancedMesh: instancedMeshRef };\n\t});\n\n\tconstructor() {\n\t\tinjectNgtsSurfaceSampler(this.surfaceSamplerState);\n\t}\n}\n"]}

package/esm2022/misc/shadow/shadow.mjs

@@ -0,0 +1,111 @@
+import { CUSTOM_ELEMENTS_SCHEMA, Component, Input, computed } from '@angular/core';
+import { NgtArgs, extend, injectNgtRef, signalStore } from 'angular-three';
+import * as THREE from 'three';
+import { CanvasTexture, Mesh, MeshBasicMaterial, PlaneGeometry } from 'three';
+import * as i0 from "@angular/core";
+extend({ Mesh, CanvasTexture, PlaneGeometry, MeshBasicMaterial });
+export class NgtsShadow {
+    constructor() {
+        this.Math = Math;
+        this.DoubleSide = THREE.DoubleSide;
+        this.inputs = signalStore({
+            fog: false,
+            depthWrite: false,
+            colorStop: 0.0,
+            color: 'black',
+            opacity: 0.5,
+        });
+        this.shadowRef = injectNgtRef();
+        this.colorStop = this.inputs.select('colorStop');
+        this.color = this.inputs.select('color');
+        this.opacity = this.inputs.select('opacity');
+        this.fog = this.inputs.select('fog');
+        this.depthWrite = this.inputs.select('depthWrite');
+        this.canvas = computed(() => {
+            const [colorStop, color] = [this.colorStop(), this.color()];
+            const canvas = document.createElement('canvas');
+            canvas.width = 128;
+            canvas.height = 128;
+            const context = canvas.getContext('2d');
+            const gradient = context.createRadialGradient(canvas.width / 2, canvas.height / 2, 0, canvas.width / 2, canvas.height / 2, canvas.width / 2);
+            gradient.addColorStop(colorStop, new THREE.Color(color).getStyle());
+            gradient.addColorStop(1, 'rgba(0,0,0,0)');
+            context.fillStyle = gradient;
+            context.fillRect(0, 0, canvas.width, canvas.height);
+            return canvas;
+        });
+    }
+    set _colorStop(colorStop) {
+        this.inputs.set({ colorStop });
+    }
+    set _fog(fog) {
+        this.inputs.set({ fog });
+    }
+    set _color(color) {
+        this.inputs.set({ color });
+    }
+    set _opacity(opacity) {
+        this.inputs.set({ opacity });
+    }
+    set _depthWrite(depthWrite) {
+        this.inputs.set({ depthWrite });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.3", ngImport: i0, type: NgtsShadow, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.3", type: NgtsShadow, isStandalone: true, selector: "ngts-shadow", inputs: { shadowRef: "shadowRef", _colorStop: ["colorStop", "_colorStop"], _fog: ["fog", "_fog"], _color: ["color", "_color"], _opacity: ["opacity", "_opacity"], _depthWrite: ["depthWrite", "_depthWrite"] }, ngImport: i0, template: `
+		<ngt-mesh ngtCompound [ref]="shadowRef" [rotation]="[-Math.PI / 2, 0, 0]">
+			<ngt-plane-geometry />
+			<ngt-mesh-basic-material
+				[transparent]="true"
+				[opacity]="opacity()"
+				[fog]="fog()"
+				[depthWrite]="depthWrite()"
+				[side]="DoubleSide"
+			>
+				<ngt-canvas-texture *args="[canvas()]" attach="map" />
+			</ngt-mesh-basic-material>
+			<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.3", ngImport: i0, type: NgtsShadow, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-shadow',
+                    standalone: true,
+                    template: `
+		<ngt-mesh ngtCompound [ref]="shadowRef" [rotation]="[-Math.PI / 2, 0, 0]">
+			<ngt-plane-geometry />
+			<ngt-mesh-basic-material
+				[transparent]="true"
+				[opacity]="opacity()"
+				[fog]="fog()"
+				[depthWrite]="depthWrite()"
+				[side]="DoubleSide"
+			>
+				<ngt-canvas-texture *args="[canvas()]" attach="map" />
+			</ngt-mesh-basic-material>
+			<ng-content />
+		</ngt-mesh>
+	`,
+                    imports: [NgtArgs],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], propDecorators: { shadowRef: [{
+                type: Input
+            }], _colorStop: [{
+                type: Input,
+                args: [{ alias: 'colorStop' }]
+            }], _fog: [{
+                type: Input,
+                args: [{ alias: 'fog' }]
+            }], _color: [{
+                type: Input,
+                args: [{ alias: 'color' }]
+            }], _opacity: [{
+                type: Input,
+                args: [{ alias: 'opacity' }]
+            }], _depthWrite: [{
+                type: Input,
+                args: [{ alias: 'depthWrite' }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shadow.js","sourceRoot":"","sources":["../../../../../../libs/soba/misc/src/shadow/shadow.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,SAAS,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACnF,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,WAAW,EAAgB,MAAM,eAAe,CAAC;AACzF,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;;AAmB9E,MAAM,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,aAAa,EAAE,iBAAiB,EAAE,CAAC,CAAC;AAuBlE,MAAM,OAAO,UAAU;IArBvB;QAsBC,SAAI,GAAG,IAAI,CAAC;QACZ,eAAU,GAAG,KAAK,CAAC,UAAU,CAAC;QAEtB,WAAM,GAAG,WAAW,CAAkB;YAC7C,GAAG,EAAE,KAAK;YACV,UAAU,EAAE,KAAK;YACjB,SAAS,EAAE,GAAG;YACd,KAAK,EAAE,OAAO;YACd,OAAO,EAAE,GAAG;SACZ,CAAC,CAAC;QAEM,cAAS,GAAG,YAAY,EAAQ,CAAC;QAsBlC,cAAS,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;QAC5C,UAAK,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAE5C,YAAO,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QACxC,QAAG,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAChC,eAAU,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QAE9C,WAAM,GAAG,QAAQ,CAAC,GAAG,EAAE;YACtB,MAAM,CAAC,SAAS,EAAE,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,EAAE,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;YAC5D,MAAM,MAAM,GAAG,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;YAChD,MAAM,CAAC,KAAK,GAAG,GAAG,CAAC;YACnB,MAAM,CAAC,MAAM,GAAG,GAAG,CAAC;YACpB,MAAM,OAAO,GAAG,MAAM,CAAC,UAAU,CAAC,IAAI,CAA6B,CAAC;YACpE,MAAM,QAAQ,GAAG,OAAO,CAAC,oBAAoB,CAC5C,MAAM,CAAC,KAAK,GAAG,CAAC,EAChB,MAAM,CAAC,MAAM,GAAG,CAAC,EACjB,CAAC,EACD,MAAM,CAAC,KAAK,GAAG,CAAC,EAChB,MAAM,CAAC,MAAM,GAAG,CAAC,EACjB,MAAM,CAAC,KAAK,GAAG,CAAC,CAChB,CAAC;YACF,QAAQ,CAAC,YAAY,CAAC,SAAS,EAAE,IAAI,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC;YACpE,QAAQ,CAAC,YAAY,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC;YAC1C,OAAO,CAAC,SAAS,GAAG,QAAQ,CAAC;YAC7B,OAAO,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;YACpD,OAAO,MAAM,CAAC;QACf,CAAC,CAAC,CAAC;KACH;IA/CA,IAAmC,UAAU,CAAC,SAAiB;QAC9D,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC;IAChC,CAAC;IAED,IAA6B,IAAI,CAAC,GAAY;QAC7C,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC;IAC1B,CAAC;IAED,IAA+B,MAAM,CAAC,KAAgC;QACrE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;IAC5B,CAAC;IAED,IAAiC,QAAQ,CAAC,OAAe;QACxD,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC;IAC9B,CAAC;IAED,IAAoC,WAAW,CAAC,UAAmB;QAClE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;IACjC,CAAC;8GAhCW,UAAU;kGAAV,UAAU,uRAlBZ;;;;;;;;;;;;;;EAcT,4DACS,OAAO;;2FAGL,UAAU;kBArBtB,SAAS;mBAAC;oBACV,QAAQ,EAAE,aAAa;oBACvB,UAAU,EAAE,IAAI;oBAChB,QAAQ,EAAE;;;;;;;;;;;;;;EAcT;oBACD,OAAO,EAAE,CAAC,OAAO,CAAC;oBAClB,OAAO,EAAE,CAAC,sBAAsB,CAAC;iBACjC;8BAaS,SAAS;sBAAjB,KAAK;gBAE6B,UAAU;sBAA5C,KAAK;uBAAC,EAAE,KAAK,EAAE,WAAW,EAAE;gBAIA,IAAI;sBAAhC,KAAK;uBAAC,EAAE,KAAK,EAAE,KAAK,EAAE;gBAIQ,MAAM;sBAApC,KAAK;uBAAC,EAAE,KAAK,EAAE,OAAO,EAAE;gBAIQ,QAAQ;sBAAxC,KAAK;uBAAC,EAAE,KAAK,EAAE,SAAS,EAAE;gBAIS,WAAW;sBAA9C,KAAK;uBAAC,EAAE,KAAK,EAAE,YAAY,EAAE","sourcesContent":["import { CUSTOM_ELEMENTS_SCHEMA, Component, Input, computed } from '@angular/core';\nimport { NgtArgs, extend, injectNgtRef, signalStore, type NgtMesh } from 'angular-three';\nimport * as THREE from 'three';\nimport { CanvasTexture, Mesh, MeshBasicMaterial, PlaneGeometry } from 'three';\n\nexport type NgtsShadowState = {\n\tcolorStop: number;\n\tfog: boolean;\n\tcolor: THREE.ColorRepresentation;\n\topacity: number;\n\tdepthWrite: boolean;\n};\n\ndeclare global {\n\tinterface HTMLElementTagNameMap {\n\t\t/**\n\t\t * @extends ngt-mesh\n\t\t */\n\t\t'ngts-shadow': NgtsShadowState & NgtMesh;\n\t}\n}\n\nextend({ Mesh, CanvasTexture, PlaneGeometry, MeshBasicMaterial });\n\n@Component({\n\tselector: 'ngts-shadow',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-mesh ngtCompound [ref]=\"shadowRef\" [rotation]=\"[-Math.PI / 2, 0, 0]\">\n\t\t\t<ngt-plane-geometry />\n\t\t\t<ngt-mesh-basic-material\n\t\t\t\t[transparent]=\"true\"\n\t\t\t\t[opacity]=\"opacity()\"\n\t\t\t\t[fog]=\"fog()\"\n\t\t\t\t[depthWrite]=\"depthWrite()\"\n\t\t\t\t[side]=\"DoubleSide\"\n\t\t\t>\n\t\t\t\t<ngt-canvas-texture *args=\"[canvas()]\" attach=\"map\" />\n\t\t\t</ngt-mesh-basic-material>\n\t\t\t<ng-content />\n\t\t</ngt-mesh>\n\t`,\n\timports: [NgtArgs],\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsShadow {\n\tMath = Math;\n\tDoubleSide = THREE.DoubleSide;\n\n\tprivate inputs = signalStore<NgtsShadowState>({\n\t\tfog: false,\n\t\tdepthWrite: false,\n\t\tcolorStop: 0.0,\n\t\tcolor: 'black',\n\t\topacity: 0.5,\n\t});\n\n\t@Input() shadowRef = injectNgtRef<Mesh>();\n\n\t@Input({ alias: 'colorStop' }) set _colorStop(colorStop: number) {\n\t\tthis.inputs.set({ colorStop });\n\t}\n\n\t@Input({ alias: 'fog' }) set _fog(fog: boolean) {\n\t\tthis.inputs.set({ fog });\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: 'opacity' }) set _opacity(opacity: number) {\n\t\tthis.inputs.set({ opacity });\n\t}\n\n\t@Input({ alias: 'depthWrite' }) set _depthWrite(depthWrite: boolean) {\n\t\tthis.inputs.set({ depthWrite });\n\t}\n\n\tprivate colorStop = this.inputs.select('colorStop');\n\tprivate color = this.inputs.select('color');\n\n\topacity = this.inputs.select('opacity');\n\tfog = this.inputs.select('fog');\n\tdepthWrite = this.inputs.select('depthWrite');\n\n\tcanvas = computed(() => {\n\t\tconst [colorStop, color] = [this.colorStop(), this.color()];\n\t\tconst canvas = document.createElement('canvas');\n\t\tcanvas.width = 128;\n\t\tcanvas.height = 128;\n\t\tconst context = canvas.getContext('2d') as CanvasRenderingContext2D;\n\t\tconst gradient = context.createRadialGradient(\n\t\t\tcanvas.width / 2,\n\t\t\tcanvas.height / 2,\n\t\t\t0,\n\t\t\tcanvas.width / 2,\n\t\t\tcanvas.height / 2,\n\t\t\tcanvas.width / 2,\n\t\t);\n\t\tgradient.addColorStop(colorStop, new THREE.Color(color).getStyle());\n\t\tgradient.addColorStop(1, 'rgba(0,0,0,0)');\n\t\tcontext.fillStyle = gradient;\n\t\tcontext.fillRect(0, 0, canvas.width, canvas.height);\n\t\treturn canvas;\n\t});\n}\n"]}