angular-three-soba 2.0.0 → 2.2.0

package/gizmos/README.md

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

package/gizmos/index.d.ts

@@ -0,0 +1,5 @@
+export * from './lib/gizmo-helper/gizmo-helper';
+export { NgtsGizmoViewcube, NgtsGizmoViewcubeOptions } from './lib/gizmo-helper/gizmo-viewcube';
+export { NgtsGizmoViewport, NgtsGizmoViewportOptions } from './lib/gizmo-helper/gizmo-viewport';
+export * from './lib/pivot-controls/pivot-controls';
+export * from './lib/transform-controls';

package/gizmos/lib/gizmo-helper/gizmo-helper.d.ts

@@ -0,0 +1,45 @@
+import { Signal, TemplateRef } from '@angular/core';
+import { Object3D, Scene, Vector3 } from 'three';
+import * as i0 from "@angular/core";
+export declare class NgtsGizmoHelperContent {
+    static ngTemplateContextGuard(_: NgtsGizmoHelperContent, ctx: unknown): ctx is {
+        container: Object3D;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGizmoHelperContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsGizmoHelperContent, "ng-template[gizmoHelperContent]", never, {}, {}, never, never, true, never>;
+}
+export interface NgtsGizmoHelperOptions {
+    alignment: 'top-left' | 'top-right' | 'bottom-right' | 'bottom-left' | 'bottom-center' | 'center-right' | 'center-left' | 'center-center' | 'top-center';
+    margin: [number, number];
+    renderPriority: number;
+    autoClear?: boolean;
+}
+export declare class NgtsGizmoHelper {
+    options: import("@angular/core").InputSignalWithTransform<NgtsGizmoHelperOptions, "" | Partial<NgtsGizmoHelperOptions>>;
+    update: import("@angular/core").OutputEmitterRef<void>;
+    protected renderPriority: Signal<number>;
+    protected margin: Signal<[number, number]>;
+    protected alignment: Signal<"top-left" | "top-right" | "bottom-right" | "bottom-left" | "bottom-center" | "center-right" | "center-left" | "center-center" | "top-center">;
+    protected scene: Scene;
+    protected content: Signal<TemplateRef<any>>;
+    private gizmoRef;
+    private virtualCameraRef;
+    private store;
+    private size;
+    private mainCamera;
+    private defaultControls;
+    private invalidate;
+    protected x: Signal<number>;
+    protected y: Signal<number>;
+    private animating;
+    private radius;
+    private focusPoint;
+    private defaultUp;
+    constructor();
+    tweenCamera(direction: Vector3): void;
+    private updateDefaultUpEffect;
+    private isOrbitControls;
+    private isCameraControls;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGizmoHelper, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsGizmoHelper, "ngts-gizmo-helper", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, { "update": "update"; }, ["content"], never, true, never>;
+}

package/gizmos/lib/gizmo-helper/gizmo-viewcube.d.ts

@@ -0,0 +1,74 @@
+import { NgtThreeEvent } from 'angular-three';
+import { CanvasTexture, Vector3 } from 'three';
+import * as i0 from "@angular/core";
+type XYZ = [number, number, number];
+interface CommonOptions {
+    font: string;
+    opacity: number;
+    color: string;
+    hoverColor: string;
+    textColor: string;
+    strokeColor: string;
+    faces: string[];
+}
+export declare class FaceMaterial {
+    hover: import("@angular/core").InputSignal<boolean>;
+    index: import("@angular/core").InputSignal<number>;
+    options: import("@angular/core").InputSignalWithTransform<CommonOptions, "" | Partial<CommonOptions>>;
+    private faces;
+    private font;
+    private color;
+    private textColor;
+    private strokeColor;
+    private hoverColor;
+    private document;
+    private store;
+    private gl;
+    protected opacity: import("@angular/core").Signal<number>;
+    protected materialColor: import("@angular/core").Signal<string>;
+    protected texture: import("@angular/core").Signal<CanvasTexture>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<FaceMaterial, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FaceMaterial, "viewcube-face-material", never, { "hover": { "alias": "hover"; "required": true; "isSignal": true; }; "index": { "alias": "index"; "required": true; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export declare class FaceCube {
+    options: import("@angular/core").InputSignal<Partial<CommonOptions>>;
+    onClick: import("@angular/core").InputSignal<((event: NgtThreeEvent<MouseEvent>) => void) | undefined>;
+    private gizmoHelper;
+    protected hover: import("@angular/core").WritableSignal<number>;
+    protected count: unknown[];
+    constructor();
+    internalOnClick(event: NgtThreeEvent<MouseEvent>): void;
+    protected readonly Math: Math;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FaceCube, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FaceCube, "viewcube-face-cube", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "onClick": { "alias": "onClick"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export declare class EdgeCube {
+    dimensions: import("@angular/core").InputSignal<XYZ>;
+    position: import("@angular/core").InputSignal<Vector3>;
+    hoverColor: import("@angular/core").InputSignalWithTransform<string, string | undefined>;
+    onClick: import("@angular/core").InputSignal<((event: NgtThreeEvent<MouseEvent>) => void) | undefined>;
+    private gizmoHelper;
+    protected hover: import("@angular/core").WritableSignal<boolean>;
+    protected color: import("@angular/core").Signal<string>;
+    constructor();
+    internalOnClick(event: NgtThreeEvent<MouseEvent>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EdgeCube, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EdgeCube, "viewcube-edge-cube", never, { "dimensions": { "alias": "dimensions"; "required": true; "isSignal": true; }; "position": { "alias": "position"; "required": true; "isSignal": true; }; "hoverColor": { "alias": "hoverColor"; "required": false; "isSignal": true; }; "onClick": { "alias": "onClick"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export type NgtsGizmoViewcubeOptions = Partial<CommonOptions>;
+export declare class NgtsGizmoViewcube {
+    options: import("@angular/core").InputSignal<Partial<CommonOptions>>;
+    click: import("@angular/core").OutputEmitterRef<NgtThreeEvent<MouseEvent>>;
+    protected hoverColor: import("@angular/core").Signal<string | undefined>;
+    protected corners: Vector3[];
+    protected cornerDimensions: XYZ;
+    protected edges: Vector3[];
+    protected edgeDimensions: XYZ[];
+    constructor();
+    protected get onClick(): ((value: NgtThreeEvent<MouseEvent>) => void) | undefined;
+    private makePositionVector;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGizmoViewcube, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsGizmoViewcube, "ngts-gizmo-viewcube", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, { "click": "click"; }, never, never, true, never>;
+}
+export {};

package/gizmos/lib/gizmo-helper/gizmo-viewport.d.ts

@@ -0,0 +1,64 @@
+import { NgtGroup, NgtThreeEvent, NgtVector3 } from 'angular-three';
+import { CanvasTexture, ColorRepresentation } from 'three';
+import * as i0 from "@angular/core";
+export declare class Axis {
+    scale: import("@angular/core").InputSignalWithTransform<number[], [number, number, number] | undefined>;
+    color: import("@angular/core").InputSignal<ColorRepresentation | undefined>;
+    rotation: import("@angular/core").InputSignal<NgtVector3>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<Axis, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Axis, "viewport-axis", never, { "scale": { "alias": "scale"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "rotation": { "alias": "rotation"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export declare class AxisHead {
+    arcStyle: import("@angular/core").InputSignal<string>;
+    position: import("@angular/core").InputSignal<NgtVector3>;
+    label: import("@angular/core").InputSignal<string | undefined>;
+    labelColor: import("@angular/core").InputSignal<string>;
+    axisHeadScale: import("@angular/core").InputSignal<number>;
+    disabled: import("@angular/core").InputSignal<boolean>;
+    font: import("@angular/core").InputSignal<string>;
+    onClick: import("@angular/core").InputSignal<((event: NgtThreeEvent<MouseEvent>) => void) | undefined>;
+    private document;
+    private gizmoHelper;
+    private store;
+    private gl;
+    protected texture: import("@angular/core").Signal<CanvasTexture>;
+    protected active: import("@angular/core").WritableSignal<boolean>;
+    protected scale: import("@angular/core").Signal<number>;
+    constructor();
+    onPointerOver(event: NgtThreeEvent<PointerEvent>): void;
+    onPointerOut(event: NgtThreeEvent<PointerEvent>): void;
+    onPointerDown(event: NgtThreeEvent<PointerEvent>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AxisHead, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AxisHead, "viewport-axis-head", never, { "arcStyle": { "alias": "arcStyle"; "required": true; "isSignal": true; }; "position": { "alias": "position"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelColor": { "alias": "labelColor"; "required": false; "isSignal": true; }; "axisHeadScale": { "alias": "axisHeadScale"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "font": { "alias": "font"; "required": false; "isSignal": true; }; "onClick": { "alias": "onClick"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export interface NgtsGizmoViewportOptions extends Partial<NgtGroup> {
+    axisColors: [string, string, string];
+    axisScale?: [number, number, number];
+    labels: [string, string, string];
+    axisHeadScale: number;
+    labelColor: string;
+    hideNegativeAxes: boolean;
+    hideAxisHeads: boolean;
+    disabled: boolean;
+    font: string;
+}
+export declare class NgtsGizmoViewport {
+    protected readonly Math: Math;
+    options: import("@angular/core").InputSignalWithTransform<NgtsGizmoViewportOptions, "" | Partial<NgtsGizmoViewportOptions>>;
+    parameters: import("@angular/core").Signal<Omit<NgtsGizmoViewportOptions, "font" | "axisColors" | "axisScale" | "labels" | "axisHeadScale" | "labelColor" | "hideNegativeAxes" | "hideAxisHeads" | "disabled">>;
+    click: import("@angular/core").OutputEmitterRef<NgtThreeEvent<MouseEvent>>;
+    protected axisColors: import("@angular/core").Signal<[string, string, string]>;
+    protected axisScale: import("@angular/core").Signal<[number, number, number] | undefined>;
+    protected hideAxisHeads: import("@angular/core").Signal<boolean>;
+    protected hideNegativeAxes: import("@angular/core").Signal<boolean>;
+    protected labels: import("@angular/core").Signal<[string, string, string]>;
+    protected axisHeadScale: import("@angular/core").Signal<number>;
+    protected labelColor: import("@angular/core").Signal<string>;
+    protected disabled: import("@angular/core").Signal<boolean>;
+    protected font: import("@angular/core").Signal<string>;
+    constructor();
+    protected get onClick(): ((value: NgtThreeEvent<MouseEvent>) => void) | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGizmoViewport, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsGizmoViewport, "ngts-gizmo-viewport", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, { "click": "click"; }, never, never, true, never>;
+}

package/{controls → gizmos}/lib/pivot-controls/pivot-controls.d.ts

@@ -60,7 +60,7 @@ export interface NgtsPivotControlsOptions {
 }
 export declare class NgtsPivotControls {
     options: import("@angular/core").InputSignalWithTransform<NgtsPivotControlsOptions, "" | Partial<NgtsPivotControlsOptions>>;
-    parameters: import("@angular/core").Signal<Omit<NgtsPivotControlsOptions, "enabled" | "hoveredColor" | "scale" | "lineWidth" | "fixed" | "offset" | "rotation" | "matrix" | "anchor" | "autoTransform" | "activeAxes" | "disableAxes" | "disableSliders" | "disableRotations" | "disableScaling" | "translationLimits" | "rotationLimits" | "scaleLimits" | "axisColors" | "annotations" | "annotationsClass" | "depthTest" | "opacity" | "visible" | "userData">>;
+    parameters: import("@angular/core").Signal<Omit<NgtsPivotControlsOptions, "opacity" | "scale" | "rotation" | "matrix" | "visible" | "userData" | "axisColors" | "hoveredColor" | "enabled" | "lineWidth" | "fixed" | "offset" | "anchor" | "autoTransform" | "activeAxes" | "disableAxes" | "disableSliders" | "disableRotations" | "disableScaling" | "translationLimits" | "rotationLimits" | "scaleLimits" | "annotations" | "annotationsClass" | "depthTest">>;
     dragStarted: import("@angular/core").OutputEmitterRef<OnDragStartParameters>;
     dragEnded: import("@angular/core").OutputEmitterRef<void>;
     dragged: import("@angular/core").OutputEmitterRef<OnDragParameters>;

package/gizmos/lib/transform-controls.d.ts

@@ -0,0 +1,50 @@
+import { ElementRef, Signal } from '@angular/core';
+import { NgtGroup, NgtObject3DNode } from 'angular-three';
+import { Camera, Object3D, Event as ThreeEvent } from 'three';
+import { TransformControls } from 'three-stdlib';
+import * as i0 from "@angular/core";
+export type NgtsTransformControlsObject = NgtObject3DNode<TransformControls, typeof TransformControls>;
+export type NgtsTransformControlsOptions = Partial<NgtsTransformControlsObject> & Partial<NgtGroup> & {
+    enabled?: boolean;
+    axis?: string | null;
+    domElement?: HTMLElement;
+    mode?: 'translate' | 'rotate' | 'scale';
+    translationSnap?: number | null;
+    rotationSnap?: number | null;
+    scaleSnap?: number | null;
+    space?: 'world' | 'local';
+    size?: number;
+    showX?: boolean;
+    showY?: boolean;
+    showZ?: boolean;
+    camera?: Camera;
+    makeDefault?: boolean;
+};
+export declare class NgtsTransformControls {
+    object: import("@angular/core").InputSignal<Object3D<import("three").Object3DEventMap> | ElementRef<Object3D<import("three").Object3DEventMap>> | null | undefined>;
+    options: import("@angular/core").InputSignal<Partial<NgtsTransformControlsOptions>>;
+    parameters: Signal<Omit<Partial<NgtsTransformControlsOptions>, "size" | "camera" | "enabled" | "axis" | "domElement" | "mode" | "translationSnap" | "rotationSnap" | "scaleSnap" | "space" | "showX" | "showY" | "showZ" | "makeDefault">>;
+    protected controlsOptions: Signal<Pick<Partial<NgtsTransformControlsOptions>, "size" | "enabled" | "axis" | "mode" | "translationSnap" | "rotationSnap" | "scaleSnap" | "space" | "showX" | "showY" | "showZ">>;
+    private camera;
+    private domElement;
+    private makeDefault;
+    change: import("@angular/core").OutputEmitterRef<ThreeEvent<string, unknown>>;
+    mouseDown: import("@angular/core").OutputEmitterRef<ThreeEvent<string, unknown>>;
+    mouseUp: import("@angular/core").OutputEmitterRef<ThreeEvent<string, unknown>>;
+    objectChange: import("@angular/core").OutputEmitterRef<ThreeEvent<string, unknown>>;
+    private groupRef;
+    private store;
+    private glDomElement;
+    private defaultCamera;
+    private events;
+    private defaultControls;
+    private invalidate;
+    controls: Signal<TransformControls<Camera>>;
+    constructor();
+    private attachControlsEffect;
+    private disableDefaultControlsEffect;
+    private setupControlsEventsEffect;
+    private updateDefaultControlsEffect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsTransformControls, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsTransformControls, "ngts-transform-controls", never, { "object": { "alias": "object"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, { "change": "change"; "mouseDown": "mouseDown"; "mouseUp": "mouseUp"; "objectChange": "objectChange"; }, never, ["*"], true, never>;
+}

package/materials/lib/custom-shader-material.d.ts

@@ -4,11 +4,11 @@ import { Material } from 'three';
 import CustomShaderMaterial from 'three-custom-shader-material/vanilla';
 import * as i0 from "@angular/core";
 export declare class NgtsCustomShaderMaterial {
-    baseMaterial: import("@angular/core").InputSignal<Material | typeof Material | ElementRef<Material>>;
+    baseMaterial: import("@angular/core").InputSignal<typeof Material | Material | ElementRef<Material>>;
     attach: import("@angular/core").InputSignal<NgtAttachable>;
     options: import("@angular/core").InputSignal<Omit<import("three-custom-shader-material/vanilla").iCSMParams<import("three-custom-shader-material/vanilla").MaterialConstructor>, "baseMaterial">>;
-    parameters: import("@angular/core").Signal<Omit<Omit<import("three-custom-shader-material/vanilla").iCSMParams<import("three-custom-shader-material/vanilla").MaterialConstructor>, "baseMaterial">, "vertexShader" | "fragmentShader" | "cacheKey" | "uniforms">>;
-    base: import("@angular/core").Signal<Material | typeof Material>;
+    parameters: import("@angular/core").Signal<Omit<Omit<import("three-custom-shader-material/vanilla").iCSMParams<import("three-custom-shader-material/vanilla").MaterialConstructor>, "baseMaterial">, "uniforms" | "vertexShader" | "fragmentShader" | "cacheKey">>;
+    base: import("@angular/core").Signal<typeof Material | Material>;
     private fragmentShader;
     private vertexShader;
     private uniforms;

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

@@ -20,11 +20,11 @@ export declare class NgtsMeshRefractionMaterial {
     envMap: import("@angular/core").InputSignal<Texture | CubeTexture>;
     attach: import("@angular/core").InputSignal<NgtAttachable>;
     options: import("@angular/core").InputSignalWithTransform<NgtsMeshRefractionMaterialOptions, "" | Partial<NgtsMeshRefractionMaterialOptions>>;
-    parameters: import("@angular/core").Signal<Omit<NgtsMeshRefractionMaterialOptions, "aberrationStrength" | "fastChroma">>;
+    parameters: import("@angular/core").Signal<Omit<NgtsMeshRefractionMaterialOptions, "fastChroma" | "aberrationStrength">>;
     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").Matrix4 | import("three").Vector4 | import("three").Quaternion | import("three").Matrix3 | CubeTexture | Int32Array | Float32Array | import("three").Vector2 | null;
+        [name: string]: number | boolean | any[] | import("three").Color | Texture | CubeTexture | Int32Array | Float32Array | import("three").Matrix4 | import("three").Matrix3 | import("three").Quaternion | import("three").Vector4 | import("three").Vector3 | import("three").Vector2 | null;
     }> | undefined>;
     private store;
     private size;
@@ -34,7 +34,7 @@ export declare class NgtsMeshRefractionMaterial {
     }>;
     private defineKeys;
     material: import("@angular/core").Signal<import("three").ShaderMaterial & {
-        [name: string]: number | boolean | any[] | import("three").Color | Texture | import("three").Vector3 | import("three").Matrix4 | import("three").Vector4 | import("three").Quaternion | import("three").Matrix3 | CubeTexture | Int32Array | Float32Array | import("three").Vector2 | null;
+        [name: string]: number | boolean | any[] | import("three").Color | Texture | CubeTexture | Int32Array | Float32Array | import("three").Matrix4 | import("three").Matrix3 | import("three").Quaternion | import("three").Vector4 | import("three").Vector3 | import("three").Vector2 | null;
     }>;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsMeshRefractionMaterial, never>;

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

@@ -29,7 +29,7 @@ export type NgtsMeshTransmissionMaterialOptions = Partial<NgtMeshPhysicalMateria
 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, "side" | "thickness" | "anisotropy" | "transmission" | "resolution" | "buffer" | "anisotropicBlur" | "samples" | "transmissionSampler" | "backside" | "backsideThickness" | "backsideEnvMapIntensity" | "backsideResolution" | "background">>;
+    parameters: import("@angular/core").Signal<Omit<NgtsMeshTransmissionMaterialOptions, "side" | "thickness" | "anisotropy" | "transmission" | "buffer" | "anisotropicBlur" | "samples" | "transmissionSampler" | "backside" | "backsideThickness" | "backsideEnvMapIntensity" | "resolution" | "backsideResolution" | "background">>;
     private resolution;
     private backsideResolution;
     private samples;

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

@@ -5,9 +5,13 @@ export declare class NgtsComputedAttribute {
     compute: import("@angular/core").InputSignal<(geometry: BufferGeometry) => BufferAttribute>;
     name: import("@angular/core").InputSignal<string>;
     options: import("@angular/core").InputSignal<Partial<{
+        set?: ((value: ArrayLike<number> | ArrayBufferView, offset?: number) => BufferAttribute) | undefined;
         name?: string | undefined;
-        clone?: (() => BufferAttribute) | undefined;
+        applyMatrix4?: ((m: import("three").Matrix4) => BufferAttribute) | undefined;
         toJSON?: (() => import("three").BufferAttributeJSON) | undefined;
+        clone?: (() => BufferAttribute) | undefined;
+        copy?: ((source: BufferAttribute) => BufferAttribute) | undefined;
+        readonly count?: number | undefined;
         array?: import("three").TypedArray | undefined;
         itemSize?: number | undefined;
         usage?: import("three").Usage | undefined;
@@ -22,7 +26,6 @@ export declare class NgtsComputedAttribute {
         }[] | undefined;
         version?: number | undefined;
         normalized?: boolean | undefined;
-        readonly count?: number | undefined;
         needsUpdate?: boolean | undefined;
         readonly isBufferAttribute?: true | undefined;
         onUploadCallback?: (() => void) | undefined;
@@ -30,14 +33,11 @@ export declare class NgtsComputedAttribute {
         setUsage?: ((usage: import("three").Usage) => BufferAttribute) | undefined;
         addUpdateRange?: ((start: number, count: number) => void) | undefined;
         clearUpdateRanges?: (() => void) | undefined;
-        copy?: ((source: BufferAttribute) => BufferAttribute) | undefined;
         copyAt?: ((index1: number, attribute: BufferAttribute, index2: number) => BufferAttribute) | undefined;
         copyArray?: ((array: ArrayLike<number>) => BufferAttribute) | undefined;
         applyMatrix3?: ((m: import("three").Matrix3) => BufferAttribute) | undefined;
-        applyMatrix4?: ((m: import("three").Matrix4) => BufferAttribute) | undefined;
         applyNormalMatrix?: ((m: import("three").Matrix3) => BufferAttribute) | undefined;
         transformDirection?: ((m: import("three").Matrix4) => BufferAttribute) | undefined;
-        set?: ((value: ArrayLike<number> | ArrayBufferView, offset?: number) => BufferAttribute) | undefined;
         getComponent?: ((index: number, component: number) => number) | undefined;
         setComponent?: ((index: number, component: number, value: number) => void) | undefined;
         getX?: ((index: number) => number) | undefined;

package/misc/lib/decal.d.ts

@@ -11,7 +11,7 @@ export interface NgtsDecalOptions extends Partial<NgtMesh> {
 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>;
     options: import("@angular/core").InputSignalWithTransform<NgtsDecalOptions, "" | Partial<NgtsDecalOptions>>;
-    parameters: import("@angular/core").Signal<Omit<NgtsDecalOptions, "position" | "scale" | "rotation" | "polygonOffsetFactor" | "depthTest" | "debug" | "map">>;
+    parameters: import("@angular/core").Signal<Omit<NgtsDecalOptions, "position" | "scale" | "rotation" | "debug" | "map" | "depthTest" | "polygonOffsetFactor">>;
     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>;
     map: import("@angular/core").Signal<Texture | null | undefined>;

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

@@ -14,7 +14,7 @@ export declare class NgtsHTML {
     groupRef: import("@angular/core").Signal<ElementRef<Group<import("three").Object3DEventMap>>>;
     occlusionMeshRef: import("@angular/core").Signal<ElementRef<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>> | undefined>;
     occlusionGeometryRef: import("@angular/core").Signal<ElementRef<PlaneGeometry> | undefined>;
-    occlude: import("@angular/core").Signal<boolean | "raycast" | Object3D<import("three").Object3DEventMap>[] | ElementRef<Object3D<import("three").Object3DEventMap>>[] | "blending">;
+    occlude: import("@angular/core").Signal<boolean | "raycast" | ElementRef<Object3D<import("three").Object3DEventMap>>[] | Object3D<import("three").Object3DEventMap>[] | "blending">;
     transform: import("@angular/core").Signal<boolean>;
     castShadow: import("@angular/core").Signal<boolean>;
     receiveShadow: import("@angular/core").Signal<boolean>;

package/misc/lib/sampler.d.ts

@@ -62,7 +62,7 @@ export declare class NgtsSampler {
     mesh: import("@angular/core").InputSignal<Mesh<BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap> | ElementRef<Mesh<BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>> | null>;
     instances: import("@angular/core").InputSignal<InstancedMesh<BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").InstancedMeshEventMap> | ElementRef<InstancedMesh<BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").InstancedMeshEventMap>> | null>;
     options: import("@angular/core").InputSignalWithTransform<NgtsSamplerOptions, "" | Partial<NgtsSamplerOptions>>;
-    parameters: import("@angular/core").Signal<Omit<NgtsSamplerOptions, "count" | "transform" | "weight">>;
+    parameters: import("@angular/core").Signal<Omit<NgtsSamplerOptions, "transform" | "weight" | "count">>;
     groupRef: import("@angular/core").Signal<ElementRef<Group<import("three").Object3DEventMap>>>;
     private meshToSample;
     private instancedToSample;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "angular-three-soba",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "publishConfig": {
     "access": "public"
   },
@@ -57,17 +57,23 @@
       "esm": "./esm2022/angular-three-soba.mjs",
       "default": "./fesm2022/angular-three-soba.mjs"
     },
+    "./abstractions": {
+      "types": "./abstractions/index.d.ts",
+      "esm2022": "./esm2022/abstractions/angular-three-soba-abstractions.mjs",
+      "esm": "./esm2022/abstractions/angular-three-soba-abstractions.mjs",
+      "default": "./fesm2022/angular-three-soba-abstractions.mjs"
+    },
     "./cameras": {
       "types": "./cameras/index.d.ts",
       "esm2022": "./esm2022/cameras/angular-three-soba-cameras.mjs",
       "esm": "./esm2022/cameras/angular-three-soba-cameras.mjs",
       "default": "./fesm2022/angular-three-soba-cameras.mjs"
     },
-    "./abstractions": {
-      "types": "./abstractions/index.d.ts",
-      "esm2022": "./esm2022/abstractions/angular-three-soba-abstractions.mjs",
-      "esm": "./esm2022/abstractions/angular-three-soba-abstractions.mjs",
-      "default": "./fesm2022/angular-three-soba-abstractions.mjs"
+    "./controls": {
+      "types": "./controls/index.d.ts",
+      "esm2022": "./esm2022/controls/angular-three-soba-controls.mjs",
+      "esm": "./esm2022/controls/angular-three-soba-controls.mjs",
+      "default": "./fesm2022/angular-three-soba-controls.mjs"
     },
     "./materials": {
       "types": "./materials/index.d.ts",
@@ -81,18 +87,18 @@
       "esm": "./esm2022/performances/angular-three-soba-performances.mjs",
       "default": "./fesm2022/angular-three-soba-performances.mjs"
     },
-    "./controls": {
-      "types": "./controls/index.d.ts",
-      "esm2022": "./esm2022/controls/angular-three-soba-controls.mjs",
-      "esm": "./esm2022/controls/angular-three-soba-controls.mjs",
-      "default": "./fesm2022/angular-three-soba-controls.mjs"
-    },
     "./staging": {
       "types": "./staging/index.d.ts",
       "esm2022": "./esm2022/staging/angular-three-soba-staging.mjs",
       "esm": "./esm2022/staging/angular-three-soba-staging.mjs",
       "default": "./fesm2022/angular-three-soba-staging.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"
+    },
     "./stats": {
       "types": "./stats/index.d.ts",
       "esm2022": "./esm2022/stats/angular-three-soba-stats.mjs",

package/performances/lib/instances/instances.d.ts

@@ -5,16 +5,21 @@ import { PositionMesh } from './position-mesh';
 import * as i0 from "@angular/core";
 export declare class NgtsInstance {
     options: import("@angular/core").InputSignal<Partial<{
+        color?: import("three").ColorRepresentation | undefined;
+        name?: string | undefined;
+        visible?: boolean | undefined;
+        userData?: Record<string, any> | undefined;
         attach: string | string[] | import("angular-three").NgtAttachFunction;
         addEventListener: (<TEventKey extends keyof import("angular-three").NgtNodeEventMap<PositionMesh>>(type: TEventKey, listener: (this: import("angular-three").NgtNodeElement<PositionMesh, typeof PositionMesh>, ev: import("angular-three").NgtNodeEventMap<PositionMesh>[TEventKey]) => any) => void) & (<TEventKey extends keyof import("angular-three").NgtAllObject3DEventsMap>(type: TEventKey, listener: (this: any, ev: import("angular-three").NgtAllObject3DEventsMap[TEventKey]) => any) => void);
         removeEventListener: (<TEventKey extends keyof import("angular-three").NgtNodeEventMap<PositionMesh>>(type: TEventKey, listener: (this: import("angular-three").NgtNodeElement<PositionMesh, typeof PositionMesh>, ev: import("angular-three").NgtNodeEventMap<PositionMesh>[TEventKey]) => any) => void) & (<TEventKey extends keyof import("angular-three").NgtAllObject3DEventsMap>(type: TEventKey, listener: (this: any, ev: import("angular-three").NgtAllObject3DEventsMap[TEventKey]) => any) => void);
         __ngt_args__: [];
+        instance?: ElementRef<InstancedMesh> | InstancedMesh | null | undefined;
+        readonly geometry?: import("three").BufferGeometry<import("three").NormalBufferAttributes> | undefined;
+        readonly isGroup?: true | undefined;
         readonly type?: string | undefined;
-        toJSON?: ((meta?: import("three").JSONMeta) => import("three").Object3DJSON) | undefined;
         readonly isObject3D?: true | undefined;
         readonly id?: number | undefined;
         uuid?: string | undefined;
-        name?: string | undefined;
         parent?: import("three").Object3D<import("three").Object3DEventMap> | null | undefined;
         children?: import("three").Object3D<import("three").Object3DEventMap>[] | undefined;
         readonly modelViewMatrix?: Matrix4 | undefined;
@@ -23,13 +28,11 @@ export declare class NgtsInstance {
         matrixAutoUpdate?: boolean | undefined;
         matrixWorldAutoUpdate?: boolean | undefined;
         matrixWorldNeedsUpdate?: boolean | undefined;
-        visible?: boolean | undefined;
         castShadow?: boolean | undefined;
         receiveShadow?: boolean | undefined;
         frustumCulled?: boolean | undefined;
         renderOrder?: number | undefined;
         animations?: import("three").AnimationClip[] | undefined;
-        userData?: Record<string, any> | undefined;
         customDepthMaterial?: import("three").Material | undefined;
         customDistanceMaterial?: import("three").Material | undefined;
         onBeforeShadow?: ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, shadowCamera: import("three").Camera, geometry: import("three").BufferGeometry, depthMaterial: import("three").Material, group: import("three").Group) => void) | undefined;
@@ -75,14 +78,11 @@ export declare class NgtsInstance {
         updateMatrix?: (() => void) | undefined;
         updateMatrixWorld?: ((force?: boolean) => void) | undefined;
         updateWorldMatrix?: ((updateParents: boolean, updateChildren: boolean) => void) | undefined;
+        toJSON?: ((meta?: import("three").JSONMeta) => import("three").Object3DJSON) | undefined;
         clone?: ((recursive?: boolean) => PositionMesh) | undefined;
         copy?: ((object: import("three").Object3D, recursive?: boolean) => PositionMesh) | undefined;
         hasEventListener?: (<T extends keyof import("three").Object3DEventMap>(type: T, listener: import("three").EventListener<import("three").Object3DEventMap[T], T, PositionMesh>) => boolean) | undefined;
         dispatchEvent?: (<T extends keyof import("three").Object3DEventMap>(event: import("three").BaseEvent<T> & import("three").Object3DEventMap[T]) => void) | undefined;
-        color?: import("three").ColorRepresentation | undefined;
-        instance?: ElementRef<InstancedMesh> | InstancedMesh | null | undefined;
-        readonly geometry?: import("three").BufferGeometry<import("three").NormalBufferAttributes> | undefined;
-        readonly isGroup?: true | undefined;
         position: import("angular-three").NgtVector3;
         up: import("angular-three").NgtVector3;
         scale: import("angular-three").NgtVector3;
@@ -107,7 +107,7 @@ export interface NgtsInstancesOptions extends Partial<NgtInstancedMesh> {
 export declare class NgtsInstances {
     protected readonly DynamicDrawUsage: 35048;
     options: import("@angular/core").InputSignalWithTransform<NgtsInstancesOptions, "" | Partial<NgtsInstancesOptions>>;
-    parameters: import("@angular/core").Signal<Omit<NgtsInstancesOptions, "frames" | "range" | "limit">>;
+    parameters: import("@angular/core").Signal<Omit<NgtsInstancesOptions, "limit" | "range" | "frames">>;
     instancedMeshRef: import("@angular/core").Signal<ElementRef<InstancedMesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").InstancedMeshEventMap>>>;
     limit: import("@angular/core").Signal<number>;
     buffers: import("@angular/core").Signal<{