angular-three-soba 1.0.2 → 1.2.0

package/performance/lib/adaptive/adaptive-events.d.ts

@@ -0,0 +1,10 @@
+import { OnInit } from '@angular/core';
+import { NgtRxStore } from 'angular-three';
+import * as i0 from "@angular/core";
+export declare class NgtsAdaptiveEvents extends NgtRxStore implements OnInit {
+    private readonly store;
+    private readonly actions;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsAdaptiveEvents, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsAdaptiveEvents, "ngts-adaptive-events", never, {}, {}, never, never, true, never>;
+}

package/performance/lib/detailed/detailed.d.ts

@@ -0,0 +1,12 @@
+import { OnInit } from '@angular/core';
+import { NgtRxStore } from 'angular-three';
+import { LOD } from 'three';
+import * as i0 from "@angular/core";
+export declare class NgtsDetailed extends NgtRxStore implements OnInit {
+    lodRef: import("angular-three").NgtInjectedRef<LOD>;
+    set distances(distances: number[]);
+    ngOnInit(): void;
+    private updateLodChildren;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsDetailed, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsDetailed, "ngts-detailed[distances]", never, { "lodRef": "lodRef"; "distances": "distances"; }, {}, never, ["*"], true, never>;
+}

package/performance/lib/stats/stats.d.ts

@@ -0,0 +1,14 @@
+import { OnInit } from '@angular/core';
+import { NgtInjectedRef, NgtRxStore } from 'angular-three';
+import * as i0 from "@angular/core";
+export declare class NgtsStats extends NgtRxStore implements OnInit {
+    private readonly document;
+    private readonly stats;
+    set showPanel(showPanel: number);
+    set parent(parent: NgtInjectedRef<HTMLElement>);
+    set classes(classes: string);
+    initialize(): void;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsStats, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsStats, "ngts-stats", never, { "showPanel": "showPanel"; "parent": "parent"; "classes": "classes"; }, {}, never, never, true, never>;
+}

package/plugin/package.json

@@ -6,5 +6,5 @@
   },
   "main": "./src/index.js",
   "types": "./src/index.d.ts",
-  "version": "1.0.2"
+  "version": "1.2.0"
 }

package/plugin/src/generators/init/init.js

@@ -1,26 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.THREE_STDLIB_VERSION = exports.ANGULAR_THREE_SOBA_VERSION = void 0;
-const tslib_1 = require("tslib");
 const devkit_1 = require("@nrwl/devkit");
 exports.ANGULAR_THREE_SOBA_VERSION = '^1.0.0';
 exports.THREE_STDLIB_VERSION = '^2.0.0';
-function default_1(tree) {
-    var _a, _b;
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        devkit_1.logger.log('Initializing Angular Three...');
-        const packageJson = (0, devkit_1.readJson)(tree, 'package.json');
-        const version = ((_a = packageJson['dependencies']) === null || _a === void 0 ? void 0 : _a['angular-three-soba']) ||
-            ((_b = packageJson['devDependencies']) === null || _b === void 0 ? void 0 : _b['angular-three-soba']) ||
-            exports.ANGULAR_THREE_SOBA_VERSION;
-        (0, devkit_1.addDependenciesToPackageJson)(tree, {
-            'angular-three-soba': version,
-            'three-stdlib': exports.THREE_STDLIB_VERSION,
-        }, {});
-        return () => {
-            (0, devkit_1.installPackagesTask)(tree);
-        };
-    });
+async function default_1(tree) {
+    devkit_1.logger.log('Initializing Angular Three...');
+    const packageJson = (0, devkit_1.readJson)(tree, 'package.json');
+    const version = packageJson['dependencies']?.['angular-three-soba'] ||
+        packageJson['devDependencies']?.['angular-three-soba'] ||
+        exports.ANGULAR_THREE_SOBA_VERSION;
+    (0, devkit_1.addDependenciesToPackageJson)(tree, {
+        'angular-three-soba': version,
+        'three-stdlib': exports.THREE_STDLIB_VERSION,
+    }, {});
+    return () => {
+        (0, devkit_1.installPackagesTask)(tree);
+    };
 }
 exports.default = default_1;
 //# sourceMappingURL=init.js.map

package/plugin/src/generators/init/init.js.map

@@ -1 +1 @@
-{"version":3,"file":"init.js","sourceRoot":"","sources":["../../../../../../../libs/plugin/src/generators/init/init.ts"],"names":[],"mappings":";;;;AAAA,yCAAyG;AAE5F,QAAA,0BAA0B,GAAG,QAAQ,CAAC;AACtC,QAAA,oBAAoB,GAAG,QAAQ,CAAC;AAE7C,mBAA+B,IAAU;;;QACrC,eAAM,CAAC,GAAG,CAAC,+BAA+B,CAAC,CAAC;QAE5C,MAAM,WAAW,GAAG,IAAA,iBAAQ,EAAC,IAAI,EAAE,cAAc,CAAC,CAAC;QAEnD,MAAM,OAAO,GACT,CAAA,MAAA,WAAW,CAAC,cAAc,CAAC,0CAAG,oBAAoB,CAAC;aACnD,MAAA,WAAW,CAAC,iBAAiB,CAAC,0CAAG,oBAAoB,CAAC,CAAA;YACtD,kCAA0B,CAAC;QAE/B,IAAA,qCAA4B,EACxB,IAAI,EACJ;YACI,oBAAoB,EAAE,OAAO;YAC7B,cAAc,EAAE,4BAAoB;SACvC,EACD,EAAE,CACL,CAAC;QAEF,OAAO,GAAG,EAAE;YACR,IAAA,4BAAmB,EAAC,IAAI,CAAC,CAAC;QAC9B,CAAC,CAAC;;CACL;AAtBD,4BAsBC"}
+{"version":3,"file":"init.js","sourceRoot":"","sources":["../../../../../../../libs/plugin/src/generators/init/init.ts"],"names":[],"mappings":";;;AAAA,yCAAyG;AAE5F,QAAA,0BAA0B,GAAG,QAAQ,CAAC;AACtC,QAAA,oBAAoB,GAAG,QAAQ,CAAC;AAE9B,KAAK,oBAAW,IAAU;IACrC,eAAM,CAAC,GAAG,CAAC,+BAA+B,CAAC,CAAC;IAE5C,MAAM,WAAW,GAAG,IAAA,iBAAQ,EAAC,IAAI,EAAE,cAAc,CAAC,CAAC;IAEnD,MAAM,OAAO,GACT,WAAW,CAAC,cAAc,CAAC,EAAE,CAAC,oBAAoB,CAAC;QACnD,WAAW,CAAC,iBAAiB,CAAC,EAAE,CAAC,oBAAoB,CAAC;QACtD,kCAA0B,CAAC;IAE/B,IAAA,qCAA4B,EACxB,IAAI,EACJ;QACI,oBAAoB,EAAE,OAAO;QAC7B,cAAc,EAAE,4BAAoB;KACvC,EACD,EAAE,CACL,CAAC;IAEF,OAAO,GAAG,EAAE;QACR,IAAA,4BAAmB,EAAC,IAAI,CAAC,CAAC;IAC9B,CAAC,CAAC;AACN,CAAC;AAtBD,4BAsBC"}

package/shaders/README.md

@@ -0,0 +1,3 @@
+# angular-three-soba/shaders
+
+Secondary entry point of `angular-three-soba`. It can be used by importing from `angular-three-soba/shaders`.

package/shaders/index.d.ts

@@ -0,0 +1 @@
+export * from './lib/shader-material/shader-material';

package/shaders/lib/shader-material/shader-material.d.ts

@@ -0,0 +1,6 @@
+import * as THREE from 'three';
+export declare function shaderMaterial(uniforms: {
+    [name: string]: THREE.CubeTexture | THREE.Texture | Int32Array | Float32Array | THREE.Matrix4 | THREE.Matrix3 | THREE.Quaternion | THREE.Vector4 | THREE.Vector3 | THREE.Vector2 | THREE.Color | number | boolean | Array<any> | null;
+}, vertexShader: string, fragmentShader: string, onInit?: (material?: THREE.ShaderMaterial) => void): typeof THREE.ShaderMaterial & {
+    key: string;
+};

package/staging/README.md

@@ -0,0 +1,3 @@
+# angular-three-soba/staging
+
+Secondary entry point of `angular-three-soba`. It can be used by importing from `angular-three-soba/staging`.

package/staging/index.d.ts

@@ -0,0 +1,12 @@
+export { NgtsAccumulativeShadows } from './lib/accumulative-shadows/accumulative-shadows';
+export { NgtsRandomizedLights } from './lib/accumulative-shadows/randomized-lights';
+export * from './lib/bounds/bounds';
+export * from './lib/center/center';
+export * from './lib/contact-shadows/contact-shadows';
+export * from './lib/environment/assets';
+export * from './lib/environment/environment';
+export * from './lib/float/float';
+export * from './lib/sky/sky';
+export * from './lib/sparkles/sparkles';
+export * from './lib/stage/stage';
+export * from './lib/stars/stars';

package/staging/lib/accumulative-shadows/accumulative-shadows.d.ts

@@ -0,0 +1,64 @@
+import { InjectionToken } from '@angular/core';
+import { NgtRxStore } from 'angular-three';
+import * as THREE from 'three';
+import { ProgressiveLightMap } from './progressive-light-map';
+import * as i0 from "@angular/core";
+type SoftShadowMaterialInputs = {
+    map: THREE.Texture;
+    color?: THREE.ColorRepresentation;
+    alphaTest?: number;
+    blend?: number;
+};
+export type NgtsAccumulativeShadowsLightApi = {
+    update: () => void;
+};
+export type NgtsAccumulativeShadowsApi = {
+    lights: Map<string, NgtsAccumulativeShadowsLightApi>;
+    temporal: boolean;
+    frames: number;
+    blend: number;
+    count: number;
+    getMesh: () => THREE.Mesh<THREE.PlaneGeometry, SoftShadowMaterialInputs & THREE.ShaderMaterial>;
+    reset: () => void;
+    update: (frames?: number) => void;
+};
+export declare const NGTS_ACCUMULATIVE_SHADOWS_API: InjectionToken<NgtsAccumulativeShadowsApi>;
+export declare class AccumulativeShadowsConsumer {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccumulativeShadowsConsumer, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AccumulativeShadowsConsumer, "ngts-accumulative-shadows-consumer", never, {}, {}, never, never, true, never>;
+}
+export declare class NgtsAccumulativeShadows extends NgtRxStore {
+    readonly nullTraverse: () => null;
+    readonly Math: Math;
+    private readonly store;
+    readonly pLM: ProgressiveLightMap;
+    readonly accumulativeShadowsRef: import("angular-three").NgtInjectedRef<THREE.Group>;
+    readonly meshRef: import("angular-three").NgtInjectedRef<THREE.Mesh<THREE.BufferGeometry, THREE.Material | THREE.Material[]>>;
+    /** How many frames it can render, more yields cleaner results but takes more time, 40 */
+    set frames(frames: number);
+    /** If frames === Infinity blend controls the refresh ratio, 100 */
+    set blend(blend: number);
+    /** Can limit the amount of frames rendered if frames === Infinity, usually to get some performance back once a movable scene has settled, Infinity */
+    set limit(limit: number);
+    /** Scale of the plane,  */
+    set scale(scale: number);
+    /** Temporal accumulates shadows over time which is more performant but has a visual regression over instant results, false  */
+    set temporal(temporal: boolean);
+    /** Opacity of the plane, 1 */
+    set opacity(opacity: number);
+    /** Discards alpha pixels, 0.65 */
+    set alphaTest(alphaTest: number);
+    /** Shadow color, black */
+    set color(color: string);
+    /** Colorblend, how much colors turn to black, 0 is black, 2 */
+    set colorBlend(colorBlend: number);
+    /** Buffer resolution, 1024 */
+    set resolution(resolution: number);
+    /** Texture tonemapping */
+    set toneMapped(toneMapped: boolean);
+    initialize(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsAccumulativeShadows, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsAccumulativeShadows, "ngts-accumulative-shadows", never, { "frames": "frames"; "blend": "blend"; "limit": "limit"; "scale": "scale"; "temporal": "temporal"; "opacity": "opacity"; "alphaTest": "alphaTest"; "color": "color"; "colorBlend": "colorBlend"; "resolution": "resolution"; "toneMapped": "toneMapped"; }, {}, never, ["*"], true, never>;
+}
+export {};

package/staging/lib/accumulative-shadows/progressive-light-map.d.ts

@@ -0,0 +1,34 @@
+import * as THREE from 'three';
+export declare class ProgressiveLightMap {
+    renderer: THREE.WebGLRenderer;
+    res: number;
+    scene: THREE.Scene;
+    object: THREE.Mesh | null;
+    buffer1Active: boolean;
+    progressiveLightMap1: THREE.WebGLRenderTarget;
+    progressiveLightMap2: THREE.WebGLRenderTarget;
+    discardMat: THREE.ShaderMaterial;
+    targetMat: THREE.MeshLambertMaterial;
+    previousShadowMap: {
+        value: THREE.Texture;
+    };
+    averagingWindow: {
+        value: number;
+    };
+    clearColor: THREE.Color;
+    clearAlpha: number;
+    lights: {
+        object: THREE.Light;
+        intensity: number;
+    }[];
+    meshes: {
+        object: THREE.Mesh;
+        material: THREE.Material | THREE.Material[];
+    }[];
+    constructor(renderer: THREE.WebGLRenderer, scene: THREE.Scene, res?: number);
+    clear(): void;
+    prepare(): void;
+    finish(): void;
+    configure(object: any): void;
+    update(camera: any, blendWindow?: number): void;
+}

package/staging/lib/accumulative-shadows/randomized-lights.d.ts

@@ -0,0 +1,42 @@
+import { InjectionToken } from '@angular/core';
+import { NgtRxStore } from 'angular-three';
+import * as THREE from 'three';
+import { NgtsAccumulativeShadowsLightApi } from './accumulative-shadows';
+import * as i0 from "@angular/core";
+export declare const NGTS_RANDOMIZED_LIGHTS_API: InjectionToken<NgtsAccumulativeShadowsLightApi>;
+export declare class RandomizedLightsConsumer {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<RandomizedLightsConsumer, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RandomizedLightsConsumer, "ngts-randomized-lights-consumer", never, {}, {}, never, never, true, never>;
+}
+export declare class NgtsRandomizedLights extends NgtRxStore {
+    lightsRef: import("angular-three").NgtInjectedRef<THREE.Group>;
+    /** How many frames it will jiggle the lights, 1.
+     *  Frames is context aware, if a provider like AccumulativeShadows exists, frames will be taken from there!  */
+    set frames(frames: number);
+    /** Light position, [0, 0, 0] */
+    set position(position: [x: number, y: number, z: number]);
+    /** Radius of the jiggle, higher values make softer light, 5 */
+    set radius(radius: number);
+    /** Amount of lights, 8 */
+    set amount(amount: number);
+    /** Light intensity, 1 */
+    set intensity(intensity: number);
+    /** Ambient occlusion, lower values mean less AO, hight more, you can mix AO and directional light, 0.5 */
+    set ambient(ambient: number);
+    /** If the lights cast shadows, this is true by default */
+    set castShadow(castShadow: boolean);
+    /** Default shadow bias, 0 */
+    set bias(bias: number);
+    /** Default map size, 512 */
+    set mapSize(mapSize: number);
+    /** Default size of the shadow camera, 10 */
+    set size(size: number);
+    /** Default shadow camera near, 0.5 */
+    set near(near: number);
+    /** Default shadow camera far, 500 */
+    set far(far: number);
+    initialize(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsRandomizedLights, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsRandomizedLights, "ngts-randomized-lights", never, { "lightsRef": "lightsRef"; "frames": "frames"; "position": "position"; "radius": "radius"; "amount": "amount"; "intensity": "intensity"; "ambient": "ambient"; "castShadow": "castShadow"; "bias": "bias"; "mapSize": "mapSize"; "size": "size"; "near": "near"; "far": "far"; }, {}, never, never, true, never>;
+}

package/staging/lib/bounds/bounds.d.ts

@@ -0,0 +1,48 @@
+import { EventEmitter, InjectionToken, OnInit } from '@angular/core';
+import { NgtRxStore } from 'angular-three';
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+export interface NgtsBoundsSize {
+    box: THREE.Box3;
+    size: THREE.Vector3;
+    center: THREE.Vector3;
+    distance: number;
+}
+export interface NgtsBoundsApi {
+    getSize: () => NgtsBoundsSize;
+    refresh: (object?: THREE.Object3D | THREE.Box3) => NgtsBoundsApi;
+    clip: () => NgtsBoundsApi;
+    fit: () => NgtsBoundsApi;
+    to: ({ position, target, }: {
+        position: [number, number, number];
+        target?: [number, number, number];
+    }) => NgtsBoundsApi;
+}
+export declare const NGTS_BOUNDS_API: InjectionToken<NgtsBoundsApi>;
+export declare class NgtsBounds extends NgtRxStore implements OnInit {
+    boundsRef: import("angular-three").NgtInjectedRef<THREE.Group>;
+    set damping(damping: number);
+    set fit(fit: boolean);
+    set clip(clip: boolean);
+    set observe(observe: boolean);
+    set margin(margin: number);
+    set eps(eps: number);
+    fitted: EventEmitter<NgtsBoundsSize>;
+    private readonly store;
+    readonly current: {
+        animating: boolean;
+        focus: THREE.Vector3;
+        camera: THREE.Vector3;
+        zoom: number;
+    };
+    readonly goal: {
+        focus: THREE.Vector3;
+        camera: THREE.Vector3;
+        zoom: number;
+    };
+    initialize(): void;
+    ngOnInit(): void;
+    private preventDragHijacking;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsBounds, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsBounds, "ngts-bounds", never, { "boundsRef": "boundsRef"; "damping": "damping"; "fit": "fit"; "clip": "clip"; "observe": "observe"; "margin": "margin"; "eps": "eps"; }, { "fitted": "fitted"; }, never, ["*"], true, never>;
+}

package/staging/lib/center/center.d.ts

@@ -0,0 +1,40 @@
+import { EventEmitter, OnInit } from '@angular/core';
+import { NgtRxStore } from 'angular-three';
+import { Box3, Group, Sphere, Vector3 } from 'three';
+import * as i0 from "@angular/core";
+export declare class NgtsCenter extends NgtRxStore implements OnInit {
+    centerRef: import("angular-three").NgtInjectedRef<Group>;
+    readonly outerRef: import("angular-three").NgtInjectedRef<Group>;
+    readonly innerRef: import("angular-three").NgtInjectedRef<Group>;
+    set top(top: boolean);
+    set right(right: boolean);
+    set bottom(bottom: boolean);
+    set left(left: boolean);
+    set front(front: boolean);
+    set back(back: boolean);
+    set disableX(disableX: boolean);
+    set disableY(disableY: boolean);
+    set disableZ(disableZ: boolean);
+    set disabled(disabled: boolean);
+    set precise(precise: boolean);
+    centered: EventEmitter<{
+        /** The next parent above <Center> */
+        parent: THREE.Object3D;
+        /** The outmost container group of the <Center> component */
+        container: THREE.Object3D;
+        width: number;
+        height: number;
+        depth: number;
+        boundingBox: THREE.Box3;
+        boundingSphere: THREE.Sphere;
+        center: THREE.Vector3;
+        verticalAlignment: number;
+        horizontalAlignment: number;
+        depthAlignment: number;
+    }>;
+    initialize(): void;
+    ngOnInit(): void;
+    private setPosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsCenter, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsCenter, "ngts-center", never, { "centerRef": "centerRef"; "top": "top"; "right": "right"; "bottom": "bottom"; "left": "left"; "front": "front"; "back": "back"; "disableX": "disableX"; "disableY": "disableY"; "disableZ": "disableZ"; "disabled": "disabled"; "precise": "precise"; }, { "centered": "centered"; }, never, ["*"], true, never>;
+}

package/staging/lib/contact-shadows/contact-shadows.d.ts

@@ -0,0 +1,29 @@
+import { NgtRxStore } from 'angular-three';
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+export declare class NgtsContactShadows extends NgtRxStore {
+    private readonly store;
+    readonly shadowCameraRef: import("angular-three").NgtInjectedRef<THREE.OrthographicCamera>;
+    readonly encoding: THREE.TextureEncoding;
+    readonly contactShadows$: import("rxjs").Observable<any>;
+    readonly Math: Math;
+    contactShadowsRef: import("angular-three").NgtInjectedRef<THREE.Group>;
+    set opacity(opacity: number);
+    set width(width: number);
+    set height(height: number);
+    set blur(blur: number);
+    set far(far: number);
+    set smooth(smooth: boolean);
+    set resolution(resolution: number);
+    set frames(frames: number);
+    set scale(scale: number | [x: number, y: number]);
+    set color(color: THREE.ColorRepresentation);
+    set depthWrite(depthWrite: boolean);
+    set renderOrder(renderOrder: number);
+    constructor();
+    initialize(): void;
+    private onBeforeRender;
+    private blurShadows;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsContactShadows, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsContactShadows, "ngts-contact-shadows", never, { "contactShadowsRef": "contactShadowsRef"; "opacity": "opacity"; "width": "width"; "height": "height"; "blur": "blur"; "far": "far"; "smooth": "smooth"; "resolution": "resolution"; "frames": "frames"; "scale": "scale"; "color": "color"; "depthWrite": "depthWrite"; "renderOrder": "renderOrder"; }, {}, never, never, true, never>;
+}

package/staging/lib/environment/assets.d.ts

@@ -0,0 +1,13 @@
+export declare const ngtsEnvironmentPresetsObj: {
+    sunset: string;
+    dawn: string;
+    night: string;
+    warehouse: string;
+    forest: string;
+    apartment: string;
+    studio: string;
+    city: string;
+    park: string;
+    lobby: string;
+};
+export type NgtsEnvironmentPresetsType = keyof typeof ngtsEnvironmentPresetsObj;

package/staging/lib/environment/environment-cube.d.ts

@@ -0,0 +1,11 @@
+import { OnInit } from '@angular/core';
+import { NgtsEnvironmentInputs } from './environment-inputs';
+import * as i0 from "@angular/core";
+export declare class NgtsEnvironmentCube extends NgtsEnvironmentInputs implements OnInit {
+    readonly textureRef: import("angular-three").NgtInjectedRef<import("three").CubeTexture | import("three").Texture>;
+    initialize(): void;
+    ngOnInit(): void;
+    private setEnvProps;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsEnvironmentCube, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsEnvironmentCube, "ngts-environment-cube", never, {}, {}, never, never, true, never>;
+}

package/staging/lib/environment/environment-ground.d.ts

@@ -0,0 +1,9 @@
+import { OnInit } from '@angular/core';
+import { NgtsEnvironmentInputs } from './environment-inputs';
+import * as i0 from "@angular/core";
+export declare class NgtsEnvironmentGround extends NgtsEnvironmentInputs implements OnInit {
+    readonly defaultTexture: import("angular-three").NgtInjectedRef<import("three").CubeTexture | import("three").Texture>;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsEnvironmentGround, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsEnvironmentGround, "ngts-environment-ground", never, {}, {}, never, never, true, never>;
+}

package/staging/lib/environment/environment-inputs.d.ts

@@ -0,0 +1,28 @@
+import { ElementRef } from '@angular/core';
+import { NgtRxStore, NgtStore } from 'angular-three';
+import { Loader, Scene, Texture, TextureEncoding } from 'three';
+import { NgtsEnvironmentPresetsType } from './assets';
+import * as i0 from "@angular/core";
+export declare abstract class NgtsEnvironmentInputs extends NgtRxStore {
+    protected readonly store: NgtStore;
+    set frames(frames: number);
+    set near(near: number);
+    set far(far: number);
+    set resolution(resolution: number);
+    set background(background: boolean | 'only');
+    set blur(blur: number);
+    set map(map: Texture);
+    set files(files: string | string[]);
+    set path(path: string);
+    set preset(preset: NgtsEnvironmentPresetsType);
+    set scene(scene: Scene | ElementRef<Scene>);
+    set extensions(extensions: (loader: Loader) => void);
+    set ground(ground: boolean | {
+        radius?: number;
+        height?: number;
+        scale?: number;
+    });
+    set encoding(encoding: TextureEncoding);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsEnvironmentInputs, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsEnvironmentInputs, never, never, { "frames": "frames"; "near": "near"; "far": "far"; "resolution": "resolution"; "background": "background"; "blur": "blur"; "map": "map"; "files": "files"; "path": "path"; "preset": "preset"; "scene": "scene"; "extensions": "extensions"; "ground": "ground"; "encoding": "encoding"; }, {}, never, never, false, never>;
+}

package/staging/lib/environment/environment-map.d.ts

@@ -0,0 +1,10 @@
+import { OnInit } from '@angular/core';
+import { NgtsEnvironmentInputs } from './environment-inputs';
+import * as i0 from "@angular/core";
+export declare class NgtsEnvironmentMap extends NgtsEnvironmentInputs implements OnInit {
+    initialize(): void;
+    ngOnInit(): void;
+    private setEnvProps;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsEnvironmentMap, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsEnvironmentMap, "ngts-environment-map", never, {}, {}, never, never, true, never>;
+}

package/staging/lib/environment/environment-portal.d.ts

@@ -0,0 +1,15 @@
+import { OnInit } from '@angular/core';
+import * as THREE from 'three';
+import { NgtsEnvironmentInputs } from './environment-inputs';
+import * as i0 from "@angular/core";
+export declare class NgtsEnvironmentPortal extends NgtsEnvironmentInputs implements OnInit {
+    readonly virtualSceneRef: import("angular-three").NgtInjectedRef<THREE.Scene>;
+    readonly cubeCameraRef: import("angular-three").NgtInjectedRef<THREE.CubeCamera>;
+    initialize(): void;
+    constructor();
+    ngOnInit(): void;
+    private setEnvProps;
+    private onBeforeRender;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsEnvironmentPortal, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsEnvironmentPortal, "ngts-environment-portal", never, {}, {}, never, ["*"], true, never>;
+}

package/staging/lib/environment/environment.d.ts

@@ -0,0 +1,12 @@
+import { TemplateRef } from '@angular/core';
+import { NgtsEnvironmentInputs } from './environment-inputs';
+import * as i0 from "@angular/core";
+export declare class NgtsEnvironmentContent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsEnvironmentContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsEnvironmentContent, "ng-template[ngtsEnvironmentContent]", never, {}, {}, never, never, true, never>;
+}
+export declare class NgtsEnvironment extends NgtsEnvironmentInputs {
+    content?: TemplateRef<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsEnvironment, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsEnvironment, "ngts-environment", never, {}, {}, ["content"], never, true, never>;
+}

package/staging/lib/environment/utils.d.ts

@@ -0,0 +1,8 @@
+import { ElementRef } from '@angular/core';
+import { Observable } from 'rxjs';
+import { CubeTexture, Texture } from 'three';
+import { NgtsEnvironmentInputs } from './environment-inputs';
+export declare function setEnvProps(background: boolean | 'only', scene: THREE.Scene | ElementRef<THREE.Scene> | undefined, defaultScene: THREE.Scene, texture: THREE.Texture, blur?: number): () => void;
+type NgtsInjectEnvironmentParams = Partial<Pick<NgtsEnvironmentInputs, 'files' | 'path' | 'preset' | 'extensions' | 'encoding'>>;
+export declare function injectNgtsEnvironment(paramsFactory: (defaultParams: NgtsInjectEnvironmentParams) => NgtsInjectEnvironmentParams | Observable<NgtsInjectEnvironmentParams>): import("angular-three").NgtInjectedRef<CubeTexture | Texture>;
+export {};

package/staging/lib/float/float.d.ts

@@ -0,0 +1,16 @@
+import { NgtRxStore } from 'angular-three';
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+export declare class NgtsFloat extends NgtRxStore {
+    private readonly offset;
+    floatRef: import("angular-three").NgtInjectedRef<THREE.Group>;
+    set speed(speed: number);
+    set rotationIntensity(rotationIntensity: number);
+    set floatIntensity(floatIntensity: number);
+    set floatingRange(floatingRange: [number?, number?]);
+    initialize(): void;
+    constructor();
+    private onBeforeRender;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsFloat, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsFloat, "ngts-float", never, { "floatRef": "floatRef"; "speed": "speed"; "rotationIntensity": "rotationIntensity"; "floatIntensity": "floatIntensity"; "floatingRange": "floatingRange"; }, {}, never, ["*"], true, never>;
+}

package/staging/lib/sky/sky.d.ts

@@ -0,0 +1,21 @@
+import { OnInit } from '@angular/core';
+import { NgtRxStore } from 'angular-three';
+import { Vector3 } from 'three';
+import { Sky } from 'three-stdlib';
+import * as i0 from "@angular/core";
+export declare function calcPosFromAngles(inclination: number, azimuth: number, vector?: Vector3): Vector3;
+export declare class NgtsSky extends NgtRxStore implements OnInit {
+    skyRef: import("angular-three").NgtInjectedRef<Sky>;
+    set distance(distance: number);
+    set sunPosition(sunPosition: THREE.Vector3 | Parameters<THREE.Vector3['set']>);
+    set inclination(inclination: number);
+    set azimuth(azimuth: number);
+    set mieCoefficient(mieCoefficient: number);
+    set mieDirectionalG(mieDirectionalG: number);
+    set rayleigh(rayleigh: number);
+    set turbidity(turbidity: number);
+    initialize(): void;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSky, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSky, "ngts-sky", never, { "skyRef": "skyRef"; "distance": "distance"; "sunPosition": "sunPosition"; "inclination": "inclination"; "azimuth": "azimuth"; "mieCoefficient": "mieCoefficient"; "mieDirectionalG": "mieDirectionalG"; "rayleigh": "rayleigh"; "turbidity": "turbidity"; }, {}, never, never, true, never>;
+}

package/staging/lib/sparkles/sparkles.d.ts

@@ -0,0 +1,29 @@
+import { NgtRxStore } from 'angular-three';
+import { BufferGeometry, Points } from 'three';
+import * as i0 from "@angular/core";
+export declare class NgtsSparkles extends NgtRxStore {
+    private readonly store;
+    readonly dpr: number;
+    readonly materialRef: import("angular-three").NgtInjectedRef<import("three").ShaderMaterial>;
+    pointsRef: import("angular-three").NgtInjectedRef<Points<BufferGeometry, import("three").Material | import("three").Material[]>>;
+    /** Number of particles (default: 100) */
+    set count(count: number);
+    /** Speed of particles (default: 1) */
+    set speed(speed: number | Float32Array);
+    /** Opacity of particles (default: 1) */
+    set opacity(opacity: number | Float32Array);
+    /** Color of particles (default: 100) */
+    set color(color: THREE.ColorRepresentation | Float32Array);
+    /** Size of particles (default: randomized between 0 and 1) */
+    set size(size: number | Float32Array);
+    /** The space the particles occupy (default: 1) */
+    set scale(scale: number | [number, number, number] | THREE.Vector3);
+    /** Movement factor (default: 1) */
+    set noise(noise: number | [number, number, number] | THREE.Vector3 | Float32Array);
+    initialize(): void;
+    constructor();
+    private onBeforeRender;
+    private getAttribute$;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSparkles, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSparkles, "ngts-sparkles", never, { "pointsRef": "pointsRef"; "count": "count"; "speed": "speed"; "opacity": "opacity"; "color": "color"; "size": "size"; "scale": "scale"; "noise": "noise"; }, {}, never, never, true, never>;
+}