angular-three-soba 1.14.1 → 2.0.0-beta.11

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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,63 @@
+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

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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,39 @@
+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

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

package/staging/stage/stage.d.ts

@@ -0,0 +1,130 @@
+import { EventEmitter, type OnChanges } from '@angular/core';
+import { type NgtsAccumulativeShadowsState } from '../accumulative-shadows/accumulative-shadows';
+import { type NgtsRandomizedLightsState } from '../accumulative-shadows/randomized-lights';
+import { type NgtsCenterState, type NgtsCenteredEvent } from '../center/center';
+import { type NgtsContactShadowsState } from '../contact-shadows/contact-shadows';
+import { NgtsEnvironmentPresetsType } from '../environment/assets';
+import { type NgtsEnvironmentInputState } from '../environment/environment-input';
+import * as i0 from "@angular/core";
+type NgtsStageShadowsState = Partial<NgtsAccumulativeShadowsState> & Partial<NgtsRandomizedLightsState> & Partial<NgtsContactShadowsState> & {
+    type: 'contact' | 'accumulative';
+    /** Shadow plane offset, default: 0 */
+    offset?: number;
+    /** Shadow bias, default: -0.0001 */
+    bias?: number;
+    /** Shadow normal bias, default: 0 */
+    normalBias?: number;
+    /** Shadow map size, default: 1024 */
+    size?: number;
+};
+export type NgtsStageState = {
+    /** Lighting setup, default: "rembrandt" */
+    preset: 'rembrandt' | 'portrait' | 'upfront' | 'soft' | {
+        main: [x: number, y: number, z: number];
+        fill: [x: number, y: number, z: number];
+    };
+    /** Controls the ground shadows, default: "contact" */
+    shadows: boolean | 'contact' | 'accumulative' | NgtsStageShadowsState;
+    /** Optionally wraps and thereby centers the models using <Bounds>, can also be a margin, default: true */
+    adjustCamera: boolean | number;
+    /** The default environment, default: "city" */
+    environment: NgtsEnvironmentPresetsType | Partial<NgtsEnvironmentInputState>;
+    /** The lighting intensity, default: 0.5 */
+    intensity: number;
+    /** To adjust centering, default: undefined */
+    center?: Partial<NgtsCenterState>;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        'ngts-stage': NgtsStageState;
+    }
+}
+export declare class NgtsStageRefit implements OnChanges {
+    boundsApi: import("@angular/core").Signal<{
+        getSize: () => {
+            box: import("three").Box3;
+            size: import("three").Vector3;
+            center: import("three").Vector3;
+            distance: number;
+        };
+        refresh(object?: import("three").Object3D<import("three").Event> | import("three").Box3 | undefined): any;
+        clip(): any;
+        to({ position, target }: {
+            position: [number, number, number];
+            target?: [number, number, number] | undefined;
+        }): any;
+        fit(): any;
+    }>;
+    radius: number;
+    adjustCamera: boolean | number;
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsStageRefit, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsStageRefit, "ngts-stage-refit", never, { "radius": { "alias": "radius"; "required": false; }; "adjustCamera": { "alias": "adjustCamera"; "required": false; }; }, {}, never, never, true, never>;
+}
+export declare class NgtsStage {
+    Number: NumberConstructor;
+    private inputs;
+    set _preset(preset: NgtsStageState['preset']);
+    set _shadows(shadows: NgtsStageState['shadows']);
+    set _adjustCamera(adjustCamera: NgtsStageState['adjustCamera']);
+    set _environment(environment: NgtsStageState['environment']);
+    set _intensity(intensity: NgtsStageState['intensity']);
+    set _center(center: NgtsStageState['center']);
+    centered: EventEmitter<NgtsCenteredEvent>;
+    private preset;
+    private environment;
+    boundingState: import("angular-three").NgtSignalStore<{
+        radius: number;
+        width: number;
+        height: number;
+        depth: number;
+    }>;
+    config: import("@angular/core").Signal<{
+        main: number[];
+        fill: number[];
+    }>;
+    shadows: import("@angular/core").Signal<boolean | "contact" | "accumulative" | NgtsStageShadowsState>;
+    intensity: import("@angular/core").Signal<number>;
+    adjustCamera: import("@angular/core").Signal<number | boolean>;
+    center: import("@angular/core").Signal<Partial<NgtsCenterState> | undefined>;
+    shadowsState: import("@angular/core").Signal<{
+        frames?: number | undefined;
+        blend?: number | undefined;
+        limit?: number | undefined;
+        scale?: number | (number & [x: number, y: number]) | undefined;
+        temporal?: boolean | undefined;
+        opacity?: number | undefined;
+        alphaTest?: number | undefined;
+        color?: (string & import("three").ColorRepresentation) | undefined;
+        colorBlend?: number | undefined;
+        resolution?: number | undefined;
+        toneMapped?: boolean | undefined;
+        position?: [x: number, y: number, z: number] | undefined;
+        radius?: number | undefined;
+        amount?: number | undefined;
+        intensity?: number | undefined;
+        ambient?: number | undefined;
+        castShadow?: boolean | undefined;
+        mapSize?: number | undefined;
+        near?: number | undefined;
+        far?: number | undefined;
+        width?: number | undefined;
+        height?: number | undefined;
+        blur?: number | undefined;
+        smooth?: boolean | undefined;
+        depthWrite?: boolean | undefined;
+        renderOrder?: number | undefined;
+        type: "contact" | "accumulative";
+        contactShadow: boolean;
+        accumulativeShadow: boolean;
+        shadowBias: number;
+        normalBias: number;
+        shadowSize: number;
+        shadowOffset: number;
+    }>;
+    environmentState: import("@angular/core").Signal<Partial<NgtsEnvironmentInputState> | null>;
+    onCentered($event: NgtsCenteredEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsStage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsStage, "ngts-stage", never, { "_preset": { "alias": "preset"; "required": false; }; "_shadows": { "alias": "shadows"; "required": false; }; "_adjustCamera": { "alias": "adjustCamera"; "required": false; }; "_environment": { "alias": "environment"; "required": false; }; "_intensity": { "alias": "intensity"; "required": false; }; "_center": { "alias": "center"; "required": false; }; }, { "centered": "centered"; }, never, ["*"], true, never>;
+}
+export {};

package/staging/stars/stars.d.ts

@@ -0,0 +1,45 @@
+import { NgtBeforeRenderEvent } from 'angular-three';
+import { StarFieldMaterial } from 'angular-three-soba/shaders';
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+export type NgtsStarsState = {
+    radius: number;
+    depth: number;
+    count: number;
+    factor: number;
+    saturation: number;
+    fade: boolean;
+    speed: number;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        'ngts-stars': NgtsStarsState;
+    }
+}
+export declare class NgtsStars {
+    private inputs;
+    AdditiveBlending: 2;
+    material: THREE.ShaderMaterial;
+    starsRef: import("angular-three").NgtInjectedRef<THREE.Points<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+    set _radius(radius: number);
+    set _depth(depth: number);
+    set _count(count: number);
+    set _factor(factor: number);
+    set _saturation(saturation: number);
+    set starsFade(fade: boolean);
+    set _speed(speed: number);
+    private count;
+    private depth;
+    private factor;
+    private radius;
+    private saturation;
+    fade: import("@angular/core").Signal<boolean>;
+    attributes: import("@angular/core").Signal<{
+        positions: Float32Array;
+        colors: Float32Array;
+        sizes: Float32Array;
+    }>;
+    onBeforeRender({ object, state }: NgtBeforeRenderEvent<InstanceType<typeof StarFieldMaterial>>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsStars, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsStars, "ngts-stars", never, { "starsRef": { "alias": "starsRef"; "required": false; }; "_radius": { "alias": "radius"; "required": false; }; "_depth": { "alias": "depth"; "required": false; }; "_count": { "alias": "count"; "required": false; }; "_factor": { "alias": "factor"; "required": false; }; "_saturation": { "alias": "saturation"; "required": false; }; "starsFade": { "alias": "fade"; "required": false; }; "_speed": { "alias": "speed"; "required": false; }; }, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,65 @@
+import { type NgtRef } from 'angular-three';
+import { WireframeMaterialState } from 'angular-three-soba/shaders';
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+export type NgtsWireframeState = {
+    geometry?: NgtRef<THREE.BufferGeometry>;
+    simplify: boolean;
+} & Required<WireframeMaterialState>;
+export declare abstract class NgtsWireframeInput {
+    inputs: import("angular-three").NgtSignalStore<NgtsWireframeState>;
+    set _geometry(geometry: NgtRef<THREE.BufferGeometry>);
+    set _simplify(simplify: boolean);
+    set _fillOpacity(fillOpacity: number);
+    set _fillMix(fillMix: number);
+    set _strokeOpacity(strokeOpacity: number);
+    set _thickness(thickness: number);
+    set _colorBackfaces(colorBackfaces: boolean);
+    set _dashInvert(dashInvert: boolean);
+    set _dash(dash: boolean);
+    set _dashRepeats(dashRepeats: number);
+    set _dashLength(dashLength: number);
+    set _squeeze(squeeze: boolean);
+    set _squeezeMin(squeezeMin: number);
+    set _squeezeMax(squeezeMax: number);
+    set _stroke(stroke: THREE.ColorRepresentation);
+    set _backfaceStroke(backfaceStroke: THREE.ColorRepresentation);
+    set _fill(fill: THREE.ColorRepresentation);
+    simplify: import("@angular/core").Signal<boolean>;
+    geometry: import("@angular/core").Signal<NgtRef<THREE.BufferGeometry<THREE.NormalBufferAttributes>> | undefined>;
+    customGeometry: import("@angular/core").Signal<THREE.BufferGeometry<THREE.NormalBufferAttributes> | undefined>;
+    strokeOpacity: import("@angular/core").Signal<number>;
+    fillOpacity: import("@angular/core").Signal<number>;
+    fillMix: import("@angular/core").Signal<number>;
+    thickness: import("@angular/core").Signal<number>;
+    colorBackfaces: import("@angular/core").Signal<boolean>;
+    dashInvert: import("@angular/core").Signal<boolean>;
+    dash: import("@angular/core").Signal<boolean>;
+    dashRepeats: import("@angular/core").Signal<number>;
+    dashLength: import("@angular/core").Signal<number>;
+    squeeze: import("@angular/core").Signal<boolean>;
+    squeezeMin: import("@angular/core").Signal<number>;
+    squeezeMax: import("@angular/core").Signal<number>;
+    stroke: import("@angular/core").Signal<THREE.ColorRepresentation>;
+    backfaceStroke: import("@angular/core").Signal<THREE.ColorRepresentation>;
+    fill: import("@angular/core").Signal<THREE.ColorRepresentation>;
+    materialState: import("@angular/core").Signal<{
+        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.ColorRepresentation;
+        backfaceStroke: THREE.ColorRepresentation;
+        fill: THREE.ColorRepresentation;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsWireframeInput, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsWireframeInput, never, never, { "_geometry": { "alias": "geometry"; "required": false; }; "_simplify": { "alias": "simplify"; "required": false; }; "_fillOpacity": { "alias": "fillOpacity"; "required": false; }; "_fillMix": { "alias": "fillMix"; "required": false; }; "_strokeOpacity": { "alias": "strokeOpacity"; "required": false; }; "_thickness": { "alias": "thickness"; "required": false; }; "_colorBackfaces": { "alias": "colorBackfaces"; "required": false; }; "_dashInvert": { "alias": "dashInvert"; "required": false; }; "_dash": { "alias": "dash"; "required": false; }; "_dashRepeats": { "alias": "dashRepeats"; "required": false; }; "_dashLength": { "alias": "dashLength"; "required": false; }; "_squeeze": { "alias": "squeeze"; "required": false; }; "_squeezeMin": { "alias": "squeezeMin"; "required": false; }; "_squeezeMax": { "alias": "squeezeMax"; "required": false; }; "_stroke": { "alias": "stroke"; "required": false; }; "_backfaceStroke": { "alias": "backfaceStroke"; "required": false; }; "_fill": { "alias": "fill"; "required": false; }; }, {}, never, never, false, never>;
+}

package/staging/wireframe/wireframe.d.ts

@@ -0,0 +1,28 @@
+import * as THREE from 'three';
+import { NgtsWireframeInput, NgtsWireframeState } from './wireframe-input';
+import * as i0 from "@angular/core";
+export declare class NgtsWireframeWithoutCustomGeometry {
+    objectRef: import("angular-three").NgtInjectedRef<THREE.Object3D<THREE.Event>>;
+    private wireframeInput;
+    private uniforms;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsWireframeWithoutCustomGeometry, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsWireframeWithoutCustomGeometry, "ngts-wireframe-without-custom-geometry", never, {}, {}, never, never, true, never>;
+}
+export declare class NgtsWireframeWithCustomGeometry {
+    DoubleSide: 2;
+    wireframeInput: NgtsWireframeInput;
+    drawnGeometry: import("@angular/core").WritableSignal<THREE.BufferGeometry<THREE.NormalBufferAttributes>>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsWireframeWithCustomGeometry, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsWireframeWithCustomGeometry, "ngts-wireframe-with-custom-geometry", never, {}, {}, never, never, true, never>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'ngts-wireframe': NgtsWireframeState;
+    }
+}
+export declare class NgtsWireframe extends NgtsWireframeInput {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsWireframe, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsWireframe, "ngts-wireframe", never, {}, {}, never, never, true, never>;
+}

package/utils/README.md

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

package/utils/content/content.d.ts

@@ -0,0 +1,8 @@
+import { Injector, TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class NgtsSobaContent {
+    injector: Injector;
+    template: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSobaContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsSobaContent, "ng-template[ngtsSobaContent]", ["sobaContent"], {}, {}, never, never, true, never>;
+}

package/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './content/content';