three-stdlib 2.22.7 → 2.22.8

package/dist/renderers/webgpu/nodes/WebGPUNodeUniform.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const WebGPUUniform = require("../WebGPUUniform.js");
+class FloatNodeUniform extends WebGPUUniform.FloatUniform {
+  constructor(nodeUniform) {
+    super(nodeUniform.name, nodeUniform.value);
+    this.nodeUniform = nodeUniform;
+  }
+  getValue() {
+    return this.nodeUniform.value;
+  }
+}
+class Vector2NodeUniform extends WebGPUUniform.Vector2Uniform {
+  constructor(nodeUniform) {
+    super(nodeUniform.name, nodeUniform.value);
+    this.nodeUniform = nodeUniform;
+  }
+  getValue() {
+    return this.nodeUniform.value;
+  }
+}
+class Vector3NodeUniform extends WebGPUUniform.Vector3Uniform {
+  constructor(nodeUniform) {
+    super(nodeUniform.name, nodeUniform.value);
+    this.nodeUniform = nodeUniform;
+  }
+  getValue() {
+    return this.nodeUniform.value;
+  }
+}
+class Vector4NodeUniform extends WebGPUUniform.Vector4Uniform {
+  constructor(nodeUniform) {
+    super(nodeUniform.name, nodeUniform.value);
+    this.nodeUniform = nodeUniform;
+  }
+  getValue() {
+    return this.nodeUniform.value;
+  }
+}
+class ColorNodeUniform extends WebGPUUniform.ColorUniform {
+  constructor(nodeUniform) {
+    super(nodeUniform.name, nodeUniform.value);
+    this.nodeUniform = nodeUniform;
+  }
+  getValue() {
+    return this.nodeUniform.value;
+  }
+}
+class Matrix3NodeUniform extends WebGPUUniform.Matrix3Uniform {
+  constructor(nodeUniform) {
+    super(nodeUniform.name, nodeUniform.value);
+    this.nodeUniform = nodeUniform;
+  }
+  getValue() {
+    return this.nodeUniform.value;
+  }
+}
+class Matrix4NodeUniform extends WebGPUUniform.Matrix4Uniform {
+  constructor(nodeUniform) {
+    super(nodeUniform.name, nodeUniform.value);
+    this.nodeUniform = nodeUniform;
+  }
+  getValue() {
+    return this.nodeUniform.value;
+  }
+}
+exports.ColorNodeUniform = ColorNodeUniform;
+exports.FloatNodeUniform = FloatNodeUniform;
+exports.Matrix3NodeUniform = Matrix3NodeUniform;
+exports.Matrix4NodeUniform = Matrix4NodeUniform;
+exports.Vector2NodeUniform = Vector2NodeUniform;
+exports.Vector3NodeUniform = Vector3NodeUniform;
+exports.Vector4NodeUniform = Vector4NodeUniform;

package/dist/renderers/webgpu/nodes/WebGPUNodeUniform.mjs

@@ -0,0 +1,73 @@
+import { FloatUniform, Vector2Uniform, Vector3Uniform, Vector4Uniform, ColorUniform, Matrix3Uniform, Matrix4Uniform } from "../WebGPUUniform.mjs";
+class FloatNodeUniform extends FloatUniform {
+  constructor(nodeUniform) {
+    super(nodeUniform.name, nodeUniform.value);
+    this.nodeUniform = nodeUniform;
+  }
+  getValue() {
+    return this.nodeUniform.value;
+  }
+}
+class Vector2NodeUniform extends Vector2Uniform {
+  constructor(nodeUniform) {
+    super(nodeUniform.name, nodeUniform.value);
+    this.nodeUniform = nodeUniform;
+  }
+  getValue() {
+    return this.nodeUniform.value;
+  }
+}
+class Vector3NodeUniform extends Vector3Uniform {
+  constructor(nodeUniform) {
+    super(nodeUniform.name, nodeUniform.value);
+    this.nodeUniform = nodeUniform;
+  }
+  getValue() {
+    return this.nodeUniform.value;
+  }
+}
+class Vector4NodeUniform extends Vector4Uniform {
+  constructor(nodeUniform) {
+    super(nodeUniform.name, nodeUniform.value);
+    this.nodeUniform = nodeUniform;
+  }
+  getValue() {
+    return this.nodeUniform.value;
+  }
+}
+class ColorNodeUniform extends ColorUniform {
+  constructor(nodeUniform) {
+    super(nodeUniform.name, nodeUniform.value);
+    this.nodeUniform = nodeUniform;
+  }
+  getValue() {
+    return this.nodeUniform.value;
+  }
+}
+class Matrix3NodeUniform extends Matrix3Uniform {
+  constructor(nodeUniform) {
+    super(nodeUniform.name, nodeUniform.value);
+    this.nodeUniform = nodeUniform;
+  }
+  getValue() {
+    return this.nodeUniform.value;
+  }
+}
+class Matrix4NodeUniform extends Matrix4Uniform {
+  constructor(nodeUniform) {
+    super(nodeUniform.name, nodeUniform.value);
+    this.nodeUniform = nodeUniform;
+  }
+  getValue() {
+    return this.nodeUniform.value;
+  }
+}
+export {
+  ColorNodeUniform,
+  FloatNodeUniform,
+  Matrix3NodeUniform,
+  Matrix4NodeUniform,
+  Vector2NodeUniform,
+  Vector3NodeUniform,
+  Vector4NodeUniform
+};

package/dist/renderers/webgpu/nodes/WebGPUNodeUniformsGroup.js

@@ -0,0 +1,14 @@
+"use strict";
+const WebGPUUniformsGroup = require("../WebGPUUniformsGroup.js");
+class WebGPUNodeUniformsGroup extends WebGPUUniformsGroup {
+  constructor(shaderStage) {
+    super("nodeUniforms");
+    let shaderStageVisibility;
+    if (shaderStage === "vertex")
+      shaderStageVisibility = GPUShaderStage.VERTEX;
+    else if (shaderStage === "fragment")
+      shaderStageVisibility = GPUShaderStage.FRAGMENT;
+    this.setVisibility(shaderStageVisibility);
+  }
+}
+module.exports = WebGPUNodeUniformsGroup;

package/dist/renderers/webgpu/nodes/WebGPUNodeUniformsGroup.mjs

@@ -0,0 +1,15 @@
+import WebGPUUniformsGroup from "../WebGPUUniformsGroup.mjs";
+class WebGPUNodeUniformsGroup extends WebGPUUniformsGroup {
+  constructor(shaderStage) {
+    super("nodeUniforms");
+    let shaderStageVisibility;
+    if (shaderStage === "vertex")
+      shaderStageVisibility = GPUShaderStage.VERTEX;
+    else if (shaderStage === "fragment")
+      shaderStageVisibility = GPUShaderStage.FRAGMENT;
+    this.setVisibility(shaderStageVisibility);
+  }
+}
+export {
+  WebGPUNodeUniformsGroup as default
+};

package/dist/renderers/webgpu/nodes/WebGPUNodes.js

@@ -0,0 +1,39 @@
+"use strict";
+const WebGPUNodeBuilder = require("./WebGPUNodeBuilder.js");
+const NodeFrame = require("../../nodes/core/NodeFrame.js");
+class WebGPUNodes {
+  constructor(renderer) {
+    this.renderer = renderer;
+    this.nodeFrame = new NodeFrame();
+    this.builders = /* @__PURE__ */ new WeakMap();
+  }
+  get(material) {
+    let nodeBuilder = this.builders.get(material);
+    if (nodeBuilder === void 0) {
+      nodeBuilder = new WebGPUNodeBuilder(material, this.renderer).build();
+      this.builders.set(material, nodeBuilder);
+    }
+    return nodeBuilder;
+  }
+  remove(material) {
+    this.builders.delete(material);
+  }
+  updateFrame() {
+    this.nodeFrame.update();
+  }
+  update(object, camera) {
+    const material = object.material;
+    const nodeBuilder = this.get(material);
+    const nodeFrame = this.nodeFrame;
+    nodeFrame.material = material;
+    nodeFrame.camera = camera;
+    nodeFrame.object = object;
+    for (let node of nodeBuilder.updateNodes) {
+      nodeFrame.updateNode(node);
+    }
+  }
+  dispose() {
+    this.builders = /* @__PURE__ */ new WeakMap();
+  }
+}
+module.exports = WebGPUNodes;

package/dist/renderers/webgpu/nodes/WebGPUNodes.mjs

@@ -0,0 +1,40 @@
+import WebGPUNodeBuilder from "./WebGPUNodeBuilder.mjs";
+import NodeFrame from "../../nodes/core/NodeFrame.mjs";
+class WebGPUNodes {
+  constructor(renderer) {
+    this.renderer = renderer;
+    this.nodeFrame = new NodeFrame();
+    this.builders = /* @__PURE__ */ new WeakMap();
+  }
+  get(material) {
+    let nodeBuilder = this.builders.get(material);
+    if (nodeBuilder === void 0) {
+      nodeBuilder = new WebGPUNodeBuilder(material, this.renderer).build();
+      this.builders.set(material, nodeBuilder);
+    }
+    return nodeBuilder;
+  }
+  remove(material) {
+    this.builders.delete(material);
+  }
+  updateFrame() {
+    this.nodeFrame.update();
+  }
+  update(object, camera) {
+    const material = object.material;
+    const nodeBuilder = this.get(material);
+    const nodeFrame = this.nodeFrame;
+    nodeFrame.material = material;
+    nodeFrame.camera = camera;
+    nodeFrame.object = object;
+    for (let node of nodeBuilder.updateNodes) {
+      nodeFrame.updateNode(node);
+    }
+  }
+  dispose() {
+    this.builders = /* @__PURE__ */ new WeakMap();
+  }
+}
+export {
+  WebGPUNodes as default
+};

package/dist/shaders/ACESFilmicToneMappingShader.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ACES Filmic Tone Mapping Shader by Stephen Hill
+ * source: https://github.com/selfshadow/ltc_code/blob/master/webgl/shaders/ltc/ltc_blit.fs
+ *
+ * this implementation of ACES is modified to accommodate a brighter viewing environment.
+ * the scale factor of 1/0.6 is subjective. see discussion in #19621.
+ */
+import type { IUniform, Texture } from 'three';
+import type { IShader } from './types';
+export declare type ACESFilmicToneMappingShaderUniforms = {
+    exposure: IUniform<number>;
+    tDiffuse: IUniform<Texture | null>;
+};
+export interface IACESFilmicToneMappingShader extends IShader<ACESFilmicToneMappingShaderUniforms> {
+}
+export declare const ACESFilmicToneMappingShader: IACESFilmicToneMappingShader;

package/dist/shaders/ACESFilmicToneMappingShader.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const ACESFilmicToneMappingShader = {
+  uniforms: {
+    tDiffuse: { value: null },
+    exposure: { value: 1 }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "#define saturate(a) clamp( a, 0.0, 1.0 )",
+    "uniform sampler2D tDiffuse;",
+    "uniform float exposure;",
+    "varying vec2 vUv;",
+    "vec3 RRTAndODTFit( vec3 v ) {",
+    "	vec3 a = v * ( v + 0.0245786 ) - 0.000090537;",
+    "	vec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;",
+    "	return a / b;",
+    "}",
+    "vec3 ACESFilmicToneMapping( vec3 color ) {",
+    // sRGB => XYZ => D65_2_D60 => AP1 => RRT_SAT
+    "	const mat3 ACESInputMat = mat3(",
+    "		vec3( 0.59719, 0.07600, 0.02840 ),",
+    // transposed from source
+    "		vec3( 0.35458, 0.90834, 0.13383 ),",
+    "		vec3( 0.04823, 0.01566, 0.83777 )",
+    "	);",
+    // ODT_SAT => XYZ => D60_2_D65 => sRGB
+    "	const mat3 ACESOutputMat = mat3(",
+    "		vec3(  1.60475, -0.10208, -0.00327 ),",
+    // transposed from source
+    "		vec3( -0.53108,  1.10813, -0.07276 ),",
+    "		vec3( -0.07367, -0.00605,  1.07602 )",
+    "	);",
+    "	color = ACESInputMat * color;",
+    // Apply RRT and ODT
+    "	color = RRTAndODTFit( color );",
+    "	color = ACESOutputMat * color;",
+    // Clamp to [0, 1]
+    "	return saturate( color );",
+    "}",
+    "void main() {",
+    "	vec4 tex = texture2D( tDiffuse, vUv );",
+    "	tex.rgb *= exposure / 0.6;",
+    // pre-exposed, outside of the tone mapping function
+    "	gl_FragColor = vec4( ACESFilmicToneMapping( tex.rgb ), tex.a );",
+    "}"
+  ].join("\n")
+};
+exports.ACESFilmicToneMappingShader = ACESFilmicToneMappingShader;

package/dist/shaders/ACESFilmicToneMappingShader.mjs

@@ -0,0 +1,55 @@
+const ACESFilmicToneMappingShader = {
+  uniforms: {
+    tDiffuse: { value: null },
+    exposure: { value: 1 }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "#define saturate(a) clamp( a, 0.0, 1.0 )",
+    "uniform sampler2D tDiffuse;",
+    "uniform float exposure;",
+    "varying vec2 vUv;",
+    "vec3 RRTAndODTFit( vec3 v ) {",
+    "	vec3 a = v * ( v + 0.0245786 ) - 0.000090537;",
+    "	vec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;",
+    "	return a / b;",
+    "}",
+    "vec3 ACESFilmicToneMapping( vec3 color ) {",
+    // sRGB => XYZ => D65_2_D60 => AP1 => RRT_SAT
+    "	const mat3 ACESInputMat = mat3(",
+    "		vec3( 0.59719, 0.07600, 0.02840 ),",
+    // transposed from source
+    "		vec3( 0.35458, 0.90834, 0.13383 ),",
+    "		vec3( 0.04823, 0.01566, 0.83777 )",
+    "	);",
+    // ODT_SAT => XYZ => D60_2_D65 => sRGB
+    "	const mat3 ACESOutputMat = mat3(",
+    "		vec3(  1.60475, -0.10208, -0.00327 ),",
+    // transposed from source
+    "		vec3( -0.53108,  1.10813, -0.07276 ),",
+    "		vec3( -0.07367, -0.00605,  1.07602 )",
+    "	);",
+    "	color = ACESInputMat * color;",
+    // Apply RRT and ODT
+    "	color = RRTAndODTFit( color );",
+    "	color = ACESOutputMat * color;",
+    // Clamp to [0, 1]
+    "	return saturate( color );",
+    "}",
+    "void main() {",
+    "	vec4 tex = texture2D( tDiffuse, vUv );",
+    "	tex.rgb *= exposure / 0.6;",
+    // pre-exposed, outside of the tone mapping function
+    "	gl_FragColor = vec4( ACESFilmicToneMapping( tex.rgb ), tex.a );",
+    "}"
+  ].join("\n")
+};
+export {
+  ACESFilmicToneMappingShader
+};

package/dist/shaders/AfterimageShader.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Afterimage shader
+ * I created this effect inspired by a demo on codepen:
+ * https://codepen.io/brunoimbrizi/pen/MoRJaN?page=1&
+ */
+import type { IUniform, Texture } from 'three';
+import type { IShader } from './types';
+export declare type AfterimageShaderUniforms = {
+    damp: IUniform<number>;
+    tNew: IUniform<Texture | null>;
+    tOld: IUniform<Texture | null>;
+};
+export interface IAfterimageShader extends IShader<AfterimageShaderUniforms> {
+}
+export declare const AfterimageShader: IAfterimageShader;

package/dist/shaders/AfterimageShader.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const AfterimageShader = {
+  uniforms: {
+    damp: { value: 0.96 },
+    tOld: { value: null },
+    tNew: { value: null }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform float damp;",
+    "uniform sampler2D tOld;",
+    "uniform sampler2D tNew;",
+    "varying vec2 vUv;",
+    "vec4 when_gt( vec4 x, float y ) {",
+    "	return max( sign( x - y ), 0.0 );",
+    "}",
+    "void main() {",
+    "	vec4 texelOld = texture2D( tOld, vUv );",
+    "	vec4 texelNew = texture2D( tNew, vUv );",
+    "	texelOld *= damp * when_gt( texelOld, 0.1 );",
+    "	gl_FragColor = max(texelNew, texelOld);",
+    "}"
+  ].join("\n")
+};
+exports.AfterimageShader = AfterimageShader;

package/dist/shaders/AfterimageShader.mjs

@@ -0,0 +1,32 @@
+const AfterimageShader = {
+  uniforms: {
+    damp: { value: 0.96 },
+    tOld: { value: null },
+    tNew: { value: null }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform float damp;",
+    "uniform sampler2D tOld;",
+    "uniform sampler2D tNew;",
+    "varying vec2 vUv;",
+    "vec4 when_gt( vec4 x, float y ) {",
+    "	return max( sign( x - y ), 0.0 );",
+    "}",
+    "void main() {",
+    "	vec4 texelOld = texture2D( tOld, vUv );",
+    "	vec4 texelNew = texture2D( tNew, vUv );",
+    "	texelOld *= damp * when_gt( texelOld, 0.1 );",
+    "	gl_FragColor = max(texelNew, texelOld);",
+    "}"
+  ].join("\n")
+};
+export {
+  AfterimageShader
+};

package/dist/shaders/BasicShader.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Simple test shader
+ */
+import type { IShader } from './types';
+export declare type BasicShaderUniforms = {};
+export interface IBasicShader extends IShader<BasicShaderUniforms> {
+}
+export declare const BasicShader: IBasicShader;

package/dist/shaders/BasicShader.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const BasicShader = {
+  uniforms: {},
+  vertexShader: [
+    "void main() {",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: ["void main() {", "	gl_FragColor = vec4( 1.0, 0.0, 0.0, 0.5 );", "}"].join("\n")
+};
+exports.BasicShader = BasicShader;

package/dist/shaders/BasicShader.mjs

@@ -0,0 +1,12 @@
+const BasicShader = {
+  uniforms: {},
+  vertexShader: [
+    "void main() {",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: ["void main() {", "	gl_FragColor = vec4( 1.0, 0.0, 0.0, 0.5 );", "}"].join("\n")
+};
+export {
+  BasicShader
+};

package/dist/shaders/BleachBypassShader.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Bleach bypass shader [http://en.wikipedia.org/wiki/Bleach_bypass]
+ * - based on Nvidia example
+ * http://developer.download.nvidia.com/shaderlibrary/webpages/shader_library.html#post_bleach_bypass
+ */
+import type { IUniform, Texture } from 'three';
+import type { IShader } from './types';
+export declare type BleachBypassShaderUniforms = {
+    opacity: IUniform<number>;
+    tDiffuse: IUniform<Texture | null>;
+};
+export interface IBleachBypassShader extends IShader<BleachBypassShaderUniforms> {
+}
+export declare const BleachBypassShader: IBleachBypassShader;

package/dist/shaders/BleachBypassShader.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const BleachBypassShader = {
+  uniforms: {
+    tDiffuse: { value: null },
+    opacity: { value: 1 }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform float opacity;",
+    "uniform sampler2D tDiffuse;",
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vec4 base = texture2D( tDiffuse, vUv );",
+    "	vec3 lumCoeff = vec3( 0.25, 0.65, 0.1 );",
+    "	float lum = dot( lumCoeff, base.rgb );",
+    "	vec3 blend = vec3( lum );",
+    "	float L = min( 1.0, max( 0.0, 10.0 * ( lum - 0.45 ) ) );",
+    "	vec3 result1 = 2.0 * base.rgb * blend;",
+    "	vec3 result2 = 1.0 - 2.0 * ( 1.0 - blend ) * ( 1.0 - base.rgb );",
+    "	vec3 newColor = mix( result1, result2, L );",
+    "	float A2 = opacity * base.a;",
+    "	vec3 mixRGB = A2 * newColor.rgb;",
+    "	mixRGB += ( ( 1.0 - A2 ) * base.rgb );",
+    "	gl_FragColor = vec4( mixRGB, base.a );",
+    "}"
+  ].join("\n")
+};
+exports.BleachBypassShader = BleachBypassShader;

package/dist/shaders/BleachBypassShader.mjs

@@ -0,0 +1,35 @@
+const BleachBypassShader = {
+  uniforms: {
+    tDiffuse: { value: null },
+    opacity: { value: 1 }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform float opacity;",
+    "uniform sampler2D tDiffuse;",
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vec4 base = texture2D( tDiffuse, vUv );",
+    "	vec3 lumCoeff = vec3( 0.25, 0.65, 0.1 );",
+    "	float lum = dot( lumCoeff, base.rgb );",
+    "	vec3 blend = vec3( lum );",
+    "	float L = min( 1.0, max( 0.0, 10.0 * ( lum - 0.45 ) ) );",
+    "	vec3 result1 = 2.0 * base.rgb * blend;",
+    "	vec3 result2 = 1.0 - 2.0 * ( 1.0 - blend ) * ( 1.0 - base.rgb );",
+    "	vec3 newColor = mix( result1, result2, L );",
+    "	float A2 = opacity * base.a;",
+    "	vec3 mixRGB = A2 * newColor.rgb;",
+    "	mixRGB += ( ( 1.0 - A2 ) * base.rgb );",
+    "	gl_FragColor = vec4( mixRGB, base.a );",
+    "}"
+  ].join("\n")
+};
+export {
+  BleachBypassShader
+};

package/dist/shaders/BlendShader.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Blend two textures
+ */
+export declare const BlendShader: {
+    uniforms: {
+        tDiffuse1: {
+            value: null;
+        };
+        tDiffuse2: {
+            value: null;
+        };
+        mixRatio: {
+            value: number;
+        };
+        opacity: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/dist/shaders/BlendShader.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const BlendShader = {
+  uniforms: {
+    tDiffuse1: { value: null },
+    tDiffuse2: { value: null },
+    mixRatio: { value: 0.5 },
+    opacity: { value: 1 }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform float opacity;",
+    "uniform float mixRatio;",
+    "uniform sampler2D tDiffuse1;",
+    "uniform sampler2D tDiffuse2;",
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vec4 texel1 = texture2D( tDiffuse1, vUv );",
+    "	vec4 texel2 = texture2D( tDiffuse2, vUv );",
+    "	gl_FragColor = opacity * mix( texel1, texel2, mixRatio );",
+    "}"
+  ].join("\n")
+};
+exports.BlendShader = BlendShader;

package/dist/shaders/BlendShader.mjs

@@ -0,0 +1,30 @@
+const BlendShader = {
+  uniforms: {
+    tDiffuse1: { value: null },
+    tDiffuse2: { value: null },
+    mixRatio: { value: 0.5 },
+    opacity: { value: 1 }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform float opacity;",
+    "uniform float mixRatio;",
+    "uniform sampler2D tDiffuse1;",
+    "uniform sampler2D tDiffuse2;",
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vec4 texel1 = texture2D( tDiffuse1, vUv );",
+    "	vec4 texel2 = texture2D( tDiffuse2, vUv );",
+    "	gl_FragColor = opacity * mix( texel1, texel2, mixRatio );",
+    "}"
+  ].join("\n")
+};
+export {
+  BlendShader
+};