angular-three-soba 1.7.0 → 1.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "angular-three-soba",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "publishConfig": {
     "access": "public"
   },
@@ -20,33 +20,10 @@
     "renderer"
   ],
   "license": "MIT",
-  "peerDependencies": {
-    "@angular/common": "^15.1.0",
-    "@angular/core": "^15.1.0",
-    "angular-three": "^1.0.0",
-    "stats.js": "^0.17.0",
-    "three": "^0.148.0 || ^0.149.0",
-    "three-stdlib": "^2.0.0",
-    "troika-three-text": "^0.47.0",
-    "@storybook/addons": "6.5.16",
-    "@storybook/theming": "6.5.16",
-    "rxjs": "7.8.0",
-    "@rx-angular/state": "1.7.0"
-  },
-  "dependencies": {
-    "@nrwl/devkit": "^15.0.0",
-    "tslib": "^2.3.0"
-  },
-  "sideEffects": false,
-  "generators": "./plugin/generators.json",
-  "schematics": "./plugin/generators.json",
-  "module": "fesm2015/angular-three-soba.mjs",
-  "es2020": "fesm2020/angular-three-soba.mjs",
-  "esm2020": "esm2020/angular-three-soba.mjs",
-  "fesm2020": "fesm2020/angular-three-soba.mjs",
-  "fesm2015": "fesm2015/angular-three-soba.mjs",
-  "typings": "index.d.ts",
   "exports": {
+    "./assets/*": {
+      "glsl": "./assets/*.glsl"
+    },
     "./package.json": {
       "default": "./package.json"
     },
@@ -90,6 +67,14 @@
       "node": "./fesm2015/angular-three-soba-loaders.mjs",
       "default": "./fesm2020/angular-three-soba-loaders.mjs"
     },
+    "./materials": {
+      "types": "./materials/index.d.ts",
+      "esm2020": "./esm2020/materials/angular-three-soba-materials.mjs",
+      "es2020": "./fesm2020/angular-three-soba-materials.mjs",
+      "es2015": "./fesm2015/angular-three-soba-materials.mjs",
+      "node": "./fesm2015/angular-three-soba-materials.mjs",
+      "default": "./fesm2020/angular-three-soba-materials.mjs"
+    },
     "./misc": {
       "types": "./misc/index.d.ts",
       "esm2020": "./esm2020/misc/angular-three-soba-misc.mjs",
@@ -122,5 +107,31 @@
       "node": "./fesm2015/angular-three-soba-staging.mjs",
       "default": "./fesm2020/angular-three-soba-staging.mjs"
     }
-  }
+  },
+  "peerDependencies": {
+    "@angular/common": "^15.1.0",
+    "@angular/core": "^15.1.0",
+    "angular-three": "^1.0.0",
+    "stats.js": "^0.17.0",
+    "three": "^0.148.0 || ^0.149.0",
+    "three-stdlib": "^2.0.0",
+    "troika-three-text": "^0.47.0",
+    "@storybook/addons": "6.5.16",
+    "@storybook/theming": "6.5.16",
+    "rxjs": "7.8.0",
+    "@rx-angular/state": "1.7.0"
+  },
+  "dependencies": {
+    "@nrwl/devkit": "^15.0.0",
+    "tslib": "^2.3.0"
+  },
+  "sideEffects": false,
+  "generators": "./plugin/generators.json",
+  "schematics": "./plugin/generators.json",
+  "module": "fesm2015/angular-three-soba.mjs",
+  "es2020": "fesm2020/angular-three-soba.mjs",
+  "esm2020": "esm2020/angular-three-soba.mjs",
+  "fesm2020": "fesm2020/angular-three-soba.mjs",
+  "fesm2015": "fesm2015/angular-three-soba.mjs",
+  "typings": "index.d.ts"
 }

package/plugin/package.json

@@ -6,5 +6,5 @@
   },
   "main": "./src/index.js",
   "types": "./src/index.d.ts",
-  "version": "1.7.0"
+  "version": "1.8.0"
 }

package/shaders/index.d.ts

@@ -1 +1,6 @@
+export * from './lib/blur-pass/blur-pass';
+export * from './lib/convolution-material/convolution-material';
+export * from './lib/mesh-distort-material/mesh-distort-material';
+export * from './lib/mesh-reflector-material/mesh-reflector-material';
+export * from './lib/mesh-wobble-material/mesh-wobble-material';
 export * from './lib/shader-material/shader-material';

package/shaders/lib/blur-pass/blur-pass.d.ts

@@ -0,0 +1,23 @@
+import { Camera, Mesh, Scene, WebGLRenderer, WebGLRenderTarget } from 'three';
+import { ConvolutionMaterial } from '../convolution-material/convolution-material';
+export interface BlurPassProps {
+    gl: WebGLRenderer;
+    resolution: number;
+    width?: number;
+    height?: number;
+    minDepthThreshold?: number;
+    maxDepthThreshold?: number;
+    depthScale?: number;
+    depthToBlurRatioBias?: number;
+}
+export declare class BlurPass {
+    readonly renderTargetA: WebGLRenderTarget;
+    readonly renderTargetB: WebGLRenderTarget;
+    readonly convolutionMaterial: ConvolutionMaterial;
+    readonly scene: Scene;
+    readonly camera: Camera;
+    readonly screen: Mesh;
+    renderToScreen: boolean;
+    constructor({ gl, resolution, width, height, minDepthThreshold, maxDepthThreshold, depthScale, depthToBlurRatioBias, }: BlurPassProps);
+    render(renderer: WebGLRenderer, inputBuffer: any, outputBuffer: any): void;
+}

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

@@ -0,0 +1,7 @@
+import { ShaderMaterial, Vector2 } from 'three';
+export declare class ConvolutionMaterial extends ShaderMaterial {
+    readonly kernel: Float32Array;
+    constructor(texelSize?: Vector2);
+    setTexelSize(x: number, y: number): void;
+    setResolution(resolution: Vector2): void;
+}

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

@@ -0,0 +1,144 @@
+import { InjectionToken, Type } from '@angular/core';
+import * as THREE from 'three';
+interface Uniform<T> {
+    value: T;
+}
+export type MeshDistortMaterial = Type<{
+    time: number;
+    distort: number;
+    radius: number;
+} & THREE.MeshPhysicalMaterial>;
+export declare const NGTS_DISTORT_MATERIAL_SHADER: InjectionToken<MeshDistortMaterial>;
+export declare function provideDistortMaterialShader(distortShader: string): {
+    provide: InjectionToken<MeshDistortMaterial>;
+    useFactory: () => {
+        new (parameters?: THREE.MeshPhysicalMaterialParameters): {
+            _time: Uniform<number>;
+            _distort: Uniform<number>;
+            _radius: Uniform<number>;
+            onBeforeCompile(shader: THREE.Shader): void;
+            time: number;
+            distort: number;
+            radius: number;
+            type: string;
+            defines: {
+                [key: string]: any;
+            };
+            clearcoat: number;
+            clearcoatMap: THREE.Texture | null;
+            clearcoatRoughness: number;
+            clearcoatRoughnessMap: THREE.Texture | null;
+            clearcoatNormalScale: THREE.Vector2;
+            clearcoatNormalMap: THREE.Texture | null;
+            reflectivity: number;
+            ior: number;
+            sheen: number;
+            sheenColor: THREE.Color;
+            sheenColorMap: THREE.Texture | null;
+            sheenRoughness: number;
+            sheenRoughnessMap: THREE.Texture | null;
+            transmission: number;
+            transmissionMap: THREE.Texture | null;
+            thickness: number;
+            thicknessMap: THREE.Texture | null;
+            attenuationDistance: number;
+            attenuationColor: THREE.Color;
+            specularIntensity: number;
+            specularColor: THREE.Color;
+            specularIntensityMap: THREE.Texture | null;
+            specularColorMap: THREE.Texture | null;
+            iridescenceMap: THREE.Texture | null;
+            iridescenceIOR: number;
+            iridescence: number;
+            iridescenceThicknessRange: number[];
+            iridescenceThicknessMap: THREE.Texture | null;
+            color: THREE.Color;
+            roughness: number;
+            metalness: number;
+            map: THREE.Texture | null;
+            lightMap: THREE.Texture | null;
+            lightMapIntensity: number;
+            aoMap: THREE.Texture | null;
+            aoMapIntensity: number;
+            emissive: THREE.Color;
+            emissiveIntensity: number;
+            emissiveMap: THREE.Texture | null;
+            bumpMap: THREE.Texture | null;
+            bumpScale: number;
+            normalMap: THREE.Texture | null;
+            normalMapType: THREE.NormalMapTypes;
+            normalScale: THREE.Vector2;
+            displacementMap: THREE.Texture | null;
+            displacementScale: number;
+            displacementBias: number;
+            roughnessMap: THREE.Texture | null;
+            metalnessMap: THREE.Texture | null;
+            alphaMap: THREE.Texture | null;
+            envMap: THREE.Texture | null;
+            envMapIntensity: number;
+            wireframe: boolean;
+            wireframeLinewidth: number;
+            wireframeLinecap: string;
+            wireframeLinejoin: string;
+            flatShading: boolean;
+            fog: boolean;
+            isMeshStandardMaterial: boolean;
+            setValues(parameters: THREE.MeshStandardMaterialParameters): void;
+            alphaTest: number;
+            alphaToCoverage: boolean;
+            blendDst: THREE.BlendingDstFactor;
+            blendDstAlpha: number | null;
+            blendEquation: THREE.BlendingEquation;
+            blendEquationAlpha: number | null;
+            blending: THREE.Blending;
+            blendSrc: THREE.BlendingSrcFactor | THREE.BlendingDstFactor;
+            blendSrcAlpha: number | null;
+            clipIntersection: boolean;
+            clippingPlanes: any;
+            clipShadows: boolean;
+            colorWrite: boolean;
+            depthFunc: THREE.DepthModes;
+            depthTest: boolean;
+            depthWrite: boolean;
+            id: number;
+            stencilWrite: boolean;
+            stencilFunc: THREE.StencilFunc;
+            stencilRef: number;
+            stencilWriteMask: number;
+            stencilFuncMask: number;
+            stencilFail: THREE.StencilOp;
+            stencilZFail: THREE.StencilOp;
+            stencilZPass: THREE.StencilOp;
+            readonly isMaterial: true;
+            name: string;
+            needsUpdate: boolean;
+            opacity: number;
+            polygonOffset: boolean;
+            polygonOffsetFactor: number;
+            polygonOffsetUnits: number;
+            precision: "highp" | "mediump" | "lowp" | null;
+            premultipliedAlpha: boolean;
+            forceSinglePass: boolean;
+            dithering: boolean;
+            side: THREE.Side;
+            shadowSide: THREE.Side | null;
+            toneMapped: boolean;
+            transparent: boolean;
+            uuid: string;
+            vertexColors: boolean;
+            visible: boolean;
+            userData: any;
+            version: number;
+            clone(): any;
+            copy(material: THREE.Material): any;
+            dispose(): void;
+            customProgramCacheKey(): string;
+            toJSON(meta?: any): any;
+            addEventListener<T extends string>(type: T, listener: THREE.EventListener<THREE.Event, T, any>): void;
+            hasEventListener<T_1 extends string>(type: T_1, listener: THREE.EventListener<THREE.Event, T_1, any>): boolean;
+            removeEventListener<T_2 extends string>(type: T_2, listener: THREE.EventListener<THREE.Event, T_2, any>): void;
+            dispatchEvent(event: THREE.Event): void;
+        };
+    };
+};
+export {};

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

@@ -0,0 +1,50 @@
+import { Matrix4, MeshStandardMaterial, Texture } from 'three';
+export declare class MeshReflectorMaterial extends MeshStandardMaterial {
+    private _tDepth;
+    private _distortionMap;
+    private _tDiffuse;
+    private _tDiffuseBlur;
+    private _textureMatrix;
+    private _hasBlur;
+    private _mirror;
+    private _mixBlur;
+    private _blurStrength;
+    private _minDepthThreshold;
+    private _maxDepthThreshold;
+    private _depthScale;
+    private _depthToBlurRatioBias;
+    private _distortion;
+    private _mixContrast;
+    constructor(parameters?: {});
+    onBeforeCompile(shader: any): void;
+    get tDiffuse(): Texture | null;
+    set tDiffuse(v: Texture | null);
+    get tDepth(): Texture | null;
+    set tDepth(v: Texture | null);
+    get distortionMap(): Texture | null;
+    set distortionMap(v: Texture | null);
+    get tDiffuseBlur(): Texture | null;
+    set tDiffuseBlur(v: Texture | null);
+    get textureMatrix(): Matrix4 | null;
+    set textureMatrix(v: Matrix4 | null);
+    get hasBlur(): boolean;
+    set hasBlur(v: boolean);
+    get mirror(): number;
+    set mirror(v: number);
+    get mixBlur(): number;
+    set mixBlur(v: number);
+    get mixStrength(): number;
+    set mixStrength(v: number);
+    get minDepthThreshold(): number;
+    set minDepthThreshold(v: number);
+    get maxDepthThreshold(): number;
+    set maxDepthThreshold(v: number);
+    get depthScale(): number;
+    set depthScale(v: number);
+    get depthToBlurRatioBias(): number;
+    set depthToBlurRatioBias(v: number);
+    get distortion(): number;
+    set distortion(v: number);
+    get mixContrast(): number;
+    set mixContrast(v: number);
+}

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

@@ -0,0 +1,15 @@
+import * as THREE from 'three';
+interface Uniform<T> {
+    value: T;
+}
+export declare class MeshWobbleMaterial extends THREE.MeshStandardMaterial {
+    _time: Uniform<number>;
+    _factor: Uniform<number>;
+    constructor(parameters?: THREE.MeshStandardMaterialParameters);
+    onBeforeCompile(shader: THREE.Shader): void;
+    get time(): number;
+    set time(v: number);
+    get factor(): number;
+    set factor(v: number);
+}
+export {};