angular-three-soba 2.0.0-beta.8 → 2.0.0

package/staging/cloud/cloud.d.ts

@@ -1,51 +0,0 @@
-import { type NgtBeforeRenderEvent, type NgtGroup } from 'angular-three';
-import { Group } from 'three';
-import * as i0 from "@angular/core";
-export type NgtsCloudState = {
-    opacity: number;
-    speed: number;
-    width: number;
-    depth: number;
-    segments: number;
-    texture: string;
-    color: THREE.ColorRepresentation;
-    depthTest: boolean;
-};
-declare global {
-    interface HTMLElementTagNameMap {
-        /**
-         * @extends ngt-group
-         */
-        'ngts-cloud': NgtsCloudState & NgtGroup;
-    }
-}
-export declare class NgtsCloud {
-    private inputs;
-    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: THREE.ColorRepresentation);
-    set _depthTest(depthTest: boolean);
-    private width;
-    private speed;
-    segments: import("@angular/core").Signal<number>;
-    depth: import("@angular/core").Signal<number>;
-    depthTest: import("@angular/core").Signal<boolean>;
-    opacity: import("@angular/core").Signal<number>;
-    color: import("@angular/core").Signal<import("three").ColorRepresentation>;
-    texture: import("@angular/core").Signal<import("three").Texture | null>;
-    clouds: import("@angular/core").Signal<{
-        x: number;
-        y: number;
-        scale: number;
-        density: number;
-        rotation: number;
-    }[]>;
-    onBeforeRender({ state, object }: NgtBeforeRenderEvent<Group>): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsCloud, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsCloud, "ngts-cloud", never, { "groupRef": { "alias": "groupRef"; "required": false; }; "_opacity": { "alias": "opacity"; "required": false; }; "_speed": { "alias": "speed"; "required": false; }; "_width": { "alias": "width"; "required": false; }; "_depth": { "alias": "depth"; "required": false; }; "_segments": { "alias": "segments"; "required": false; }; "_texture": { "alias": "texture"; "required": false; }; "_color": { "alias": "color"; "required": false; }; "_depthTest": { "alias": "depthTest"; "required": false; }; }, {}, never, never, true, never>;
-}

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

@@ -1,70 +0,0 @@
-import { type NgtGroup } from 'angular-three';
-import * as THREE from 'three';
-import * as i0 from "@angular/core";
-export type NgtsContactShadowsState = {
-    opacity: number;
-    width: number;
-    height: number;
-    blur: number;
-    far: number;
-    smooth: boolean;
-    resolution: number;
-    frames: number;
-    scale: number | [x: number, y: number];
-    color: THREE.ColorRepresentation;
-    depthWrite: boolean;
-    renderOrder: number;
-};
-declare global {
-    interface HTMLElementTagNameMap {
-        /**
-         * @extends ngt-group
-         */
-        'ngts-contact-shadows': NgtsContactShadowsState & NgtGroup;
-    }
-}
-export declare class NgtsContactShadows {
-    private inputs;
-    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);
-    Math: Math;
-    private store;
-    shadowCameraRef: import("angular-three").NgtInjectedRef<THREE.OrthographicCamera>;
-    private scale;
-    private width;
-    private height;
-    private far;
-    private resolution;
-    private color;
-    private scaledWidth;
-    private scaledHeight;
-    renderOrder: import("@angular/core").Signal<number>;
-    opacity: import("@angular/core").Signal<number>;
-    depthWrite: import("@angular/core").Signal<boolean>;
-    cameraArgs: import("@angular/core").Signal<number[]>;
-    contactShadows: import("@angular/core").Signal<{
-        renderTarget: THREE.WebGLRenderTarget<THREE.Texture>;
-        planeGeometry: THREE.PlaneGeometry;
-        depthMaterial: THREE.MeshDepthMaterial;
-        blurPlane: THREE.Mesh<THREE.PlaneGeometry, THREE.Material | THREE.Material[]>;
-        horizontalBlurMaterial: THREE.ShaderMaterial;
-        verticalBlurMaterial: THREE.ShaderMaterial;
-        renderTargetBlur: THREE.WebGLRenderTarget<THREE.Texture>;
-    }>;
-    constructor();
-    private beforeRender;
-    private blurShadows;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsContactShadows, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsContactShadows, "ngts-contact-shadows", never, { "contactShadowsRef": { "alias": "contactShadowsRef"; "required": false; }; "_opacity": { "alias": "opacity"; "required": false; }; "_width": { "alias": "width"; "required": false; }; "_height": { "alias": "height"; "required": false; }; "_blur": { "alias": "blur"; "required": false; }; "_far": { "alias": "far"; "required": false; }; "_smooth": { "alias": "smooth"; "required": false; }; "_resolution": { "alias": "resolution"; "required": false; }; "_frames": { "alias": "frames"; "required": false; }; "_scale": { "alias": "scale"; "required": false; }; "_color": { "alias": "color"; "required": false; }; "_depthWrite": { "alias": "depthWrite"; "required": false; }; "_renderOrder": { "alias": "renderOrder"; "required": false; }; }, {}, never, never, true, never>;
-}

package/staging/environment/assets.d.ts

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

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

@@ -1,15 +0,0 @@
-import { NgtsEnvironmentInput } from './environment-input';
-import * as i0 from "@angular/core";
-export declare class NgtsEnvironmentCube {
-    environmentInput: NgtsEnvironmentInput;
-    private inputs;
-    set _background(background: boolean);
-    private store;
-    private scene;
-    private background;
-    private textureRef;
-    constructor();
-    private setEnvProps;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsEnvironmentCube, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsEnvironmentCube, "ngts-environment-cube", never, { "_background": { "alias": "background"; "required": false; }; }, {}, never, never, true, never>;
-}

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

@@ -1,13 +0,0 @@
-import { NgtsEnvironmentInput } from './environment-input';
-import * as i0 from "@angular/core";
-export declare class NgtsEnvironmentGround {
-    environmentInput: NgtsEnvironmentInput;
-    private defaultTexture;
-    texture: import("@angular/core").Signal<import("three").Texture>;
-    groundArgs: import("@angular/core").Signal<import("three").Texture[]>;
-    height: import("@angular/core").Signal<any>;
-    radius: import("@angular/core").Signal<any>;
-    scale: import("@angular/core").Signal<any>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsEnvironmentGround, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsEnvironmentGround, "ngts-environment-ground", never, {}, {}, never, never, true, never>;
-}

package/staging/environment/environment-input.d.ts

@@ -1,68 +0,0 @@
-import { ElementRef } from '@angular/core';
-import type { Loader, Scene, Texture, TextureEncoding } from 'three';
-import { NgtsEnvironmentPresetsType } from './assets';
-import * as i0 from "@angular/core";
-export type NgtsEnvironmentInputState = {
-    frames?: number;
-    near?: number;
-    far?: number;
-    resolution?: number;
-    background?: boolean | 'only';
-    blur?: number;
-    map?: Texture;
-    files?: string | string[];
-    path?: string;
-    preset?: NgtsEnvironmentPresetsType;
-    scene?: Scene | ElementRef<Scene>;
-    extensions?: (loader: Loader) => void;
-    ground?: boolean | {
-        radius?: number;
-        height?: number;
-        scale?: number;
-    };
-    encoding?: TextureEncoding;
-};
-export declare abstract class NgtsEnvironmentInput {
-    inputs: import("angular-three").NgtSignalStore<NgtsEnvironmentInputState>;
-    set _frames(frames: NgtsEnvironmentInputState['frames']);
-    set _near(near: NgtsEnvironmentInputState['near']);
-    set _far(far: NgtsEnvironmentInputState['far']);
-    set _resolution(resolution: NgtsEnvironmentInputState['resolution']);
-    set _background(background: NgtsEnvironmentInputState['background']);
-    set _blur(blur: NgtsEnvironmentInputState['blur']);
-    set _map(map: NgtsEnvironmentInputState['map']);
-    set _files(files: NgtsEnvironmentInputState['files']);
-    set _path(path: NgtsEnvironmentInputState['path']);
-    set _preset(preset: NgtsEnvironmentInputState['preset']);
-    set _scene(scene: NgtsEnvironmentInputState['scene']);
-    set _extensions(extensions: NgtsEnvironmentInputState['extensions']);
-    set _ground(ground: NgtsEnvironmentInputState['ground']);
-    set _encoding(encoding: NgtsEnvironmentInputState['encoding']);
-    frames: import("@angular/core").Signal<number | undefined>;
-    near: import("@angular/core").Signal<number | undefined>;
-    far: import("@angular/core").Signal<number | undefined>;
-    resolution: import("@angular/core").Signal<number | undefined>;
-    background: import("@angular/core").Signal<boolean | "only" | undefined>;
-    blur: import("@angular/core").Signal<number | undefined>;
-    map: import("@angular/core").Signal<Texture | undefined>;
-    files: import("@angular/core").Signal<string | string[] | undefined>;
-    path: import("@angular/core").Signal<string | undefined>;
-    preset: import("@angular/core").Signal<"apartment" | "city" | "dawn" | "forest" | "lobby" | "night" | "park" | "studio" | "sunset" | "warehouse" | undefined>;
-    scene: import("@angular/core").Signal<Scene | ElementRef<Scene> | undefined>;
-    extensions: import("@angular/core").Signal<((loader: Loader) => void) | undefined>;
-    ground: import("@angular/core").Signal<boolean | {
-        radius?: number | undefined;
-        height?: number | undefined;
-        scale?: number | undefined;
-    } | undefined>;
-    encoding: import("@angular/core").Signal<TextureEncoding | undefined>;
-    params: import("@angular/core").Signal<{
-        files: string | string[] | undefined;
-        path: string | undefined;
-        preset: "apartment" | "city" | "dawn" | "forest" | "lobby" | "night" | "park" | "studio" | "sunset" | "warehouse" | undefined;
-        extensions: ((loader: Loader) => void) | undefined;
-        encoding: TextureEncoding | undefined;
-    }>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsEnvironmentInput, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsEnvironmentInput, never, never, { "_frames": { "alias": "frames"; "required": false; }; "_near": { "alias": "near"; "required": false; }; "_far": { "alias": "far"; "required": false; }; "_resolution": { "alias": "resolution"; "required": false; }; "_background": { "alias": "background"; "required": false; }; "_blur": { "alias": "blur"; "required": false; }; "_map": { "alias": "map"; "required": false; }; "_files": { "alias": "files"; "required": false; }; "_path": { "alias": "path"; "required": false; }; "_preset": { "alias": "preset"; "required": false; }; "_scene": { "alias": "scene"; "required": false; }; "_extensions": { "alias": "extensions"; "required": false; }; "_ground": { "alias": "ground"; "required": false; }; "_encoding": { "alias": "encoding"; "required": false; }; }, {}, never, never, false, never>;
-}

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

@@ -1,16 +0,0 @@
-import { NgtsEnvironmentInput } from './environment-input';
-import * as i0 from "@angular/core";
-export declare class NgtsEnvironmentMap {
-    environmentInput: NgtsEnvironmentInput;
-    private store;
-    private inputs;
-    set _map(map: THREE.Texture);
-    set _background(background: boolean);
-    constructor();
-    private scene;
-    private background;
-    private map;
-    private setEnvProps;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsEnvironmentMap, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsEnvironmentMap, "ngts-environment-map", never, { "_map": { "alias": "map"; "required": false; }; "_background": { "alias": "background"; "required": false; }; }, {}, never, never, true, never>;
-}

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

@@ -1,18 +0,0 @@
-import * as THREE from 'three';
-import { NgtsEnvironmentInput } from './environment-input';
-import * as i0 from "@angular/core";
-export declare class NgtsEnvironmentPortal {
-    environmentInput: NgtsEnvironmentInput;
-    private store;
-    private gl;
-    private scene;
-    virtualSceneRef: import("angular-three").NgtInjectedRef<THREE.Scene>;
-    cubeCameraRef: import("angular-three").NgtInjectedRef<THREE.CubeCamera>;
-    private fbo;
-    cameraArgs: import("@angular/core").Signal<(number | THREE.WebGLCubeRenderTarget)[]>;
-    constructor();
-    private setEnvProps;
-    private beforeRender;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsEnvironmentPortal, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsEnvironmentPortal, "ngts-environment-portal", never, {}, {}, never, ["*"], true, never>;
-}

package/staging/environment/environment.d.ts

@@ -1,8 +0,0 @@
-import { TemplateRef } from '@angular/core';
-import { NgtsEnvironmentInput } from './environment-input';
-import * as i0 from "@angular/core";
-export declare class NgtsEnvironment extends NgtsEnvironmentInput {
-    content?: TemplateRef<unknown>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsEnvironment, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsEnvironment, "ngts-environment", never, {}, {}, ["content"], never, true, never>;
-}

package/staging/environment/utils.d.ts

@@ -1,7 +0,0 @@
-import { ElementRef, Injector } from '@angular/core';
-import { CubeTexture } from 'three';
-import { type NgtsEnvironmentInputState } from './environment-input';
-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<NgtsEnvironmentInputState, 'files' | 'path' | 'preset' | 'extensions' | 'encoding'>>;
-export declare function injectNgtsEnvironment(paramsFactory: () => Partial<NgtsInjectEnvironmentParams>, injector?: Injector): import("angular-three").NgtInjectedRef<import("three").Texture | CubeTexture>;
-export {};

package/staging/float/float.d.ts

@@ -1,31 +0,0 @@
-import { type NgtGroup } from 'angular-three';
-import * as THREE from 'three';
-import * as i0 from "@angular/core";
-export type NgtsFloatState = {
-    enabled: boolean;
-    speed: number;
-    rotationIntensity: number;
-    floatIntensity: number;
-    floatingRange: [number?, number?];
-};
-declare global {
-    interface HTMLElementTagNameMap {
-        /**
-         * @extends ngt-group
-         */
-        'ngts-float': NgtsFloatState & NgtGroup;
-    }
-}
-export declare class NgtsFloat {
-    private inputs;
-    floatRef: import("angular-three").NgtInjectedRef<THREE.Group>;
-    set _enabled(enabled: boolean);
-    set _speed(speed: number);
-    set _rotationIntensity(rotationIntensity: number);
-    set _floatIntensity(floatIntensity: number);
-    set _floatingRange(floatingRange: [number?, number?]);
-    constructor();
-    private beforeRender;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsFloat, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsFloat, "ngts-float", never, { "floatRef": { "alias": "floatRef"; "required": false; }; "_enabled": { "alias": "enabled"; "required": false; }; "_speed": { "alias": "speed"; "required": false; }; "_rotationIntensity": { "alias": "rotationIntensity"; "required": false; }; "_floatIntensity": { "alias": "floatIntensity"; "required": false; }; "_floatingRange": { "alias": "floatingRange"; "required": false; }; }, {}, never, ["*"], true, never>;
-}

package/staging/matcap-texture/matcap-texture.d.ts

@@ -1,13 +0,0 @@
-import { Signal, type Injector } from '@angular/core';
-export type NgtsMatcapTextureState = {
-    id: string | number;
-    format: number;
-    onLoad?: (texture: THREE.Texture | THREE.Texture[]) => void;
-};
-export declare function injectNgtsMatcapTexture(matcapTextureState: () => Partial<NgtsMatcapTextureState>, { injector }?: {
-    injector?: Injector;
-}): {
-    texture: Signal<import("three").Texture | null>;
-    numTot: () => number;
-    url: () => string;
-};

package/staging/normal-texture/normal-texture.d.ts

@@ -1,16 +0,0 @@
-import { type Injector, type Signal } from '@angular/core';
-import * as THREE from 'three';
-export type NgtsNormalTextureState = {
-    id: string | number;
-    repeat: number[];
-    anisotropy: number;
-    offset: number[];
-    onLoad?: (texture: THREE.Texture | THREE.Texture[]) => void;
-};
-export declare function injectNgtsNormalTexture(normalTextureState: () => Partial<NgtsNormalTextureState>, { injector }?: {
-    injector?: Injector;
-}): {
-    texture: Signal<THREE.Texture | null>;
-    numTot: () => number;
-    url: () => string;
-};

package/staging/sky/sky.d.ts

@@ -1,48 +0,0 @@
-import { type NgtMesh } from 'angular-three';
-import * as THREE from 'three';
-import { Sky } from 'three-stdlib';
-import * as i0 from "@angular/core";
-export interface NgtsSkyState {
-    distance: number;
-    sunPosition: THREE.Vector3 | Parameters<THREE.Vector3['set']>;
-    inclination: number;
-    azimuth: number;
-    mieCoefficient: number;
-    mieDirectionalG: number;
-    rayleigh: number;
-    turbidity: number;
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        /**
-         * @extends three-stdlib|Sky
-         * @extends ngt-mesh
-         */
-        'ngts-sky': NgtsSkyState & Sky & NgtMesh;
-    }
-}
-export declare class NgtsSky {
-    private inputs;
-    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);
-    private inclination;
-    private azimuth;
-    private sunPos;
-    private distance;
-    sunPosition: import("@angular/core").Signal<THREE.Vector3 | [x: number, y: number, z: number]>;
-    scale: import("@angular/core").Signal<THREE.Vector3>;
-    mieCoefficient: import("@angular/core").Signal<number>;
-    mieDirectionalG: import("@angular/core").Signal<number>;
-    rayleigh: import("@angular/core").Signal<number>;
-    turbidity: import("@angular/core").Signal<number>;
-    sky: Sky;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSky, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSky, "ngts-sky", never, { "skyRef": { "alias": "skyRef"; "required": false; }; "_distance": { "alias": "distance"; "required": false; }; "_sunPosition": { "alias": "sunPosition"; "required": false; }; "_inclination": { "alias": "inclination"; "required": false; }; "_azimuth": { "alias": "azimuth"; "required": false; }; "_mieCoefficient": { "alias": "mieCoefficient"; "required": false; }; "_mieDirectionalG": { "alias": "mieDirectionalG"; "required": false; }; "_rayleigh": { "alias": "rayleigh"; "required": false; }; "_turbidity": { "alias": "turbidity"; "required": false; }; }, {}, never, ["*"], true, never>;
-}

package/staging/sparkles/sparkles.d.ts

@@ -1,63 +0,0 @@
-import { Signal } from '@angular/core';
-import { type NgtPoints } from 'angular-three';
-import * as THREE from 'three';
-import * as i0 from "@angular/core";
-export type NgtsSparklesState = {
-    /** Number of particles (default: 100) */
-    count: number;
-    /** Speed of particles (default: 1) */
-    speed: number | Float32Array;
-    /** Opacity of particles (default: 1) */
-    opacity: number | Float32Array;
-    /** Color of particles (default: 100) */
-    color?: THREE.ColorRepresentation | Float32Array;
-    /** Size of particles (default: randomized between 0 and 1) */
-    size?: number | Float32Array;
-    /** The space the particles occupy (default: 1) */
-    scale: number | [number, number, number] | THREE.Vector3;
-    /** Movement factor (default: 1) */
-    noise: number | [number, number, number] | THREE.Vector3 | Float32Array;
-};
-declare global {
-    interface HTMLElementTagNameMap {
-        /**
-         * @extends ngt-points
-         */
-        'ngts-sparkles': NgtsSparklesState & NgtPoints;
-    }
-}
-export declare class NgtsSparkles {
-    private inputs;
-    sparklesRef: import("angular-three").NgtInjectedRef<THREE.Points<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | 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);
-    private store;
-    dpr: Signal<number>;
-    private scale;
-    private count;
-    private color;
-    positions: Signal<Float32Array>;
-    sizes: Signal<Float32Array>;
-    opacities: Signal<Float32Array>;
-    speeds: Signal<Float32Array>;
-    noises: Signal<Float32Array>;
-    colors: Signal<Float32Array>;
-    key: Signal<string>;
-    constructor();
-    private beforeRender;
-    private getComputed;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSparkles, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSparkles, "ngts-sparkles", never, { "sparklesRef": { "alias": "sparklesRef"; "required": false; }; "_count": { "alias": "count"; "required": false; }; "_speed": { "alias": "speed"; "required": false; }; "_opacity": { "alias": "opacity"; "required": false; }; "_color": { "alias": "color"; "required": false; }; "_size": { "alias": "size"; "required": false; }; "_scale": { "alias": "scale"; "required": false; }; "_noise": { "alias": "noise"; "required": false; }; }, {}, never, never, true, never>;
-}

package/staging/spot-light/shadow-mesh-input.d.ts

@@ -1,29 +0,0 @@
-import * as i0 from "@angular/core";
-export type NgtsSpotLightShadowMeshInputState = {
-    distance: number;
-    alphaTest: number;
-    scale: number;
-    map: THREE.Texture;
-    shader: string;
-    width: number;
-    height: number;
-};
-export declare abstract class NgtsSpotLightShadowMeshInput {
-    inputs: import("angular-three").NgtSignalStore<NgtsSpotLightShadowMeshInputState>;
-    set _distance(distance: number);
-    set _alphaTest(alphaTest: number);
-    set _scale(scale: number);
-    set _map(map: THREE.Texture);
-    set _shader(shader: string);
-    set _width(width: number);
-    set _height(height: number);
-    distance: import("@angular/core").Signal<number>;
-    alphaTest: import("@angular/core").Signal<number>;
-    scale: import("@angular/core").Signal<number>;
-    map: import("@angular/core").Signal<import("three").Texture>;
-    shader: import("@angular/core").Signal<string>;
-    width: import("@angular/core").Signal<number>;
-    height: import("@angular/core").Signal<number>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSpotLightShadowMeshInput, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsSpotLightShadowMeshInput, never, never, { "_distance": { "alias": "distance"; "required": false; }; "_alphaTest": { "alias": "alphaTest"; "required": false; }; "_scale": { "alias": "scale"; "required": false; }; "_map": { "alias": "map"; "required": false; }; "_shader": { "alias": "shader"; "required": false; }; "_width": { "alias": "width"; "required": false; }; "_height": { "alias": "height"; "required": false; }; }, {}, never, never, false, never>;
-}

package/staging/spot-light/shadow-mesh.d.ts

@@ -1,37 +0,0 @@
-import { type NgtInjectedRef } from 'angular-three';
-import * as THREE from 'three';
-import { NgtsSpotLightShadowMeshInput, type NgtsSpotLightShadowMeshInputState } from './shadow-mesh-input';
-import * as i0 from "@angular/core";
-export declare class NgtsSpotLightShadowMeshNoShader {
-    shadowMeshInput: NgtsSpotLightShadowMeshInput;
-    meshRef: NgtInjectedRef<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
-    DoubleSide: 2;
-    private spotLightApi;
-    debug: import("@angular/core").Signal<boolean>;
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSpotLightShadowMeshNoShader, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSpotLightShadowMeshNoShader, "ngts-spot-light-shadow-mesh-no-shader", never, {}, {}, never, ["*"], true, never>;
-}
-export declare class NgtsSpotLightShadowMeshShader {
-    shadowMeshInput: NgtsSpotLightShadowMeshInput;
-    meshRef: NgtInjectedRef<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
-    DoubleSide: 2;
-    RepeatWrapping: 1000;
-    private spotLightApi;
-    debug: import("@angular/core").Signal<boolean>;
-    renderTarget: import("@angular/core").Signal<THREE.WebGLRenderTarget<THREE.Texture>>;
-    private uniforms;
-    private fsQuad;
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSpotLightShadowMeshShader, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSpotLightShadowMeshShader, "ngts-spot-light-shadow-mesh-shader", never, {}, {}, never, ["*"], true, never>;
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        'ngts-spot-light-shadow': NgtsSpotLightShadowMeshInputState;
-    }
-}
-export declare class NgtsSpotLightShadow extends NgtsSpotLightShadowMeshInput {
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSpotLightShadow, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSpotLightShadow, "ngts-spot-light-shadow", never, {}, {}, never, never, true, never>;
-}

package/staging/spot-light/spot-light-input.d.ts

@@ -1,38 +0,0 @@
-import * as i0 from "@angular/core";
-export type NgtsSpotLightInputState = {
-    depthBuffer?: THREE.DepthTexture;
-    angle: number;
-    distance: number;
-    attenuation: number;
-    anglePower: number;
-    radiusTop: number;
-    radiusBottom: number;
-    opacity: number;
-    color: string | number;
-    debug: boolean;
-};
-export declare abstract class NgtsSpotLightInput {
-    inputs: import("angular-three").NgtSignalStore<NgtsSpotLightInputState>;
-    set _depthBuffer(depthBuffer: THREE.DepthTexture);
-    set _angle(angle: number);
-    set _distance(distance: number);
-    set _attenuation(attenuation: number);
-    set _anglePower(anglePower: number);
-    set _radiusTop(radiusTop: number);
-    set _radiusBottom(radiusBottom: number);
-    set _opacity(opacity: number);
-    set _color(color: string | number);
-    set _debug(debug: boolean);
-    debug: import("@angular/core").Signal<boolean>;
-    color: import("@angular/core").Signal<string | number>;
-    opacity: import("@angular/core").Signal<number>;
-    radiusBottom: import("@angular/core").Signal<number>;
-    radiusTop: import("@angular/core").Signal<number>;
-    anglePower: import("@angular/core").Signal<number>;
-    attenuation: import("@angular/core").Signal<number>;
-    distance: import("@angular/core").Signal<number>;
-    angle: import("@angular/core").Signal<number>;
-    depthBuffer: import("@angular/core").Signal<import("three").DepthTexture | undefined>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSpotLightInput, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsSpotLightInput, never, never, { "_depthBuffer": { "alias": "depthBuffer"; "required": false; }; "_angle": { "alias": "angle"; "required": false; }; "_distance": { "alias": "distance"; "required": false; }; "_attenuation": { "alias": "attenuation"; "required": false; }; "_anglePower": { "alias": "anglePower"; "required": false; }; "_radiusTop": { "alias": "radiusTop"; "required": false; }; "_radiusBottom": { "alias": "radiusBottom"; "required": false; }; "_opacity": { "alias": "opacity"; "required": false; }; "_color": { "alias": "color"; "required": false; }; "_debug": { "alias": "debug"; "required": false; }; }, {}, never, never, false, never>;
-}

package/staging/spot-light/spot-light.d.ts

@@ -1,39 +0,0 @@
-import { NgtSpotLight } from 'angular-three';
-import { SpotLight } from 'three';
-import { NgtsSpotLightInput, type NgtsSpotLightInputState } from './spot-light-input';
-import * as i0 from "@angular/core";
-declare global {
-    interface HTMLElementTagNameMap {
-        /**
-         * @extends ngt-spot-light
-         */
-        'ngts-spot-light': NgtsSpotLightInputState & NgtSpotLight;
-    }
-}
-export declare const injectNgtsSpotLightApi: {
-    (): {
-        spotLight: import("angular-three").NgtInjectedRef<SpotLight>;
-        debug: import("@angular/core").Signal<boolean>;
-    };
-    (injectOptions: import("@angular/core").InjectOptions & {
-        optional?: false | undefined;
-    }): {
-        spotLight: import("angular-three").NgtInjectedRef<SpotLight>;
-        debug: import("@angular/core").Signal<boolean>;
-    };
-    (injectOptions: import("@angular/core").InjectOptions): {
-        spotLight: import("angular-three").NgtInjectedRef<SpotLight>;
-        debug: import("@angular/core").Signal<boolean>;
-    } | null;
-}, provideNgtsSpotLightApi: (value?: {
-    spotLight: import("angular-three").NgtInjectedRef<SpotLight>;
-    debug: import("@angular/core").Signal<boolean>;
-} | undefined) => import("@angular/core").Provider;
-export declare class NgtsSpotLight extends NgtsSpotLightInput {
-    spotLightRef: import("angular-three").NgtInjectedRef<SpotLight>;
-    volumetric: import("@angular/core").WritableSignal<boolean>;
-    set _volumetric(volumetric: boolean);
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSpotLight, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSpotLight, "ngts-spot-light", never, { "spotLightRef": { "alias": "spotLightRef"; "required": false; }; "_volumetric": { "alias": "volumetric"; "required": false; }; }, {}, never, ["*"], true, never>;
-}

package/staging/spot-light/volumetric-mesh.d.ts

@@ -1,24 +0,0 @@
-import { SpotLightMaterial } from 'angular-three-soba/shaders';
-import * as THREE from 'three';
-import { NgtsSpotLightInput } from './spot-light-input';
-import * as i0 from "@angular/core";
-export declare class NgtsVolumetricMesh {
-    spotLightInput: NgtsSpotLightInput;
-    mesh: import("angular-three").NgtInjectedRef<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
-    material: SpotLightMaterial;
-    nullRaycast: () => null;
-    private vec;
-    private store;
-    private size;
-    private dpr;
-    private radiusTop;
-    private radiusBottom;
-    near: import("@angular/core").Signal<number>;
-    far: import("@angular/core").Signal<number>;
-    resolution: import("@angular/core").Signal<number[]>;
-    geometry: import("@angular/core").Signal<THREE.CylinderGeometry>;
-    constructor();
-    private beforeRender;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsVolumetricMesh, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsVolumetricMesh, "ngts-volumetric-mesh", never, {}, {}, never, never, true, never>;
-}