angular-three-soba 2.0.0-beta.4 → 2.0.0-beta.41

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

@@ -3,16 +3,22 @@ import * as THREE from 'three';
 import { NgtsSpotLightInput } from './spot-light-input';
 import * as i0 from "@angular/core";
 export declare class NgtsVolumetricMesh {
-    #private;
-    protected readonly spotLightInput: NgtsSpotLightInput;
-    readonly mesh: import("angular-three").NgtInjectedRef<THREE.Mesh<THREE.BufferGeometry, THREE.Material | THREE.Material[]>>;
-    readonly material: SpotLightMaterial;
-    readonly nullRaycast: () => null;
-    readonly geometry: import("@angular/core").Signal<THREE.CylinderGeometry>;
-    readonly near: import("@angular/core").Signal<number>;
-    readonly far: import("@angular/core").Signal<number>;
-    readonly resolution: import("@angular/core").Signal<number[]>;
+    spotLightInput: NgtsSpotLightInput;
+    mesh: import("angular-three").NgtInjectedRef<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+    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

@@ -1,13 +1,12 @@
-import { EventEmitter, OnChanges } from '@angular/core';
-import { NgtSignalStore } from 'angular-three';
-import { NgtsAccumulativeShadows } from '../accumulative-shadows/accumulative-shadows';
-import { NgtsRandomizedLights } from '../accumulative-shadows/randomized-lights';
-import { NgtsCenter } from '../center/center';
-import { NgtsContactShadows } from '../contact-shadows/contact-shadows';
-import { NgtsEnvironmentPresetsType } from '../environment/assets';
-import { NgtsEnvironmentInput } from '../environment/environment-input';
+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 type { NgtsEnvironmentPresetsType } from '../environment/assets';
+import { type NgtsEnvironmentInputState } from '../environment/environment-input';
 import * as i0 from "@angular/core";
-type NgtsStageShadows = Partial<NgtsAccumulativeShadows> & Partial<NgtsRandomizedLights> & Partial<NgtsContactShadows> & {
+type NgtsStageShadowsState = Partial<NgtsAccumulativeShadowsState> & Partial<NgtsRandomizedLightsState> & Partial<NgtsContactShadowsState> & {
     type: 'contact' | 'accumulative';
     /** Shadow plane offset, default: 0 */
     offset?: number;
@@ -18,89 +17,114 @@ type NgtsStageShadows = Partial<NgtsAccumulativeShadows> & Partial<NgtsRandomize
     /** Shadow map size, default: 1024 */
     size?: number;
 };
-interface NgtsStageProps {
+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' | NgtsStageShadows;
+    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<NgtsEnvironmentInput>;
+    environment: NgtsEnvironmentPresetsType | Partial<NgtsEnvironmentInputState>;
     /** The lighting intensity, default: 0.5 */
     intensity: number;
     /** To adjust centering, default: undefined */
-    center?: Partial<NgtsCenter>;
+    center?: Partial<NgtsCenterState>;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        'ngts-stage': NgtsStageState;
+    }
 }
 export declare class NgtsStageRefit implements OnChanges {
-    #private;
+    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").Object3DEventMap> | 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;
+    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 extends NgtSignalStore<NgtsStageProps> {
-    #private;
-    readonly Number: NumberConstructor;
-    set preset(preset: NgtsStageProps['preset']);
-    set shadows(shadows: NgtsStageProps['shadows']);
-    set adjustCamera(adjustCamera: NgtsStageProps['adjustCamera']);
-    set environment(environment: NgtsStageProps['environment']);
-    set intensity(intensity: NgtsStageProps['intensity']);
-    set center(center: NgtsStageProps['center']);
-    centered: EventEmitter<{
-        parent: import("three").Object3D<import("three").Event>;
-        /** To adjust centering, default: undefined */
-        container: import("three").Object3D<import("three").Event>;
-        width: number;
-        height: number;
-        depth: number;
-        boundingBox: import("three").Box3;
-        boundingSphere: import("three").Sphere;
-        center: import("three").Vector3;
-        verticalAlignment: number;
-        horizontalAlignment: number;
-        depthAlignment: number;
-    }>;
-    readonly boundingState: import("@angular/core").WritableSignal<{
+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;
     }>;
-    readonly stageShadows: import("@angular/core").Signal<boolean | "contact" | "accumulative" | NgtsStageShadows>;
-    readonly stageIntensity: import("@angular/core").Signal<number>;
-    readonly stageAdjustCamera: import("@angular/core").Signal<number | boolean>;
-    readonly stageCenter: import("@angular/core").Signal<Partial<NgtsCenter> | undefined>;
-    readonly config: import("@angular/core").Signal<{
+    config: import("@angular/core").Signal<{
         main: number[];
         fill: number[];
     }>;
-    readonly shadowsInfo: import("@angular/core").Signal<any>;
-    readonly spotLightPosition: import("@angular/core").Signal<[number, number, number]>;
-    readonly pointLightPosition: import("@angular/core").Signal<number[]>;
-    readonly environmentInfo: import("@angular/core").Signal<Partial<NgtsEnvironmentInput> | null>;
-    constructor();
-    onCentered(props: {
-        /** The next parent above <Center> */
-        parent: THREE.Object3D;
-        /** The outmost container group of the <Center> component */
-        container: THREE.Object3D;
-        width: number;
-        height: number;
-        depth: number;
-        boundingBox: THREE.Box3;
-        boundingSphere: THREE.Sphere;
-        center: THREE.Vector3;
-        verticalAlignment: number;
-        horizontalAlignment: number;
-        depthAlignment: number;
-    }): void;
+    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>;
+    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

@@ -1,7 +1,8 @@
-import { NgtSignalStore } from 'angular-three';
+import { type NgtBeforeRenderEvent } from 'angular-three';
+import { StarFieldMaterial } from 'angular-three-soba/shaders';
 import * as THREE from 'three';
 import * as i0 from "@angular/core";
-export interface NgtsStarsState {
+export type NgtsStarsState = {
     radius: number;
     depth: number;
     count: number;
@@ -9,26 +10,36 @@ export interface NgtsStarsState {
     saturation: number;
     fade: boolean;
     speed: number;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        'ngts-stars': NgtsStarsState;
+    }
 }
-export declare class NgtsStars extends NgtSignalStore<NgtsStarsState> {
-    #private;
-    readonly AdditiveBlending: 2;
-    readonly material: THREE.ShaderMaterial;
-    starsRef: import("angular-three").NgtInjectedRef<THREE.Points<THREE.BufferGeometry, THREE.Material | THREE.Material[]>>;
-    set radius(radius: number);
-    set depth(depth: number);
-    set count(count: number);
-    set factor(factor: number);
-    set saturation(saturation: number);
+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);
-    readonly fade: import("@angular/core").Signal<boolean>;
-    readonly bufferAttributes: import("@angular/core").Signal<{
+    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;
     }>;
-    constructor();
+    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>;
+    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 type { 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, type NgtsWireframeState } from './wireframe-input';
+import * as i0 from "@angular/core";
+export declare class NgtsWireframeWithoutCustomGeometry {
+    objectRef: import("angular-three").NgtInjectedRef<THREE.Object3D<THREE.Object3DEventMap>>;
+    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/constants.d.ts

@@ -0,0 +1 @@
+export declare const revision: number;

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,2 @@
+export { revision } from './constants';
+export * from './content/content';