angular-three-soba 1.13.0 → 2.0.0-beta.2

package/fesm2020/angular-three-soba.mjs

@@ -1,6 +0,0 @@
-var index = void 0;
-
-/**
- * Generated bundle index. Do not edit.
- */
-//# sourceMappingURL=angular-three-soba.mjs.map

package/fesm2020/angular-three-soba.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"angular-three-soba.mjs","sources":["../../../../libs/angular-three-soba/src/index.ts","../../../../libs/angular-three-soba/src/angular-three-soba.ts"],"sourcesContent":["export default void 0;\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":"AAAA,YAAe,KAAK,CAAC;;ACArB;;AAEG"}

package/loaders/lib/cube-texture-loader/cube-texture-loader.d.ts

@@ -1,3 +0,0 @@
-import { Observable } from 'rxjs';
-import * as THREE from 'three';
-export declare function injectCubeTextureLoader(files: string[] | Observable<string[]>, path: string): Observable<THREE.CubeTexture>;

package/loaders/lib/gltf-loader/gltf-loader.d.ts

@@ -1,8 +0,0 @@
-import { NgtLoaderResults, NgtObjectMap } from 'angular-three';
-import { Observable } from 'rxjs';
-import { GLTF, GLTFLoader } from 'three-stdlib/loaders/GLTFLoader';
-export interface NgtsGLTFLoader {
-    <TInput extends string | string[] | Record<string, string>>(path: TInput | Observable<TInput>, useDraco?: boolean | string, useMeshOpt?: boolean, extensions?: (loader: GLTFLoader) => void): Observable<NgtLoaderResults<TInput, GLTF & NgtObjectMap>>;
-    preload: <TInput extends string | string[] | Record<string, string>>(path: TInput | Observable<TInput>, useDraco?: boolean | string, useMeshOpt?: boolean, extensions?: (loader: GLTFLoader) => void) => void;
-}
-export declare const injectNgtsGLTFLoader: NgtsGLTFLoader;

package/loaders/lib/loader/loader.d.ts

@@ -1,26 +0,0 @@
-import { ElementRef, OnInit } from '@angular/core';
-import { NgtRxStore } from 'angular-three';
-import * as i0 from "@angular/core";
-export declare class NgtsLoader extends NgtRxStore implements OnInit {
-    private readonly progress;
-    readonly vm$: import("rxjs").Observable<{
-        shown: any;
-        containerClass: any;
-        innerClass: any;
-        barClass: any;
-        dataClass: any;
-        progress: number;
-        active: boolean;
-    }>;
-    set containerClass(containerClass: string);
-    set innerClass(innerClass: string);
-    set barClass(barClass: string);
-    set dataClass(dataClass: string);
-    set dataInterpolation(dataInterpolation: (value: number) => string);
-    set initialState(initialState: (value: boolean) => boolean);
-    progressSpanRef?: ElementRef<HTMLSpanElement>;
-    initialize(): void;
-    ngOnInit(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsLoader, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsLoader, "ngts-loader", never, { "containerClass": "containerClass"; "innerClass": "innerClass"; "barClass": "barClass"; "dataClass": "dataClass"; "dataInterpolation": "dataInterpolation"; "initialState": "initialState"; }, {}, never, never, true, never>;
-}

package/loaders/lib/progress/progress.d.ts

@@ -1,16 +0,0 @@
-import { NgtRxStore } from 'angular-three';
-export declare function injectNgtsProgress(): NgtRxStore<{
-    errors: string[];
-    active: boolean;
-    progress: number;
-    item: string;
-    loaded: number;
-    total: number;
-}, {
-    errors: string[];
-    active: boolean;
-    progress: number;
-    item: string;
-    loaded: number;
-    total: number;
-} & Record<string, any>>;

package/loaders/lib/texture-loader/texture-loader.d.ts

@@ -1,5 +0,0 @@
-import { NgtLoaderResults } from 'angular-three';
-import { Observable } from 'rxjs';
-import * as THREE from 'three';
-export declare const IsObject: (url: any) => url is Record<string, string>;
-export declare function injectNgtsTextureLoader<TInput extends string[] | string | Record<string, string>>(input: TInput | Observable<TInput>, onLoad?: (texture: THREE.Texture | THREE.Texture[]) => void): Observable<NgtLoaderResults<TInput, THREE.Texture>>;

package/materials/lib/mesh-distort-material/mesh-distort-material.d.ts

@@ -1,24 +0,0 @@
-import { NgtRxStore } from 'angular-three';
-import { MeshDistortMaterial } from 'angular-three-soba/shaders';
-import * as i0 from "@angular/core";
-export declare class NgtsMeshDistortMaterial extends NgtRxStore {
-    readonly MeshDistortMaterial: MeshDistortMaterial;
-    readonly material: {
-        time: number;
-        distort: number;
-        radius: number;
-    } & import("three").MeshPhysicalMaterial;
-    materialRef: import("angular-three").NgtInjectedRef<{
-        time: number;
-        distort: number;
-        radius: number;
-    } & import("three").MeshPhysicalMaterial>;
-    set time(time: number);
-    set distort(distort: number);
-    set radius(radius: number);
-    set speed(speed: number);
-    initialize(): void;
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsMeshDistortMaterial, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsMeshDistortMaterial, "ngts-mesh-distort-material", never, { "materialRef": "materialRef"; "time": "time"; "distort": "distort"; "radius": "radius"; "speed": "speed"; }, {}, never, never, true, never>;
-}

package/materials/lib/mesh-reflector-material/mesh-reflector-material.d.ts

@@ -1,41 +0,0 @@
-import { NgtRxStore } from 'angular-three';
-import { MeshReflectorMaterial } from 'angular-three-soba/shaders';
-import * as THREE from 'three';
-import * as i0 from "@angular/core";
-export declare class NgtsMeshReflectorMaterial extends NgtRxStore {
-    materialRef: import("angular-three").NgtInjectedRef<MeshReflectorMaterial>;
-    set resolution(resolution: number);
-    set mixBlur(mixBlur: number);
-    set mixStrength(mixStrength: number);
-    set blur(blur: [number, number] | number);
-    set mirror(mirror: number);
-    set minDepthThreshold(minDepthThreshold: number);
-    set maxDepthThreshold(maxDepthThreshold: number);
-    set depthScale(depthScale: number);
-    set depthToBlurRatioBias(depthToBlurRatioBias: number);
-    set distortionMap(distortionMap: THREE.Texture);
-    set distortion(distortion: number);
-    set mixContrast(mixContrast: number);
-    set reflectorOffset(reflectorOffset: number);
-    readonly defines$: import("rxjs").Observable<any>;
-    get reflectorProps(): any;
-    private readonly store;
-    private readonly reflectorPlane;
-    private readonly normal;
-    private readonly reflectorWorldPosition;
-    private readonly cameraWorldPosition;
-    private readonly rotationMatrix;
-    private readonly lookAtPosition;
-    private readonly clipPlane;
-    private readonly view;
-    private readonly target;
-    private readonly q;
-    private readonly textureMatrix;
-    private readonly virtualCamera;
-    initialize(): void;
-    constructor();
-    private beforeRender;
-    private onBeforeRender;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsMeshReflectorMaterial, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsMeshReflectorMaterial, "ngts-mesh-reflector-material", never, { "materialRef": "materialRef"; "resolution": "resolution"; "mixBlur": "mixBlur"; "mixStrength": "mixStrength"; "blur": "blur"; "mirror": "mirror"; "minDepthThreshold": "minDepthThreshold"; "maxDepthThreshold": "maxDepthThreshold"; "depthScale": "depthScale"; "depthToBlurRatioBias": "depthToBlurRatioBias"; "distortionMap": "distortionMap"; "distortion": "distortion"; "mixContrast": "mixContrast"; "reflectorOffset": "reflectorOffset"; }, {}, never, ["*"], true, never>;
-}

package/materials/lib/mesh-refraction-material/mesh-refraction-material.d.ts

@@ -1,28 +0,0 @@
-import { OnInit } from '@angular/core';
-import { NgtRxStore } from 'angular-three';
-import * as i0 from "@angular/core";
-export declare class NgtsMeshRefractionMaterial extends NgtRxStore implements OnInit {
-    materialRef: import("angular-three").NgtInjectedRef<import("three").ShaderMaterial>;
-    /** Environment map */
-    set envMap(envMap: THREE.CubeTexture | THREE.Texture);
-    /** Number of ray-cast bounces, it can be expensive to have too many, 2 */
-    set bounces(bounces: number);
-    /** Refraction index, 2.4 */
-    set ior(ior: number);
-    /** Fresnel (strip light), 0 */
-    set fresnel(fresnel: number);
-    /** RGB shift intensity, can be expensive, 0 */
-    set aberrationStrength(aberrationStrength: number);
-    /** Color, white */
-    set color(color: THREE.ColorRepresentation);
-    /** If this is on it uses fewer ray casts for the RGB shift sacrificing physical accuracy, true */
-    set fastChroma(fastChroma: boolean);
-    readonly defines$: import("rxjs").Observable<any>;
-    private readonly store;
-    initialize(): void;
-    constructor();
-    ngOnInit(): void;
-    private setupGeometry;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsMeshRefractionMaterial, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsMeshRefractionMaterial, "ngts-mesh-refraction-material", never, { "materialRef": "materialRef"; "envMap": "envMap"; "bounces": "bounces"; "ior": "ior"; "fresnel": "fresnel"; "aberrationStrength": "aberrationStrength"; "color": "color"; "fastChroma": "fastChroma"; }, {}, never, ["*"], true, never>;
-}

package/materials/lib/mesh-transmission-material/mesh-transmission-material.d.ts

@@ -1,46 +0,0 @@
-import { NgtRxStore } from 'angular-three';
-import { MeshTransmissionMaterial } from 'angular-three-soba/shaders';
-import * as THREE from 'three';
-import * as i0 from "@angular/core";
-export declare class NgtsMeshTranmissionMaterial extends NgtRxStore {
-    materialRef: import("angular-three").NgtInjectedRef<MeshTransmissionMaterial & {
-        time: number;
-        buffer?: THREE.Texture | undefined;
-    }>;
-    /** transmissionSampler, you can use the threejs transmission sampler texture that is
-     *  generated once for all transmissive materials. The upside is that it can be faster if you
-     *  use multiple MeshPhysical and Transmission materials, the downside is that transmissive materials
-     *  using this can't see other transparent or transmissive objects, default: false */
-    set transmissionSampler(transmissionSampler: boolean);
-    /** Render the backside of the material (more cost, better results), default: false */
-    set backside(backside: boolean);
-    /** Backside thickness (when backside is true), default: 0 */
-    set backsideThickness(backsideThickness: number);
-    /** Resolution of the local buffer, default: undefined (fullscreen) */
-    set resolution(resolution: number);
-    /** Resolution of the local buffer for backfaces, default: undefined (fullscreen) */
-    set backsideResolution(backsideResolution: number);
-    /** Refraction samples, default: 10 */
-    set samples(samples: number);
-    /** Buffer scene background (can be a texture, a cubetexture or a color), default: null */
-    set background(background: THREE.Texture | THREE.Color);
-    set transmission(transmission: number);
-    set thickness(thickness: number);
-    set roughness(roughness: number);
-    set chromaticAberration(chromaticAberration: number);
-    set anisotropy(anisotropy: number);
-    set distortion(distortion: number);
-    set distortionScale(distortionScale: number);
-    set temporalDistortion(temporalDistortion: number);
-    /** The scene rendered into a texture (use it to share a texture between materials), default: null  */
-    set buffer(buffer: THREE.Texture);
-    /** Internals */
-    set time(time: number);
-    readonly discardMaterial: THREE.ShaderMaterial;
-    readonly fboBackRef: import("angular-three").NgtInjectedRef<THREE.WebGLRenderTarget>;
-    readonly fboMainRef: import("angular-three").NgtInjectedRef<THREE.WebGLRenderTarget>;
-    initialize(): void;
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsMeshTranmissionMaterial, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsMeshTranmissionMaterial, "ngts-mesh-transmission-material", never, { "materialRef": "materialRef"; "transmissionSampler": "transmissionSampler"; "backside": "backside"; "backsideThickness": "backsideThickness"; "resolution": "resolution"; "backsideResolution": "backsideResolution"; "samples": "samples"; "background": "background"; "transmission": "transmission"; "thickness": "thickness"; "roughness": "roughness"; "chromaticAberration": "chromaticAberration"; "anisotropy": "anisotropy"; "distortion": "distortion"; "distortionScale": "distortionScale"; "temporalDistortion": "temporalDistortion"; "buffer": "buffer"; "time": "time"; }, {}, never, never, true, never>;
-}

package/materials/lib/mesh-wobble-material/mesh-wobble-material.d.ts

@@ -1,14 +0,0 @@
-import { NgtRxStore } from 'angular-three';
-import { MeshWobbleMaterial } from 'angular-three-soba/shaders';
-import * as i0 from "@angular/core";
-export declare class NgtsMeshWobbleMaterial extends NgtRxStore {
-    readonly material: MeshWobbleMaterial;
-    materialRef: import("angular-three").NgtInjectedRef<MeshWobbleMaterial>;
-    set time(time: number);
-    set factor(factor: number);
-    set speed(speed: number);
-    initialize(): void;
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsMeshWobbleMaterial, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsMeshWobbleMaterial, "ngts-mesh-wobble-material", never, { "materialRef": "materialRef"; "time": "time"; "factor": "factor"; "speed": "speed"; }, {}, never, never, true, never>;
-}

package/misc/lib/animations/animations.d.ts

@@ -1,13 +0,0 @@
-import { NgtInjectedRef } from 'angular-three';
-import { Observable } from 'rxjs';
-import * as THREE from 'three';
-import { AnimationClip } from 'three';
-type Api = {
-    ref: NgtInjectedRef<THREE.Object3D>;
-    clips: THREE.AnimationClip[];
-    mixer: THREE.AnimationMixer;
-    names: string[];
-    actions: Record<string, THREE.AnimationAction>;
-};
-export declare function injectNgtsAnimations(animations$: Observable<AnimationClip[]>, ref?: NgtInjectedRef<THREE.Object3D> | THREE.Object3D): Api;
-export {};

package/misc/lib/depth-buffer/depth-buffer.d.ts

@@ -1,7 +0,0 @@
-import { Observable } from 'rxjs';
-import * as THREE from 'three';
-export interface NgtsDepthBufferParams {
-    size: number;
-    frames: number;
-}
-export declare function injectNgtsDepthBuffer(paramsFactory?: (defaultParams: Partial<NgtsDepthBufferParams>) => NgtsDepthBufferParams | Observable<NgtsDepthBufferParams>): import("angular-three").NgtInjectedRef<THREE.DepthTexture>;

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

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

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

@@ -1,13 +0,0 @@
-import { OnInit } from '@angular/core';
-import { NgtBeforeRenderEvent, 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;
-    onLODBeforeRender({ object, state }: NgtBeforeRenderEvent<THREE.LOD>): 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

@@ -1,15 +0,0 @@
-import { ElementRef, OnInit } from '@angular/core';
-import { 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: HTMLElement | ElementRef<HTMLElement>);
-    set classes(classes: string);
-    set right(right: boolean);
-    initialize(): void;
-    ngOnInit(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsStats, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsStats, "ngts-stats", never, { "showPanel": "showPanel"; "parent": "parent"; "classes": "classes"; "right": "right"; }, {}, never, never, true, never>;
-}

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

@@ -1,58 +0,0 @@
-import { InjectionToken } from '@angular/core';
-import { NgtRxStore } from 'angular-three';
-import { SoftShadowMaterialInputs } from 'angular-three-soba/shaders';
-import * as THREE from 'three';
-import { ProgressiveLightMap } from './progressive-light-map';
-import * as i0 from "@angular/core";
-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, "[ngtsAccumulativeShadowsConsumer]", 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>;
-}

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

@@ -1,42 +0,0 @@
-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, "[ngtsRandomizedLightsConsumer]", 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

@@ -1,48 +0,0 @@
-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/camera-shake/camera-shake.d.ts

@@ -1,28 +0,0 @@
-import { OnInit } from '@angular/core';
-import { NgtRxStore } from 'angular-three';
-import * as i0 from "@angular/core";
-export declare class NgtsCameraShake extends NgtRxStore implements OnInit {
-    private readonly store;
-    private initialRotation;
-    private readonly yawNoise;
-    private readonly pitchNoise;
-    private readonly rollNoise;
-    set intensity(intensity: number);
-    set decay(decay: boolean);
-    set decayRate(decayRate: number);
-    set maxYaw(maxYaw: number);
-    set maxPitch(maxPitch: number);
-    set maxRoll(maxRoll: number);
-    set yawFrequency(yawFrequency: number);
-    set pitchFrequency(pitchFrequency: number);
-    set rollFrequency(rollFrequency: number);
-    initialize(): void;
-    constructor();
-    ngOnInit(): void;
-    private setChangeEvent;
-    getIntensity(): any;
-    setIntensity(intensity: number): void;
-    private constraintIntensity;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsCameraShake, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsCameraShake, "ngts-camera-shake", never, { "intensity": "intensity"; "decay": "decay"; "decayRate": "decayRate"; "maxYaw": "maxYaw"; "maxPitch": "maxPitch"; "maxRoll": "maxRoll"; "yawFrequency": "yawFrequency"; "pitchFrequency": "pitchFrequency"; "rollFrequency": "rollFrequency"; }, {}, never, never, true, never>;
-}

package/staging/lib/caustics/caustics.d.ts

@@ -1,47 +0,0 @@
-import { ElementRef, OnInit } from '@angular/core';
-import { NgtRxStore } from 'angular-three';
-import * as THREE from 'three';
-import * as i0 from "@angular/core";
-export declare class NgtsCaustics extends NgtRxStore implements OnInit {
-    readonly CustomBlending: 5;
-    readonly OneFactor: 201;
-    readonly SrcAlphaFactor: 204;
-    readonly Math: Math;
-    readonly planeRef: import("angular-three").NgtInjectedRef<THREE.Mesh<THREE.BufferGeometry, THREE.Material | THREE.Material[]>>;
-    readonly sceneRef: import("angular-three").NgtInjectedRef<THREE.Scene>;
-    readonly cameraRef: import("angular-three").NgtInjectedRef<THREE.OrthographicCamera>;
-    causticsRef: import("angular-three").NgtInjectedRef<THREE.Group>;
-    /** How many frames it will render, set it to Infinity for runtime, default: 1 */
-    set frames(frames: number);
-    /** Enables visual cues to help you stage your scene, default: false */
-    set debug(debug: boolean);
-    /** Will display caustics only and skip the models, default: false */
-    set causticsOnly(causticsOnly: boolean);
-    /** Will include back faces and enable the backsideIOR prop, default: false */
-    set backside(backside: boolean);
-    /** The IOR refraction index, default: 1.1 */
-    set ior(ior: number);
-    /** The IOR refraction index for back faces (only available when backside is enabled), default: 1.1 */
-    set backsideIOR(backsideIOR: number);
-    /** The texel size, default: 0.3125 */
-    set worldRadius(worldRadius: number);
-    /** Intensity of the prjected caustics, default: 0.05 */
-    set intensity(intensity: number);
-    /** Caustics color, default: white */
-    set color(color: THREE.ColorRepresentation);
-    /** Buffer resolution, default: 2048 */
-    set resolution(resolution: number);
-    /** Camera position, it will point towards the contents bounds center, default: [5, 5, 5] */
-    set lightSource(lightSource: [x: number, y: number, z: number] | ElementRef<THREE.Object3D>);
-    readonly normalTargetFbo: import("angular-three").NgtInjectedRef<THREE.WebGLRenderTarget>;
-    readonly normalTargetBFbo: import("angular-three").NgtInjectedRef<THREE.WebGLRenderTarget>;
-    readonly causticsTargetFbo: import("angular-three").NgtInjectedRef<THREE.WebGLRenderTarget>;
-    readonly causticsTargetBFbo: import("angular-three").NgtInjectedRef<THREE.WebGLRenderTarget>;
-    private readonly store;
-    initialize(): void;
-    ngOnInit(): void;
-    private updateWorldMatrix;
-    private setBeforeRender;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsCaustics, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsCaustics, "ngts-caustics", never, { "causticsRef": "causticsRef"; "frames": "frames"; "debug": "debug"; "causticsOnly": "causticsOnly"; "backside": "backside"; "ior": "ior"; "backsideIOR": "backsideIOR"; "worldRadius": "worldRadius"; "intensity": "intensity"; "color": "color"; "resolution": "resolution"; "lightSource": "lightSource"; }, {}, never, ["*"], true, never>;
-}

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

@@ -1,40 +0,0 @@
-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/cloud/cloud.d.ts

@@ -1,23 +0,0 @@
-import { NgtBeforeRenderEvent, NgtRxStore } from 'angular-three';
-import { Observable } from 'rxjs';
-import { ColorRepresentation, Group, Texture } from 'three';
-import * as i0 from "@angular/core";
-export declare class NgtsCloud extends NgtRxStore {
-    private readonly store;
-    readonly encoding: import("three").TextureEncoding;
-    groupRef: import("angular-three").NgtInjectedRef<Group>;
-    set opacity(opacity: number);
-    set speed(speed: number);
-    set width(width: number);
-    set depth(depth: number);
-    set segments(segments: number);
-    set texture(texture: string);
-    set color(color: ColorRepresentation);
-    set depthTest(depthTest: boolean);
-    readonly clouds$: Observable<any>;
-    readonly cloudTexture$: Observable<Texture>;
-    initialize(): void;
-    onBeforeRender({ state, object }: NgtBeforeRenderEvent<Group>): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsCloud, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsCloud, "ngts-cloud", never, { "groupRef": "groupRef"; "opacity": "opacity"; "speed": "speed"; "width": "width"; "depth": "depth"; "segments": "segments"; "texture": "texture"; "color": "color"; "depthTest": "depthTest"; }, {}, never, never, true, never>;
-}

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

@@ -1,29 +0,0 @@
-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>;
-}