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

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

@@ -1,99 +0,0 @@
-import { type NgtMeshStandardMaterial } from 'angular-three';
-import { MeshReflectorMaterial } from 'angular-three-soba/shaders';
-import * as THREE from 'three';
-import * as i0 from "@angular/core";
-export type NgtsMeshReflectorMaterialState = {
-    resolution: number;
-    mixBlur: number;
-    mixStrength: number;
-    blur: [number, number] | number;
-    mirror: number;
-    minDepthThreshold: number;
-    maxDepthThreshold: number;
-    depthScale: number;
-    depthToBlurRatioBias: number;
-    distortionMap?: THREE.Texture;
-    distortion: number;
-    mixContrast: number;
-    reflectorOffset: number;
-};
-declare global {
-    interface HTMLElementTagNameMap {
-        /**
-         * @extends ngt-mesh-standard-material
-         */
-        'ngts-mesh-reflector-material': NgtsMeshReflectorMaterialState & NgtMeshStandardMaterial;
-    }
-}
-export declare class NgtsMeshReflectorMaterial {
-    private inputs;
-    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);
-    private reflectorProps;
-    defines: import("@angular/core").Signal<{
-        USE_BLUR: string | undefined;
-        USE_DEPTH: string | undefined;
-        USE_DISTORTION: string | undefined;
-    }>;
-    mirror: import("@angular/core").Signal<number>;
-    textureMatrix: import("@angular/core").Signal<THREE.Matrix4>;
-    mixBlur: import("@angular/core").Signal<number>;
-    tDiffuse: import("@angular/core").Signal<THREE.Texture>;
-    tDepth: import("@angular/core").Signal<THREE.DepthTexture>;
-    tDiffuseBlur: import("@angular/core").Signal<THREE.Texture>;
-    hasBlur: import("@angular/core").Signal<boolean>;
-    mixStrength: import("@angular/core").Signal<number>;
-    minDepthThreshold: import("@angular/core").Signal<number>;
-    maxDepthThreshold: import("@angular/core").Signal<number>;
-    depthScale: import("@angular/core").Signal<number>;
-    depthToBlurRatioBias: import("@angular/core").Signal<number>;
-    distortion: import("@angular/core").Signal<number>;
-    distortionMap: import("@angular/core").Signal<THREE.Texture | undefined>;
-    mixContrast: import("@angular/core").Signal<number>;
-    private store;
-    private gl;
-    private reflectorPlane;
-    private normal;
-    private reflectorWorldPosition;
-    private cameraWorldPosition;
-    private rotationMatrix;
-    private lookAtPosition;
-    private clipPlane;
-    private view;
-    private target;
-    private q;
-    private virtualCamera;
-    private _textureMatrix;
-    private __blur;
-    private __resolution;
-    private __mirror;
-    private __mixBlur;
-    private __mixStrength;
-    private __minDepthThreshold;
-    private __maxDepthThreshold;
-    private __depthScale;
-    private __depthToBlurRatioBias;
-    private __distortion;
-    private __distortionMap;
-    private __mixContrast;
-    private normalizedBlur;
-    private __hasBlur;
-    private states;
-    constructor();
-    private onBeforeRender;
-    private beforeRender;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsMeshReflectorMaterial, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsMeshReflectorMaterial, "ngts-mesh-reflector-material", never, { "materialRef": { "alias": "materialRef"; "required": false; }; "_resolution": { "alias": "resolution"; "required": false; }; "_mixBlur": { "alias": "mixBlur"; "required": false; }; "_mixStrength": { "alias": "mixStrength"; "required": false; }; "_blur": { "alias": "blur"; "required": false; }; "_mirror": { "alias": "mirror"; "required": false; }; "_minDepthThreshold": { "alias": "minDepthThreshold"; "required": false; }; "_maxDepthThreshold": { "alias": "maxDepthThreshold"; "required": false; }; "_depthScale": { "alias": "depthScale"; "required": false; }; "_depthToBlurRatioBias": { "alias": "depthToBlurRatioBias"; "required": false; }; "_distortionMap": { "alias": "distortionMap"; "required": false; }; "_distortion": { "alias": "distortion"; "required": false; }; "_mixContrast": { "alias": "mixContrast"; "required": false; }; "_reflectorOffset": { "alias": "reflectorOffset"; "required": false; }; }, {}, never, ["*"], true, never>;
-}

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

@@ -1,62 +0,0 @@
-import { type NgtShaderMaterial } from 'angular-three';
-import type { NgtsMeshTranmissionMaterialState } from '../mesh-transmission-material/mesh-transmission-material';
-import * as i0 from "@angular/core";
-export type NgtsMeshRefractionMaterialState = {
-    /** Environment map */
-    envMap: THREE.CubeTexture | THREE.Texture;
-    /** Number of ray-cast bounces, it can be expensive to have too many, 2 */
-    bounces: number;
-    /** Refraction index, 2.4 */
-    ior: number;
-    /** Fresnel (strip light), 0 */
-    fresnel: number;
-    /** RGB shift intensity, can be expensive, 0 */
-    aberrationStrength: number;
-    /** Color, white */
-    color: THREE.ColorRepresentation;
-    /** If this is on it uses fewer ray casts for the RGB shift sacrificing physical accuracy, true */
-    fastChroma: boolean;
-};
-declare global {
-    interface HTMLElementTagNameMap {
-        /**
-         * @extends ngt-shader-material
-         */
-        'ngts-mesh-refraction-material': NgtsMeshTranmissionMaterialState & NgtShaderMaterial;
-    }
-}
-export declare class NgtsMeshRefractionMaterial {
-    private inputs;
-    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);
-    envMap: import("@angular/core").Signal<import("three").Texture | import("three").CubeTexture>;
-    bounces: import("@angular/core").Signal<number>;
-    ior: import("@angular/core").Signal<number>;
-    fresnel: import("@angular/core").Signal<number>;
-    aberrationStrength: import("@angular/core").Signal<number>;
-    color: import("@angular/core").Signal<import("three").ColorRepresentation>;
-    fastChroma: import("@angular/core").Signal<boolean>;
-    private store;
-    private size;
-    defines: import("@angular/core").Signal<{
-        [key: string]: string;
-    } | null>;
-    resolution: import("@angular/core").Signal<number[]>;
-    constructor();
-    private setupGeometry;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsMeshRefractionMaterial, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsMeshRefractionMaterial, "ngts-mesh-refraction-material", never, { "materialRef": { "alias": "materialRef"; "required": false; }; "_envMap": { "alias": "envMap"; "required": true; }; "_bounces": { "alias": "bounces"; "required": false; }; "_ior": { "alias": "ior"; "required": false; }; "_fresnel": { "alias": "fresnel"; "required": false; }; "_aberrationStrength": { "alias": "aberrationStrength"; "required": false; }; "_color": { "alias": "color"; "required": false; }; "_fastChroma": { "alias": "fastChroma"; "required": false; }; }, {}, never, ["*"], true, never>;
-}

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

@@ -1,107 +0,0 @@
-import { type NgtMeshPhysicalMaterial } from 'angular-three';
-import { MeshTransmissionMaterial } from 'angular-three-soba/shaders';
-import * as THREE from 'three';
-import * as i0 from "@angular/core";
-export type NgtsMeshTranmissionMaterialState = {
-    /** 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 */
-    transmissionSampler: boolean;
-    /** Render the backside of the material (more cost, better results), default: false */
-    backside: boolean;
-    /** Backside thickness (when backside is true), default: 0 */
-    backsideThickness: number;
-    /** Resolution of the local buffer, default: undefined (fullscreen) */
-    resolution: number;
-    /** Resolution of the local buffer for backfaces, default: undefined (fullscreen) */
-    backsideResolution: number;
-    /** Refraction samples, default: 10 */
-    samples: number;
-    /** Buffer scene background (can be a texture, a cubetexture or a color), default: null */
-    background: THREE.Texture | THREE.Color;
-    transmission: number;
-    thickness: number;
-    roughness: number;
-    chromaticAberration: number;
-    anisotropy: number;
-    anisotropicBlur: number;
-    distortion: number;
-    distortionScale: number;
-    temporalDistortion: number;
-    /** The scene rendered into a texture (use it to share a texture between materials), default: null  */
-    buffer: THREE.Texture | null;
-    /** Internals */
-    time: number;
-};
-declare global {
-    interface HTMLElementTagNameMap {
-        /**
-         * @extends ngt-mesh-physical-material
-         */
-        'ngts-mesh-transmission-material': NgtsMeshTranmissionMaterialState & NgtMeshPhysicalMaterial;
-    }
-}
-export declare class NgtsMeshTranmissionMaterial {
-    private inputs;
-    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 _anisotropicBlur(anisotropicBlur: 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);
-    transmissionSampler: import("@angular/core").Signal<boolean>;
-    backside: import("@angular/core").Signal<boolean>;
-    transmission: import("@angular/core").Signal<number>;
-    thickness: import("@angular/core").Signal<number>;
-    backsideThickness: import("@angular/core").Signal<number>;
-    samples: import("@angular/core").Signal<number>;
-    roughness: import("@angular/core").Signal<number>;
-    anisotropy: import("@angular/core").Signal<number>;
-    anisotropicBlur: import("@angular/core").Signal<number>;
-    chromaticAberration: import("@angular/core").Signal<number>;
-    distortion: import("@angular/core").Signal<number>;
-    distortionScale: import("@angular/core").Signal<number>;
-    temporalDistortion: import("@angular/core").Signal<number>;
-    buffer: import("@angular/core").Signal<THREE.Texture | null>;
-    time: import("@angular/core").Signal<number>;
-    private discardMaterial;
-    private backsideResolution;
-    private resolution;
-    private fboBackSettings;
-    private fboMainSettings;
-    fboBackRef: import("angular-three").NgtInjectedRef<THREE.WebGLRenderTarget<THREE.Texture> | null>;
-    fboMainRef: import("angular-three").NgtInjectedRef<THREE.WebGLRenderTarget<THREE.Texture> | null>;
-    side: 0;
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsMeshTranmissionMaterial, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsMeshTranmissionMaterial, "ngts-mesh-transmission-material", never, { "materialRef": { "alias": "materialRef"; "required": false; }; "_transmissionSampler": { "alias": "transmissionSampler"; "required": false; }; "_backside": { "alias": "backside"; "required": false; }; "_backsideThickness": { "alias": "backsideThickness"; "required": false; }; "_resolution": { "alias": "resolution"; "required": false; }; "_backsideResolution": { "alias": "backsideResolution"; "required": false; }; "_samples": { "alias": "samples"; "required": false; }; "_background": { "alias": "background"; "required": false; }; "_transmission": { "alias": "transmission"; "required": false; }; "_thickness": { "alias": "thickness"; "required": false; }; "_roughness": { "alias": "roughness"; "required": false; }; "_chromaticAberration": { "alias": "chromaticAberration"; "required": false; }; "_anisotropy": { "alias": "anisotropy"; "required": false; }; "_anisotropicBlur": { "alias": "anisotropicBlur"; "required": false; }; "_distortion": { "alias": "distortion"; "required": false; }; "_distortionScale": { "alias": "distortionScale"; "required": false; }; "_temporalDistortion": { "alias": "temporalDistortion"; "required": false; }; "_buffer": { "alias": "buffer"; "required": false; }; "_time": { "alias": "time"; "required": false; }; }, {}, never, never, true, never>;
-}

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

@@ -1,29 +0,0 @@
-import { type NgtMeshStandardMaterial } from 'angular-three';
-import { MeshWobbleMaterial } from 'angular-three-soba/shaders';
-import * as i0 from "@angular/core";
-export type NgtsMeshWobbleMaterialState = {
-    time: number;
-    factor: number;
-    speed: number;
-};
-declare global {
-    interface HTMLElementTagNameMap {
-        /**
-         * @extends ngt-mesh-standard-material
-         */
-        'ngts-mesh-wobble-material': NgtsMeshWobbleMaterialState & NgtMeshStandardMaterial;
-    }
-}
-export declare class NgtsMeshWobbleMaterial {
-    private inputs;
-    materialRef: import("angular-three").NgtInjectedRef<MeshWobbleMaterial>;
-    set _time(time: number);
-    set _factor(factor: number);
-    set _speed(speed: number);
-    material: MeshWobbleMaterial;
-    time: import("@angular/core").Signal<number>;
-    factor: import("@angular/core").Signal<number>;
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsMeshWobbleMaterial, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsMeshWobbleMaterial, "ngts-mesh-wobble-material", never, { "materialRef": { "alias": "materialRef"; "required": false; }; "_time": { "alias": "time"; "required": false; }; "_factor": { "alias": "factor"; "required": false; }; "_speed": { "alias": "speed"; "required": false; }; }, {}, never, never, true, never>;
-}

package/materials/point-material/point-material.d.ts

@@ -1,24 +0,0 @@
-import { type NgtPointsMaterial } from 'angular-three';
-import * as THREE from 'three';
-import * as i0 from "@angular/core";
-export declare class PointMaterial extends THREE.PointsMaterial {
-    constructor(parameters: THREE.PointsMaterialParameters);
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        /**
-         * @extends ngt-points-material
-         */
-        'ngt-point-material': NgtPointsMaterial;
-        /**
-         * @extends ngt-points-material
-         */
-        'ngts-point-material': NgtPointsMaterial;
-    }
-}
-export declare class NgtsPointMaterial {
-    pointMaterialRef: import("angular-three").NgtInjectedRef<PointMaterial>;
-    material: PointMaterial;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsPointMaterial, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsPointMaterial, "ngts-point-material", never, { "pointMaterialRef": { "alias": "pointMaterialRef"; "required": false; }; }, {}, never, never, true, never>;
-}

package/misc/animations/animations.d.ts

@@ -1,15 +0,0 @@
-import { Injector } from '@angular/core';
-import { type NgtRef } from 'angular-three';
-import * as THREE from 'three';
-export declare function injectNgtsAnimations(animationsFactory: () => THREE.AnimationClip[], { ref, injector, playFirstClip, }?: {
-    ref?: NgtRef<THREE.Object3D>;
-    playFirstClip?: boolean;
-    injector?: Injector;
-}): {
-    ref: import("angular-three").NgtInjectedRef<THREE.Object3D<THREE.Event>>;
-    actions: Record<string, THREE.AnimationAction>;
-    mixer: THREE.AnimationMixer;
-    names: string[];
-    clips: THREE.AnimationClip[];
-    ready: import("@angular/core").Signal<boolean>;
-};

package/misc/caustics/caustics.d.ts

@@ -1,87 +0,0 @@
-import { ElementRef } from '@angular/core';
-import { type NgtGroup } from 'angular-three';
-import * as THREE from 'three';
-import * as i0 from "@angular/core";
-export type NgtsCausticsState = {
-    /** How many frames it will render, set it to Infinity for runtime, default: 1 */
-    frames: number;
-    /** Enables visual cues to help you stage your scene, default: false */
-    debug: boolean;
-    /** Will display caustics only and skip the models, default: false */
-    causticsOnly: boolean;
-    /** Will include back faces and enable the backsideIOR prop, default: false */
-    backside: boolean;
-    /** The IOR refraction index, default: 1.1 */
-    ior: number;
-    /** The IOR refraction index for back faces (only available when backside is enabled), default: 1.1 */
-    backsideIOR: number;
-    /** The texel size, default: 0.3125 */
-    worldRadius: number;
-    /** Intensity of the prjected caustics, default: 0.05 */
-    intensity: number;
-    /** Caustics color, default: white */
-    color: THREE.ColorRepresentation;
-    /** Buffer resolution, default: 2048 */
-    resolution: number;
-    /** Camera position, it will point towards the contents bounds center, default: [5, 5, 5] */
-    lightSource: [x: number, y: number, z: number] | ElementRef<THREE.Object3D>;
-};
-declare global {
-    interface HTMLElementTagNameMap {
-        /**
-         * @extends ngt-group
-         */
-        'ngts-caustics': NgtsCausticsState & NgtGroup;
-    }
-}
-export declare class NgtsCaustics {
-    CustomBlending: 5;
-    OneFactor: 201;
-    SrcAlphaFactor: 204;
-    Math: Math;
-    private inputs;
-    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>);
-    private resolution;
-    private normalTargetSettings;
-    private causticsTargetSettings;
-    private normalTargetFbo;
-    private normalTargetBFbo;
-    causticsTargetFbo: import("angular-three").NgtInjectedRef<THREE.WebGLRenderTarget<THREE.Texture> | null>;
-    causticsTargetBFbo: import("angular-three").NgtInjectedRef<THREE.WebGLRenderTarget<THREE.Texture> | null>;
-    private store;
-    color: import("@angular/core").Signal<THREE.ColorRepresentation>;
-    debug: import("@angular/core").Signal<boolean>;
-    planeRef: import("angular-three").NgtInjectedRef<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
-    sceneRef: import("angular-three").NgtInjectedRef<THREE.Scene>;
-    cameraRef: import("angular-three").NgtInjectedRef<THREE.OrthographicCamera>;
-    private sceneChildren;
-    private planeChildren;
-    private causticsChildren;
-    constructor();
-    private updateWorldMatrix;
-    private setBeforeRender;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsCaustics, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsCaustics, "ngts-caustics", never, { "causticsRef": { "alias": "causticsRef"; "required": false; }; "_frames": { "alias": "frames"; "required": false; }; "_debug": { "alias": "debug"; "required": false; }; "_causticsOnly": { "alias": "causticsOnly"; "required": false; }; "_backside": { "alias": "backside"; "required": false; }; "_ior": { "alias": "ior"; "required": false; }; "_backsideIOR": { "alias": "backsideIOR"; "required": false; }; "_worldRadius": { "alias": "worldRadius"; "required": false; }; "_intensity": { "alias": "intensity"; "required": false; }; "_color": { "alias": "color"; "required": false; }; "_resolution": { "alias": "resolution"; "required": false; }; "_lightSource": { "alias": "lightSource"; "required": false; }; }, {}, never, ["*"], true, never>;
-}

package/misc/decal/decal.d.ts

@@ -1,49 +0,0 @@
-import { type NgtEuler, type NgtMesh, type NgtRef, type NgtVector3 } from 'angular-three';
-import * as THREE from 'three';
-import * as i0 from "@angular/core";
-export type NgtsDecalState = {
-    debug: boolean;
-    mesh?: NgtRef<THREE.Mesh>;
-    position: NgtVector3;
-    rotation: NgtEuler | number;
-    scale: NgtVector3;
-    map?: THREE.Texture;
-    polygonOffsetFactor: number;
-    depthTest: boolean;
-};
-declare global {
-    interface HTMLElementTagNameMap {
-        /**
-         * @extends ngt-mesh
-         */
-        'ngts-decal': NgtsDecalState & NgtMesh;
-    }
-}
-export declare class NgtsDecal {
-    private inputs;
-    decalRef: import("angular-three").NgtInjectedRef<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
-    set _debug(debug: boolean);
-    set _mesh(mesh: NgtRef<THREE.Mesh>);
-    set _position(position: NgtVector3);
-    set _rotation(rotation: NgtEuler | number);
-    set _scale(scale: NgtVector3);
-    set _map(map: THREE.Texture);
-    set _polygonOffsetFactor(polygonOffsetFactor: number);
-    set _depthTest(depthTest: boolean);
-    private mesh;
-    private __position;
-    private __rotation;
-    private __scale;
-    private position;
-    private rotation;
-    private scale;
-    helperRef: import("angular-three").NgtInjectedRef<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
-    debug: import("@angular/core").Signal<boolean>;
-    depthTest: import("@angular/core").Signal<boolean>;
-    polygonOffsetFactor: import("@angular/core").Signal<number>;
-    map: import("@angular/core").Signal<THREE.Texture | undefined>;
-    constructor();
-    private processDecal;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsDecal, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsDecal, "ngts-decal", never, { "decalRef": { "alias": "decalRef"; "required": false; }; "_debug": { "alias": "debug"; "required": false; }; "_mesh": { "alias": "mesh"; "required": false; }; "_position": { "alias": "position"; "required": false; }; "_rotation": { "alias": "rotation"; "required": false; }; "_scale": { "alias": "scale"; "required": false; }; "_map": { "alias": "map"; "required": false; }; "_polygonOffsetFactor": { "alias": "polygonOffsetFactor"; "required": false; }; "_depthTest": { "alias": "depthTest"; "required": false; }; }, {}, never, ["*"], true, never>;
-}

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

@@ -1,9 +0,0 @@
-import { type Injector } from '@angular/core';
-import * as THREE from 'three';
-export interface NgtsDepthBufferParams {
-    size: number;
-    frames: number;
-}
-export declare function injectNgtsDepthBuffer(paramsFactory?: () => Partial<NgtsDepthBufferParams>, { injector }?: {
-    injector?: Injector;
-}): import("angular-three").NgtInjectedRef<THREE.DepthTexture | null>;

package/misc/example/example.d.ts

@@ -1,81 +0,0 @@
-import { Group } from 'three';
-import * as i0 from "@angular/core";
-/**
- * define states of a component. usually acts for inputs signalStore
- */
-export type NgtsExampleState = {
-    font: string;
-    color: THREE.ColorRepresentation;
-    debug: boolean;
-    bevelSize: number;
-};
-/**
- * We can setup public API for this soba component with createInjectionToken + forwardRef
- * the `example.api` is **usually** a computed property in the component class
- *
- * @see Bounds for example
- */
-export declare const injectNgtsExampleApi: {
-    (): import("@angular/core").Signal<{
-        bevelSize: number;
-        increment: () => void;
-        decrement: () => void;
-    }>;
-    (injectOptions: import("@angular/core").InjectOptions & {
-        optional?: false | undefined;
-    }): import("@angular/core").Signal<{
-        bevelSize: number;
-        increment: () => void;
-        decrement: () => void;
-    }>;
-    (injectOptions: import("@angular/core").InjectOptions): import("@angular/core").Signal<{
-        bevelSize: number;
-        increment: () => void;
-        decrement: () => void;
-    }> | null;
-}, provideNgtsExampleApi: (value?: import("@angular/core").Signal<{
-    bevelSize: number;
-    increment: () => void;
-    decrement: () => void;
-}> | undefined) => import("@angular/core").Provider;
-export declare class NgtsExample {
-    /**
-     * use signalStore to store inputs with default inputs
-     */
-    private inputs;
-    /**
-     * a soba component usually has a Input for the component ref and this Input always has a default value with injectNgtRef
-     */
-    exampleRef: import("angular-three").NgtInjectedRef<Group>;
-    /**
-     * setup Input for the Inputs state. Use alias to have an easier time to setup computed
-     *
-     * @example: this way "private font" and "set _font" won't conflict
-     * private font = this.inputs.select('font');
-     */
-    set _font(font: string);
-    set _color(color: THREE.ColorRepresentation);
-    set _debug(debug: boolean);
-    set _bevelSize(bevelSize: number);
-    /**
-     * exposes signals from inputs
-     */
-    bevelSize: import("@angular/core").Signal<number>;
-    font: import("@angular/core").Signal<string>;
-    debug: import("@angular/core").Signal<boolean>;
-    color: import("@angular/core").Signal<import("three").ColorRepresentation>;
-    /**
-     * can have internal state
-     */
-    count: import("@angular/core").WritableSignal<number>;
-    /**
-     * Expose the public API for this soba component
-     */
-    api: import("@angular/core").Signal<{
-        bevelSize: number;
-        increment: () => void;
-        decrement: () => void;
-    }>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsExample, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsExample, "ngts-example", never, { "exampleRef": { "alias": "exampleRef"; "required": false; }; "_font": { "alias": "font"; "required": true; }; "_color": { "alias": "color"; "required": false; }; "_debug": { "alias": "debug"; "required": false; }; "_bevelSize": { "alias": "bevelSize"; "required": false; }; }, {}, never, ["*"], true, never>;
-}

package/misc/fbo/fbo.d.ts

@@ -1,17 +0,0 @@
-import { type Injector } from '@angular/core';
-import * as THREE from 'three';
-interface FBOSettings extends THREE.WebGLRenderTargetOptions {
-    /** Defines the count of MSAA samples. Can only be used with WebGL 2. Default: 0 */
-    samples?: number;
-    /** If set, the scene depth will be rendered into buffer.depthTexture. Default: false */
-    depth?: boolean;
-}
-export interface NgtsFBOParams {
-    width?: number | FBOSettings;
-    height?: number;
-    settings?: FBOSettings;
-}
-export declare function injectNgtsFBO(fboParams: () => NgtsFBOParams, { injector }?: {
-    injector?: Injector;
-}): import("angular-three").NgtInjectedRef<THREE.WebGLRenderTarget<THREE.Texture> | null>;
-export {};