angular-three-soba 1.10.0 → 1.11.0

package/materials/index.d.ts

@@ -1,3 +1,5 @@
 export * from './lib/mesh-distort-material/mesh-distort-material';
 export * from './lib/mesh-reflector-material/mesh-reflector-material';
+export * from './lib/mesh-refraction-material/mesh-refraction-material';
+export * from './lib/mesh-transmission-material/mesh-transmission-material';
 export * from './lib/mesh-wobble-material/mesh-wobble-material';

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

@@ -0,0 +1,28 @@
+import { OnInit } from '@angular/core';
+import { NgtRxStore } from 'angular-three';
+import * as i0 from "@angular/core";
+export declare class NgtsMeshRefractionMaterial extends NgtRxStore implements OnInit {
+    materialRef: import("angular-three").NgtInjectedRef<import("three").ShaderMaterial>;
+    /** Environment map */
+    set envMap(envMap: THREE.CubeTexture | THREE.Texture);
+    /** Number of ray-cast bounces, it can be expensive to have too many, 2 */
+    set bounces(bounces: number);
+    /** Refraction index, 2.4 */
+    set ior(ior: number);
+    /** Fresnel (strip light), 0 */
+    set fresnel(fresnel: number);
+    /** RGB shift intensity, can be expensive, 0 */
+    set aberrationStrength(aberrationStrength: number);
+    /** Color, white */
+    set color(color: THREE.ColorRepresentation);
+    /** If this is on it uses fewer ray casts for the RGB shift sacrificing physical accuracy, true */
+    set fastChroma(fastChroma: boolean);
+    readonly defines$: import("rxjs").Observable<any>;
+    private readonly store;
+    initialize(): void;
+    constructor();
+    ngOnInit(): void;
+    private setupGeometry;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsMeshRefractionMaterial, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsMeshRefractionMaterial, "ngts-mesh-refraction-material", never, { "materialRef": "materialRef"; "envMap": "envMap"; "bounces": "bounces"; "ior": "ior"; "fresnel": "fresnel"; "aberrationStrength": "aberrationStrength"; "color": "color"; "fastChroma": "fastChroma"; }, {}, never, ["*"], true, never>;
+}

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

@@ -0,0 +1,47 @@
+import { NgtRxStore } from 'angular-three';
+import { MeshTransmissionMaterial } from 'angular-three-soba/shaders';
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+export declare class NgtsMeshTranmissionMaterial extends NgtRxStore {
+    materialRef: import("angular-three").NgtInjectedRef<MeshTransmissionMaterial & {
+        time: number;
+        buffer?: THREE.Texture | undefined;
+    }>;
+    /** 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
+     *  using this can't see other transparent or transmissive objects, default: false */
+    set transmissionSampler(transmissionSampler: boolean);
+    /** Render the backside of the material (more cost, better results), default: false */
+    set backside(backside: boolean);
+    /** Backside thickness (when backside is true), default: 0 */
+    set backsideThickness(backsideThickness: number);
+    /** Resolution of the local buffer, default: undefined (fullscreen) */
+    set resolution(resolution: number);
+    /** Resolution of the local buffer for backfaces, default: undefined (fullscreen) */
+    set backsideResolution(backsideResolution: number);
+    /** Refraction samples, default: 10 */
+    set samples(samples: number);
+    /** Buffer scene background (can be a texture, a cubetexture or a color), default: null */
+    set background(background: THREE.Texture | THREE.Color);
+    set transmission(transmission: number);
+    set thickness(thickness: number);
+    set roughness(roughness: number);
+    set chromaticAberration(chromaticAberration: number);
+    set anisotropy(anisotropy: number);
+    set distortion(distortion: number);
+    set distortionScale(distortionScale: number);
+    set temporalDistortion(temporalDistortion: number);
+    /** The scene rendered into a texture (use it to share a texture between materials), default: null  */
+    set buffer(buffer: THREE.Texture);
+    /** Internals */
+    set time(time: number);
+    readonly discardMaterial: THREE.ShaderMaterial;
+    readonly fboBackRef: import("angular-three").NgtInjectedRef<THREE.WebGLRenderTarget>;
+    readonly fboMainRef: import("angular-three").NgtInjectedRef<THREE.WebGLRenderTarget>;
+    initialize(): void;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsMeshTranmissionMaterial, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsMeshTranmissionMaterial, "ngts-mesh-transmission-material", never, { "materialRef": "materialRef"; "transmissionSampler": "transmissionSampler"; "backside": "backside"; "backsideThickness": "backsideThickness"; "resolution": "resolution"; "backsideResolution": "backsideResolution"; "samples": "samples"; "background": "background"; "transmission": "transmission"; "thickness": "thickness"; "roughness": "roughness"; "chromaticAberration": "chromaticAberration"; "anisotropy": "anisotropy"; "distortion": "distortion"; "distortionScale": "distortionScale"; "temporalDistortion": "temporalDistortion"; "buffer": "buffer"; "time": "time"; }, {}, never, never, true, never>;
+}

package/misc/lib/fbo/fbo.d.ts

@@ -1,13 +1,15 @@
 import { Observable } from 'rxjs';
 import * as THREE from 'three';
-interface FBOSettings<T extends boolean = false> extends THREE.WebGLRenderTargetOptions {
-    multisample?: T;
+interface FBOSettings extends THREE.WebGLRenderTargetOptions {
+    /** Defines the count of MSAA samples. Can only be used with WebGL 2. Default: 0 */
     samples?: number;
+    /** If set, the scene depth will be rendered into buffer.depthTexture. Default: false */
+    depth?: boolean;
 }
-export interface NgtsFBOParams<T extends boolean = false> {
-    width?: number | FBOSettings<T>;
+export interface NgtsFBOParams {
+    width?: number | FBOSettings;
     height?: number;
-    settings?: FBOSettings<T>;
+    settings?: FBOSettings;
 }
-export declare function injectNgtsFBO<T extends boolean = false>(paramsFactory: (defaultParams: Partial<NgtsFBOParams<T>>) => NgtsFBOParams<T> | Observable<NgtsFBOParams<T>>): import("angular-three").NgtInjectedRef<THREE.WebGLRenderTarget>;
+export declare function injectNgtsFBO(paramsFactory: (defaultParams: Partial<NgtsFBOParams>) => NgtsFBOParams | Observable<NgtsFBOParams>): import("angular-three").NgtInjectedRef<THREE.WebGLRenderTarget>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "angular-three-soba",
-  "version": "1.10.0",
+  "version": "1.11.0",
   "publishConfig": {
     "access": "public"
   },
@@ -115,9 +115,9 @@
     "three-mesh-bvh": "^0.5.0",
     "three-stdlib": "^2.0.0",
     "troika-three-text": "^0.47.0",
+    "rxjs": "~7.8.0",
     "@storybook/addons": "6.5.16",
     "@storybook/theming": "6.5.16",
-    "rxjs": "~7.8.0",
     "@rx-angular/state": "^1.7.0"
   },
   "dependencies": {

package/plugin/package.json

@@ -5,5 +5,5 @@
   },
   "main": "./src/index.js",
   "types": "./src/index.d.ts",
-  "version": "1.10.0"
+  "version": "1.11.0"
 }

package/shaders/index.d.ts

@@ -1,8 +1,12 @@
 export * from './lib/blur-pass/blur-pass';
+export * from './lib/caustics-material/caustics-material';
+export * from './lib/caustics-projection-material/caustics-projection-material';
 export * from './lib/convolution-material/convolution-material';
+export * from './lib/discard-material/discard-material';
 export * from './lib/mesh-distort-material/mesh-distort-material';
 export * from './lib/mesh-reflector-material/mesh-reflector-material';
 export * from './lib/mesh-refraction-material/mesh-refraction-material';
+export * from './lib/mesh-transmission-material/mesh-transmission-material';
 export * from './lib/mesh-wobble-material/mesh-wobble-material';
 export * from './lib/shader-material/shader-material';
 export * from './lib/spot-light-material/spot-light-material';

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

@@ -0,0 +1,4 @@
+import * as THREE from 'three';
+export declare const CausticsMaterial: typeof THREE.ShaderMaterial & {
+    key: string;
+};

package/shaders/lib/caustics-projection-material/caustics-projection-material.d.ts

@@ -0,0 +1,4 @@
+import * as THREE from 'three';
+export declare const CausticsProjectionMaterial: typeof THREE.ShaderMaterial & {
+    key: string;
+};

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

@@ -0,0 +1,3 @@
+export declare const DiscardMaterial: typeof import("three").ShaderMaterial & {
+    key: string;
+};

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

@@ -0,0 +1,25 @@
+import * as THREE from 'three';
+interface Uniform<T> {
+    value: T;
+}
+export declare class MeshTransmissionMaterial extends THREE.MeshPhysicalMaterial {
+    uniforms: {
+        chromaticAberration: Uniform<number>;
+        transmission: Uniform<number>;
+        transmissionMap: Uniform<THREE.Texture | null>;
+        _transmission: Uniform<number>;
+        thickness: Uniform<number>;
+        roughness: Uniform<number>;
+        thicknessMap: Uniform<THREE.Texture | null>;
+        attenuationDistance: Uniform<number>;
+        attenuationColor: Uniform<THREE.Color>;
+        anisotropy: Uniform<number>;
+        time: Uniform<number>;
+        distortion: Uniform<number>;
+        distortionScale: Uniform<number>;
+        temporalDistortion: Uniform<number>;
+        buffer: Uniform<THREE.Texture | null>;
+    };
+    constructor(samples?: number, transmissionSampler?: boolean);
+}
+export {};

package/staging/index.d.ts

@@ -2,6 +2,7 @@ export { NgtsAccumulativeShadows } from './lib/accumulative-shadows/accumulative
 export { NgtsRandomizedLights } from './lib/accumulative-shadows/randomized-lights';
 export * from './lib/bounds/bounds';
 export * from './lib/camera-shake/camera-shake';
+export * from './lib/caustics/caustics';
 export * from './lib/center/center';
 export * from './lib/cloud/cloud';
 export * from './lib/contact-shadows/contact-shadows';

package/staging/lib/caustics/caustics.d.ts

@@ -0,0 +1,48 @@
+import { ElementRef, OnInit } from '@angular/core';
+import { NgtRxStore } from 'angular-three';
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+export declare class NgtsCaustics extends NgtRxStore implements OnInit {
+    readonly CustomBlending: THREE.Blending;
+    readonly OneFactor: THREE.BlendingDstFactor;
+    readonly SrcAlphaFactor: THREE.BlendingDstFactor;
+    readonly Math: Math;
+    readonly planeRef: import("angular-three").NgtInjectedRef<THREE.Mesh<THREE.BufferGeometry, THREE.Material | THREE.Material[]>>;
+    readonly sceneRef: import("angular-three").NgtInjectedRef<THREE.Scene>;
+    readonly cameraRef: import("angular-three").NgtInjectedRef<THREE.OrthographicCamera>;
+    causticsRef: import("angular-three").NgtInjectedRef<THREE.Group>;
+    /** How many frames it will render, set it to Infinity for runtime, default: 1 */
+    set frames(frames: number);
+    /** Enables visual cues to help you stage your scene, default: false */
+    set debug(debug: boolean);
+    /** Will display caustics only and skip the models, default: false */
+    set causticsOnly(causticsOnly: boolean);
+    /** Will include back faces and enable the backsideIOR prop, default: false */
+    set backside(backside: boolean);
+    /** The IOR refraction index, default: 1.1 */
+    set ior(ior: number);
+    /** The IOR refraction index for back faces (only available when backside is enabled), default: 1.1 */
+    set backsideIOR(backsideIOR: number);
+    /** The texel size, default: 0.3125 */
+    set worldRadius(worldRadius: number);
+    /** Intensity of the prjected caustics, default: 0.05 */
+    set intensity(intensity: number);
+    /** Caustics color, default: white */
+    set color(color: THREE.ColorRepresentation);
+    /** Buffer resolution, default: 2048 */
+    set resolution(resolution: number);
+    /** Camera position, it will point towards the contents bounds center, default: [5, 5, 5] */
+    set lightSource(lightSource: [x: number, y: number, z: number] | ElementRef<THREE.Object3D>);
+    readonly normalTargetFbo: import("angular-three").NgtInjectedRef<THREE.WebGLRenderTarget>;
+    readonly normalTargetBFbo: import("angular-three").NgtInjectedRef<THREE.WebGLRenderTarget>;
+    readonly causticsTargetFbo: import("angular-three").NgtInjectedRef<THREE.WebGLRenderTarget>;
+    readonly causticsTargetBFbo: import("angular-three").NgtInjectedRef<THREE.WebGLRenderTarget>;
+    private readonly store;
+    private readonly cdr;
+    initialize(): void;
+    ngOnInit(): void;
+    private updateWorldMatrix;
+    private setBeforeRender;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsCaustics, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsCaustics, "ngts-caustics", never, { "causticsRef": "causticsRef"; "frames": "frames"; "debug": "debug"; "causticsOnly": "causticsOnly"; "backside": "backside"; "ior": "ior"; "backsideIOR": "backsideIOR"; "worldRadius": "worldRadius"; "intensity": "intensity"; "color": "color"; "resolution": "resolution"; "lightSource": "lightSource"; }, {}, never, ["*"], true, never>;
+}

package/staging/lib/environment/environment-cube.d.ts

@@ -2,7 +2,7 @@ import { OnInit } from '@angular/core';
 import { NgtsEnvironmentInputs } from './environment-inputs';
 import * as i0 from "@angular/core";
 export declare class NgtsEnvironmentCube extends NgtsEnvironmentInputs implements OnInit {
-    readonly textureRef: import("angular-three").NgtInjectedRef<import("three").CubeTexture | import("three").Texture>;
+    readonly textureRef: import("angular-three").NgtInjectedRef<import("three").Texture | import("three").CubeTexture>;
     initialize(): void;
     ngOnInit(): void;
     private setEnvProps;

package/staging/lib/environment/environment-ground.d.ts

@@ -2,7 +2,7 @@ import { OnInit } from '@angular/core';
 import { NgtsEnvironmentInputs } from './environment-inputs';
 import * as i0 from "@angular/core";
 export declare class NgtsEnvironmentGround extends NgtsEnvironmentInputs implements OnInit {
-    readonly defaultTexture: import("angular-three").NgtInjectedRef<import("three").CubeTexture | import("three").Texture>;
+    readonly defaultTexture: import("angular-three").NgtInjectedRef<import("three").Texture | import("three").CubeTexture>;
     ngOnInit(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsEnvironmentGround, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtsEnvironmentGround, "ngts-environment-ground", never, {}, {}, never, never, true, never>;

package/staging/lib/environment/utils.d.ts

@@ -4,5 +4,5 @@ import { CubeTexture, Texture } from 'three';
 import { NgtsEnvironmentInputs } from './environment-inputs';
 export declare function setEnvProps(background: boolean | 'only', scene: THREE.Scene | ElementRef<THREE.Scene> | undefined, defaultScene: THREE.Scene, texture: THREE.Texture, blur?: number): () => void;
 type NgtsInjectEnvironmentParams = Partial<Pick<NgtsEnvironmentInputs, 'files' | 'path' | 'preset' | 'extensions' | 'encoding'>>;
-export declare function injectNgtsEnvironment(paramsFactory: (defaultParams: NgtsInjectEnvironmentParams) => NgtsInjectEnvironmentParams | Observable<NgtsInjectEnvironmentParams>): import("angular-three").NgtInjectedRef<CubeTexture | Texture>;
+export declare function injectNgtsEnvironment(paramsFactory: (defaultParams: NgtsInjectEnvironmentParams) => NgtsInjectEnvironmentParams | Observable<NgtsInjectEnvironmentParams>): import("angular-three").NgtInjectedRef<Texture | CubeTexture>;
 export {};