angular-three-soba 1.14.0 → 2.0.0-beta.10

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';