angular-three-soba 2.0.0-beta.2 → 2.0.0-beta.21

package/misc/html/html.d.ts

@@ -0,0 +1,214 @@
+import { EventEmitter, TemplateRef } from '@angular/core';
+import { type NgtGroup, type NgtRef, type NgtVector3 } from 'angular-three';
+import * as THREE from 'three';
+import { defaultCalculatePosition } from './html-wrapper';
+import * as i0 from "@angular/core";
+type PointerEventsProperties = 'auto' | 'none' | 'visiblePainted' | 'visibleFill' | 'visibleStroke' | 'visible' | 'painted' | 'fill' | 'stroke' | 'all' | 'inherit';
+export type NgtsHtmlState = {
+    as: keyof HTMLElementTagNameMap;
+    prepend: boolean;
+    transform: boolean;
+    zIndexRange: Array<number>;
+    calculatePosition: typeof defaultCalculatePosition;
+    fullscreen: boolean;
+    center: boolean;
+    sprite: boolean;
+    pointerEvents: PointerEventsProperties;
+    eps: number;
+    scale: NgtVector3;
+    content?: TemplateRef<unknown>;
+    distanceFactor?: number;
+    style?: CSSStyleDeclaration;
+    renderedDivClass?: string;
+    wrapperClass?: string;
+    portal?: NgtRef<HTMLElement>;
+    occlude: NgtRef<THREE.Object3D>[] | boolean | 'raycast' | 'blending';
+    material?: NgtRef<THREE.Material>;
+    geometry?: NgtRef<THREE.BufferGeometry>;
+    castShadow: boolean;
+    receiveShadow: boolean;
+};
+export declare const injectNgtsHtmlInputs: {
+    (): {
+        zIndexRange: import("@angular/core").Signal<number[]>;
+        prepend: import("@angular/core").Signal<boolean>;
+        transform: import("@angular/core").Signal<boolean>;
+        center: import("@angular/core").Signal<boolean>;
+        fullscreen: import("@angular/core").Signal<boolean>;
+        calculatePosition: import("@angular/core").Signal<typeof defaultCalculatePosition>;
+        wrapperClass: import("@angular/core").Signal<string | undefined>;
+        renderedDivClass: import("@angular/core").Signal<string | undefined>;
+        style: import("@angular/core").Signal<CSSStyleDeclaration | undefined>;
+        pointerEvents: import("@angular/core").Signal<PointerEventsProperties>;
+        eps: import("@angular/core").Signal<number>;
+        distanceFactor: import("@angular/core").Signal<number | undefined>;
+        sprite: import("@angular/core").Signal<boolean>;
+        as: import("@angular/core").Signal<keyof HTMLElementTagNameMap>;
+        portal: import("@angular/core").Signal<NgtRef<HTMLElement> | undefined>;
+        content: import("@angular/core").Signal<TemplateRef<unknown> | undefined>;
+        occlude: import("@angular/core").Signal<boolean | "raycast" | NgtRef<THREE.Object3D<THREE.Event>>[] | "blending">;
+        isRayCastOcclusion: import("@angular/core").Signal<boolean>;
+        occlusionMeshRef: import("angular-three").NgtInjectedRef<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+        occluded: EventEmitter<boolean>;
+        geometry: import("@angular/core").Signal<NgtRef<THREE.BufferGeometry<THREE.NormalBufferAttributes>> | undefined>;
+        scale: import("@angular/core").Signal<NgtVector3>;
+        groupRef: import("angular-three").NgtInjectedRef<THREE.Group>;
+        state: import("@angular/core").Signal<NgtsHtmlState>;
+    };
+    (injectOptions: import("@angular/core").InjectOptions & {
+        optional?: false | undefined;
+    }): {
+        zIndexRange: import("@angular/core").Signal<number[]>;
+        prepend: import("@angular/core").Signal<boolean>;
+        transform: import("@angular/core").Signal<boolean>;
+        center: import("@angular/core").Signal<boolean>;
+        fullscreen: import("@angular/core").Signal<boolean>;
+        calculatePosition: import("@angular/core").Signal<typeof defaultCalculatePosition>;
+        wrapperClass: import("@angular/core").Signal<string | undefined>;
+        renderedDivClass: import("@angular/core").Signal<string | undefined>;
+        style: import("@angular/core").Signal<CSSStyleDeclaration | undefined>;
+        pointerEvents: import("@angular/core").Signal<PointerEventsProperties>;
+        eps: import("@angular/core").Signal<number>;
+        distanceFactor: import("@angular/core").Signal<number | undefined>;
+        sprite: import("@angular/core").Signal<boolean>;
+        as: import("@angular/core").Signal<keyof HTMLElementTagNameMap>;
+        portal: import("@angular/core").Signal<NgtRef<HTMLElement> | undefined>;
+        content: import("@angular/core").Signal<TemplateRef<unknown> | undefined>;
+        occlude: import("@angular/core").Signal<boolean | "raycast" | NgtRef<THREE.Object3D<THREE.Event>>[] | "blending">;
+        isRayCastOcclusion: import("@angular/core").Signal<boolean>;
+        occlusionMeshRef: import("angular-three").NgtInjectedRef<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+        occluded: EventEmitter<boolean>;
+        geometry: import("@angular/core").Signal<NgtRef<THREE.BufferGeometry<THREE.NormalBufferAttributes>> | undefined>;
+        scale: import("@angular/core").Signal<NgtVector3>;
+        groupRef: import("angular-three").NgtInjectedRef<THREE.Group>;
+        state: import("@angular/core").Signal<NgtsHtmlState>;
+    };
+    (injectOptions: import("@angular/core").InjectOptions): {
+        zIndexRange: import("@angular/core").Signal<number[]>;
+        prepend: import("@angular/core").Signal<boolean>;
+        transform: import("@angular/core").Signal<boolean>;
+        center: import("@angular/core").Signal<boolean>;
+        fullscreen: import("@angular/core").Signal<boolean>;
+        calculatePosition: import("@angular/core").Signal<typeof defaultCalculatePosition>;
+        wrapperClass: import("@angular/core").Signal<string | undefined>;
+        renderedDivClass: import("@angular/core").Signal<string | undefined>;
+        style: import("@angular/core").Signal<CSSStyleDeclaration | undefined>;
+        pointerEvents: import("@angular/core").Signal<PointerEventsProperties>;
+        eps: import("@angular/core").Signal<number>;
+        distanceFactor: import("@angular/core").Signal<number | undefined>;
+        sprite: import("@angular/core").Signal<boolean>;
+        as: import("@angular/core").Signal<keyof HTMLElementTagNameMap>;
+        portal: import("@angular/core").Signal<NgtRef<HTMLElement> | undefined>;
+        content: import("@angular/core").Signal<TemplateRef<unknown> | undefined>;
+        occlude: import("@angular/core").Signal<boolean | "raycast" | NgtRef<THREE.Object3D<THREE.Event>>[] | "blending">;
+        isRayCastOcclusion: import("@angular/core").Signal<boolean>;
+        occlusionMeshRef: import("angular-three").NgtInjectedRef<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+        occluded: EventEmitter<boolean>;
+        geometry: import("@angular/core").Signal<NgtRef<THREE.BufferGeometry<THREE.NormalBufferAttributes>> | undefined>;
+        scale: import("@angular/core").Signal<NgtVector3>;
+        groupRef: import("angular-three").NgtInjectedRef<THREE.Group>;
+        state: import("@angular/core").Signal<NgtsHtmlState>;
+    } | null;
+}, provideNgtsHtmlInputs: (value?: {
+    zIndexRange: import("@angular/core").Signal<number[]>;
+    prepend: import("@angular/core").Signal<boolean>;
+    transform: import("@angular/core").Signal<boolean>;
+    center: import("@angular/core").Signal<boolean>;
+    fullscreen: import("@angular/core").Signal<boolean>;
+    calculatePosition: import("@angular/core").Signal<typeof defaultCalculatePosition>;
+    wrapperClass: import("@angular/core").Signal<string | undefined>;
+    renderedDivClass: import("@angular/core").Signal<string | undefined>;
+    style: import("@angular/core").Signal<CSSStyleDeclaration | undefined>;
+    pointerEvents: import("@angular/core").Signal<PointerEventsProperties>;
+    eps: import("@angular/core").Signal<number>;
+    distanceFactor: import("@angular/core").Signal<number | undefined>;
+    sprite: import("@angular/core").Signal<boolean>;
+    as: import("@angular/core").Signal<keyof HTMLElementTagNameMap>;
+    portal: import("@angular/core").Signal<NgtRef<HTMLElement> | undefined>;
+    content: import("@angular/core").Signal<TemplateRef<unknown> | undefined>;
+    occlude: import("@angular/core").Signal<boolean | "raycast" | NgtRef<THREE.Object3D<THREE.Event>>[] | "blending">;
+    isRayCastOcclusion: import("@angular/core").Signal<boolean>;
+    occlusionMeshRef: import("angular-three").NgtInjectedRef<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+    occluded: EventEmitter<boolean>;
+    geometry: import("@angular/core").Signal<NgtRef<THREE.BufferGeometry<THREE.NormalBufferAttributes>> | undefined>;
+    scale: import("@angular/core").Signal<NgtVector3>;
+    groupRef: import("angular-three").NgtInjectedRef<THREE.Group>;
+    state: import("@angular/core").Signal<NgtsHtmlState>;
+} | undefined) => import("@angular/core").Provider;
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-group
+         */
+        'ngts-html': NgtsHtmlState & NgtGroup;
+    }
+}
+export declare class NgtsHtml {
+    DoubleSide: 2;
+    inputs: import("angular-three").NgtSignalStore<NgtsHtmlState>;
+    set content(content: TemplateRef<unknown>);
+    groupRef: import("angular-three").NgtInjectedRef<THREE.Group>;
+    set _as(as: keyof HTMLElementTagNameMap);
+    set _zIndexRange(zIndexRange: Array<number>);
+    set _portal(portal: NgtRef<HTMLElement>);
+    set _occlude(occlude: NgtsHtmlState['occlude']);
+    set _castShadow(castShadow: NgtsHtmlState['castShadow']);
+    set _receiveShadow(receiveShadow: NgtsHtmlState['receiveShadow']);
+    set _material(material: NgtsHtmlState['material']);
+    set _geometry(geometry: NgtsHtmlState['geometry']);
+    set _scale(scale: NgtsHtmlState['scale']);
+    set _prepend(prepend: boolean);
+    set _transform(transform: boolean);
+    set _center(center: boolean);
+    set _sprite(sprite: boolean);
+    set _fullscreen(fullscreen: boolean);
+    set _eps(eps: number);
+    set _distanceFactor(distanceFactor: number);
+    set _wrapperClass(wrapperClass: string);
+    set _renderedDivClass(renderedDivClass: string);
+    set _style(style: CSSStyleDeclaration);
+    set _pointerEvents(pointerEvents: PointerEventsProperties);
+    set _calculatePosition(calculatePosition: NgtsHtmlState['calculatePosition']);
+    occluded: EventEmitter<boolean>;
+    occlusionMeshRef: import("angular-three").NgtInjectedRef<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+    private transform;
+    isRayCastOcclusion: import("@angular/core").Signal<boolean>;
+    occlude: import("@angular/core").Signal<boolean | "raycast" | NgtRef<THREE.Object3D<THREE.Event>>[] | "blending">;
+    castShadow: import("@angular/core").Signal<boolean>;
+    receiveShadow: import("@angular/core").Signal<boolean>;
+    geometry: import("@angular/core").Signal<NgtRef<THREE.BufferGeometry<THREE.NormalBufferAttributes>> | undefined>;
+    material: import("@angular/core").Signal<NgtRef<THREE.Material> | undefined>;
+    scale: import("@angular/core").Signal<NgtVector3>;
+    shaders: import("@angular/core").Signal<{
+        vertexShader: string | undefined;
+        fragmentShader: string;
+    }>;
+    state: {
+        zIndexRange: import("@angular/core").Signal<number[]>;
+        prepend: import("@angular/core").Signal<boolean>;
+        transform: import("@angular/core").Signal<boolean>;
+        center: import("@angular/core").Signal<boolean>;
+        fullscreen: import("@angular/core").Signal<boolean>;
+        calculatePosition: import("@angular/core").Signal<typeof defaultCalculatePosition>;
+        wrapperClass: import("@angular/core").Signal<string | undefined>;
+        renderedDivClass: import("@angular/core").Signal<string | undefined>;
+        style: import("@angular/core").Signal<CSSStyleDeclaration | undefined>;
+        pointerEvents: import("@angular/core").Signal<PointerEventsProperties>;
+        eps: import("@angular/core").Signal<number>;
+        distanceFactor: import("@angular/core").Signal<number | undefined>;
+        sprite: import("@angular/core").Signal<boolean>;
+        as: import("@angular/core").Signal<keyof HTMLElementTagNameMap>;
+        portal: import("@angular/core").Signal<NgtRef<HTMLElement> | undefined>;
+        content: import("@angular/core").Signal<TemplateRef<unknown> | undefined>;
+        occlude: import("@angular/core").Signal<boolean | "raycast" | NgtRef<THREE.Object3D<THREE.Event>>[] | "blending">;
+        isRayCastOcclusion: import("@angular/core").Signal<boolean>;
+        occlusionMeshRef: import("angular-three").NgtInjectedRef<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+        occluded: EventEmitter<boolean>;
+        geometry: import("@angular/core").Signal<NgtRef<THREE.BufferGeometry<THREE.NormalBufferAttributes>> | undefined>;
+        scale: import("@angular/core").Signal<NgtVector3>;
+        groupRef: import("angular-three").NgtInjectedRef<THREE.Group>;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsHtml, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsHtml, "ngts-html", never, { "groupRef": { "alias": "groupRef"; "required": false; }; "_as": { "alias": "as"; "required": false; }; "_zIndexRange": { "alias": "zIndexRange"; "required": false; }; "_portal": { "alias": "portal"; "required": false; }; "_occlude": { "alias": "occlude"; "required": false; }; "_castShadow": { "alias": "castShadow"; "required": false; }; "_receiveShadow": { "alias": "receiveShadow"; "required": false; }; "_material": { "alias": "material"; "required": false; }; "_geometry": { "alias": "geometry"; "required": false; }; "_scale": { "alias": "scale"; "required": false; }; "_prepend": { "alias": "prepend"; "required": false; }; "_transform": { "alias": "transform"; "required": false; }; "_center": { "alias": "center"; "required": false; }; "_sprite": { "alias": "sprite"; "required": false; }; "_fullscreen": { "alias": "fullscreen"; "required": false; }; "_eps": { "alias": "eps"; "required": false; }; "_distanceFactor": { "alias": "distanceFactor"; "required": false; }; "_wrapperClass": { "alias": "wrapperClass"; "required": false; }; "_renderedDivClass": { "alias": "renderedDivClass"; "required": false; }; "_style": { "alias": "style"; "required": false; }; "_pointerEvents": { "alias": "pointerEvents"; "required": false; }; "_calculatePosition": { "alias": "calculatePosition"; "required": false; }; }, { "occluded": "occluded"; }, ["content"], never, true, never>;
+}
+export {};

package/misc/index.d.ts

@@ -1,4 +1,13 @@
 export * from './animations/animations';
 export * from './bake-shadows/bake-shadows';
+export * from './caustics/caustics';
+export * from './decal/decal';
 export * from './depth-buffer/depth-buffer';
+export * from './example/example';
 export * from './fbo/fbo';
+export * from './html/html';
+export * from './sampler/sampler';
+export * from './shadow/shadow';
+export * from './stats-gl/stats-gl';
+export * from './trail-texture/inject-trail-texture';
+export * from './trail/trail';

package/misc/sampler/sampler.d.ts

@@ -0,0 +1,67 @@
+import { Injector } from '@angular/core';
+import { type NgtGroup, type NgtRef } from 'angular-three';
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+type SamplePayload = {
+    /**
+     * The position of the sample.
+     */
+    position: THREE.Vector3;
+    /**
+     * The normal of the mesh at the sampled position.
+     */
+    normal: THREE.Vector3;
+    /**
+     * The vertex color of the mesh at the sampled position.
+     */
+    color: THREE.Color;
+};
+type TransformPayload = SamplePayload & {
+    /**
+     * The dummy object used to transform each instance.
+     * This object's matrix will be updated after transforming & it will be used
+     * to set the instance's matrix.
+     */
+    dummy: THREE.Object3D;
+    /**
+     * The mesh that's initially passed to the sampler.
+     * Use this if you need to apply transforms from your mesh to your instances
+     * or if you need to grab attributes from the geometry.
+     */
+    sampledMesh: THREE.Mesh;
+};
+export type NgtsSurfaceSamplerTransformFn = (payload: TransformPayload, i: number) => void;
+export type NgtsSurfaceSamplerState = {
+    count: number;
+    mesh: NgtRef<THREE.Mesh>;
+    transform?: NgtsSurfaceSamplerTransformFn;
+    weight?: string;
+    instancedMesh?: NgtRef<THREE.InstancedMesh>;
+};
+export declare function injectNgtsSurfaceSampler(surfaceSamplerState: () => (Partial<Omit<NgtsSurfaceSamplerState, 'mesh'>> & {
+    mesh: NgtRef<THREE.Mesh>;
+}) | null, { injector }?: {
+    injector?: Injector;
+}): import("@angular/core").Signal<THREE.InstancedBufferAttribute>;
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-group
+         */
+        'ngts-sampler': NgtsSurfaceSamplerState & NgtGroup;
+    }
+}
+export declare class NgtsSampler {
+    private inputs;
+    samplerRef: import("angular-three").NgtInjectedRef<THREE.Group>;
+    set _count(count: number);
+    set _mesh(mesh: NgtRef<THREE.Mesh>);
+    set _transform(transform: NgtsSurfaceSamplerTransformFn);
+    set _weight(weight: string);
+    set _instancedMesh(instancedMesh: NgtRef<THREE.InstancedMesh>);
+    private surfaceSamplerState;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSampler, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSampler, "ngts-sampler", never, { "samplerRef": { "alias": "samplerRef"; "required": false; }; "_count": { "alias": "count"; "required": false; }; "_mesh": { "alias": "mesh"; "required": false; }; "_transform": { "alias": "transform"; "required": false; }; "_weight": { "alias": "weight"; "required": false; }; "_instancedMesh": { "alias": "instancedMesh"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+export {};

package/misc/shadow/shadow.d.ts

@@ -0,0 +1,37 @@
+import { type NgtMesh } from 'angular-three';
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+export type NgtsShadowState = {
+    colorStop: number;
+    fog: boolean;
+    color: THREE.ColorRepresentation;
+    opacity: number;
+    depthWrite: boolean;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-mesh
+         */
+        'ngts-shadow': NgtsShadowState & NgtMesh;
+    }
+}
+export declare class NgtsShadow {
+    Math: Math;
+    DoubleSide: 2;
+    private inputs;
+    shadowRef: import("angular-three").NgtInjectedRef<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+    set _colorStop(colorStop: number);
+    set _fog(fog: boolean);
+    set _color(color: THREE.ColorRepresentation);
+    set _opacity(opacity: number);
+    set _depthWrite(depthWrite: boolean);
+    private colorStop;
+    private color;
+    opacity: import("@angular/core").Signal<number>;
+    fog: import("@angular/core").Signal<boolean>;
+    depthWrite: import("@angular/core").Signal<boolean>;
+    canvas: import("@angular/core").Signal<HTMLCanvasElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsShadow, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsShadow, "ngts-shadow", never, { "shadowRef": { "alias": "shadowRef"; "required": false; }; "_colorStop": { "alias": "colorStop"; "required": false; }; "_fog": { "alias": "fog"; "required": false; }; "_color": { "alias": "color"; "required": false; }; "_opacity": { "alias": "opacity"; "required": false; }; "_depthWrite": { "alias": "depthWrite"; "required": false; }; }, {}, never, ["*"], true, never>;
+}

package/misc/stats-gl/stats-gl.d.ts

@@ -0,0 +1,24 @@
+import { type NgtRef } from 'angular-three';
+import Stats from 'stats-gl';
+import * as i0 from "@angular/core";
+export type NgtsStatsGLState = {
+    parent?: NgtRef<HTMLElement>;
+    containerClass?: string;
+    config?: ConstructorParameters<typeof Stats>[0];
+};
+export declare class NgtsStatsGL {
+    private inputs;
+    set _parent(parent: NgtRef<HTMLElement>);
+    set _containerClass(containerClass: string);
+    set _config(config: NgtsStatsGLState['config']);
+    private document;
+    private store;
+    private gl;
+    private config;
+    private parent;
+    private containerClass;
+    private stats;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsStatsGL, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsStatsGL, "ngts-stats-gl", never, { "_parent": { "alias": "parent"; "required": false; }; "_containerClass": { "alias": "containerClass"; "required": false; }; "_config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
+}

package/misc/trail/trail.d.ts

@@ -0,0 +1,57 @@
+import { type Injector } from '@angular/core';
+import { type NgtRef } from 'angular-three';
+import { MeshLineGeometry, MeshLineMaterial } from 'meshline';
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+export type NgtsTrailSettings = {
+    width: number;
+    length: number;
+    decay: number;
+    /**
+     * Wether to use the target's world or local positions
+     */
+    local: boolean;
+    stride: number;
+    interval: number;
+};
+export declare function injectNgtsTrail(targetFactory: () => NgtRef<THREE.Object3D> | null, settingsFactory: () => Partial<NgtsTrailSettings>, { injector }?: {
+    injector?: Injector;
+}): import("angular-three").NgtInjectedRef<Float32Array>;
+export type NgtsTrailState = {
+    color: THREE.ColorRepresentation;
+    attenuation: (width: number) => number;
+    settings: NgtsTrailSettings;
+    target?: NgtRef<THREE.Object3D>;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        'ngts-trail': NgtsTrailState;
+    }
+}
+export declare class NgtsTrail {
+    private inputs;
+    trailRef: import("angular-three").NgtInjectedRef<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+    set _color(color: THREE.ColorRepresentation);
+    set _attenuation(attenuation: (width: number) => number);
+    set _target(target: NgtRef<THREE.Object3D>);
+    set _settings(settings: Partial<NgtsTrailSettings>);
+    groupRef: import("angular-three").NgtInjectedRef<THREE.Group>;
+    private children;
+    private store;
+    private size;
+    private target;
+    private settings;
+    private width;
+    private color;
+    private attenuation;
+    private anchor;
+    private points;
+    scene: import("@angular/core").Signal<THREE.Scene>;
+    geometry: MeshLineGeometry;
+    material: import("@angular/core").Signal<MeshLineMaterial>;
+    constructor();
+    private setMaterialSize;
+    private beforeRender;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsTrail, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsTrail, "ngts-trail", never, { "trailRef": { "alias": "trailRef"; "required": false; }; "_color": { "alias": "color"; "required": false; }; "_attenuation": { "alias": "attenuation"; "required": false; }; "_target": { "alias": "target"; "required": false; }; "_settings": { "alias": "settings"; "required": false; }; }, {}, never, ["*"], true, never>;
+}

package/misc/trail-texture/inject-trail-texture.d.ts

@@ -0,0 +1,9 @@
+import { Injector } from '@angular/core';
+import { type NgtThreeEvent } from 'angular-three';
+import { type TrailConfig } from './trail-texture';
+export declare function injectNgtsTrailTexture(trailConfigFn: () => Partial<TrailConfig>, { injector }?: {
+    injector?: Injector;
+}): {
+    texture: import("@angular/core").Signal<import("three").Texture>;
+    onMove: (ev: NgtThreeEvent<PointerEvent>) => void;
+};

package/misc/trail-texture/trail-texture.d.ts

@@ -0,0 +1,50 @@
+import { Texture } from 'three';
+export type Point = {
+    x: number;
+    y: number;
+    age: number;
+    force: number;
+};
+export type TrailConfig = {
+    /** texture size (default: 256x256) */
+    size?: number;
+    /** Max age (ms) of trail points (default: 750) */
+    maxAge?: number;
+    /** Trail radius (default: 0.3) */
+    radius?: number;
+    /** Canvas trail opacity (default: 0.2) */
+    intensity?: number;
+    /** Add points in between slow pointer events (default: 0) */
+    interpolate?: number;
+    /** Moving average of pointer force (default: 0) */
+    smoothing?: number;
+    /** Minimum pointer force (default: 0.3) */
+    minForce?: number;
+    /** Blend mode (default: 'screen') */
+    blend?: CanvasRenderingContext2D['globalCompositeOperation'];
+    /** Easing (default: easeCircOut) */
+    ease?: (t: number) => number;
+};
+export declare class TrailTexture {
+    trail: Point[];
+    canvas: HTMLCanvasElement;
+    ctx: CanvasRenderingContext2D;
+    texture: Texture;
+    force: number;
+    size: number;
+    maxAge: number;
+    radius: number;
+    intensity: number;
+    ease: (t: number) => number;
+    minForce: number;
+    interpolate: number;
+    smoothing: number;
+    blend: CanvasRenderingContext2D['globalCompositeOperation'];
+    constructor({ size, maxAge, radius, intensity, interpolate, smoothing, minForce, blend, // source-over is canvas default. Others are slower
+    ease, }?: TrailConfig);
+    initTexture(): void;
+    update(delta: number): void;
+    clear(): void;
+    addTouch(point: Pick<Point, 'x' | 'y'>): void;
+    drawTouch(point: Point): void;
+}

package/modifiers/README.md

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

package/modifiers/curve-modifier/curve-modifier.d.ts

@@ -0,0 +1,23 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+export type NgtsCurveModifierState = {
+    curve?: THREE.Curve<THREE.Vector3>;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        'ngts-curve-modifier': NgtsCurveModifierState;
+    }
+}
+export declare class NgtsCurveModifier {
+    private inputs;
+    set _curve(curve: THREE.Curve<THREE.Vector3>);
+    private curve;
+    sceneRef: import("angular-three").NgtInjectedRef<import("angular-three").NgtInstanceNode<THREE.Scene>>;
+    private sceneRefChildren;
+    private modifier?;
+    modifierObject: import("@angular/core").WritableSignal<THREE.Object3D<THREE.Event> | null>;
+    constructor();
+    moveAlongCurve(value: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsCurveModifier, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsCurveModifier, "ngts-curve-modifier", never, { "_curve": { "alias": "curve"; "required": false; }; }, {}, never, ["*"], true, never>;
+}

package/modifiers/index.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "angular-three-soba",
-  "version": "2.0.0-beta.2",
+  "version": "2.0.0-beta.21",
   "publishConfig": {
     "access": "public"
   },
@@ -45,6 +45,12 @@
       "esm": "./esm2022/cameras/angular-three-soba-cameras.mjs",
       "default": "./fesm2022/angular-three-soba-cameras.mjs"
     },
+    "./gizmos": {
+      "types": "./gizmos/index.d.ts",
+      "esm2022": "./esm2022/gizmos/angular-three-soba-gizmos.mjs",
+      "esm": "./esm2022/gizmos/angular-three-soba-gizmos.mjs",
+      "default": "./fesm2022/angular-three-soba-gizmos.mjs"
+    },
     "./controls": {
       "types": "./controls/index.d.ts",
       "esm2022": "./esm2022/controls/angular-three-soba-controls.mjs",
@@ -69,11 +75,17 @@
       "esm": "./esm2022/misc/angular-three-soba-misc.mjs",
       "default": "./fesm2022/angular-three-soba-misc.mjs"
     },
-    "./performance": {
-      "types": "./performance/index.d.ts",
-      "esm2022": "./esm2022/performance/angular-three-soba-performance.mjs",
-      "esm": "./esm2022/performance/angular-three-soba-performance.mjs",
-      "default": "./fesm2022/angular-three-soba-performance.mjs"
+    "./modifiers": {
+      "types": "./modifiers/index.d.ts",
+      "esm2022": "./esm2022/modifiers/angular-three-soba-modifiers.mjs",
+      "esm": "./esm2022/modifiers/angular-three-soba-modifiers.mjs",
+      "default": "./fesm2022/angular-three-soba-modifiers.mjs"
+    },
+    "./performances": {
+      "types": "./performances/index.d.ts",
+      "esm2022": "./esm2022/performances/angular-three-soba-performances.mjs",
+      "esm": "./esm2022/performances/angular-three-soba-performances.mjs",
+      "default": "./fesm2022/angular-three-soba-performances.mjs"
     },
     "./shaders": {
       "types": "./shaders/index.d.ts",
@@ -86,28 +98,31 @@
       "esm2022": "./esm2022/staging/angular-three-soba-staging.mjs",
       "esm": "./esm2022/staging/angular-three-soba-staging.mjs",
       "default": "./fesm2022/angular-three-soba-staging.mjs"
+    },
+    "./utils": {
+      "types": "./utils/index.d.ts",
+      "esm2022": "./esm2022/utils/angular-three-soba-utils.mjs",
+      "esm": "./esm2022/utils/angular-three-soba-utils.mjs",
+      "default": "./fesm2022/angular-three-soba-utils.mjs"
     }
   },
   "peerDependencies": {
     "@angular/common": "^16.0.0",
     "@angular/core": "^16.0.0",
     "angular-three": "^2.0.0",
-    "three": "^0.148.0 || ^0.149.0 || ^0.150.0 || ^0.151.0 || ^0.152.0",
+    "meshline": "^3.1.0",
+    "stats-gl": "^1.0.0",
     "stats.js": "^0.17.0",
-    "three-mesh-bvh": "^0.5.0",
+    "three": ">=0.148.0",
+    "three-mesh-bvh": "^0.5.0 || ^0.6.0",
     "three-stdlib": "^2.0.0",
-    "troika-three-text": "^0.47.0",
-    "@storybook/addons": "7.0.8",
-    "@storybook/theming": "7.0.8"
+    "troika-three-text": "^0.47.0"
   },
   "dependencies": {
-    "tslib": "^2.3.0",
-    "@nx/devkit": "^16.0.0",
-    "nx": "^16.0.0"
+    "tslib": "^2.3.0"
   },
   "sideEffects": false,
-  "generators": "./plugin/generators.json",
-  "schematics": "./plugin/generators.json",
+  "web-types": "./web-types.json",
   "module": "fesm2022/angular-three-soba.mjs",
   "typings": "index.d.ts"
 }

package/performances/README.md

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

package/performances/adaptive-dpr/adaptive-dpr.d.ts

@@ -0,0 +1,14 @@
+import * as i0 from "@angular/core";
+export declare class NgtsAdaptiveDpr {
+    private pixelated;
+    set _pixelated(pixelated: boolean);
+    private store;
+    private current;
+    private active;
+    private setDpr;
+    private initialDpr;
+    private domElement;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsAdaptiveDpr, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsAdaptiveDpr, "ngts-adaptive-dpr", never, { "_pixelated": { "alias": "pixelated"; "required": false; }; }, {}, never, never, true, never>;
+}

package/{performance/adaptive → performances/adaptive-events}/adaptive-events.d.ts

@@ -1,5 +1,8 @@
 import * as i0 from "@angular/core";
 export declare class NgtsAdaptiveEvents {
+    private store;
+    private setEvents;
+    private current;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsAdaptiveEvents, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsAdaptiveEvents, "ngts-adaptive-events", never, {}, {}, never, never, true, never>;

package/performances/index.d.ts

@@ -0,0 +1,7 @@
+export * from './adaptive-dpr/adaptive-dpr';
+export * from './adaptive-events/adaptive-events';
+export * from './instances/instances';
+export * from './instances/position-mesh';
+export * from './points/points';
+export * from './segments/segment-object';
+export * from './segments/segments';