angular-three-soba 2.0.0-beta.8 → 2.0.0

package/performances/lib/points/position-point.d.ts

@@ -0,0 +1,21 @@
+import { ElementRef } from '@angular/core';
+import { NgtObject3DNode } from 'angular-three';
+import { Color, Group, Intersection, Points, Raycaster } from 'three';
+export type NgtPositionPoint = NgtObject3DNode<PositionPoint, typeof PositionPoint>;
+export declare class PositionPoint extends Group {
+    size: number;
+    color: Color;
+    instance: ElementRef<Points> | Points | null | undefined;
+    constructor();
+    get geometry(): import("three").BufferGeometry<import("three").NormalBufferAttributes> | undefined;
+    raycast(raycaster: Raycaster, intersects: Intersection[]): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-group
+         * @rawOptions instance|color|size
+         */
+        'ngt-position-point': NgtPositionPoint;
+    }
+}

package/performances/lib/segments/segment-object.d.ts

@@ -0,0 +1,17 @@
+import { NgtNode } from 'angular-three';
+import { Color, Vector3 } from 'three';
+export type NgtSegmentObject = NgtNode<SegmentObject, typeof SegmentObject>;
+export declare class SegmentObject {
+    color: Color;
+    start: Vector3;
+    end: Vector3;
+    constructor();
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @rawOptions start|color|end
+         */
+        'ngt-segment-object': NgtSegmentObject;
+    }
+}

package/performances/lib/segments/segments.d.ts

@@ -0,0 +1,97 @@
+import { ElementRef } from '@angular/core';
+import { NgtVector3 } from 'angular-three';
+import { ColorRepresentation, Vector2 } from 'three';
+import { Line2, LineMaterial, LineMaterialParameters, LineSegmentsGeometry } from 'three-stdlib';
+import { SegmentObject } from './segment-object';
+import * as i0 from "@angular/core";
+export declare class NgtsSegment {
+    start: import("@angular/core").InputSignal<NgtVector3>;
+    end: import("@angular/core").InputSignal<NgtVector3>;
+    color: import("@angular/core").InputSignal<ColorRepresentation | undefined>;
+    normalizedStart: import("@angular/core").Signal<import("three").Vector3>;
+    normalizedEnd: import("@angular/core").Signal<import("three").Vector3>;
+    segmentRef: import("@angular/core").Signal<ElementRef<SegmentObject>>;
+    segments: NgtsSegments;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSegment, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSegment, "ngts-segment", never, { "start": { "alias": "start"; "required": true; "isSignal": true; }; "end": { "alias": "end"; "required": true; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export interface NgtsSegmentsOptions extends LineMaterialParameters {
+    limit: number;
+    lineWidth: number;
+}
+export declare class NgtsSegments {
+    options: import("@angular/core").InputSignalWithTransform<NgtsSegmentsOptions, "" | Partial<NgtsSegmentsOptions>>;
+    parameters: import("@angular/core").Signal<Omit<NgtsSegmentsOptions, "limit" | "lineWidth">>;
+    private lineWidth;
+    private limit;
+    lineRef: import("@angular/core").Signal<ElementRef<Line2> | undefined>;
+    segments: Array<ElementRef<SegmentObject> | SegmentObject>;
+    line: Line2;
+    material: LineMaterial;
+    geometry: LineSegmentsGeometry;
+    resolution: Vector2;
+    materialParameters: import("@angular/core").Signal<{
+        name?: string | undefined;
+        visible?: boolean | undefined;
+        userData?: Record<string, any> | undefined;
+        color?: number | undefined;
+        alphaToCoverage?: boolean | undefined;
+        dashed?: boolean | undefined;
+        dashScale?: number | undefined;
+        dashSize?: number | undefined;
+        dashOffset?: number | undefined;
+        gapSize?: number | undefined;
+        linewidth: number;
+        resolution: Vector2;
+        wireframe?: boolean | undefined;
+        worldUnits?: boolean | undefined;
+        alphaHash?: boolean | undefined;
+        alphaTest?: number | undefined;
+        blendAlpha?: number | undefined;
+        blendColor?: ColorRepresentation | undefined;
+        blendDst?: import("three").BlendingDstFactor | undefined;
+        blendDstAlpha?: number | undefined;
+        blendEquation?: import("three").BlendingEquation | undefined;
+        blendEquationAlpha?: number | undefined;
+        blending?: import("three").Blending | undefined;
+        blendSrc?: import("three").BlendingSrcFactor | import("three").BlendingDstFactor | undefined;
+        blendSrcAlpha?: number | undefined;
+        clipIntersection?: boolean | undefined;
+        clippingPlanes?: import("three").Plane[] | undefined;
+        clipShadows?: boolean | undefined;
+        colorWrite?: boolean | undefined;
+        defines?: any;
+        depthFunc?: import("three").DepthModes | undefined;
+        depthTest?: boolean | undefined;
+        depthWrite?: boolean | undefined;
+        opacity?: number | undefined;
+        polygonOffset?: boolean | undefined;
+        polygonOffsetFactor?: number | undefined;
+        polygonOffsetUnits?: number | undefined;
+        precision?: "highp" | "mediump" | "lowp" | null | undefined;
+        premultipliedAlpha?: boolean | undefined;
+        forceSinglePass?: boolean | undefined;
+        dithering?: boolean | undefined;
+        side?: import("three").Side | undefined;
+        shadowSide?: import("three").Side | undefined;
+        toneMapped?: boolean | undefined;
+        transparent?: boolean | undefined;
+        vertexColors: boolean;
+        format?: import("three").PixelFormat | undefined;
+        stencilWrite?: boolean | undefined;
+        stencilFunc?: import("three").StencilFunc | undefined;
+        stencilRef?: number | undefined;
+        stencilWriteMask?: number | undefined;
+        stencilFuncMask?: number | undefined;
+        stencilFail?: import("three").StencilOp | undefined;
+        stencilZFail?: import("three").StencilOp | undefined;
+        stencilZPass?: import("three").StencilOp | undefined;
+    }>;
+    positions: import("@angular/core").Signal<number[]>;
+    colors: import("@angular/core").Signal<number[]>;
+    constructor();
+    subscribe(ref: ElementRef<SegmentObject> | SegmentObject): () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSegments, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSegments, "ngts-segments", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/shaders/index.d.ts

@@ -1,17 +1,3 @@
-export * from './blur-pass/blur-pass';
-export * from './caustics/caustics-material';
-export * from './caustics/caustics-projection-material';
-export * from './convolution-material/convolution-material';
-export * from './discard-material/discard-material';
-export * from './grid-material/grid-material';
-export * from './mesh-distort-material/mesh-distort-material';
-export * from './mesh-reflector-material/mesh-reflector-material';
-export * from './mesh-refraction-material/mesh-refraction-material';
-export * from './mesh-transmission-material/mesh-transmission-material';
-export * from './mesh-wobble-material/mesh-wobble-material';
-export * from './shader-material/shader-material';
-export * from './soft-shadow-material/soft-shadow-material';
-export * from './sparkles-material/sparkles-material';
-export * from './spot-light-material/spot-light-material';
-export * from './star-field-material/star-field-material';
-export * from './wireframe-material/wireframe-material';
+export * from './lib/grid-material';
+export * from './lib/mesh-refraction-material';
+export * from './lib/point-material';

package/shaders/lib/grid-material.d.ts

@@ -0,0 +1,69 @@
+import { NgtMaterial } from 'angular-three';
+import { Color, ColorRepresentation, Side, Vector3 } from 'three';
+export interface GridMaterialOptions {
+    /** Cell size, default: 0.5 */
+    cellSize: number;
+    /** Cell thickness, default: 0.5 */
+    cellThickness: number;
+    /** Cell color, default: black */
+    cellColor: ColorRepresentation;
+    /** Section size, default: 1 */
+    sectionSize: number;
+    /** Section thickness, default: 1 */
+    sectionThickness: number;
+    /** Section color, default: #2080ff */
+    sectionColor: ColorRepresentation;
+    /** Follow camera, default: false */
+    followCamera: boolean;
+    /** Display the grid infinitely, default: false */
+    infiniteGrid: boolean;
+    /** Fade distance, default: 100 */
+    fadeDistance: number;
+    /** Fade strength, default: 1 */
+    fadeStrength: number;
+    /** Fade from camera (1) or origin (0), or somewhere in between, default: camera */
+    fadeFrom: number;
+    /** Material side, default: THREE.BackSide */
+    side: Side;
+}
+export declare const GridMaterial: (new (parameters?: (import("three").ShaderMaterialParameters & Partial<{
+    cellSize: number;
+    sectionSize: number;
+    fadeDistance: number;
+    fadeStrength: number;
+    fadeFrom: number;
+    cellThickness: number;
+    sectionThickness: number;
+    cellColor: Color;
+    sectionColor: Color;
+    infiniteGrid: false;
+    followCamera: false;
+    worldCamProjPosition: Vector3;
+    worldPlanePosition: Vector3;
+}>) | undefined) => import("three").ShaderMaterial & {
+    cellSize: number;
+    sectionSize: number;
+    fadeDistance: number;
+    fadeStrength: number;
+    fadeFrom: number;
+    cellThickness: number;
+    sectionThickness: number;
+    cellColor: Color;
+    sectionColor: Color;
+    infiniteGrid: false;
+    followCamera: false;
+    worldCamProjPosition: Vector3;
+    worldPlanePosition: Vector3;
+}) & {
+    key: string;
+};
+export type NgtGridMaterial = NgtMaterial<InstanceType<typeof GridMaterial>, [GridMaterialOptions]>;
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-shader-material
+         * @options GridMaterialOptions
+         */
+        'ngt-grid-material': NgtGridMaterial;
+    }
+}

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

@@ -0,0 +1,11 @@
+import * as THREE from 'three';
+declare module 'three-mesh-bvh' {
+    const shaderIntersectFunction: string;
+}
+export declare const MeshRefractionMaterial: (new (parameters?: (THREE.ShaderMaterialParameters & Partial<{
+    [name: string]: number | boolean | any[] | THREE.Color | THREE.CubeTexture | THREE.Texture | Int32Array | Float32Array | THREE.Matrix4 | THREE.Matrix3 | THREE.Quaternion | THREE.Vector4 | THREE.Vector3 | THREE.Vector2 | null;
+}>) | undefined) => THREE.ShaderMaterial & {
+    [name: string]: number | boolean | any[] | THREE.Color | THREE.CubeTexture | THREE.Texture | Int32Array | Float32Array | THREE.Matrix4 | THREE.Matrix3 | THREE.Quaternion | THREE.Vector4 | THREE.Vector3 | THREE.Vector2 | null;
+}) & {
+    key: string;
+};

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

@@ -0,0 +1,14 @@
+import { NgtMaterial } from 'angular-three';
+import { PointsMaterial, PointsMaterialParameters } from 'three';
+export declare class PointMaterial extends PointsMaterial {
+    constructor(props: PointsMaterialParameters);
+}
+export type NgtPointMaterial = NgtMaterial<PointMaterial, [PointsMaterialParameters]>;
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-points-material
+         */
+        'ngt-point-material': NgtPointMaterial;
+    }
+}