angular-three-soba 2.0.0-beta.9 → 2.1.0

package/esm2022/misc/lib/html/html-content.mjs

@@ -0,0 +1,327 @@
+import { NgTemplateOutlet } from '@angular/common';
+import { afterNextRender, ChangeDetectionStrategy, Component, computed, inject, input, output, Renderer2, untracked, viewChild, } from '@angular/core';
+import { injectBeforeRender, NgtHTML, pick, resolveRef } from 'angular-three';
+import { injectAutoEffect } from 'ngxtension/auto-effect';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { Vector3 } from 'three';
+import { NgtsHTML } from './html';
+import { defaultCalculatePosition, epsilon, getCameraCSSMatrix, getObjectCSSMatrix, isObjectBehindCamera, isObjectVisible, objectScale, objectZIndex, } from './utils';
+import * as i0 from "@angular/core";
+const defaultHtmlContentOptions = {
+    eps: 0.001,
+    zIndexRange: [16777271, 0],
+    pointerEvents: 'auto',
+    calculatePosition: defaultCalculatePosition,
+    containerClass: '',
+    containerStyle: {},
+    center: false,
+    prepend: false,
+    fullscreen: false,
+    sprite: false,
+};
+export class NgtsHTMLContent extends NgtHTML {
+    constructor() {
+        super();
+        this.options = input(defaultHtmlContentOptions, {
+            transform: mergeInputs(defaultHtmlContentOptions),
+            alias: 'ngtsHTMLContent',
+        });
+        this.occluded = output();
+        this.html = inject(NgtsHTML);
+        this.transformOuterRef = viewChild('transformOuter');
+        this.transformInnerRef = viewChild('transformInner');
+        this.containerRef = viewChild('container');
+        this.gl = this.store.select('gl');
+        this.events = this.store.select('events');
+        this.camera = this.store.select('camera');
+        this.scene = this.store.select('scene');
+        this.size = this.store.select('size');
+        this.parent = pick(this.options, 'parent');
+        this.zIndexRange = pick(this.options, 'zIndexRange');
+        this.calculatePosition = pick(this.options, 'calculatePosition');
+        this.prepend = pick(this.options, 'prepend');
+        this.center = pick(this.options, 'center');
+        this.fullscreen = pick(this.options, 'fullscreen');
+        this.pointerEvents = pick(this.options, 'pointerEvents');
+        this.containerClass = pick(this.options, 'containerClass');
+        this.containerStyle = pick(this.options, 'containerStyle');
+        this.target = computed(() => {
+            const parent = resolveRef(this.parent());
+            if (parent)
+                return parent;
+            return (this.events().connected || this.gl().domElement.parentNode);
+        });
+        const autoEffect = injectAutoEffect();
+        const renderer = inject(Renderer2);
+        let isMeshSizeSet = false;
+        afterNextRender(() => {
+            autoEffect(() => {
+                const [occlude, canvasEl, zIndexRange] = [
+                    this.html.occlude(),
+                    untracked(this.gl).domElement,
+                    untracked(this.zIndexRange),
+                ];
+                if (occlude && occlude === 'blending') {
+                    renderer.setStyle(canvasEl, 'z-index', `${Math.floor(zIndexRange[0] / 2)}`);
+                    renderer.setStyle(canvasEl, 'position', 'absolute');
+                    renderer.setStyle(canvasEl, 'pointer-events', 'none');
+                }
+                else {
+                    renderer.removeStyle(canvasEl, 'z-index');
+                    renderer.removeStyle(canvasEl, 'position');
+                    renderer.removeStyle(canvasEl, 'pointer-events');
+                }
+            });
+            autoEffect(() => {
+                const [transform, target, hostEl, prepend, scene, calculatePosition, group, size, camera] = [
+                    this.html.transform(),
+                    this.target(),
+                    this.host.nativeElement,
+                    untracked(this.prepend),
+                    untracked(this.scene),
+                    untracked(this.calculatePosition),
+                    untracked(this.html.groupRef).nativeElement,
+                    untracked(this.size),
+                    untracked(this.camera),
+                ];
+                scene.updateMatrixWorld();
+                renderer.setStyle(hostEl, 'position', 'absolute');
+                renderer.setStyle(hostEl, 'top', '0');
+                renderer.setStyle(hostEl, 'left', '0');
+                if (transform) {
+                    renderer.setStyle(hostEl, 'pointer-events', 'none');
+                    renderer.setStyle(hostEl, 'overflow', 'hidden');
+                    renderer.removeStyle(hostEl, 'transform');
+                    renderer.removeStyle(hostEl, 'transform-origin');
+                }
+                else {
+                    const vec = calculatePosition(group, camera, size);
+                    renderer.setStyle(hostEl, 'transform', `translate3d(${vec[0]}px,${vec[1]}px,0)`);
+                    renderer.setStyle(hostEl, 'transform-origin', '0 0');
+                    renderer.removeStyle(hostEl, 'pointer-events');
+                    renderer.removeStyle(hostEl, 'overflow');
+                }
+                if (prepend)
+                    target.prepend(hostEl);
+                else
+                    target.appendChild(hostEl);
+                return () => {
+                    if (target)
+                        target.removeChild(hostEl);
+                };
+            });
+            autoEffect(() => {
+                this.options();
+                this.html.options();
+                isMeshSizeSet = false;
+            });
+        });
+        let visible = true;
+        let oldZoom = 0;
+        let oldPosition = [0, 0];
+        injectBeforeRender(({ camera: rootCamera }) => {
+            const [hostEl, transformOuterEl, transformInnerEl, group, occlusionMesh, occlusionGeometry, isRaycastOcclusion, { camera, size, viewport, raycaster, scene }, { calculatePosition, eps, zIndexRange, sprite, distanceFactor }, { transform, occlude, scale },] = [
+                this.host.nativeElement,
+                this.transformOuterRef()?.nativeElement,
+                this.transformInnerRef()?.nativeElement,
+                this.html.groupRef().nativeElement,
+                this.html.occlusionMeshRef()?.nativeElement,
+                this.html.occlusionGeometryRef()?.nativeElement,
+                this.html.isRaycastOcclusion(),
+                this.store.snapshot,
+                this.options(),
+                this.html.options(),
+            ];
+            if (group) {
+                camera.updateMatrixWorld();
+                group.updateWorldMatrix(true, false);
+                const vec = transform ? oldPosition : calculatePosition(group, camera, size);
+                if (transform ||
+                    Math.abs(oldZoom - camera.zoom) > eps ||
+                    Math.abs(oldPosition[0] - vec[0]) > eps ||
+                    Math.abs(oldPosition[1] - vec[1]) > eps) {
+                    const isBehindCamera = isObjectBehindCamera(group, camera);
+                    let raytraceTarget = false;
+                    if (isRaycastOcclusion) {
+                        if (Array.isArray(occlude)) {
+                            raytraceTarget = occlude.map((item) => resolveRef(item));
+                        }
+                        else if (occlude !== 'blending') {
+                            raytraceTarget = [scene];
+                        }
+                    }
+                    const previouslyVisible = visible;
+                    if (raytraceTarget) {
+                        const isVisible = isObjectVisible(group, camera, raycaster, raytraceTarget);
+                        visible = isVisible && !isBehindCamera;
+                    }
+                    else {
+                        visible = !isBehindCamera;
+                    }
+                    if (previouslyVisible !== visible) {
+                        if (this.occluded['listeners'])
+                            this.occluded.emit(!visible);
+                        else
+                            renderer.setStyle(hostEl, 'display', visible ? 'block' : 'none');
+                    }
+                    const halfRange = Math.floor(zIndexRange[0] / 2);
+                    const zRange = occlude
+                        ? isRaycastOcclusion //
+                            ? [zIndexRange[0], halfRange]
+                            : [halfRange - 1, 0]
+                        : zIndexRange;
+                    renderer.setStyle(hostEl, 'z-index', `${objectZIndex(group, camera, zRange)}`);
+                    if (transform) {
+                        const [widthHalf, heightHalf] = [size.width / 2, size.height / 2];
+                        const fov = camera.projectionMatrix.elements[5] * heightHalf;
+                        const { isOrthographicCamera, top, left, bottom, right } = camera;
+                        const cameraMatrix = getCameraCSSMatrix(camera.matrixWorldInverse);
+                        const cameraTransform = isOrthographicCamera
+                            ? `scale(${fov})translate(${epsilon(-(right + left) / 2)}px,${epsilon((top + bottom) / 2)}px)`
+                            : `translateZ(${fov}px)`;
+                        let matrix = group.matrixWorld;
+                        if (sprite) {
+                            matrix = camera.matrixWorldInverse.clone().transpose().copyPosition(matrix).scale(group.scale);
+                            matrix.elements[3] = matrix.elements[7] = matrix.elements[11] = 0;
+                            matrix.elements[15] = 1;
+                        }
+                        renderer.setStyle(hostEl, 'width', size.width + 'px');
+                        renderer.setStyle(hostEl, 'height', size.height + 'px');
+                        renderer.setStyle(hostEl, 'perspective', isOrthographicCamera ? '' : `${fov}px`);
+                        if (transformOuterEl && transformInnerEl) {
+                            renderer.setStyle(transformOuterEl, 'transform', `${cameraTransform}${cameraMatrix}translate(${widthHalf}px,${heightHalf}px)`);
+                            renderer.setStyle(transformInnerEl, 'transform', getObjectCSSMatrix(matrix, 1 / ((distanceFactor || 10) / 400)));
+                        }
+                    }
+                    else {
+                        const scale = distanceFactor === undefined ? 1 : objectScale(group, camera) * distanceFactor;
+                        renderer.setStyle(hostEl, 'transform', `translate3d(${vec[0]}px,${vec[1]}px,0) scale(${scale})`);
+                    }
+                    oldPosition = vec;
+                    oldZoom = camera.zoom;
+                }
+            }
+            if (!isRaycastOcclusion && occlusionMesh && !isMeshSizeSet) {
+                if (transform) {
+                    if (transformOuterEl) {
+                        const el = transformOuterEl.children[0];
+                        if (el?.clientWidth && el?.clientHeight) {
+                            const { isOrthographicCamera } = camera;
+                            if (isOrthographicCamera || occlusionGeometry) {
+                                if (scale) {
+                                    if (!Array.isArray(scale)) {
+                                        occlusionMesh.scale.setScalar(1 / scale);
+                                    }
+                                    else if (scale instanceof Vector3) {
+                                        occlusionMesh.scale.copy(scale.clone().divideScalar(1));
+                                    }
+                                    else {
+                                        occlusionMesh.scale.set(1 / scale[0], 1 / scale[1], 1 / scale[2]);
+                                    }
+                                }
+                            }
+                            else {
+                                const ratio = (distanceFactor || 10) / 400;
+                                const w = el.clientWidth * ratio;
+                                const h = el.clientHeight * ratio;
+                                occlusionMesh.scale.set(w, h, 1);
+                            }
+                            isMeshSizeSet = true;
+                        }
+                    }
+                }
+                else {
+                    const ele = hostEl.children[0];
+                    if (ele?.clientWidth && ele?.clientHeight) {
+                        const ratio = 1 / viewport.factor;
+                        const w = ele.clientWidth * ratio;
+                        const h = ele.clientHeight * ratio;
+                        occlusionMesh.scale.set(w, h, 1);
+                        isMeshSizeSet = true;
+                    }
+                    occlusionMesh.lookAt(rootCamera.position);
+                }
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsHTMLContent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.0", type: NgtsHTMLContent, isStandalone: true, selector: "[ngtsHTMLContent]", inputs: { options: { classPropertyName: "options", publicName: "ngtsHTMLContent", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { occluded: "occluded" }, host: { attributes: { "data-ngts-html-content": "" } }, viewQueries: [{ propertyName: "transformOuterRef", first: true, predicate: ["transformOuter"], descendants: true, isSignal: true }, { propertyName: "transformInnerRef", first: true, predicate: ["transformInner"], descendants: true, isSignal: true }, { propertyName: "containerRef", first: true, predicate: ["container"], descendants: true, isSignal: true }], usesInheritance: true, ngImport: i0, template: `
+		@if (html.transform()) {
+			<div
+				#transformOuter
+				style="position: absolute; top: 0; left: 0; transform-style: preserve-3d; pointer-events: none;"
+				[style.width.px]="size().width"
+				[style.height.px]="size().height"
+			>
+				<div #transformInner style="position: absolute" [style.pointer-events]="pointerEvents()">
+					<div #container [class]="containerClass()" [style]="containerStyle()">
+						<ng-container [ngTemplateOutlet]="content" />
+					</div>
+				</div>
+			</div>
+		} @else {
+			<div
+				#container
+				style="position:absolute"
+				[style.transform]="center() ? 'translate3d(-50%,-50%,0)' : 'none'"
+				[style.top]="fullscreen() ? -size().height / 2 + 'px' : 'unset'"
+				[style.left]="fullscreen() ? -size().width / 2 + 'px' : 'unset'"
+				[style.width]="fullscreen() ? size().width : 'unset'"
+				[style.height]="fullscreen() ? size().height : 'unset'"
+				[class]="containerClass()"
+				[style]="containerStyle()"
+			>
+				<ng-container [ngTemplateOutlet]="content" />
+			</div>
+		}
+
+		<ng-template #content>
+			<ng-content />
+		</ng-template>
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsHTMLContent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: '[ngtsHTMLContent]',
+                    standalone: true,
+                    template: `
+		@if (html.transform()) {
+			<div
+				#transformOuter
+				style="position: absolute; top: 0; left: 0; transform-style: preserve-3d; pointer-events: none;"
+				[style.width.px]="size().width"
+				[style.height.px]="size().height"
+			>
+				<div #transformInner style="position: absolute" [style.pointer-events]="pointerEvents()">
+					<div #container [class]="containerClass()" [style]="containerStyle()">
+						<ng-container [ngTemplateOutlet]="content" />
+					</div>
+				</div>
+			</div>
+		} @else {
+			<div
+				#container
+				style="position:absolute"
+				[style.transform]="center() ? 'translate3d(-50%,-50%,0)' : 'none'"
+				[style.top]="fullscreen() ? -size().height / 2 + 'px' : 'unset'"
+				[style.left]="fullscreen() ? -size().width / 2 + 'px' : 'unset'"
+				[style.width]="fullscreen() ? size().width : 'unset'"
+				[style.height]="fullscreen() ? size().height : 'unset'"
+				[class]="containerClass()"
+				[style]="containerStyle()"
+			>
+				<ng-container [ngTemplateOutlet]="content" />
+			</div>
+		}
+
+		<ng-template #content>
+			<ng-content />
+		</ng-template>
+	`,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [NgTemplateOutlet],
+                    host: { 'data-ngts-html-content': '' },
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"html-content.js","sourceRoot":"","sources":["../../../../../../../libs/soba/misc/src/lib/html/html-content.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgTemplateOutlet } from '@angular/common';\nimport {\n\tafterNextRender,\n\tChangeDetectionStrategy,\n\tComponent,\n\tcomputed,\n\tElementRef,\n\tinject,\n\tinput,\n\toutput,\n\tRenderer2,\n\tuntracked,\n\tviewChild,\n} from '@angular/core';\nimport { injectBeforeRender, NgtHTML, pick, resolveRef } from 'angular-three';\nimport { injectAutoEffect } from 'ngxtension/auto-effect';\nimport { mergeInputs } from 'ngxtension/inject-inputs';\nimport { Object3D, OrthographicCamera, Vector3 } from 'three';\nimport { NgtsHTML } from './html';\nimport {\n\tCalculatePosition,\n\tdefaultCalculatePosition,\n\tepsilon,\n\tgetCameraCSSMatrix,\n\tgetObjectCSSMatrix,\n\tisObjectBehindCamera,\n\tisObjectVisible,\n\tobjectScale,\n\tobjectZIndex,\n} from './utils';\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 interface NgtsHTMLContentOptions {\n\teps: number;\n\tzIndexRange: [number, number];\n\tcenter: boolean;\n\tprepend: boolean;\n\tfullscreen: boolean;\n\tcontainerClass: string;\n\tcontainerStyle: Partial<CSSStyleDeclaration>;\n\tpointerEvents: PointerEventsProperties;\n\tcalculatePosition: CalculatePosition;\n\tsprite: boolean;\n\tdistanceFactor?: number;\n\tparent?: HTMLElement | ElementRef<HTMLElement>;\n}\n\nconst defaultHtmlContentOptions: NgtsHTMLContentOptions = {\n\teps: 0.001,\n\tzIndexRange: [16777271, 0],\n\tpointerEvents: 'auto',\n\tcalculatePosition: defaultCalculatePosition,\n\tcontainerClass: '',\n\tcontainerStyle: {},\n\tcenter: false,\n\tprepend: false,\n\tfullscreen: false,\n\tsprite: false,\n};\n\n@Component({\n\tselector: '[ngtsHTMLContent]',\n\tstandalone: true,\n\ttemplate: `\n\t\t@if (html.transform()) {\n\t\t\t<div\n\t\t\t\t#transformOuter\n\t\t\t\tstyle=\"position: absolute; top: 0; left: 0; transform-style: preserve-3d; pointer-events: none;\"\n\t\t\t\t[style.width.px]=\"size().width\"\n\t\t\t\t[style.height.px]=\"size().height\"\n\t\t\t>\n\t\t\t\t<div #transformInner style=\"position: absolute\" [style.pointer-events]=\"pointerEvents()\">\n\t\t\t\t\t<div #container [class]=\"containerClass()\" [style]=\"containerStyle()\">\n\t\t\t\t\t\t<ng-container [ngTemplateOutlet]=\"content\" />\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t} @else {\n\t\t\t<div\n\t\t\t\t#container\n\t\t\t\tstyle=\"position:absolute\"\n\t\t\t\t[style.transform]=\"center() ? 'translate3d(-50%,-50%,0)' : 'none'\"\n\t\t\t\t[style.top]=\"fullscreen() ? -size().height / 2 + 'px' : 'unset'\"\n\t\t\t\t[style.left]=\"fullscreen() ? -size().width / 2 + 'px' : 'unset'\"\n\t\t\t\t[style.width]=\"fullscreen() ? size().width : 'unset'\"\n\t\t\t\t[style.height]=\"fullscreen() ? size().height : 'unset'\"\n\t\t\t\t[class]=\"containerClass()\"\n\t\t\t\t[style]=\"containerStyle()\"\n\t\t\t>\n\t\t\t\t<ng-container [ngTemplateOutlet]=\"content\" />\n\t\t\t</div>\n\t\t}\n\n\t\t<ng-template #content>\n\t\t\t<ng-content />\n\t\t</ng-template>\n\t`,\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\timports: [NgTemplateOutlet],\n\thost: { 'data-ngts-html-content': '' },\n})\nexport class NgtsHTMLContent extends NgtHTML {\n\toptions = input(defaultHtmlContentOptions, {\n\t\ttransform: mergeInputs(defaultHtmlContentOptions),\n\t\talias: 'ngtsHTMLContent',\n\t});\n\toccluded = output<boolean>();\n\n\thtml = inject(NgtsHTML);\n\n\ttransformOuterRef = viewChild<ElementRef<HTMLDivElement>>('transformOuter');\n\ttransformInnerRef = viewChild<ElementRef<HTMLDivElement>>('transformInner');\n\tcontainerRef = viewChild<ElementRef<HTMLDivElement>>('container');\n\n\tprivate gl = this.store.select('gl');\n\tprivate events = this.store.select('events');\n\tprivate camera = this.store.select('camera');\n\tprivate scene = this.store.select('scene');\n\tsize = this.store.select('size');\n\n\tprivate parent = pick(this.options, 'parent');\n\tprivate zIndexRange = pick(this.options, 'zIndexRange');\n\tprivate calculatePosition = pick(this.options, 'calculatePosition');\n\tprivate prepend = pick(this.options, 'prepend');\n\tcenter = pick(this.options, 'center');\n\tfullscreen = pick(this.options, 'fullscreen');\n\tpointerEvents = pick(this.options, 'pointerEvents');\n\tcontainerClass = pick(this.options, 'containerClass');\n\tcontainerStyle = pick(this.options, 'containerStyle');\n\n\tprivate target = computed(() => {\n\t\tconst parent = resolveRef(this.parent());\n\t\tif (parent) return parent;\n\t\treturn (this.events().connected || this.gl().domElement.parentNode) as HTMLElement;\n\t});\n\n\tconstructor() {\n\t\tsuper();\n\n\t\tconst autoEffect = injectAutoEffect();\n\t\tconst renderer = inject(Renderer2);\n\n\t\tlet isMeshSizeSet = false;\n\n\t\tafterNextRender(() => {\n\t\t\tautoEffect(() => {\n\t\t\t\tconst [occlude, canvasEl, zIndexRange] = [\n\t\t\t\t\tthis.html.occlude(),\n\t\t\t\t\tuntracked(this.gl).domElement,\n\t\t\t\t\tuntracked(this.zIndexRange),\n\t\t\t\t];\n\n\t\t\t\tif (occlude && occlude === 'blending') {\n\t\t\t\t\trenderer.setStyle(canvasEl, 'z-index', `${Math.floor(zIndexRange[0] / 2)}`);\n\t\t\t\t\trenderer.setStyle(canvasEl, 'position', 'absolute');\n\t\t\t\t\trenderer.setStyle(canvasEl, 'pointer-events', 'none');\n\t\t\t\t} else {\n\t\t\t\t\trenderer.removeStyle(canvasEl, 'z-index');\n\t\t\t\t\trenderer.removeStyle(canvasEl, 'position');\n\t\t\t\t\trenderer.removeStyle(canvasEl, 'pointer-events');\n\t\t\t\t}\n\t\t\t});\n\n\t\t\tautoEffect(() => {\n\t\t\t\tconst [transform, target, hostEl, prepend, scene, calculatePosition, group, size, camera] = [\n\t\t\t\t\tthis.html.transform(),\n\t\t\t\t\tthis.target(),\n\t\t\t\t\tthis.host.nativeElement,\n\t\t\t\t\tuntracked(this.prepend),\n\t\t\t\t\tuntracked(this.scene),\n\t\t\t\t\tuntracked(this.calculatePosition),\n\t\t\t\t\tuntracked(this.html.groupRef).nativeElement,\n\t\t\t\t\tuntracked(this.size),\n\t\t\t\t\tuntracked(this.camera),\n\t\t\t\t];\n\n\t\t\t\tscene.updateMatrixWorld();\n\t\t\t\trenderer.setStyle(hostEl, 'position', 'absolute');\n\t\t\t\trenderer.setStyle(hostEl, 'top', '0');\n\t\t\t\trenderer.setStyle(hostEl, 'left', '0');\n\n\t\t\t\tif (transform) {\n\t\t\t\t\trenderer.setStyle(hostEl, 'pointer-events', 'none');\n\t\t\t\t\trenderer.setStyle(hostEl, 'overflow', 'hidden');\n\t\t\t\t\trenderer.removeStyle(hostEl, 'transform');\n\t\t\t\t\trenderer.removeStyle(hostEl, 'transform-origin');\n\t\t\t\t} else {\n\t\t\t\t\tconst vec = calculatePosition(group, camera, size);\n\t\t\t\t\trenderer.setStyle(hostEl, 'transform', `translate3d(${vec[0]}px,${vec[1]}px,0)`);\n\t\t\t\t\trenderer.setStyle(hostEl, 'transform-origin', '0 0');\n\t\t\t\t\trenderer.removeStyle(hostEl, 'pointer-events');\n\t\t\t\t\trenderer.removeStyle(hostEl, 'overflow');\n\t\t\t\t}\n\n\t\t\t\tif (prepend) target.prepend(hostEl);\n\t\t\t\telse target.appendChild(hostEl);\n\n\t\t\t\treturn () => {\n\t\t\t\t\tif (target) target.removeChild(hostEl);\n\t\t\t\t};\n\t\t\t});\n\n\t\t\tautoEffect(() => {\n\t\t\t\tthis.options();\n\t\t\t\tthis.html.options();\n\t\t\t\tisMeshSizeSet = false;\n\t\t\t});\n\t\t});\n\n\t\tlet visible = true;\n\t\tlet oldZoom = 0;\n\t\tlet oldPosition = [0, 0];\n\n\t\tinjectBeforeRender(({ camera: rootCamera }) => {\n\t\t\tconst [\n\t\t\t\thostEl,\n\t\t\t\ttransformOuterEl,\n\t\t\t\ttransformInnerEl,\n\t\t\t\tgroup,\n\t\t\t\tocclusionMesh,\n\t\t\t\tocclusionGeometry,\n\t\t\t\tisRaycastOcclusion,\n\t\t\t\t{ camera, size, viewport, raycaster, scene },\n\t\t\t\t{ calculatePosition, eps, zIndexRange, sprite, distanceFactor },\n\t\t\t\t{ transform, occlude, scale },\n\t\t\t] = [\n\t\t\t\tthis.host.nativeElement,\n\t\t\t\tthis.transformOuterRef()?.nativeElement,\n\t\t\t\tthis.transformInnerRef()?.nativeElement,\n\t\t\t\tthis.html.groupRef().nativeElement,\n\t\t\t\tthis.html.occlusionMeshRef()?.nativeElement,\n\t\t\t\tthis.html.occlusionGeometryRef()?.nativeElement,\n\t\t\t\tthis.html.isRaycastOcclusion(),\n\t\t\t\tthis.store.snapshot,\n\t\t\t\tthis.options(),\n\t\t\t\tthis.html.options(),\n\t\t\t];\n\n\t\t\tif (group) {\n\t\t\t\tcamera.updateMatrixWorld();\n\t\t\t\tgroup.updateWorldMatrix(true, false);\n\t\t\t\tconst vec = transform ? oldPosition : calculatePosition(group, camera, size);\n\n\t\t\t\tif (\n\t\t\t\t\ttransform ||\n\t\t\t\t\tMath.abs(oldZoom - camera.zoom) > eps ||\n\t\t\t\t\tMath.abs(oldPosition[0] - vec[0]) > eps ||\n\t\t\t\t\tMath.abs(oldPosition[1] - vec[1]) > eps\n\t\t\t\t) {\n\t\t\t\t\tconst isBehindCamera = isObjectBehindCamera(group, camera);\n\t\t\t\t\tlet raytraceTarget: null | undefined | boolean | Object3D[] = false;\n\n\t\t\t\t\tif (isRaycastOcclusion) {\n\t\t\t\t\t\tif (Array.isArray(occlude)) {\n\t\t\t\t\t\t\traytraceTarget = occlude.map((item) => resolveRef(item)) as Object3D[];\n\t\t\t\t\t\t} else if (occlude !== 'blending') {\n\t\t\t\t\t\t\traytraceTarget = [scene];\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\tconst previouslyVisible = visible;\n\t\t\t\t\tif (raytraceTarget) {\n\t\t\t\t\t\tconst isVisible = isObjectVisible(group, camera, raycaster, raytraceTarget);\n\t\t\t\t\t\tvisible = isVisible && !isBehindCamera;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tvisible = !isBehindCamera;\n\t\t\t\t\t}\n\n\t\t\t\t\tif (previouslyVisible !== visible) {\n\t\t\t\t\t\tif (this.occluded['listeners']) this.occluded.emit(!visible);\n\t\t\t\t\t\telse renderer.setStyle(hostEl, 'display', visible ? 'block' : 'none');\n\t\t\t\t\t}\n\n\t\t\t\t\tconst halfRange = Math.floor(zIndexRange[0] / 2);\n\t\t\t\t\tconst zRange = occlude\n\t\t\t\t\t\t? isRaycastOcclusion //\n\t\t\t\t\t\t\t? [zIndexRange[0], halfRange]\n\t\t\t\t\t\t\t: [halfRange - 1, 0]\n\t\t\t\t\t\t: zIndexRange;\n\n\t\t\t\t\trenderer.setStyle(hostEl, 'z-index', `${objectZIndex(group, camera, zRange)}`);\n\n\t\t\t\t\tif (transform) {\n\t\t\t\t\t\tconst [widthHalf, heightHalf] = [size.width / 2, size.height / 2];\n\t\t\t\t\t\tconst fov = camera.projectionMatrix.elements[5] * heightHalf;\n\t\t\t\t\t\tconst { isOrthographicCamera, top, left, bottom, right } = camera as OrthographicCamera;\n\t\t\t\t\t\tconst cameraMatrix = getCameraCSSMatrix(camera.matrixWorldInverse);\n\t\t\t\t\t\tconst cameraTransform = isOrthographicCamera\n\t\t\t\t\t\t\t? `scale(${fov})translate(${epsilon(-(right + left) / 2)}px,${epsilon((top + bottom) / 2)}px)`\n\t\t\t\t\t\t\t: `translateZ(${fov}px)`;\n\t\t\t\t\t\tlet matrix = group.matrixWorld;\n\t\t\t\t\t\tif (sprite) {\n\t\t\t\t\t\t\tmatrix = camera.matrixWorldInverse.clone().transpose().copyPosition(matrix).scale(group.scale);\n\t\t\t\t\t\t\tmatrix.elements[3] = matrix.elements[7] = matrix.elements[11] = 0;\n\t\t\t\t\t\t\tmatrix.elements[15] = 1;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\trenderer.setStyle(hostEl, 'width', size.width + 'px');\n\t\t\t\t\t\trenderer.setStyle(hostEl, 'height', size.height + 'px');\n\t\t\t\t\t\trenderer.setStyle(hostEl, 'perspective', isOrthographicCamera ? '' : `${fov}px`);\n\n\t\t\t\t\t\tif (transformOuterEl && transformInnerEl) {\n\t\t\t\t\t\t\trenderer.setStyle(\n\t\t\t\t\t\t\t\ttransformOuterEl,\n\t\t\t\t\t\t\t\t'transform',\n\t\t\t\t\t\t\t\t`${cameraTransform}${cameraMatrix}translate(${widthHalf}px,${heightHalf}px)`,\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\trenderer.setStyle(\n\t\t\t\t\t\t\t\ttransformInnerEl,\n\t\t\t\t\t\t\t\t'transform',\n\t\t\t\t\t\t\t\tgetObjectCSSMatrix(matrix, 1 / ((distanceFactor || 10) / 400)),\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\tconst scale = distanceFactor === undefined ? 1 : objectScale(group, camera) * distanceFactor;\n\t\t\t\t\t\trenderer.setStyle(hostEl, 'transform', `translate3d(${vec[0]}px,${vec[1]}px,0) scale(${scale})`);\n\t\t\t\t\t}\n\t\t\t\t\toldPosition = vec;\n\t\t\t\t\toldZoom = camera.zoom;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (!isRaycastOcclusion && occlusionMesh && !isMeshSizeSet) {\n\t\t\t\tif (transform) {\n\t\t\t\t\tif (transformOuterEl) {\n\t\t\t\t\t\tconst el = transformOuterEl.children[0];\n\n\t\t\t\t\t\tif (el?.clientWidth && el?.clientHeight) {\n\t\t\t\t\t\t\tconst { isOrthographicCamera } = camera as OrthographicCamera;\n\n\t\t\t\t\t\t\tif (isOrthographicCamera || occlusionGeometry) {\n\t\t\t\t\t\t\t\tif (scale) {\n\t\t\t\t\t\t\t\t\tif (!Array.isArray(scale)) {\n\t\t\t\t\t\t\t\t\t\tocclusionMesh.scale.setScalar(1 / (scale as number));\n\t\t\t\t\t\t\t\t\t} else if (scale instanceof Vector3) {\n\t\t\t\t\t\t\t\t\t\tocclusionMesh.scale.copy(scale.clone().divideScalar(1));\n\t\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\t\tocclusionMesh.scale.set(1 / scale[0], 1 / scale[1], 1 / scale[2]);\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tconst ratio = (distanceFactor || 10) / 400;\n\t\t\t\t\t\t\t\tconst w = el.clientWidth * ratio;\n\t\t\t\t\t\t\t\tconst h = el.clientHeight * ratio;\n\n\t\t\t\t\t\t\t\tocclusionMesh.scale.set(w, h, 1);\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\tisMeshSizeSet = true;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tconst ele = hostEl.children[0];\n\n\t\t\t\t\tif (ele?.clientWidth && ele?.clientHeight) {\n\t\t\t\t\t\tconst ratio = 1 / viewport.factor;\n\t\t\t\t\t\tconst w = ele.clientWidth * ratio;\n\t\t\t\t\t\tconst h = ele.clientHeight * ratio;\n\n\t\t\t\t\t\tocclusionMesh.scale.set(w, h, 1);\n\n\t\t\t\t\t\tisMeshSizeSet = true;\n\t\t\t\t\t}\n\n\t\t\t\t\tocclusionMesh.lookAt(rootCamera.position);\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t}\n}\n"]}

package/esm2022/misc/lib/html/html.mjs

@@ -0,0 +1,129 @@
+import { ChangeDetectionStrategy, Component, computed, CUSTOM_ELEMENTS_SCHEMA, input, viewChild, } from '@angular/core';
+import { extend, is, omit, pick } from 'angular-three';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { DoubleSide, Group, Mesh, PlaneGeometry, ShaderMaterial } from 'three';
+import * as i0 from "@angular/core";
+const defaultHtmlOptions = {
+    occlude: false,
+    transform: false,
+    castShadow: false,
+    receiveShadow: false,
+};
+export class NgtsHTML {
+    constructor() {
+        this.options = input(defaultHtmlOptions, { transform: mergeInputs(defaultHtmlOptions) });
+        this.parameters = omit(this.options, ['occlude', 'castShadow', 'receiveShadow', 'transform']);
+        this.groupRef = viewChild.required('group');
+        this.occlusionMeshRef = viewChild('occlusionMesh');
+        this.occlusionGeometryRef = viewChild('occlusionGeometry');
+        this.occlude = pick(this.options, 'occlude');
+        this.transform = pick(this.options, 'transform');
+        this.castShadow = pick(this.options, 'castShadow');
+        this.receiveShadow = pick(this.options, 'receiveShadow');
+        this.scale = pick(this.options, 'scale');
+        this.isRaycastOcclusion = computed(() => {
+            const occlude = this.occlude();
+            return (occlude && occlude !== 'blending') || (Array.isArray(occlude) && occlude.length && is.ref(occlude[0]));
+        });
+        this.shaders = computed(() => {
+            const transform = this.transform();
+            const vertexShader = !transform
+                ? /* language=glsl 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;
+            const fragmentShader = /* language=glsl glsl */ `
+      void main() {
+        gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
+      }
+    `;
+            return { vertexShader, fragmentShader };
+        });
+        this.vertexShader = pick(this.shaders, 'vertexShader');
+        this.fragmentShader = pick(this.shaders, 'fragmentShader');
+        this.DoubleSide = DoubleSide;
+        extend({ Group, Mesh, PlaneGeometry, ShaderMaterial });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsHTML, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.0", type: NgtsHTML, isStandalone: true, selector: "ngts-html", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "groupRef", first: true, predicate: ["group"], descendants: true, isSignal: true }, { propertyName: "occlusionMeshRef", first: true, predicate: ["occlusionMesh"], descendants: true, isSignal: true }, { propertyName: "occlusionGeometryRef", first: true, predicate: ["occlusionGeometry"], descendants: true, isSignal: true }], ngImport: i0, template: `
+		<ngt-group #group [parameters]="parameters()">
+			@if (occlude() && !isRaycastOcclusion()) {
+				<ngt-mesh #occlusionMesh [castShadow]="castShadow()" [receiveShadow]="receiveShadow()">
+					<ng-content select="[data-occlusion-geometry]">
+						<ngt-plane-geometry #occlusionGeometry />
+					</ng-content>
+					<ng-content select="[data-occlusion-material]">
+						<ngt-shader-material
+							[side]="DoubleSide"
+							[vertexShader]="vertexShader()"
+							[fragmentShader]="fragmentShader()"
+						/>
+					</ng-content>
+				</ngt-mesh>
+			}
+		</ngt-group>
+
+		<ng-content />
+	`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsHTML, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-html',
+                    standalone: true,
+                    template: `
+		<ngt-group #group [parameters]="parameters()">
+			@if (occlude() && !isRaycastOcclusion()) {
+				<ngt-mesh #occlusionMesh [castShadow]="castShadow()" [receiveShadow]="receiveShadow()">
+					<ng-content select="[data-occlusion-geometry]">
+						<ngt-plane-geometry #occlusionGeometry />
+					</ng-content>
+					<ng-content select="[data-occlusion-material]">
+						<ngt-shader-material
+							[side]="DoubleSide"
+							[vertexShader]="vertexShader()"
+							[fragmentShader]="fragmentShader()"
+						/>
+					</ng-content>
+				</ngt-mesh>
+			}
+		</ngt-group>
+
+		<ng-content />
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"html.js","sourceRoot":"","sources":["../../../../../../../libs/soba/misc/src/lib/html/html.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n\tChangeDetectionStrategy,\n\tComponent,\n\tcomputed,\n\tCUSTOM_ELEMENTS_SCHEMA,\n\tElementRef,\n\tinput,\n\tviewChild,\n} from '@angular/core';\nimport { extend, is, NgtGroup, omit, pick } from 'angular-three';\nimport { mergeInputs } from 'ngxtension/inject-inputs';\nimport { DoubleSide, Group, Mesh, Object3D, PlaneGeometry, ShaderMaterial } from 'three';\n\nexport interface NgtsHTMLOptions extends Partial<NgtGroup> {\n\tocclude: ElementRef<Object3D>[] | Object3D[] | boolean | 'raycast' | 'blending';\n\ttransform: boolean;\n\tcastShadow: boolean;\n\treceiveShadow: boolean;\n}\n\nconst defaultHtmlOptions: NgtsHTMLOptions = {\n\tocclude: false,\n\ttransform: false,\n\tcastShadow: false,\n\treceiveShadow: false,\n};\n\n@Component({\n\tselector: 'ngts-html',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-group #group [parameters]=\"parameters()\">\n\t\t\t@if (occlude() && !isRaycastOcclusion()) {\n\t\t\t\t<ngt-mesh #occlusionMesh [castShadow]=\"castShadow()\" [receiveShadow]=\"receiveShadow()\">\n\t\t\t\t\t<ng-content select=\"[data-occlusion-geometry]\">\n\t\t\t\t\t\t<ngt-plane-geometry #occlusionGeometry />\n\t\t\t\t\t</ng-content>\n\t\t\t\t\t<ng-content select=\"[data-occlusion-material]\">\n\t\t\t\t\t\t<ngt-shader-material\n\t\t\t\t\t\t\t[side]=\"DoubleSide\"\n\t\t\t\t\t\t\t[vertexShader]=\"vertexShader()\"\n\t\t\t\t\t\t\t[fragmentShader]=\"fragmentShader()\"\n\t\t\t\t\t\t/>\n\t\t\t\t\t</ng-content>\n\t\t\t\t</ngt-mesh>\n\t\t\t}\n\t\t</ngt-group>\n\n\t\t<ng-content />\n\t`,\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class NgtsHTML {\n\toptions = input(defaultHtmlOptions, { transform: mergeInputs(defaultHtmlOptions) });\n\tparameters = omit(this.options, ['occlude', 'castShadow', 'receiveShadow', 'transform']);\n\n\tgroupRef = viewChild.required<ElementRef<Group>>('group');\n\tocclusionMeshRef = viewChild<ElementRef<Mesh>>('occlusionMesh');\n\tocclusionGeometryRef = viewChild<ElementRef<PlaneGeometry>>('occlusionGeometry');\n\n\tocclude = pick(this.options, 'occlude');\n\ttransform = pick(this.options, 'transform');\n\tcastShadow = pick(this.options, 'castShadow');\n\treceiveShadow = pick(this.options, 'receiveShadow');\n\tscale = pick(this.options, 'scale');\n\n\tisRaycastOcclusion = computed(() => {\n\t\tconst occlude = this.occlude();\n\t\treturn (occlude && occlude !== 'blending') || (Array.isArray(occlude) && occlude.length && is.ref(occlude[0]));\n\t});\n\n\tprivate shaders = computed(() => {\n\t\tconst transform = this.transform();\n\t\tconst vertexShader = !transform\n\t\t\t? /* language=glsl 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: undefined;\n\n\t\tconst fragmentShader = /* language=glsl glsl */ `\n      void main() {\n        gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);\n      }\n    `;\n\n\t\treturn { vertexShader, fragmentShader };\n\t});\n\n\tvertexShader = pick(this.shaders, 'vertexShader');\n\tfragmentShader = pick(this.shaders, 'fragmentShader');\n\n\tconstructor() {\n\t\textend({ Group, Mesh, PlaneGeometry, ShaderMaterial });\n\t}\n\n\tprotected readonly DoubleSide = DoubleSide;\n}\n"]}

package/esm2022/misc/lib/html/utils.mjs

@@ -0,0 +1,74 @@
+import { OrthographicCamera, PerspectiveCamera, Vector2, Vector3 } from 'three';
+const v1 = new Vector3();
+const v2 = new Vector3();
+const v3 = new Vector3();
+const v4 = new Vector2();
+export function defaultCalculatePosition(el, camera, size) {
+    const objectPos = v1.setFromMatrixPosition(el.matrixWorld);
+    objectPos.project(camera);
+    const widthHalf = size.width / 2;
+    const heightHalf = size.height / 2;
+    return [objectPos.x * widthHalf + widthHalf, -(objectPos.y * heightHalf) + heightHalf];
+}
+export function isObjectBehindCamera(el, camera) {
+    const objectPos = v1.setFromMatrixPosition(el.matrixWorld);
+    const cameraPos = v2.setFromMatrixPosition(camera.matrixWorld);
+    const deltaCamObj = objectPos.sub(cameraPos);
+    const camDir = camera.getWorldDirection(v3);
+    return deltaCamObj.angleTo(camDir) > Math.PI / 2;
+}
+export function isObjectVisible(el, camera, raycaster, occlude) {
+    const elPos = v1.setFromMatrixPosition(el.matrixWorld);
+    const screenPos = elPos.clone();
+    screenPos.project(camera);
+    v4.set(screenPos.x, screenPos.y);
+    raycaster.setFromCamera(v4, camera);
+    const intersects = raycaster.intersectObjects(occlude, true);
+    if (intersects.length) {
+        const intersectionDistance = intersects[0].distance;
+        const pointDistance = elPos.distanceTo(raycaster.ray.origin);
+        return pointDistance < intersectionDistance;
+    }
+    return true;
+}
+export function objectScale(el, camera) {
+    if (camera instanceof OrthographicCamera)
+        return camera.zoom;
+    if (camera instanceof PerspectiveCamera) {
+        const objectPos = v1.setFromMatrixPosition(el.matrixWorld);
+        const cameraPos = v2.setFromMatrixPosition(camera.matrixWorld);
+        const vFOV = (camera.fov * Math.PI) / 180;
+        const dist = objectPos.distanceTo(cameraPos);
+        const scaleFOV = 2 * Math.tan(vFOV / 2) * dist;
+        return 1 / scaleFOV;
+    }
+    return 1;
+}
+export function objectZIndex(el, camera, zIndexRange) {
+    if (camera instanceof PerspectiveCamera || camera instanceof OrthographicCamera) {
+        const objectPos = v1.setFromMatrixPosition(el.matrixWorld);
+        const cameraPos = v2.setFromMatrixPosition(camera.matrixWorld);
+        const dist = objectPos.distanceTo(cameraPos);
+        const A = (zIndexRange[1] - zIndexRange[0]) / (camera.far - camera.near);
+        const B = zIndexRange[1] - A * camera.far;
+        return Math.round(A * dist + B);
+    }
+    return undefined;
+}
+export function epsilon(value) {
+    return Math.abs(value) < 1e-10 ? 0 : value;
+}
+export function getCSSMatrix(matrix, multipliers, prepend = '') {
+    let matrix3d = 'matrix3d(';
+    for (let i = 0; i !== 16; i++) {
+        matrix3d += epsilon(multipliers[i] * matrix.elements[i]) + (i !== 15 ? ',' : ')');
+    }
+    return prepend + matrix3d;
+}
+export const getCameraCSSMatrix = ((multipliers) => {
+    return (matrix) => getCSSMatrix(matrix, multipliers);
+})([1, -1, 1, 1, 1, -1, 1, 1, 1, -1, 1, 1, 1, -1, 1, 1]);
+export const getObjectCSSMatrix = ((scaleMultipliers) => {
+    return (matrix, factor) => getCSSMatrix(matrix, scaleMultipliers(factor), 'translate(-50%,-50%)');
+})((f) => [1 / f, 1 / f, 1 / f, 1, -1 / f, -1 / f, -1 / f, -1, 1 / f, 1 / f, 1 / f, 1, 1, 1, 1, 1]);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../../../libs/soba/misc/src/lib/html/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { Camera, Matrix4, Object3D, OrthographicCamera, PerspectiveCamera, Raycaster, Vector2, Vector3 } from 'three';\n\nconst v1 = new Vector3();\nconst v2 = new Vector3();\nconst v3 = new Vector3();\nconst v4 = new Vector2();\n\nexport function defaultCalculatePosition(el: Object3D, camera: Camera, size: { width: number; height: number }) {\n\tconst objectPos = v1.setFromMatrixPosition(el.matrixWorld);\n\tobjectPos.project(camera);\n\tconst widthHalf = size.width / 2;\n\tconst heightHalf = size.height / 2;\n\treturn [objectPos.x * widthHalf + widthHalf, -(objectPos.y * heightHalf) + heightHalf];\n}\n\nexport type CalculatePosition = typeof defaultCalculatePosition;\n\nexport function isObjectBehindCamera(el: Object3D, camera: Camera) {\n\tconst objectPos = v1.setFromMatrixPosition(el.matrixWorld);\n\tconst cameraPos = v2.setFromMatrixPosition(camera.matrixWorld);\n\tconst deltaCamObj = objectPos.sub(cameraPos);\n\tconst camDir = camera.getWorldDirection(v3);\n\treturn deltaCamObj.angleTo(camDir) > Math.PI / 2;\n}\n\nexport function isObjectVisible(el: Object3D, camera: Camera, raycaster: Raycaster, occlude: Object3D[]) {\n\tconst elPos = v1.setFromMatrixPosition(el.matrixWorld);\n\tconst screenPos = elPos.clone();\n\tscreenPos.project(camera);\n\tv4.set(screenPos.x, screenPos.y);\n\traycaster.setFromCamera(v4, camera);\n\tconst intersects = raycaster.intersectObjects(occlude, true);\n\tif (intersects.length) {\n\t\tconst intersectionDistance = intersects[0].distance;\n\t\tconst pointDistance = elPos.distanceTo(raycaster.ray.origin);\n\t\treturn pointDistance < intersectionDistance;\n\t}\n\treturn true;\n}\n\nexport function objectScale(el: Object3D, camera: Camera) {\n\tif (camera instanceof OrthographicCamera) return camera.zoom;\n\tif (camera instanceof PerspectiveCamera) {\n\t\tconst objectPos = v1.setFromMatrixPosition(el.matrixWorld);\n\t\tconst cameraPos = v2.setFromMatrixPosition(camera.matrixWorld);\n\t\tconst vFOV = (camera.fov * Math.PI) / 180;\n\t\tconst dist = objectPos.distanceTo(cameraPos);\n\t\tconst scaleFOV = 2 * Math.tan(vFOV / 2) * dist;\n\t\treturn 1 / scaleFOV;\n\t}\n\treturn 1;\n}\n\nexport function objectZIndex(el: Object3D, camera: Camera, zIndexRange: Array<number>) {\n\tif (camera instanceof PerspectiveCamera || camera instanceof OrthographicCamera) {\n\t\tconst objectPos = v1.setFromMatrixPosition(el.matrixWorld);\n\t\tconst cameraPos = v2.setFromMatrixPosition(camera.matrixWorld);\n\t\tconst dist = objectPos.distanceTo(cameraPos);\n\t\tconst A = (zIndexRange[1] - zIndexRange[0]) / (camera.far - camera.near);\n\t\tconst B = zIndexRange[1] - A * camera.far;\n\t\treturn Math.round(A * dist + B);\n\t}\n\treturn undefined;\n}\n\nexport function epsilon(value: number) {\n\treturn Math.abs(value) < 1e-10 ? 0 : value;\n}\n\nexport function getCSSMatrix(matrix: Matrix4, multipliers: number[], prepend = '') {\n\tlet matrix3d = 'matrix3d(';\n\tfor (let i = 0; i !== 16; i++) {\n\t\tmatrix3d += epsilon(multipliers[i] * matrix.elements[i]) + (i !== 15 ? ',' : ')');\n\t}\n\treturn prepend + matrix3d;\n}\n\nexport const getCameraCSSMatrix = ((multipliers: number[]) => {\n\treturn (matrix: Matrix4) => getCSSMatrix(matrix, multipliers);\n})([1, -1, 1, 1, 1, -1, 1, 1, 1, -1, 1, 1, 1, -1, 1, 1]);\n\nexport const getObjectCSSMatrix = ((scaleMultipliers: (n: number) => number[]) => {\n\treturn (matrix: Matrix4, factor: number) => getCSSMatrix(matrix, scaleMultipliers(factor), 'translate(-50%,-50%)');\n})((f: number) => [1 / f, 1 / f, 1 / f, 1, -1 / f, -1 / f, -1 / f, -1, 1 / f, 1 / f, 1 / f, 1, 1, 1, 1, 1]);\n"]}