angular-three-soba 3.7.0 → 4.0.0-next.2

package/materials/lib/mesh-portal-material.d.ts

@@ -1,117 +1,22 @@
 import { ElementRef, TemplateRef } from '@angular/core';
-import { NgtAttachable, NgtShaderMaterial } from 'angular-three';
-import { Scene, ShaderMaterial } from 'three';
+import { NgtAttachable, NgtThreeElements } from 'angular-three';
+import { NgtMeshPortalMaterial } from 'angular-three-soba/vanilla-exports';
+import * as THREE from 'three';
 import * as i0 from "@angular/core";
 /**
  * This directive is used inside of the render texture, hence has access to the render texture store (a portal store)
  */
 export declare class ManagePortalScene {
     events: import("@angular/core").InputSignal<boolean | undefined>;
-    rootScene: import("@angular/core").InputSignal<Scene>;
-    material: import("@angular/core").InputSignal<import("angular-three").NgtExtendedColors<import("angular-three").NgtOverwrite<Partial<{
-        fragmentShader: string;
-        vertexShader: string;
-        uniforms: {
-            [uniform: string]: import("three").IUniform;
-        };
-        defines: {
-            [key: string]: any;
-        };
-        map?: (import("three").Texture | null) | undefined;
-        wireframe: boolean;
-        wireframeLinewidth: number;
-        fog: boolean;
-        setValues: (parameters: import("three").ShaderMaterialParameters) => void;
-        readonly isMaterial: true;
-        type: string;
-        alphaHash: boolean;
-        alphaToCoverage: boolean;
-        blendAlpha: number;
-        blendColor: import("three").Color;
-        blendDst: import("three").BlendingDstFactor;
-        blendDstAlpha: number | null;
-        blendEquation: import("three").BlendingEquation;
-        blendEquationAlpha: number | null;
-        blending: import("three").Blending;
-        blendSrc: import("three").BlendingSrcFactor | import("three").BlendingDstFactor;
-        blendSrcAlpha: number | null;
-        clipIntersection: boolean;
-        clippingPlanes: import("three").Plane[] | null;
-        clipShadows: boolean;
-        colorWrite: boolean;
-        depthFunc: import("three").DepthModes;
-        depthTest: boolean;
-        depthWrite: boolean;
-        id: number;
-        stencilWrite: boolean;
-        stencilFunc: import("three").StencilFunc;
-        stencilRef: number;
-        stencilWriteMask: number;
-        stencilFuncMask: number;
-        stencilFail: import("three").StencilOp;
-        stencilZFail: import("three").StencilOp;
-        stencilZPass: import("three").StencilOp;
-        name: string;
-        opacity: number;
-        polygonOffset: boolean;
-        polygonOffsetFactor: number;
-        polygonOffsetUnits: number;
-        precision: "highp" | "mediump" | "lowp" | null;
-        premultipliedAlpha: boolean;
-        forceSinglePass: boolean;
-        dithering: boolean;
-        side: import("three").Side;
-        shadowSide: import("three").Side | null;
-        toneMapped: boolean;
-        transparent: boolean;
-        uuid: string;
-        vertexColors: boolean;
-        visible: boolean;
-        userData: Record<string, any>;
-        version: number;
-        alphaTest: number;
-        onBeforeRender: (renderer: import("three").WebGLRenderer, scene: Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry, object: import("three").Object3D, group: import("three").Group) => void;
-        onBeforeCompile: (parameters: import("three").WebGLProgramParametersWithUniforms, renderer: import("three").WebGLRenderer) => void;
-        customProgramCacheKey: () => string;
-        toJSON: (meta?: import("three").JSONMeta) => import("three").ShaderMaterialJSON;
-        clone: () => ShaderMaterial & import("@pmndrs/vanilla").PortalMaterialType;
-        copy: (material: import("three").Material) => ShaderMaterial & import("@pmndrs/vanilla").PortalMaterialType;
-        dispose: () => void;
-        needsUpdate: boolean;
-        onBuild: (object: import("three").Object3D, parameters: import("three").WebGLProgramParametersWithUniforms, renderer: import("three").WebGLRenderer) => void;
-        hasEventListener: <T extends "dispose">(type: T, listener: import("three").EventListener<{
-            dispose: {};
-        }[T], T, ShaderMaterial & import("@pmndrs/vanilla").PortalMaterialType>) => boolean;
-        dispatchEvent: <T extends "dispose">(event: import("three").BaseEvent<T> & {
-            dispose: {};
-        }[T]) => void;
-        resolution: import("three").Vector2;
-        blur: number;
-        size?: number | undefined;
-        sdf?: (import("three").Texture | null) | undefined;
-        readonly isShaderMaterial: true;
-        uniformsGroups: import("three").UniformsGroup[];
-        linewidth: number;
-        lights: boolean;
-        clipping: boolean;
-        extensions: {
-            clipCullDistance: boolean;
-            multiDraw: boolean;
-        };
-        defaultAttributeValues: any;
-        index0AttributeName: string | undefined;
-        uniformsNeedUpdate: boolean;
-        glslVersion: import("three").GLSLVersion | null;
-    }>, import("angular-three").NgtNodeElement<ShaderMaterial & import("@pmndrs/vanilla").PortalMaterialType, (new (parameters?: (import("three").ShaderMaterialParameters & Partial<import("@pmndrs/vanilla").PortalMaterialType>) | undefined) => ShaderMaterial & import("@pmndrs/vanilla").PortalMaterialType) & {
-        key: string;
-    }>>>>;
+    rootScene: import("@angular/core").InputSignal<THREE.Scene>;
+    material: import("@angular/core").InputSignal<NgtMeshPortalMaterial>;
     priority: import("@angular/core").InputSignal<number>;
     worldUnits: import("@angular/core").InputSignal<boolean>;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<ManagePortalScene, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<ManagePortalScene, "ngts-manage-portal-scene", never, { "events": { "alias": "events"; "required": false; "isSignal": true; }; "rootScene": { "alias": "rootScene"; "required": true; "isSignal": true; }; "material": { "alias": "material"; "required": true; "isSignal": true; }; "priority": { "alias": "priority"; "required": true; "isSignal": true; }; "worldUnits": { "alias": "worldUnits"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
-export interface NgtsMeshPortalMaterialOptions extends Partial<NgtShaderMaterial> {
+export interface NgtsMeshPortalMaterialOptions extends Partial<NgtThreeElements['ngt-shader-material']> {
     /** Mix the portals own scene with the world scene, 0 = world scene render,
      *  0.5 = both scenes render, 1 = portal scene renders, defaults to 0.   */
     blend: number;
@@ -131,27 +36,23 @@ export interface NgtsMeshPortalMaterialOptions extends Partial<NgtShaderMaterial
 export declare class NgtsMeshPortalMaterial {
     attach: import("@angular/core").InputSignal<NgtAttachable>;
     options: import("@angular/core").InputSignalWithTransform<NgtsMeshPortalMaterialOptions, "" | Partial<NgtsMeshPortalMaterialOptions>>;
-    parameters: import("@angular/core").Signal<Omit<NgtsMeshPortalMaterialOptions, "resolution" | "blur" | "events" | "worldUnits" | "eventPriority" | "renderPriority">>;
-    blur: import("@angular/core").Signal<number>;
-    eventPriority: import("@angular/core").Signal<number>;
-    renderPriority: import("@angular/core").Signal<number>;
-    events: import("@angular/core").Signal<boolean>;
-    worldUnits: import("@angular/core").Signal<boolean>;
-    materialRef: import("@angular/core").Signal<ElementRef<ShaderMaterial & import("@pmndrs/vanilla").PortalMaterialType>>;
-    content: import("@angular/core").Signal<TemplateRef<any>>;
+    protected parameters: import("@angular/core").Signal<Omit<NgtsMeshPortalMaterialOptions, "resolution" | "blur" | "events" | "worldUnits" | "eventPriority" | "renderPriority">>;
+    protected blur: import("@angular/core").Signal<number>;
+    protected eventPriority: import("@angular/core").Signal<number>;
+    protected renderPriority: import("@angular/core").Signal<number>;
+    protected events: import("@angular/core").Signal<boolean>;
+    protected worldUnits: import("@angular/core").Signal<boolean>;
+    materialRef: import("@angular/core").Signal<ElementRef<THREE.ShaderMaterial & import("@pmndrs/vanilla").PortalMaterialType>>;
+    protected content: import("@angular/core").Signal<TemplateRef<any>>;
     private store;
-    private size;
-    private viewport;
-    private gl;
-    private setEvents;
-    rootScene: import("@angular/core").Signal<Scene>;
-    materialResolution: import("@angular/core").Signal<number[]>;
+    protected rootScene: import("angular-three").DeepSignal<THREE.Scene>;
+    protected materialResolution: import("@angular/core").Signal<number[]>;
     private resolution;
     private parent;
     private visible;
-    renderTextureFrames: import("@angular/core").Signal<number>;
-    renderTextureCompute: import("@angular/core").Signal<(event: import("angular-three").NgtDomEvent, root: import("angular-three").NgtSignalStore<import("angular-three").NgtState>, previous: import("angular-three").NgtSignalStore<import("angular-three").NgtState> | null) => false | undefined>;
-    priority: import("@angular/core").WritableSignal<number>;
+    protected renderTextureFrames: import("@angular/core").Signal<number>;
+    protected renderTextureCompute: (event: import("angular-three").NgtDomEvent, root: import("angular-three").SignalState<import("angular-three").NgtState>, previous: import("angular-three").SignalState<import("angular-three").NgtState> | null) => false | undefined;
+    protected priority: import("@angular/core").WritableSignal<number>;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsMeshPortalMaterial, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtsMeshPortalMaterial, "ngts-mesh-portal-material", never, { "attach": { "alias": "attach"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, ["content"], never, true, never>;

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

@@ -1,9 +1,9 @@
 import { ElementRef } from '@angular/core';
-import { NgtAttachable, NgtMeshStandardMaterial } from 'angular-three';
+import { NgtAttachable, NgtThreeElements } from 'angular-three';
 import { MeshReflectorMaterial } from 'angular-three-soba/vanilla-exports';
-import { Texture } from 'three';
+import * as THREE from 'three';
 import * as i0 from "@angular/core";
-export interface NgtsMeshReflectorMaterialOptions extends Partial<NgtMeshStandardMaterial> {
+export interface NgtsMeshReflectorMaterialOptions extends Partial<NgtThreeElements['ngt-mesh-standard-material']> {
     resolution: number;
     mixBlur: number;
     mixStrength: number;
@@ -16,14 +16,13 @@ export interface NgtsMeshReflectorMaterialOptions extends Partial<NgtMeshStandar
     distortion: number;
     mixContrast: number;
     reflectorOffset: number;
-    distortionMap?: Texture;
+    distortionMap?: THREE.Texture;
 }
 export declare class NgtsMeshReflectorMaterial {
     attach: import("@angular/core").InputSignal<NgtAttachable>;
     options: import("@angular/core").InputSignalWithTransform<NgtsMeshReflectorMaterialOptions, "" | Partial<NgtsMeshReflectorMaterialOptions>>;
     private parameters;
     private store;
-    private gl;
     materialRef: import("@angular/core").Signal<ElementRef<MeshReflectorMaterial> | undefined>;
     private reflectOptions;
     private blur;

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

@@ -1,8 +1,8 @@
 import { ElementRef } from '@angular/core';
-import { NgtAttachable, NgtShaderMaterial } from 'angular-three';
-import { ColorRepresentation, CubeTexture, Texture } from 'three';
+import { NgtAttachable, NgtThreeElements } from 'angular-three';
+import * as THREE from 'three';
 import * as i0 from "@angular/core";
-export interface NgtsMeshRefractionMaterialOptions extends Partial<NgtShaderMaterial> {
+export interface NgtsMeshRefractionMaterialOptions extends Partial<NgtThreeElements['ngt-shader-material']> {
     /** Number of ray-cast bounces, it can be expensive to have too many, 2 */
     bounces: number;
     /** Refraction index, 2.4 */
@@ -12,29 +12,28 @@ export interface NgtsMeshRefractionMaterialOptions extends Partial<NgtShaderMate
     /** RGB shift intensity, can be expensive, 0 */
     aberrationStrength: number;
     /** Color, white */
-    color: ColorRepresentation;
+    color: THREE.ColorRepresentation;
     /** If this is on it uses fewer ray casts for the RGB shift sacrificing physical accuracy, true */
     fastChroma: boolean;
 }
 export declare class NgtsMeshRefractionMaterial {
-    envMap: import("@angular/core").InputSignal<Texture | CubeTexture>;
+    envMap: import("@angular/core").InputSignal<THREE.Texture | THREE.CubeTexture>;
     attach: import("@angular/core").InputSignal<NgtAttachable>;
     options: import("@angular/core").InputSignalWithTransform<NgtsMeshRefractionMaterialOptions, "" | Partial<NgtsMeshRefractionMaterialOptions>>;
-    parameters: import("@angular/core").Signal<Omit<NgtsMeshRefractionMaterialOptions, "aberrationStrength" | "fastChroma">>;
+    protected parameters: import("@angular/core").Signal<Omit<NgtsMeshRefractionMaterialOptions, "aberrationStrength" | "fastChroma">>;
     private fastChroma;
-    aberrationStrength: import("@angular/core").Signal<number>;
-    materialRef: import("@angular/core").Signal<ElementRef<import("three").ShaderMaterial & {
-        [name: string]: number | boolean | any[] | import("three").Color | Texture | import("three").Vector3 | import("three").Quaternion | import("three").Matrix4 | import("three").Matrix3 | import("three").Vector2 | import("three").Vector4 | CubeTexture | Int32Array | Float32Array | null;
+    protected aberrationStrength: import("@angular/core").Signal<number>;
+    materialRef: import("@angular/core").Signal<ElementRef<THREE.ShaderMaterial & {
+        [name: string]: number | boolean | any[] | THREE.Color | THREE.Matrix3 | THREE.Matrix4 | THREE.Quaternion | THREE.Vector2 | THREE.Vector3 | THREE.Vector4 | THREE.Texture | THREE.CubeTexture | Int32Array | Float32Array | null;
     }> | undefined>;
     private store;
-    private size;
-    resolution: import("@angular/core").Signal<number[]>;
-    defines: import("@angular/core").Signal<{
+    protected resolution: import("@angular/core").Signal<number[]>;
+    protected defines: import("@angular/core").Signal<{
         [key: string]: string;
     }>;
     private defineKeys;
-    material: import("@angular/core").Signal<import("three").ShaderMaterial & {
-        [name: string]: number | boolean | any[] | import("three").Color | Texture | import("three").Vector3 | import("three").Quaternion | import("three").Matrix4 | import("three").Matrix3 | import("three").Vector2 | import("three").Vector4 | CubeTexture | Int32Array | Float32Array | null;
+    protected material: import("@angular/core").Signal<THREE.ShaderMaterial & {
+        [name: string]: number | boolean | any[] | THREE.Color | THREE.Matrix3 | THREE.Matrix4 | THREE.Quaternion | THREE.Vector2 | THREE.Vector3 | THREE.Vector4 | THREE.Texture | THREE.CubeTexture | Int32Array | Float32Array | null;
     }>;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsMeshRefractionMaterial, never>;

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

@@ -1,12 +1,12 @@
 import { ElementRef } from '@angular/core';
-import { NgtAttachable, NgtMeshPhysicalMaterial } from 'angular-three';
+import { NgtAttachable, NgtThreeElements } from 'angular-three';
 import { MeshTransmissionMaterial } from 'angular-three-soba/vanilla-exports';
-import { Color, Texture } from 'three';
+import * as THREE from 'three';
 import * as i0 from "@angular/core";
 export type MeshTransmissionMaterialOptions = ConstructorParameters<typeof MeshTransmissionMaterial>[0];
-export type NgtsMeshTransmissionMaterialOptions = Partial<NgtMeshPhysicalMaterial> & Omit<MeshTransmissionMaterialOptions, 'buffer' | 'anisotropicBlur' | 'samples' | 'transmissionSampler'> & {
+export type NgtsMeshTransmissionMaterialOptions = Partial<NgtThreeElements['ngt-mesh-physical-material']> & Omit<MeshTransmissionMaterialOptions, 'buffer' | 'anisotropicBlur' | 'samples' | 'transmissionSampler'> & {
     anisotropicBlur?: number;
-    buffer?: Texture;
+    buffer?: THREE.Texture;
     /** transmissionSampler, you can use the threejs transmission sampler texture that is
      *  generated once for all transmissive materials. The upside is that it can be faster if you
      *  use multiple MeshPhysical and Transmission materials, the downside is that transmissive materials
@@ -24,12 +24,12 @@ export type NgtsMeshTransmissionMaterialOptions = Partial<NgtMeshPhysicalMateria
     /** Refraction samples, default: 6 */
     samples: number;
     /** Buffer scene background (can be a texture, a cubetexture or a color), default: null */
-    background?: Texture | Color;
+    background?: THREE.Texture | THREE.Color;
 };
 export declare class NgtsMeshTransmissionMaterial {
     attach: import("@angular/core").InputSignal<NgtAttachable>;
     options: import("@angular/core").InputSignalWithTransform<NgtsMeshTransmissionMaterialOptions, "" | Partial<NgtsMeshTransmissionMaterialOptions>>;
-    parameters: import("@angular/core").Signal<Omit<NgtsMeshTransmissionMaterialOptions, "thickness" | "anisotropy" | "transmission" | "side" | "resolution" | "buffer" | "anisotropicBlur" | "samples" | "transmissionSampler" | "backside" | "backsideThickness" | "backsideEnvMapIntensity" | "backsideResolution" | "background">>;
+    protected parameters: import("@angular/core").Signal<Omit<NgtsMeshTransmissionMaterialOptions, "thickness" | "anisotropy" | "transmission" | "side" | "resolution" | "background" | "buffer" | "anisotropicBlur" | "samples" | "transmissionSampler" | "backside" | "backsideThickness" | "backsideEnvMapIntensity" | "backsideResolution">>;
     private resolution;
     private backsideResolution;
     private samples;
@@ -40,10 +40,10 @@ export declare class NgtsMeshTransmissionMaterial {
     private backside;
     private backsideThickness;
     private backsideEnvMapIntensity;
-    transmissionSampler: import("@angular/core").Signal<boolean>;
-    transmission: import("@angular/core").Signal<number | undefined>;
-    thickness: import("@angular/core").Signal<number | undefined>;
-    side: import("@angular/core").Signal<import("three").Side | undefined>;
+    protected transmissionSampler: import("@angular/core").Signal<boolean>;
+    protected transmission: import("@angular/core").Signal<Readonly<number | undefined>>;
+    protected thickness: import("@angular/core").Signal<Readonly<number | undefined>>;
+    protected side: import("@angular/core").Signal<0 | 1 | 2 | undefined>;
     materialRef: import("@angular/core").Signal<ElementRef<MeshTransmissionMaterial & {
         samples?: number | undefined;
         transmissionSampler?: boolean | undefined;
@@ -55,7 +55,7 @@ export declare class NgtsMeshTransmissionMaterial {
         thickness?: number | undefined;
         thicknessMap?: null | undefined;
         attenuationDistance?: number | undefined;
-        attenuationColor?: Color | undefined;
+        attenuationColor?: THREE.Color | undefined;
         anisotropicBlur?: number | undefined;
         time?: number | undefined;
         distortion?: number | undefined;
@@ -66,10 +66,10 @@ export declare class NgtsMeshTransmissionMaterial {
     private backResolution;
     private fboBack;
     private fboMain;
-    bufferTexture: import("@angular/core").Signal<Texture>;
-    anisotropicBlurOption: import("@angular/core").Signal<number | undefined>;
+    protected bufferTexture: import("@angular/core").Signal<THREE.Texture>;
+    protected anisotropicBlurOption: import("@angular/core").Signal<Readonly<number | undefined>>;
     private discardMaterial;
-    material: import("@angular/core").Signal<MeshTransmissionMaterial>;
+    protected material: import("@angular/core").Signal<MeshTransmissionMaterial>;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsMeshTransmissionMaterial, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtsMeshTransmissionMaterial, "ngts-mesh-transmission-material", never, { "attach": { "alias": "attach"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;

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

@@ -1,14 +1,14 @@
-import { NgtAttachable, NgtMeshStandardMaterial } from 'angular-three';
+import { NgtAttachable, NgtThreeElements } from 'angular-three';
 import { MeshWobbleMaterial, MeshWobbleMaterialParameters } from 'angular-three-soba/vanilla-exports';
 import * as i0 from "@angular/core";
-export interface NgtsMeshWobbleMaterialOptions extends MeshWobbleMaterialParameters, Partial<NgtMeshStandardMaterial> {
+export interface NgtsMeshWobbleMaterialOptions extends MeshWobbleMaterialParameters, Partial<NgtThreeElements['ngt-mesh-standard-material']> {
     speed: number;
 }
 export declare class NgtsMeshWobbleMaterial {
     attach: import("@angular/core").InputSignal<NgtAttachable>;
     options: import("@angular/core").InputSignalWithTransform<NgtsMeshWobbleMaterialOptions, "" | Partial<NgtsMeshWobbleMaterialOptions>>;
-    parameters: import("@angular/core").Signal<Omit<NgtsMeshWobbleMaterialOptions, "speed">>;
-    material: MeshWobbleMaterial;
+    protected parameters: import("@angular/core").Signal<Omit<NgtsMeshWobbleMaterialOptions, "speed">>;
+    protected material: MeshWobbleMaterial;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsMeshWobbleMaterial, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtsMeshWobbleMaterial, "ngts-mesh-wobble-material", never, { "attach": { "alias": "attach"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;

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

@@ -1,11 +1,11 @@
 import { NgtAttachable } from 'angular-three';
 import { PointMaterial } from 'angular-three-soba/shaders';
-import { PointsMaterialParameters } from 'three';
+import * as THREE from 'three';
 import * as i0 from "@angular/core";
 export declare class NgtsPointMaterial {
     attach: import("@angular/core").InputSignal<NgtAttachable>;
-    options: import("@angular/core").InputSignal<PointsMaterialParameters>;
-    material: PointMaterial;
+    options: import("@angular/core").InputSignal<THREE.PointsMaterialParameters>;
+    protected material: PointMaterial;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsPointMaterial, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtsPointMaterial, "ngts-point-material", never, { "attach": { "alias": "attach"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;

package/misc/lib/animations.d.ts

@@ -1,9 +1,9 @@
-import { ElementRef, Injector, Signal } from '@angular/core';
-import { AnimationAction, AnimationClip, AnimationMixer, Object3D } from 'three';
+import { ElementRef, Injector } from '@angular/core';
+import * as THREE from 'three';
 /**
  * name: any to allow consumers to pass in type-safe animation clips
  */
-type NgtsAnimationClipWithoutName = Omit<AnimationClip, 'name'> & {
+type NgtsAnimationClipWithoutName = Omit<THREE.AnimationClip, 'name'> & {
     name: any;
 };
 export type NgtsAnimationClip = Omit<NgtsAnimationClipWithoutName, 'clone'> & {
@@ -15,21 +15,21 @@ export type NgtsAnimationClips<TAnimationNames extends string> = {
     };
 }[TAnimationNames];
 export type NgtsAnimationApi<T extends NgtsAnimationClip> = {
-    /**
-     * Whether or not the animations finishes initialized
-     *
-     * @deprecated 3.5.0 - use `isReady` getter for better type-narrow instead. Will be removed in 4.0.0
-     */
-    ready: Signal<boolean>;
     clips: T[];
-    mixer: AnimationMixer;
+    mixer: THREE.AnimationMixer;
     names: T['name'][];
 } & ({
+    /**
+     * Whether or not the animations finishes initialized
+     */
     get isReady(): true;
     actions: {
-        [key in T['name']]: AnimationAction;
+        [key in T['name']]: THREE.AnimationAction;
     };
 } | {
+    /**
+     * Whether or not the animations finishes initialized
+     */
     get isReady(): false;
 });
 export type NgtsAnimation<TAnimation extends NgtsAnimationClip = NgtsAnimationClip> = TAnimation[] | {
@@ -38,7 +38,7 @@ export type NgtsAnimation<TAnimation extends NgtsAnimationClip = NgtsAnimationCl
 /**
  * Use afterNextRender
  */
-export declare function injectAnimations<TAnimation extends NgtsAnimationClip>(animations: () => NgtsAnimation<TAnimation> | undefined | null, object: ElementRef<Object3D> | Object3D | (() => ElementRef<Object3D> | Object3D | undefined | null), { injector }?: {
+export declare function injectAnimations<TAnimation extends NgtsAnimationClip>(animations: () => NgtsAnimation<TAnimation> | undefined | null, object: ElementRef<THREE.Object3D> | THREE.Object3D | (() => ElementRef<THREE.Object3D> | THREE.Object3D | undefined | null), { injector }?: {
     injector?: Injector;
 }): NgtsAnimationApi<TAnimation>;
 export {};

package/misc/lib/computed-attribute.d.ts

@@ -1,55 +1,12 @@
 import { ElementRef } from '@angular/core';
-import { BufferAttribute, BufferGeometry } from 'three';
+import * as THREE from 'three';
 import * as i0 from "@angular/core";
 export declare class NgtsComputedAttribute {
-    compute: import("@angular/core").InputSignal<(geometry: BufferGeometry) => BufferAttribute>;
+    compute: import("@angular/core").InputSignal<(geometry: THREE.BufferGeometry) => THREE.BufferAttribute>;
     name: import("@angular/core").InputSignal<string>;
-    options: import("@angular/core").InputSignal<Partial<import("angular-three").NgtExtendedColors<import("angular-three").NgtOverwrite<Partial<{
-        name: string;
-        clone: () => BufferAttribute;
-        toJSON: () => import("three").BufferAttributeJSON;
-        array: import("three").TypedArray;
-        itemSize: number;
-        usage: import("three").Usage;
-        gpuType: import("three").AttributeGPUType;
-        updateRanges: Array<{
-            start: number;
-            count: number;
-        }>;
-        version: number;
-        normalized: boolean;
-        readonly count: number;
-        needsUpdate: boolean;
-        readonly isBufferAttribute: true;
-        onUploadCallback: () => void;
-        onUpload: (callback: () => void) => BufferAttribute;
-        setUsage: (usage: import("three").Usage) => BufferAttribute;
-        addUpdateRange: (start: number, count: number) => void;
-        clearUpdateRanges: () => void;
-        copy: (source: BufferAttribute) => BufferAttribute;
-        copyAt: (index1: number, attribute: BufferAttribute, index2: number) => BufferAttribute;
-        copyArray: (array: ArrayLike<number>) => BufferAttribute;
-        applyMatrix3: (m: import("three").Matrix3) => BufferAttribute;
-        applyMatrix4: (m: import("three").Matrix4) => BufferAttribute;
-        applyNormalMatrix: (m: import("three").Matrix3) => BufferAttribute;
-        transformDirection: (m: import("three").Matrix4) => BufferAttribute;
-        set: (value: ArrayLike<number> | ArrayBufferView, offset?: number) => BufferAttribute;
-        getComponent: (index: number, component: number) => number;
-        setComponent: (index: number, component: number, value: number) => void;
-        getX: (index: number) => number;
-        setX: (index: number, x: number) => BufferAttribute;
-        getY: (index: number) => number;
-        setY: (index: number, y: number) => BufferAttribute;
-        getZ: (index: number) => number;
-        setZ: (index: number, z: number) => BufferAttribute;
-        getW: (index: number) => number;
-        setW: (index: number, z: number) => BufferAttribute;
-        setXY: (index: number, x: number, y: number) => BufferAttribute;
-        setXYZ: (index: number, x: number, y: number, z: number) => BufferAttribute;
-        setXYZW: (index: number, x: number, y: number, z: number, w: number) => BufferAttribute;
-    }>, import("angular-three").NgtNodeElement<BufferAttribute, typeof BufferAttribute>>>>>;
-    bufferAttribute: BufferAttribute;
-    attributeRef: import("@angular/core").Signal<ElementRef<BufferAttribute> | undefined>;
+    options: import("@angular/core").InputSignal<Partial<import("angular-three").NgtThreeElement<typeof THREE.BufferGeometry>>>;
+    protected bufferAttribute: THREE.BufferAttribute;
+    attributeRef: import("@angular/core").Signal<ElementRef<THREE.BufferAttribute> | undefined>;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsComputedAttribute, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtsComputedAttribute, "ngts-computed-attribute", never, { "compute": { "alias": "compute"; "required": true; "isSignal": true; }; "name": { "alias": "name"; "required": true; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;

package/misc/lib/decal.d.ts

@@ -1,20 +1,20 @@
 import { ElementRef } from '@angular/core';
-import { NgtMesh } from 'angular-three';
-import { Mesh, Texture } from 'three';
+import { NgtThreeElements } from 'angular-three';
+import * as THREE from 'three';
 import * as i0 from "@angular/core";
-export interface NgtsDecalOptions extends Partial<NgtMesh> {
+export interface NgtsDecalOptions extends Partial<NgtThreeElements['ngt-mesh']> {
     polygonOffsetFactor: number;
     depthTest: boolean;
     debug: boolean;
-    map?: Texture | null;
+    map?: THREE.Texture | null;
 }
 export declare class NgtsDecal {
-    mesh: import("@angular/core").InputSignal<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap> | ElementRef<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>> | null | undefined>;
+    mesh: import("@angular/core").InputSignal<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap> | ElementRef<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>> | null | undefined>;
     options: import("@angular/core").InputSignalWithTransform<NgtsDecalOptions, "" | Partial<NgtsDecalOptions>>;
-    parameters: import("@angular/core").Signal<Omit<NgtsDecalOptions, "position" | "scale" | "rotation" | "polygonOffsetFactor" | "depthTest" | "debug" | "map">>;
-    meshRef: import("@angular/core").Signal<ElementRef<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>>;
-    helperRef: import("@angular/core").Signal<ElementRef<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>> | undefined>;
-    protected map: import("@angular/core").Signal<Texture | null | undefined>;
+    protected parameters: import("@angular/core").Signal<Omit<NgtsDecalOptions, "debug" | "scale" | "map" | "position" | "rotation" | "depthTest" | "polygonOffsetFactor">>;
+    meshRef: import("@angular/core").Signal<ElementRef<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>>;
+    private helperRef;
+    protected map: import("@angular/core").Signal<THREE.Texture | null | undefined>;
     protected depthTest: import("@angular/core").Signal<boolean>;
     protected polygonOffsetFactor: import("@angular/core").Signal<number>;
     protected debug: import("@angular/core").Signal<boolean>;

package/misc/lib/deprecated.d.ts

@@ -1,8 +1,8 @@
-import { BufferAttribute } from 'three';
+import type * as THREE from 'three';
 /**
  * NOTE: Sets `BufferAttribute.updateRange` since r159.
  */
-export declare const setUpdateRange: (attribute: BufferAttribute, updateRange: {
+export declare const setUpdateRange: (attribute: THREE.BufferAttribute, updateRange: {
     offset: number;
     count: number;
 }) => void;

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

@@ -1,8 +1,8 @@
 import { Injector } from '@angular/core';
-import { DepthTexture } from 'three';
+import * as THREE from 'three';
 export declare function injectDepthBuffer(params?: () => {
     size?: number;
     frames?: number;
 }, { injector }?: {
     injector?: Injector;
-}): import("@angular/core").Signal<DepthTexture | null>;
+}): import("@angular/core").Signal<THREE.DepthTexture | null>;

package/misc/lib/fbo.d.ts

@@ -1,5 +1,5 @@
 import { Injector } from '@angular/core';
-import { ColorSpace, DepthTexture, MagnificationTextureFilter, MinificationTextureFilter, TextureDataType, WebGLRenderTarget, Wrapping } from 'three';
+import * as THREE from 'three';
 import { TextureEncoding } from './deprecated';
 import * as i0 from "@angular/core";
 interface FBOSettings {
@@ -7,19 +7,19 @@ interface FBOSettings {
     samples?: number;
     /** If set, the scene depth will be rendered into buffer.depthTexture. Default: false */
     depth?: boolean;
-    wrapS?: Wrapping | undefined;
-    wrapT?: Wrapping | undefined;
-    magFilter?: MagnificationTextureFilter | undefined;
-    minFilter?: MinificationTextureFilter | undefined;
+    wrapS?: THREE.Wrapping | undefined;
+    wrapT?: THREE.Wrapping | undefined;
+    magFilter?: THREE.MagnificationTextureFilter | undefined;
+    minFilter?: THREE.MinificationTextureFilter | undefined;
     format?: number | undefined;
-    type?: TextureDataType | undefined;
+    type?: THREE.TextureDataType | undefined;
     anisotropy?: number | undefined;
     depthBuffer?: boolean | undefined;
     stencilBuffer?: boolean | undefined;
     generateMipmaps?: boolean | undefined;
-    depthTexture?: DepthTexture | undefined;
+    depthTexture?: THREE.DepthTexture | undefined;
     encoding?: TextureEncoding | undefined;
-    colorSpace?: ColorSpace | undefined;
+    colorSpace?: THREE.ColorSpace | undefined;
 }
 export interface NgtsFBOParams {
     width?: number | FBOSettings;
@@ -28,7 +28,7 @@ export interface NgtsFBOParams {
 }
 export declare function injectFBO(params?: () => NgtsFBOParams, { injector }?: {
     injector?: Injector;
-}): import("@angular/core").Signal<WebGLRenderTarget<import("three").Texture>>;
+}): import("@angular/core").Signal<THREE.WebGLRenderTarget<THREE.Texture>>;
 export declare class NgtsFBO {
     fbo: import("@angular/core").InputSignal<{
         width: NgtsFBOParams["width"];

package/misc/lib/html/html-content.d.ts

@@ -21,15 +21,13 @@ export interface NgtsHTMLContentOptions {
 export declare class NgtsHTMLContent extends NgtHTML {
     options: import("@angular/core").InputSignalWithTransform<NgtsHTMLContentOptions, "" | Partial<NgtsHTMLContentOptions>>;
     occluded: import("@angular/core").OutputEmitterRef<boolean>;
-    html: NgtsHTML;
     transformOuterRef: import("@angular/core").Signal<ElementRef<HTMLDivElement> | undefined>;
     transformInnerRef: import("@angular/core").Signal<ElementRef<HTMLDivElement> | undefined>;
     containerRef: import("@angular/core").Signal<ElementRef<HTMLDivElement> | undefined>;
-    private gl;
-    private events;
-    private camera;
-    private scene;
-    protected size: import("@angular/core").Signal<import("angular-three").NgtSize>;
+    protected html: NgtsHTML;
+    private host;
+    private store;
+    protected size: import("angular-three").DeepSignal<import("angular-three").NgtSize>;
     private parent;
     private zIndexRange;
     private calculatePosition;
@@ -42,6 +40,6 @@ export declare class NgtsHTMLContent extends NgtHTML {
     private target;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsHTMLContent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsHTMLContent, "[ngtsHTMLContent]", never, { "options": { "alias": "ngtsHTMLContent"; "required": false; "isSignal": true; }; }, { "occluded": "occluded"; }, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsHTMLContent, "div[htmlContent]", never, { "options": { "alias": "htmlContent"; "required": false; "isSignal": true; }; }, { "occluded": "occluded"; }, never, ["*"], true, never>;
 }
 export {};