angular-three-soba 2.0.0-beta.26 → 2.0.0-beta.261

package/esm2022/staging/lib/render-texture.mjs

@@ -0,0 +1,213 @@
+import { NgTemplateOutlet } from '@angular/common';
+import { CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, Component, Directive, TemplateRef, computed, contentChild, input, } from '@angular/core';
+import { NgtArgs, NgtPortal, NgtPortalContent, extend, getLocalState, injectBeforeRender, injectStore, omit, pick, prepare, } from 'angular-three';
+import { injectFBO } from 'angular-three-soba/misc';
+import { injectAutoEffect } from 'ngxtension/auto-effect';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { Group, Object3D, Scene } from 'three';
+import * as i0 from "@angular/core";
+extend({ Group });
+export class NgtsRenderTextureContainer {
+    constructor() {
+        this.fbo = input.required();
+        this.renderPriority = input.required();
+        this.frames = input.required();
+        this.injector = input.required();
+        this.store = injectStore();
+        injectAutoEffect()(() => {
+            // track
+            this.store.state();
+            const renderPriority = this.renderPriority();
+            let count = 0;
+            let oldAutoClear;
+            let oldXrEnabled;
+            let oldRenderTarget;
+            let oldIsPresenting;
+            const sub = injectBeforeRender(({ gl, scene, camera }) => {
+                const [fbo, frames] = [this.fbo(), this.frames()];
+                // NOTE: render  the frames ^ 2
+                if (frames === Infinity || count < frames * frames) {
+                    oldAutoClear = gl.autoClear;
+                    oldXrEnabled = gl.xr.enabled;
+                    oldRenderTarget = gl.getRenderTarget();
+                    oldIsPresenting = gl.xr.isPresenting;
+                    gl.autoClear = true;
+                    gl.xr.enabled = false;
+                    gl.xr.isPresenting = false;
+                    gl.setRenderTarget(fbo);
+                    gl.render(scene, camera);
+                    gl.setRenderTarget(oldRenderTarget);
+                    gl.autoClear = oldAutoClear;
+                    gl.xr.enabled = oldXrEnabled;
+                    gl.xr.isPresenting = oldIsPresenting;
+                    count++;
+                }
+            }, { priority: renderPriority, injector: this.injector() });
+            return () => sub();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: NgtsRenderTextureContainer, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.1.0", type: NgtsRenderTextureContainer, isStandalone: true, selector: "ngts-render-texture-container", inputs: { fbo: { classPropertyName: "fbo", publicName: "fbo", isSignal: true, isRequired: true, transformFunction: null }, renderPriority: { classPropertyName: "renderPriority", publicName: "renderPriority", isSignal: true, isRequired: true, transformFunction: null }, frames: { classPropertyName: "frames", publicName: "frames", isSignal: true, isRequired: true, transformFunction: null }, injector: { classPropertyName: "injector", publicName: "injector", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0, template: `
+		<ng-content />
+	`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: NgtsRenderTextureContainer, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: true,
+                    selector: 'ngts-render-texture-container',
+                    template: `
+		<ng-content />
+	`,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [] });
+const defaultOptions = {
+    samples: 8,
+    renderPriority: 0,
+    eventPriority: 0,
+    frames: Infinity,
+    stencilBuffer: false,
+    depthBuffer: true,
+    generateMipmaps: false,
+};
+export class NgtsRenderTextureContent {
+    static ngTemplateContextGuard(_, ctx) {
+        return true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: NgtsRenderTextureContent, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.0", type: NgtsRenderTextureContent, isStandalone: true, selector: "ng-template[renderTextureContent]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: NgtsRenderTextureContent, decorators: [{
+            type: Directive,
+            args: [{ selector: 'ng-template[renderTextureContent]', standalone: true }]
+        }] });
+let incrementId = 0;
+export class NgtsRenderTexture {
+    constructor() {
+        this.attach = input('map');
+        this.options = input(defaultOptions, { transform: mergeInputs(defaultOptions) });
+        this.parameters = omit(this.options, [
+            'samples',
+            'renderPriority',
+            'eventPriority',
+            'frames',
+            'stencilBuffer',
+            'depthBuffer',
+            'generateMipmaps',
+            'compute',
+            'width',
+            'height',
+        ]);
+        this.content = contentChild.required(NgtsRenderTextureContent, { read: TemplateRef });
+        this.store = injectStore();
+        this.size = this.store.select('size');
+        this.viewport = this.store.select('viewport');
+        this.fboParams = computed(() => ({
+            width: (this.options().width || this.size().width) * this.viewport().dpr,
+            height: (this.options().height || this.size().height) * this.viewport().dpr,
+            settings: {
+                samples: this.options().samples,
+                depthBuffer: this.options().depthBuffer,
+                stencilBuffer: this.options().stencilBuffer,
+                generateMipmaps: this.options().generateMipmaps,
+            },
+        }));
+        this.renderPriority = pick(this.options, 'renderPriority');
+        this.frames = pick(this.options, 'frames');
+        this.fbo = injectFBO(this.fboParams);
+        this.virtualScene = computed(() => {
+            const scene = prepare(new Scene());
+            scene.name = `ngts-render-texture-virtual-scene-${incrementId++}`;
+            return scene;
+        });
+        this.eventPriority = pick(this.options, 'eventPriority');
+        this.compute = computed(() => this.options().compute || this.uvCompute);
+        this.uvCompute = (event, root, previous) => {
+            const fbo = this.fbo();
+            if (!fbo)
+                return;
+            const state = root.snapshot;
+            const previousState = previous?.snapshot;
+            // Since this is only a texture it does not have an easy way to obtain the parent, which we
+            // need to transform event coordinates to local coordinates. We use r3f internals to find the
+            // next Object3D.
+            let parent = getLocalState(fbo.texture)?.parent();
+            while (parent && !(parent instanceof Object3D)) {
+                parent = getLocalState(parent)?.parent();
+            }
+            if (!parent)
+                return;
+            // First we call the previous state-onion-layers compute, this is what makes it possible to nest portals
+            if (previousState && !previousState.raycaster.camera) {
+                previousState.events.compute?.(event, previous, previous.snapshot.previousRoot);
+            }
+            // We run a quick check against the parent, if it isn't hit there's no need to raycast at all
+            const [intersection] = previousState?.raycaster.intersectObject(parent) || [];
+            if (!intersection)
+                return;
+            // We take that hits uv coords, set up this layers raycaster, et voilà, we have raycasting on arbitrary surfaces
+            const uv = intersection.uv;
+            if (!uv)
+                return;
+            state.raycaster.setFromCamera(state.pointer.set(uv.x * 2 - 1, uv.y * 2 - 1), state.camera);
+        };
+    }
+    onPointerOver() {
+        /* noop */
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: NgtsRenderTexture, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.1.0", type: NgtsRenderTexture, isStandalone: true, selector: "ngts-render-texture", inputs: { attach: { classPropertyName: "attach", publicName: "attach", isSignal: true, isRequired: false, transformFunction: null }, options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, queries: [{ propertyName: "content", first: true, predicate: NgtsRenderTextureContent, descendants: true, read: TemplateRef, isSignal: true }], ngImport: i0, template: `
+		<ngt-portal [container]="virtualScene()" [state]="{ events: { compute: compute(), priority: eventPriority() } }">
+			<ng-template portalContent let-injector="injector" let-container="container">
+				<ngts-render-texture-container
+					[fbo]="fbo()"
+					[renderPriority]="renderPriority()"
+					[frames]="frames()"
+					[injector]="injector"
+				>
+					<ng-container
+						[ngTemplateOutlet]="content()"
+						[ngTemplateOutletInjector]="injector"
+						[ngTemplateOutletContext]="{ container, injector }"
+					/>
+					<ngt-group (pointerover)="onPointerOver()" />
+				</ngts-render-texture-container>
+			</ng-template>
+		</ngt-portal>
+
+		<ngt-primitive *args="[fbo().texture]" [attach]="attach()" [parameters]="parameters()" />
+	`, isInline: true, dependencies: [{ kind: "component", type: NgtPortal, selector: "ngt-portal", inputs: ["container", "state", "autoRender", "autoRenderPriority"] }, { kind: "component", type: NgtsRenderTextureContainer, selector: "ngts-render-texture-container", inputs: ["fbo", "renderPriority", "frames", "injector"] }, { kind: "directive", type: NgtPortalContent, selector: "ng-template[portalContent]" }, { kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }, { kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: NgtsRenderTexture, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-render-texture',
+                    standalone: true,
+                    template: `
+		<ngt-portal [container]="virtualScene()" [state]="{ events: { compute: compute(), priority: eventPriority() } }">
+			<ng-template portalContent let-injector="injector" let-container="container">
+				<ngts-render-texture-container
+					[fbo]="fbo()"
+					[renderPriority]="renderPriority()"
+					[frames]="frames()"
+					[injector]="injector"
+				>
+					<ng-container
+						[ngTemplateOutlet]="content()"
+						[ngTemplateOutletInjector]="injector"
+						[ngTemplateOutletContext]="{ container, injector }"
+					/>
+					<ngt-group (pointerover)="onPointerOver()" />
+				</ngts-render-texture-container>
+			</ng-template>
+		</ngt-portal>
+
+		<ngt-primitive *args="[fbo().texture]" [attach]="attach()" [parameters]="parameters()" />
+	`,
+                    imports: [NgtPortal, NgtsRenderTextureContainer, NgtPortalContent, NgtArgs, NgTemplateOutlet],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"render-texture.js","sourceRoot":"","sources":["../../../../../../libs/soba/staging/src/lib/render-texture.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgTemplateOutlet } from '@angular/common';\nimport {\n\tCUSTOM_ELEMENTS_SCHEMA,\n\tChangeDetectionStrategy,\n\tComponent,\n\tDirective,\n\tInjector,\n\tTemplateRef,\n\tcomputed,\n\tcontentChild,\n\tinput,\n} from '@angular/core';\nimport {\n\tNgtArgs,\n\tNgtComputeFunction,\n\tNgtPortal,\n\tNgtPortalContent,\n\tNgtTexture,\n\textend,\n\tgetLocalState,\n\tinjectBeforeRender,\n\tinjectStore,\n\tomit,\n\tpick,\n\tprepare,\n} from 'angular-three';\nimport { injectFBO } from 'angular-three-soba/misc';\nimport { injectAutoEffect } from 'ngxtension/auto-effect';\nimport { mergeInputs } from 'ngxtension/inject-inputs';\nimport { Group, Object3D, Scene, WebGLRenderTarget } from 'three';\n\nextend({ Group });\n\nexport interface NgtsRenderTextureOptions extends Partial<Omit<NgtTexture, 'attach'>> {\n\t/** Optional width of the texture, defaults to viewport bounds */\n\twidth?: number;\n\t/** Optional height of the texture, defaults to viewport bounds */\n\theight?: number;\n\t/** Optional fbo samples */\n\tsamples: number;\n\t/** Optional stencil buffer, defaults to false */\n\tstencilBuffer: boolean;\n\t/** Optional depth buffer, defaults to true */\n\tdepthBuffer: boolean;\n\t/** Optional generate mipmaps, defaults to false */\n\tgenerateMipmaps: boolean;\n\t/** Optional render priority, defaults to 0 */\n\trenderPriority: number;\n\t/** Optional event priority, defaults to 0 */\n\teventPriority: number;\n\t/** Optional frame count, defaults to Infinity. If you set it to 1, it would only render a single frame, etc */\n\tframes: number;\n\t/** Optional event compute, defaults to undefined */\n\tcompute?: (event: any, state: any, previous: any) => false | undefined;\n}\n\n@Component({\n\tstandalone: true,\n\tselector: 'ngts-render-texture-container',\n\ttemplate: `\n\t\t<ng-content />\n\t`,\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class NgtsRenderTextureContainer {\n\tfbo = input.required<WebGLRenderTarget>();\n\trenderPriority = input.required<number>();\n\tframes = input.required<number>();\n\tinjector = input.required<Injector>();\n\n\tprivate store = injectStore();\n\n\tconstructor() {\n\t\tinjectAutoEffect()(() => {\n\t\t\t// track\n\t\t\tthis.store.state();\n\t\t\tconst renderPriority = this.renderPriority();\n\n\t\t\tlet count = 0;\n\t\t\tlet oldAutoClear: boolean;\n\t\t\tlet oldXrEnabled: boolean;\n\t\t\tlet oldRenderTarget: WebGLRenderTarget | null;\n\t\t\tlet oldIsPresenting: boolean;\n\t\t\tconst sub = injectBeforeRender(\n\t\t\t\t({ gl, scene, camera }) => {\n\t\t\t\t\tconst [fbo, frames] = [this.fbo(), this.frames()];\n\t\t\t\t\t// NOTE: render  the frames ^ 2\n\t\t\t\t\tif (frames === Infinity || count < frames * frames) {\n\t\t\t\t\t\toldAutoClear = gl.autoClear;\n\t\t\t\t\t\toldXrEnabled = gl.xr.enabled;\n\t\t\t\t\t\toldRenderTarget = gl.getRenderTarget();\n\t\t\t\t\t\toldIsPresenting = gl.xr.isPresenting;\n\t\t\t\t\t\tgl.autoClear = true;\n\t\t\t\t\t\tgl.xr.enabled = false;\n\t\t\t\t\t\tgl.xr.isPresenting = false;\n\t\t\t\t\t\tgl.setRenderTarget(fbo);\n\t\t\t\t\t\tgl.render(scene, camera);\n\t\t\t\t\t\tgl.setRenderTarget(oldRenderTarget);\n\t\t\t\t\t\tgl.autoClear = oldAutoClear;\n\t\t\t\t\t\tgl.xr.enabled = oldXrEnabled;\n\t\t\t\t\t\tgl.xr.isPresenting = oldIsPresenting;\n\t\t\t\t\t\tcount++;\n\t\t\t\t\t}\n\t\t\t\t},\n\t\t\t\t{ priority: renderPriority, injector: this.injector() },\n\t\t\t);\n\n\t\t\treturn () => sub();\n\t\t});\n\t}\n}\n\nconst defaultOptions: NgtsRenderTextureOptions = {\n\tsamples: 8,\n\trenderPriority: 0,\n\teventPriority: 0,\n\tframes: Infinity,\n\tstencilBuffer: false,\n\tdepthBuffer: true,\n\tgenerateMipmaps: false,\n};\n\n@Directive({ selector: 'ng-template[renderTextureContent]', standalone: true })\nexport class NgtsRenderTextureContent {\n\tstatic ngTemplateContextGuard(\n\t\t_: NgtsRenderTextureContent,\n\t\tctx: unknown,\n\t): ctx is { container: Object3D; injector: Injector } {\n\t\treturn true;\n\t}\n}\n\nlet incrementId = 0;\n\n@Component({\n\tselector: 'ngts-render-texture',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-portal [container]=\"virtualScene()\" [state]=\"{ events: { compute: compute(), priority: eventPriority() } }\">\n\t\t\t<ng-template portalContent let-injector=\"injector\" let-container=\"container\">\n\t\t\t\t<ngts-render-texture-container\n\t\t\t\t\t[fbo]=\"fbo()\"\n\t\t\t\t\t[renderPriority]=\"renderPriority()\"\n\t\t\t\t\t[frames]=\"frames()\"\n\t\t\t\t\t[injector]=\"injector\"\n\t\t\t\t>\n\t\t\t\t\t<ng-container\n\t\t\t\t\t\t[ngTemplateOutlet]=\"content()\"\n\t\t\t\t\t\t[ngTemplateOutletInjector]=\"injector\"\n\t\t\t\t\t\t[ngTemplateOutletContext]=\"{ container, injector }\"\n\t\t\t\t\t/>\n\t\t\t\t\t<ngt-group (pointerover)=\"onPointerOver()\" />\n\t\t\t\t</ngts-render-texture-container>\n\t\t\t</ng-template>\n\t\t</ngt-portal>\n\n\t\t<ngt-primitive *args=\"[fbo().texture]\" [attach]=\"attach()\" [parameters]=\"parameters()\" />\n\t`,\n\timports: [NgtPortal, NgtsRenderTextureContainer, NgtPortalContent, NgtArgs, NgTemplateOutlet],\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class NgtsRenderTexture {\n\tattach = input<string | string[]>('map');\n\toptions = input(defaultOptions, { transform: mergeInputs(defaultOptions) });\n\tparameters = omit(this.options, [\n\t\t'samples',\n\t\t'renderPriority',\n\t\t'eventPriority',\n\t\t'frames',\n\t\t'stencilBuffer',\n\t\t'depthBuffer',\n\t\t'generateMipmaps',\n\t\t'compute',\n\t\t'width',\n\t\t'height',\n\t]);\n\n\tcontent = contentChild.required(NgtsRenderTextureContent, { read: TemplateRef });\n\n\tprivate store = injectStore();\n\tprivate size = this.store.select('size');\n\tprivate viewport = this.store.select('viewport');\n\n\tprivate fboParams = computed(() => ({\n\t\twidth: (this.options().width || this.size().width) * this.viewport().dpr,\n\t\theight: (this.options().height || this.size().height) * this.viewport().dpr,\n\t\tsettings: {\n\t\t\tsamples: this.options().samples,\n\t\t\tdepthBuffer: this.options().depthBuffer,\n\t\t\tstencilBuffer: this.options().stencilBuffer,\n\t\t\tgenerateMipmaps: this.options().generateMipmaps,\n\t\t},\n\t}));\n\n\trenderPriority = pick(this.options, 'renderPriority');\n\tframes = pick(this.options, 'frames');\n\tfbo = injectFBO(this.fboParams);\n\tvirtualScene = computed(() => {\n\t\tconst scene = prepare(new Scene());\n\t\tscene.name = `ngts-render-texture-virtual-scene-${incrementId++}`;\n\t\treturn scene;\n\t});\n\teventPriority = pick(this.options, 'eventPriority');\n\tcompute = computed(() => this.options().compute || this.uvCompute);\n\n\tuvCompute: NgtComputeFunction = (event, root, previous) => {\n\t\tconst fbo = this.fbo();\n\t\tif (!fbo) return;\n\t\tconst state = root.snapshot;\n\t\tconst previousState = previous?.snapshot;\n\n\t\t// Since this is only a texture it does not have an easy way to obtain the parent, which we\n\t\t// need to transform event coordinates to local coordinates. We use r3f internals to find the\n\t\t// next Object3D.\n\t\tlet parent = getLocalState(fbo.texture)?.parent();\n\t\twhile (parent && !(parent instanceof Object3D)) {\n\t\t\tparent = getLocalState(parent)?.parent();\n\t\t}\n\n\t\tif (!parent) return;\n\t\t// First we call the previous state-onion-layers compute, this is what makes it possible to nest portals\n\t\tif (previousState && !previousState.raycaster.camera) {\n\t\t\tpreviousState.events.compute?.(event, previous, previous.snapshot.previousRoot);\n\t\t}\n\t\t// We run a quick check against the parent, if it isn't hit there's no need to raycast at all\n\t\tconst [intersection] = previousState?.raycaster.intersectObject(parent) || [];\n\t\tif (!intersection) return;\n\t\t// We take that hits uv coords, set up this layers raycaster, et voilà, we have raycasting on arbitrary surfaces\n\t\tconst uv = intersection.uv;\n\t\tif (!uv) return;\n\t\tstate.raycaster.setFromCamera(state.pointer.set(uv.x * 2 - 1, uv.y * 2 - 1), state.camera);\n\t};\n\n\tonPointerOver() {\n\t\t/* noop */\n\t}\n}\n"]}

package/esm2022/staging/lib/sky.mjs

@@ -0,0 +1,86 @@
+import { ChangeDetectionStrategy, Component, computed, CUSTOM_ELEMENTS_SCHEMA, input } from '@angular/core';
+import { NgtArgs, omit, pick, vector3 } from 'angular-three';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { Vector3 } from 'three';
+import { Sky } from 'three-stdlib';
+import * as i0 from "@angular/core";
+export function calcPosFromAngles(inclination, azimuth, vector = new Vector3()) {
+    const theta = Math.PI * (inclination - 0.5);
+    const phi = 2 * Math.PI * (azimuth - 0.5);
+    vector.x = Math.cos(phi);
+    vector.y = Math.sin(theta);
+    vector.z = Math.sin(phi);
+    return vector;
+}
+const defaultOptions = {
+    distance: 1000,
+    inclination: 0.6,
+    azimuth: 0.1,
+    mieCoefficient: 0.005,
+    mieDirectionalG: 0.8,
+    rayleigh: 0.5,
+    turbidity: 10,
+};
+export class NgtsSky {
+    constructor() {
+        this.options = input(defaultOptions, { transform: mergeInputs(defaultOptions) });
+        this.parameters = omit(this.options, [
+            'distance',
+            'inclination',
+            'azimuth',
+            'sunPosition',
+            'turbidity',
+            'mieCoefficient',
+            'mieDirectionalG',
+            'sunPosition',
+        ]);
+        this.distance = pick(this.options, 'distance');
+        this.turbidity = pick(this.options, 'turbidity');
+        this.mieCoefficient = pick(this.options, 'mieCoefficient');
+        this.mieDirectionalG = pick(this.options, 'mieDirectionalG');
+        this.rayleigh = pick(this.options, 'rayleigh');
+        this.scale = computed(() => new Vector3().setScalar(this.distance()));
+        this.inclination = pick(this.options, 'inclination');
+        this.azimuth = pick(this.options, 'azimuth');
+        this.sunPosition = vector3(this.options, 'sunPosition', true);
+        this.calculatedSunPosition = computed(() => {
+            const sunPosition = this.sunPosition();
+            if (sunPosition)
+                return sunPosition;
+            return calcPosFromAngles(this.inclination(), this.azimuth());
+        });
+        this.sky = new Sky();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: NgtsSky, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.1.0", type: NgtsSky, isStandalone: true, selector: "ngts-sky", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `
+		<ngt-primitive *args="[sky]" [parameters]="parameters()" [scale]="scale()">
+			<ngt-value attach="material.uniforms.mieCoefficient.value" [rawValue]="mieCoefficient()" />
+			<ngt-value attach="material.uniforms.mieDirectionalG.value" [rawValue]="mieDirectionalG()" />
+			<ngt-value attach="material.uniforms.rayleigh.value" [rawValue]="rayleigh()" />
+			<ngt-value attach="material.uniforms.sunPosition.value" [rawValue]="calculatedSunPosition()" />
+			<ngt-value attach="material.uniforms.turbidity.value" [rawValue]="turbidity()" />
+			<ng-content />
+		</ngt-primitive>
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: NgtsSky, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-sky',
+                    standalone: true,
+                    template: `
+		<ngt-primitive *args="[sky]" [parameters]="parameters()" [scale]="scale()">
+			<ngt-value attach="material.uniforms.mieCoefficient.value" [rawValue]="mieCoefficient()" />
+			<ngt-value attach="material.uniforms.mieDirectionalG.value" [rawValue]="mieDirectionalG()" />
+			<ngt-value attach="material.uniforms.rayleigh.value" [rawValue]="rayleigh()" />
+			<ngt-value attach="material.uniforms.sunPosition.value" [rawValue]="calculatedSunPosition()" />
+			<ngt-value attach="material.uniforms.turbidity.value" [rawValue]="turbidity()" />
+			<ng-content />
+		</ngt-primitive>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [NgtArgs],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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