angular-three-soba 2.0.0-beta.26 → 2.0.0-beta.261

package/staging/lib/randomized-lights.d.ts

@@ -0,0 +1,54 @@
+import { ElementRef } from '@angular/core';
+import { NgtGroup } from 'angular-three';
+import { Group } from 'three';
+import * as i0 from "@angular/core";
+export interface NgtsRandomizedLightsOptions extends Partial<NgtGroup> {
+    /** How many frames it will jiggle the lights, 1.
+     *  Frames is context aware, if a provider like AccumulativeShadows exists, frames will be taken from there!  */
+    frames: number;
+    /** Light position, [0, 0, 0] */
+    position: [x: number, y: number, z: number];
+    /** Radius of the jiggle, higher values make softer light, 5 */
+    radius: number;
+    /** Amount of lights, 8 */
+    amount: number;
+    /** Light intensity, 1 */
+    intensity: number;
+    /** Ambient occlusion, lower values mean less AO, hight more, you can mix AO and directional light, 0.5 */
+    ambient: number;
+    /** If the lights cast shadows, this is true by default */
+    castShadow: boolean;
+    /** Default shadow bias, 0 */
+    bias: number;
+    /** Default map size, 512 */
+    mapSize: number;
+    /** Default size of the shadow camera, 10 */
+    size: number;
+    /** Default shadow camera near, 0.5 */
+    near: number;
+    /** Default shadow camera far, 500 */
+    far: number;
+}
+export declare class NgtsRandomizedLights {
+    options: import("@angular/core").InputSignalWithTransform<NgtsRandomizedLightsOptions, "" | Partial<NgtsRandomizedLightsOptions>>;
+    parameters: import("@angular/core").Signal<Omit<NgtsRandomizedLightsOptions, keyof NgtsRandomizedLightsOptions>>;
+    lights: import("@angular/core").Signal<ElementRef<Group<import("three").Object3DEventMap>>>;
+    private accumulativeShadows;
+    castShadow: import("@angular/core").Signal<boolean>;
+    bias: import("@angular/core").Signal<number>;
+    intensity: import("@angular/core").Signal<number>;
+    amount: import("@angular/core").Signal<number>;
+    private mapSize;
+    shadowMapSize: import("@angular/core").Signal<number[]>;
+    private position;
+    length: import("@angular/core").Signal<number>;
+    count: import("@angular/core").Signal<number[]>;
+    private size;
+    private near;
+    private far;
+    cameraArgs: import("@angular/core").Signal<number[]>;
+    constructor();
+    update(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsRandomizedLights, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsRandomizedLights, "ngts-randomized-lights", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/staging/lib/render-texture.d.ts

@@ -0,0 +1,64 @@
+import { Injector, TemplateRef } from '@angular/core';
+import { NgtComputeFunction, NgtTexture } from 'angular-three';
+import { Object3D, Scene, WebGLRenderTarget } from 'three';
+import * as i0 from "@angular/core";
+export interface NgtsRenderTextureOptions extends Partial<Omit<NgtTexture, 'attach'>> {
+    /** Optional width of the texture, defaults to viewport bounds */
+    width?: number;
+    /** Optional height of the texture, defaults to viewport bounds */
+    height?: number;
+    /** Optional fbo samples */
+    samples: number;
+    /** Optional stencil buffer, defaults to false */
+    stencilBuffer: boolean;
+    /** Optional depth buffer, defaults to true */
+    depthBuffer: boolean;
+    /** Optional generate mipmaps, defaults to false */
+    generateMipmaps: boolean;
+    /** Optional render priority, defaults to 0 */
+    renderPriority: number;
+    /** Optional event priority, defaults to 0 */
+    eventPriority: number;
+    /** Optional frame count, defaults to Infinity. If you set it to 1, it would only render a single frame, etc */
+    frames: number;
+    /** Optional event compute, defaults to undefined */
+    compute?: (event: any, state: any, previous: any) => false | undefined;
+}
+export declare class NgtsRenderTextureContainer {
+    fbo: import("@angular/core").InputSignal<WebGLRenderTarget<import("three").Texture>>;
+    renderPriority: import("@angular/core").InputSignal<number>;
+    frames: import("@angular/core").InputSignal<number>;
+    injector: import("@angular/core").InputSignal<Injector>;
+    private store;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsRenderTextureContainer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsRenderTextureContainer, "ngts-render-texture-container", never, { "fbo": { "alias": "fbo"; "required": true; "isSignal": true; }; "renderPriority": { "alias": "renderPriority"; "required": true; "isSignal": true; }; "frames": { "alias": "frames"; "required": true; "isSignal": true; }; "injector": { "alias": "injector"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+export declare class NgtsRenderTextureContent {
+    static ngTemplateContextGuard(_: NgtsRenderTextureContent, ctx: unknown): ctx is {
+        container: Object3D;
+        injector: Injector;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsRenderTextureContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsRenderTextureContent, "ng-template[renderTextureContent]", never, {}, {}, never, never, true, never>;
+}
+export declare class NgtsRenderTexture {
+    attach: import("@angular/core").InputSignal<string | string[]>;
+    options: import("@angular/core").InputSignalWithTransform<NgtsRenderTextureOptions, "" | Partial<NgtsRenderTextureOptions>>;
+    parameters: import("@angular/core").Signal<Omit<NgtsRenderTextureOptions, "frames" | "width" | "height" | "generateMipmaps" | "samples" | "stencilBuffer" | "depthBuffer" | "renderPriority" | "eventPriority" | "compute">>;
+    content: import("@angular/core").Signal<TemplateRef<any>>;
+    private store;
+    private size;
+    private viewport;
+    private fboParams;
+    renderPriority: import("@angular/core").Signal<number>;
+    frames: import("@angular/core").Signal<number>;
+    fbo: import("@angular/core").Signal<WebGLRenderTarget<import("three").Texture>>;
+    virtualScene: import("@angular/core").Signal<import("angular-three").NgtInstanceNode<Scene>>;
+    eventPriority: import("@angular/core").Signal<number>;
+    compute: import("@angular/core").Signal<NgtComputeFunction>;
+    uvCompute: NgtComputeFunction;
+    onPointerOver(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsRenderTexture, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsRenderTexture, "ngts-render-texture", never, { "attach": { "alias": "attach"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, ["content"], never, true, never>;
+}

package/staging/lib/sky.d.ts

@@ -0,0 +1,32 @@
+import { NgtMesh, NgtVector3 } from 'angular-three';
+import { Vector3 } from 'three';
+import { Sky } from 'three-stdlib';
+import * as i0 from "@angular/core";
+export declare function calcPosFromAngles(inclination: number, azimuth: number, vector?: Vector3): Vector3;
+export interface NgtsSkyOptions extends Partial<Omit<NgtMesh, 'scale'>> {
+    distance: number;
+    inclination: number;
+    azimuth: number;
+    mieCoefficient: number;
+    mieDirectionalG: number;
+    rayleigh: number;
+    turbidity: number;
+    sunPosition?: NgtVector3;
+}
+export declare class NgtsSky {
+    options: import("@angular/core").InputSignalWithTransform<NgtsSkyOptions, "" | Partial<NgtsSkyOptions>>;
+    parameters: import("@angular/core").Signal<Omit<NgtsSkyOptions, "distance" | "inclination" | "azimuth" | "mieCoefficient" | "mieDirectionalG" | "turbidity" | "sunPosition">>;
+    distance: import("@angular/core").Signal<number>;
+    turbidity: import("@angular/core").Signal<number>;
+    mieCoefficient: import("@angular/core").Signal<number>;
+    mieDirectionalG: import("@angular/core").Signal<number>;
+    rayleigh: import("@angular/core").Signal<number>;
+    scale: import("@angular/core").Signal<Vector3>;
+    private inclination;
+    private azimuth;
+    private sunPosition;
+    calculatedSunPosition: import("@angular/core").Signal<Vector3>;
+    sky: Sky;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSky, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSky, "ngts-sky", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/staging/lib/spot-light.d.ts

@@ -0,0 +1,120 @@
+import { ElementRef } from '@angular/core';
+import { NgtSpotLight } from 'angular-three';
+import { ColorRepresentation, CylinderGeometry, DepthTexture, Mesh, ShaderMaterial, SpotLight, SpotLightHelper, Texture, Vector3 } from 'three';
+import * as i0 from "@angular/core";
+export interface NgtsSpotLightOptions extends Partial<NgtSpotLight> {
+    depthBuffer?: DepthTexture;
+    attenuation?: number;
+    anglePower?: number;
+    radiusTop?: number;
+    radiusBottom?: number;
+    opacity?: number;
+    color?: ColorRepresentation;
+    volumetric?: boolean;
+    debug?: boolean;
+}
+export type NgtsVolumetricMeshOptions = Omit<NgtsSpotLightOptions, 'volumetric'>;
+export declare class NgtsVolumetricMesh {
+    nullRaycast: () => null;
+    options: import("@angular/core").InputSignalWithTransform<NgtsVolumetricMeshOptions, "" | Partial<NgtsVolumetricMeshOptions>>;
+    mesh: import("@angular/core").Signal<ElementRef<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>>;
+    private store;
+    size: import("@angular/core").Signal<import("angular-three").NgtSize>;
+    dpr: import("@angular/core").Signal<number>;
+    camera: import("@angular/core").Signal<import("angular-three").NgtCameraManual>;
+    private radiusTop;
+    private radiusBottom;
+    private angle;
+    private distance;
+    private normalizedRadiusTop;
+    private normalizedRadiusBottom;
+    material: ShaderMaterial & {
+        depth: Texture | null;
+        opacity: number;
+        attenuation: number;
+        anglePower: number;
+        spotPosition: Vector3;
+        lightColor: import("three").Color;
+        cameraNear: number;
+        cameraFar: number;
+        resolution: import("three").Vector2;
+        transparent: boolean;
+        depthWrite: boolean;
+    };
+    opacity: import("@angular/core").Signal<number | undefined>;
+    color: import("@angular/core").Signal<ColorRepresentation | undefined>;
+    attenuation: import("@angular/core").Signal<number | undefined>;
+    anglePower: import("@angular/core").Signal<number | undefined>;
+    depthBuffer: import("@angular/core").Signal<DepthTexture | undefined>;
+    geometry: import("@angular/core").Signal<CylinderGeometry>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsVolumetricMesh, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsVolumetricMesh, "ngts-volumetric-mesh", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+interface NgtsShadowMeshOptions {
+    distance: number;
+    alphaTest: number;
+    scale: number;
+    width: number;
+    height: number;
+    map?: Texture;
+}
+export declare class NgtsSpotLightShadowShader {
+    protected readonly DoubleSide: 2;
+    shader: import("@angular/core").InputSignal<string>;
+    options: import("@angular/core").InputSignalWithTransform<NgtsShadowMeshOptions, "" | Partial<NgtsShadowMeshOptions>>;
+    mesh: import("@angular/core").Signal<ElementRef<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>>;
+    private spotLight;
+    debug: import("@angular/core").Signal<boolean | undefined>;
+    scale: import("@angular/core").Signal<number>;
+    alphaTest: import("@angular/core").Signal<number>;
+    private width;
+    private height;
+    private map;
+    private distance;
+    private renderTarget;
+    texture: import("@angular/core").Signal<Texture>;
+    private fsQuad;
+    private uniforms;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSpotLightShadowShader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSpotLightShadowShader, "ngts-spot-light-shadow-shader", never, { "shader": { "alias": "shader"; "required": true; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+export declare class NgtsSpotLightShadowNoShader {
+    protected readonly DoubleSide: 2;
+    options: import("@angular/core").InputSignalWithTransform<NgtsShadowMeshOptions, "" | Partial<NgtsShadowMeshOptions>>;
+    mesh: import("@angular/core").Signal<ElementRef<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>>;
+    private spotLight;
+    debug: import("@angular/core").Signal<boolean | undefined>;
+    alphaTest: import("@angular/core").Signal<number>;
+    scale: import("@angular/core").Signal<number>;
+    map: import("@angular/core").Signal<Texture | undefined>;
+    private width;
+    private height;
+    private distance;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSpotLightShadowNoShader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSpotLightShadowNoShader, "ngts-spot-light-shadow-no-shader", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+export declare class NgtsSpotLightShadow {
+    shader: import("@angular/core").InputSignal<string | undefined>;
+    options: import("@angular/core").InputSignalWithTransform<NgtsShadowMeshOptions, "" | Partial<NgtsShadowMeshOptions>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSpotLightShadow, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSpotLightShadow, "ngts-spot-light-shadow", never, { "shader": { "alias": "shader"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export declare class NgtsSpotLight {
+    protected readonly SpotLightHelper: typeof SpotLightHelper;
+    options: import("@angular/core").InputSignalWithTransform<NgtsSpotLightOptions, "" | Partial<NgtsSpotLightOptions>>;
+    parameters: import("@angular/core").Signal<Omit<NgtsSpotLightOptions, "opacity" | "color" | "distance" | "debug" | "depthBuffer" | "angle" | "attenuation" | "anglePower" | "radiusTop" | "radiusBottom" | "volumetric">>;
+    volumetricOptions: import("@angular/core").Signal<Pick<NgtsSpotLightOptions, "opacity" | "color" | "distance" | "debug" | "depthBuffer" | "angle" | "attenuation" | "anglePower" | "radiusTop" | "radiusBottom">>;
+    spotLight: import("@angular/core").Signal<ElementRef<SpotLight>>;
+    debug: import("@angular/core").Signal<boolean | undefined>;
+    angle: import("@angular/core").Signal<number | undefined>;
+    color: import("@angular/core").Signal<ColorRepresentation | undefined>;
+    distance: import("@angular/core").Signal<number | undefined>;
+    volumetric: import("@angular/core").Signal<boolean | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSpotLight, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSpotLight, "ngts-spot-light", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+export {};