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

package/shaders/mesh-reflector-material/mesh-reflector-material.d.ts

@@ -1,50 +0,0 @@
-import { Matrix4, MeshStandardMaterial, Texture } from 'three';
-export declare class MeshReflectorMaterial extends MeshStandardMaterial {
-    private _tDepth;
-    private _distortionMap;
-    private _tDiffuse;
-    private _tDiffuseBlur;
-    private _textureMatrix;
-    private _hasBlur;
-    private _mirror;
-    private _mixBlur;
-    private _blurStrength;
-    private _minDepthThreshold;
-    private _maxDepthThreshold;
-    private _depthScale;
-    private _depthToBlurRatioBias;
-    private _distortion;
-    private _mixContrast;
-    constructor(parameters?: {});
-    onBeforeCompile(shader: any): void;
-    get tDiffuse(): Texture | null;
-    set tDiffuse(v: Texture | null);
-    get tDepth(): Texture | null;
-    set tDepth(v: Texture | null);
-    get distortionMap(): Texture | null;
-    set distortionMap(v: Texture | null);
-    get tDiffuseBlur(): Texture | null;
-    set tDiffuseBlur(v: Texture | null);
-    get textureMatrix(): Matrix4 | null;
-    set textureMatrix(v: Matrix4 | null);
-    get hasBlur(): boolean;
-    set hasBlur(v: boolean);
-    get mirror(): number;
-    set mirror(v: number);
-    get mixBlur(): number;
-    set mixBlur(v: number);
-    get mixStrength(): number;
-    set mixStrength(v: number);
-    get minDepthThreshold(): number;
-    set minDepthThreshold(v: number);
-    get maxDepthThreshold(): number;
-    set maxDepthThreshold(v: number);
-    get depthScale(): number;
-    set depthScale(v: number);
-    get depthToBlurRatioBias(): number;
-    set depthToBlurRatioBias(v: number);
-    get distortion(): number;
-    set distortion(v: number);
-    get mixContrast(): number;
-    set mixContrast(v: number);
-}

package/shaders/mesh-refraction-material/mesh-refraction-material.d.ts

@@ -1,4 +0,0 @@
-import * as THREE from 'three';
-export declare const MeshRefractionMaterial: typeof THREE.ShaderMaterial & {
-    key: string;
-};

package/shaders/mesh-transmission-material/mesh-transmission-material.d.ts

@@ -1,25 +0,0 @@
-import * as THREE from 'three';
-interface Uniform<T> {
-    value: T;
-}
-export declare class MeshTransmissionMaterial extends THREE.MeshPhysicalMaterial {
-    uniforms: {
-        chromaticAberration: Uniform<number>;
-        transmission: Uniform<number>;
-        transmissionMap: Uniform<THREE.Texture | null>;
-        _transmission: Uniform<number>;
-        thickness: Uniform<number>;
-        roughness: Uniform<number>;
-        thicknessMap: Uniform<THREE.Texture | null>;
-        attenuationDistance: Uniform<number>;
-        attenuationColor: Uniform<THREE.Color>;
-        anisotropicBlur: Uniform<number>;
-        time: Uniform<number>;
-        distortion: Uniform<number>;
-        distortionScale: Uniform<number>;
-        temporalDistortion: Uniform<number>;
-        buffer: Uniform<THREE.Texture | null>;
-    };
-    constructor(samples?: number, transmissionSampler?: boolean);
-}
-export {};

package/shaders/mesh-wobble-material/mesh-wobble-material.d.ts

@@ -1,16 +0,0 @@
-import * as THREE from 'three';
-interface Uniform<T> {
-    value: T;
-}
-export declare class MeshWobbleMaterial extends THREE.MeshStandardMaterial {
-    _time: Uniform<number>;
-    _factor: Uniform<number>;
-    constructor(parameters?: THREE.MeshStandardMaterialParameters);
-    onBeforeCompile(shader: THREE.Shader): void;
-    get time(): number;
-    set time(v: number);
-    get factor(): number;
-    set factor(v: number);
-    speed: number;
-}
-export {};

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

@@ -1,6 +0,0 @@
-import * as THREE from 'three';
-export declare function shaderMaterial<Uniforms extends {
-    [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;
-}>(uniforms: Uniforms, vertexShader: string, fragmentShader: string, onInit?: (material?: THREE.ShaderMaterial) => void): typeof THREE.ShaderMaterial & {
-    key: string;
-};

package/shaders/soft-shadow-material/soft-shadow-material.d.ts

@@ -1,19 +0,0 @@
-import type { NgtShaderMaterial } from 'angular-three';
-import * as THREE from 'three';
-export declare const SoftShadowMaterial: typeof THREE.ShaderMaterial & {
-    key: string;
-};
-export type NgtSoftShadowMaterialState = {
-    map: THREE.Texture;
-    color?: THREE.ColorRepresentation;
-    alphaTest?: number;
-    blend?: number;
-};
-declare global {
-    interface HTMLElementTagNameMap {
-        /**
-         *  @extends ngt-shader-material
-         */
-        'ngt-soft-shadow-material': NgtSoftShadowMaterialState & NgtShaderMaterial;
-    }
-}

package/shaders/sparkles-material/sparkles-material.d.ts

@@ -1,17 +0,0 @@
-import type { NgtShaderMaterial } from 'angular-three';
-import * as THREE from 'three';
-export declare const SparklesMaterial: typeof THREE.ShaderMaterial & {
-    key: string;
-};
-export type NgtSparklesMaterialState = {
-    time?: number;
-    pixelRatio?: number;
-};
-declare global {
-    interface HTMLElementTagNameMap {
-        /**
-         * @extends ngt-shader-material
-         */
-        'ngt-sparkles-material': NgtSparklesMaterialState & NgtShaderMaterial;
-    }
-}

package/shaders/spot-light-material/spot-light-material.d.ts

@@ -1,13 +0,0 @@
-import type { NgtShaderMaterial } from 'angular-three';
-import * as THREE from 'three';
-export declare class SpotLightMaterial extends THREE.ShaderMaterial {
-    constructor();
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        /**
-         * @extends ngt-shader-material
-         */
-        'ngt-spot-light-material': NgtShaderMaterial;
-    }
-}

package/shaders/star-field-material/star-field-material.d.ts

@@ -1,13 +0,0 @@
-import type { NgtShaderMaterial } from 'angular-three';
-import * as THREE from 'three';
-export declare const StarFieldMaterial: typeof THREE.ShaderMaterial & {
-    key: string;
-};
-declare global {
-    interface HTMLElementTagNameMap {
-        /**
-         * @extends ngt-shader-material
-         */
-        'ngt-star-field-material': NgtShaderMaterial;
-    }
-}

package/shaders/wireframe-material/wireframe-material.d.ts

@@ -1,58 +0,0 @@
-import { type Injector } from '@angular/core';
-import { type NgtShaderMaterial } from 'angular-three';
-import * as THREE from 'three';
-export type WireframeMaterialState = {
-    fillOpacity?: number;
-    fillMix?: number;
-    strokeOpacity?: number;
-    thickness?: number;
-    colorBackfaces?: boolean;
-    dashInvert?: boolean;
-    dash?: boolean;
-    dashRepeats?: number;
-    dashLength?: number;
-    squeeze?: boolean;
-    squeezeMin?: number;
-    squeezeMax?: number;
-    stroke?: THREE.ColorRepresentation;
-    backfaceStroke?: THREE.ColorRepresentation;
-    fill?: THREE.ColorRepresentation;
-};
-export declare const WireframeMaterialShaders: {
-    uniforms: {
-        strokeOpacity: number;
-        fillOpacity: number;
-        fillMix: number;
-        thickness: number;
-        colorBackfaces: boolean;
-        dashInvert: boolean;
-        dash: boolean;
-        dashRepeats: number;
-        dashLength: number;
-        squeeze: boolean;
-        squeezeMin: number;
-        squeezeMax: number;
-        stroke: THREE.Color;
-        backfaceStroke: THREE.Color;
-        fill: THREE.Color;
-    };
-    vertex: string;
-    fragment: string;
-};
-export declare const WireframeMaterial: typeof THREE.ShaderMaterial & {
-    key: string;
-};
-declare global {
-    interface HTMLElementTagNameMap {
-        /**
-         * @extends ngt-shader-material
-         */
-        'ngt-wireframe-material': WireframeMaterialState & NgtShaderMaterial;
-    }
-}
-export declare function setWireframeOverride(material: THREE.Material, uniforms: {
-    [key: string]: THREE.IUniform<any>;
-}): void;
-export declare function injectNgtsWireframeUniforms(uniformsFactory: () => Record<string, THREE.IUniform<any>>, stateFactory: () => Partial<WireframeMaterialState>, { injector }?: {
-    injector?: Injector;
-}): void;

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

@@ -1,146 +0,0 @@
-import { type Signal } from '@angular/core';
-import { type NgtGroup } from 'angular-three';
-import { type NgtSoftShadowMaterialState } from 'angular-three-soba/shaders';
-import { Group, Mesh, PlaneGeometry } from 'three';
-import { ProgressiveLightMap } from './progressive-light-map';
-import * as i0 from "@angular/core";
-export type NgtsAccumulativeShadowsState = {
-    /** How many frames it can render, more yields cleaner results but takes more time, 40 */
-    frames: number;
-    /** If frames === Infinity blend controls the refresh ratio, 100 */
-    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 */
-    limit: number;
-    /** Scale of the plane,  */
-    scale: number;
-    /** Temporal accumulates shadows over time which is more performant but has a visual regression over instant results, false  */
-    temporal: boolean;
-    /** Opacity of the plane, 1 */
-    opacity: number;
-    /** Discards alpha pixels, 0.65 */
-    alphaTest: number;
-    /** Shadow color, black */
-    color: string;
-    /** Colorblend, how much colors turn to black, 0 is black, 2 */
-    colorBlend: number;
-    /** Buffer resolution, 1024 */
-    resolution: number;
-    /** Texture tonemapping */
-    toneMapped: boolean;
-};
-declare global {
-    interface HTMLElementTagNameMap {
-        /**
-         * @extends ngt-group
-         */
-        'ngts-accumulative-shadows': NgtsAccumulativeShadowsState & NgtGroup;
-    }
-}
-export type NgtsAccumulativeShadowsLightApi = {
-    update: () => void;
-};
-export declare const injectNgtsAccumulativeShadowsApi: {
-    (): Signal<{
-        lights: Map<string, Signal<NgtsAccumulativeShadowsLightApi>>;
-        temporal: boolean;
-        frames: number;
-        blend: number;
-        count: number;
-        getMesh: () => Mesh<PlaneGeometry, NgtSoftShadowMaterialState & import("three").ShaderMaterial>;
-        reset: () => void;
-        update: (frames?: number) => void;
-    }>;
-    (injectOptions: import("@angular/core").InjectOptions & {
-        optional?: false | undefined;
-    }): Signal<{
-        lights: Map<string, Signal<NgtsAccumulativeShadowsLightApi>>;
-        temporal: boolean;
-        frames: number;
-        blend: number;
-        count: number;
-        getMesh: () => Mesh<PlaneGeometry, NgtSoftShadowMaterialState & import("three").ShaderMaterial>;
-        reset: () => void;
-        update: (frames?: number) => void;
-    }>;
-    (injectOptions: import("@angular/core").InjectOptions): Signal<{
-        lights: Map<string, Signal<NgtsAccumulativeShadowsLightApi>>;
-        temporal: boolean;
-        frames: number;
-        blend: number;
-        count: number;
-        getMesh: () => Mesh<PlaneGeometry, NgtSoftShadowMaterialState & import("three").ShaderMaterial>;
-        reset: () => void;
-        update: (frames?: number) => void;
-    }> | null;
-}, provideNgtsAccumulativeShadowsApi: (value?: Signal<{
-    lights: Map<string, Signal<NgtsAccumulativeShadowsLightApi>>;
-    temporal: boolean;
-    frames: number;
-    blend: number;
-    count: number;
-    getMesh: () => Mesh<PlaneGeometry, NgtSoftShadowMaterialState & import("three").ShaderMaterial>;
-    reset: () => void;
-    update: (frames?: number) => void;
-}> | undefined) => import("@angular/core").Provider;
-export declare class NgtsAccumulativeShadows {
-    private inputs;
-    nullTraverse: () => null;
-    Math: Math;
-    accumulativeShadowsRef: import("angular-three").NgtInjectedRef<Group>;
-    /** 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);
-    meshRef: import("angular-three").NgtInjectedRef<Mesh<PlaneGeometry, NgtSoftShadowMaterialState & import("three").ShaderMaterial>>;
-    private store;
-    private gl;
-    private scene;
-    private camera;
-    private invalidate;
-    private resolution;
-    private alphaTest;
-    private opacity;
-    private temporal;
-    private blend;
-    private frames;
-    pLM: Signal<ProgressiveLightMap>;
-    scale: Signal<number>;
-    toneMapped: Signal<boolean>;
-    color: Signal<string>;
-    colorBlend: Signal<number>;
-    map: Signal<import("three").Texture>;
-    api: Signal<{
-        lights: Map<string, Signal<NgtsAccumulativeShadowsLightApi>>;
-        temporal: boolean;
-        frames: number;
-        blend: number;
-        count: number;
-        getMesh: () => Mesh<PlaneGeometry, NgtSoftShadowMaterialState & import("three").ShaderMaterial>;
-        reset: () => void;
-        update: (frames?: number) => void;
-    }>;
-    constructor();
-    private configure;
-    private resetAndUpdate;
-    private beforeRender;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsAccumulativeShadows, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsAccumulativeShadows, "ngts-accumulative-shadows", never, { "accumulativeShadowsRef": { "alias": "accumulativeShadowsRef"; "required": false; }; "_frames": { "alias": "frames"; "required": false; }; "_blend": { "alias": "blend"; "required": false; }; "_limit": { "alias": "limit"; "required": false; }; "_scale": { "alias": "scale"; "required": false; }; "_temporal": { "alias": "temporal"; "required": false; }; "_opacity": { "alias": "opacity"; "required": false; }; "_alphaTest": { "alias": "alphaTest"; "required": false; }; "_color": { "alias": "color"; "required": false; }; "_colorBlend": { "alias": "colorBlend"; "required": false; }; "_resolution": { "alias": "resolution"; "required": false; }; "_toneMapped": { "alias": "toneMapped"; "required": false; }; }, {}, never, ["*"], true, never>;
-}

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

@@ -1,34 +0,0 @@
-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: THREE.Mesh): void;
-    update(camera: THREE.Camera, blendWindow?: number): void;
-}

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

@@ -1,90 +0,0 @@
-import { type NgtGroup } from 'angular-three';
-import * as THREE from 'three';
-import * as i0 from "@angular/core";
-export type NgtsRandomizedLightsState = {
-    /** 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!  */
-    frames: number;
-    /** Light position, [0, 0, 0] */
-    position: [x: number, y: number, z: number];
-    /** Radius of the jiggle, higher values make softer light, 5 */
-    radius: number;
-    /** Amount of lights, 8 */
-    amount: number;
-    /** Light intensity, 1 */
-    intensity: number;
-    /** Ambient occlusion, lower values mean less AO, hight more, you can mix AO and directional light, 0.5 */
-    ambient: number;
-    /** If the lights cast shadows, this is true by default */
-    castShadow: boolean;
-    /** Default shadow bias, 0 */
-    bias: number;
-    /** Default map size, 512 */
-    mapSize: number;
-    /** Default size of the shadow camera, 10 */
-    size: number;
-    /** Default shadow camera near, 0.5 */
-    near: number;
-    /** Default shadow camera far, 500 */
-    far: number;
-};
-declare global {
-    interface HTMLElementTagNameMap {
-        /**
-         * @extends ngt-group
-         */
-        'ngts-randomized-lights': NgtsRandomizedLightsState & NgtGroup;
-    }
-}
-export declare class NgtsRandomizedLights {
-    private inputs;
-    Math: Math;
-    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);
-    private position;
-    private ambient;
-    private radius;
-    private mapSize;
-    private size;
-    private near;
-    private far;
-    private length;
-    private shadowsApi;
-    amount: import("@angular/core").Signal<number>;
-    castShadow: import("@angular/core").Signal<boolean>;
-    intensity: import("@angular/core").Signal<number>;
-    bias: import("@angular/core").Signal<number>;
-    shadowsMapSize: import("@angular/core").Signal<number[]>;
-    cameraArgs: import("@angular/core").Signal<number[]>;
-    api: import("@angular/core").Signal<{
-        update: () => void;
-    }>;
-    constructor();
-    private updateLightMap;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsRandomizedLights, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsRandomizedLights, "ngts-randomized-lights", never, { "lightsRef": { "alias": "lightsRef"; "required": false; }; "_frames": { "alias": "frames"; "required": false; }; "_position": { "alias": "position"; "required": false; }; "_radius": { "alias": "radius"; "required": false; }; "_amount": { "alias": "amount"; "required": false; }; "_intensity": { "alias": "intensity"; "required": false; }; "_ambient": { "alias": "ambient"; "required": false; }; "_castShadow": { "alias": "castShadow"; "required": false; }; "_bias": { "alias": "bias"; "required": false; }; "_mapSize": { "alias": "mapSize"; "required": false; }; "_size": { "alias": "size"; "required": false; }; "_near": { "alias": "near"; "required": false; }; "_far": { "alias": "far"; "required": false; }; }, {}, never, ["*"], true, never>;
-}

package/staging/backdrop/backdrop.d.ts

@@ -1,30 +0,0 @@
-import { type NgtGroup } from 'angular-three';
-import { PlaneGeometry } from 'three';
-import * as i0 from "@angular/core";
-export type NgtsBackdropState = {
-    floor: number;
-    segments: number;
-    receiveShadow: boolean;
-};
-declare global {
-    interface HTMLElementTagNameMap {
-        /**
-         * @extends ngt-group
-         */
-        'ngts-backdrop': NgtsBackdropState & NgtGroup;
-    }
-}
-export declare class NgtsBackdrop {
-    Math: Math;
-    private inputs;
-    set _floor(floor: number);
-    set _segments(segments: number);
-    set _receiveShadow(receiveShadow: boolean);
-    private floor;
-    planeRef: import("angular-three").NgtInjectedRef<PlaneGeometry>;
-    segments: import("@angular/core").Signal<number>;
-    receiveShadow: import("@angular/core").Signal<boolean>;
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsBackdrop, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsBackdrop, "ngts-backdrop", never, { "_floor": { "alias": "floor"; "required": false; }; "_segments": { "alias": "segments"; "required": false; }; "_receiveShadow": { "alias": "receiveShadow"; "required": false; }; }, {}, never, ["*"], true, never>;
-}

package/staging/bb-anchor/bb-anchor.d.ts

@@ -1,27 +0,0 @@
-import { type NgtGroup } from 'angular-three';
-import * as THREE from 'three';
-import * as i0 from "@angular/core";
-export type NgtsBBAnchorState = {
-    anchor: THREE.Vector3 | [number, number, number];
-};
-declare global {
-    interface HTMLElementTagNameMap {
-        /**
-         * @extends ngt-group
-         */
-        'ngts-bb-anchor': NgtsBBAnchorState & NgtGroup;
-    }
-}
-export declare class NgtsBBAnchor {
-    private inputs;
-    set _anchor(anchor: NgtsBBAnchorState['anchor']);
-    groupRef: import("angular-three").NgtInjectedRef<THREE.Group>;
-    private parentRef;
-    private anchor;
-    private xyz;
-    constructor();
-    private reattachParent;
-    private beforeRender;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsBBAnchor, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsBBAnchor, "ngts-bb-anchor", never, { "_anchor": { "alias": "anchor"; "required": true; }; }, {}, never, ["*"], true, never>;
-}