three-stdlib 2.16.0 → 2.16.2

package/renderers/webgpu/nodes/WebGPUNodeBuilder.js

@@ -1,140 +1,204 @@
-"use strict";
-const WebGPUNodeUniformsGroup = require("./WebGPUNodeUniformsGroup.js");
-const WebGPUNodeUniform = require("./WebGPUNodeUniform.js");
-const WebGPUSampler = require("../WebGPUSampler.js");
-const WebGPUSampledTexture = require("../WebGPUSampledTexture.js");
-const NodeSlot = require("../../nodes/core/NodeSlot.js");
-const NodeBuilder = require("../../nodes/core/NodeBuilder.js");
-const ModelViewProjectionNode = require("../../nodes/accessors/ModelViewProjectionNode.js");
-const ShaderLib = require("./ShaderLib.js");
+import WebGPUNodeUniformsGroup from './WebGPUNodeUniformsGroup.js';
+import { FloatNodeUniform, Vector2NodeUniform, Vector3NodeUniform, Vector4NodeUniform, ColorNodeUniform, Matrix3NodeUniform, Matrix4NodeUniform } from './WebGPUNodeUniform.js';
+import WebGPUSampler from '../WebGPUSampler.js';
+import { WebGPUSampledTexture } from '../WebGPUSampledTexture.js';
+import NodeSlot from '../../nodes/core/NodeSlot.js';
+import NodeBuilder from '../../nodes/core/NodeBuilder.js';
+import ModelViewProjectionNode from '../../nodes/accessors/ModelViewProjectionNode.js';
+import ShaderLib from './ShaderLib.js';
+import '../WebGPUUniformsGroup.js';
+import '../WebGPUBinding.js';
+import '../constants.js';
+import '../WebGPUUniform.js';
+import 'three';
+import '../../nodes/core/NodeUniform.js';
+import '../../nodes/core/NodeAttribute.js';
+import '../../nodes/core/NodeVary.js';
+import '../../nodes/core/constants.js';
+import '../../nodes/core/Node.js';
+import '../../nodes/accessors/CameraNode.js';
+import '@babel/runtime/helpers/esm/defineProperty';
+import '../../nodes/inputs/Vector3Node.js';
+import '../../nodes/core/InputNode.js';
+import '../../nodes/inputs/Matrix4Node.js';
+import '../../nodes/accessors/ModelNode.js';
+import '../../nodes/inputs/Matrix3Node.js';
+import '../../nodes/math/OperatorNode.js';
+import '../../nodes/accessors/PositionNode.js';
+import '../../nodes/core/AttributeNode.js';
+
 class WebGPUNodeBuilder extends NodeBuilder {
   constructor(material, renderer) {
     super(material, renderer);
-    this.bindings = { vertex: [], fragment: [] };
-    this.bindingsOffset = { vertex: 0, fragment: 0 };
+    this.bindings = {
+      vertex: [],
+      fragment: []
+    };
+    this.bindingsOffset = {
+      vertex: 0,
+      fragment: 0
+    };
     this.uniformsGroup = {};
     this.nativeShader = null;
+
     this._parseMaterial();
   }
+
   _parseMaterial() {
-    const material = this.material;
-    this.nativeShader = ShaderLib.common;
+    const material = this.material; // get shader
+
+    this.nativeShader = ShaderLib.common; // parse inputs
+
     if (material.isMeshBasicMaterial || material.isPointsMaterial || material.isLineBasicMaterial) {
       const mvpNode = new ModelViewProjectionNode();
-      if (material.positionNode !== void 0) {
+
+      if (material.positionNode !== undefined) {
         mvpNode.position = material.positionNode;
       }
-      this.addSlot("vertex", new NodeSlot(mvpNode, "MVP", "vec4"));
-      if (material.colorNode !== void 0) {
-        this.addSlot("fragment", new NodeSlot(material.colorNode, "COLOR", "vec4"));
+
+      this.addSlot('vertex', new NodeSlot(mvpNode, 'MVP', 'vec4'));
+
+      if (material.colorNode !== undefined) {
+        this.addSlot('fragment', new NodeSlot(material.colorNode, 'COLOR', 'vec4'));
       }
-      if (material.opacityNode !== void 0) {
-        this.addSlot("fragment", new NodeSlot(material.opacityNode, "OPACITY", "float"));
+
+      if (material.opacityNode !== undefined) {
+        this.addSlot('fragment', new NodeSlot(material.opacityNode, 'OPACITY', 'float'));
       }
     }
   }
+
   getTexture(textureProperty, uvSnippet) {
     return `texture( sampler2D( ${textureProperty}, ${textureProperty}_sampler ), ${uvSnippet} )`;
   }
+
   getPropertyName(node) {
     if (node.isNodeUniform) {
       const name = node.name;
       const type = node.type;
-      if (type === "texture") {
+
+      if (type === 'texture') {
         return name;
       } else {
         return `nodeUniforms.${name}`;
       }
     }
+
     return super.getPropertyName(node);
   }
+
   getBindings() {
     const bindings = this.bindings;
     return [...bindings.vertex, ...bindings.fragment];
   }
+
   getUniformFromNode(node, shaderStage, type) {
     const uniformNode = super.getUniformFromNode(node, shaderStage, type);
     const nodeData = this.getDataFromNode(node, shaderStage);
-    if (nodeData.uniformGPU === void 0) {
+
+    if (nodeData.uniformGPU === undefined) {
       let uniformGPU;
       const bindings = this.bindings[shaderStage];
-      if (type === "texture") {
+
+      if (type === 'texture') {
         const sampler = new WebGPUSampler(`${uniformNode.name}_sampler`, uniformNode.value);
-        const texture = new WebGPUSampledTexture.WebGPUSampledTexture(uniformNode.name, uniformNode.value);
+        const texture = new WebGPUSampledTexture(uniformNode.name, uniformNode.value); // add first textures in sequence and group for last
+
         const lastBinding = bindings[bindings.length - 1];
         const index = lastBinding && lastBinding.isUniformsGroup ? bindings.length - 1 : bindings.length;
         bindings.splice(index, 0, sampler, texture);
-        uniformGPU = { sampler, texture };
+        uniformGPU = {
+          sampler,
+          texture
+        };
       } else {
         let uniformsGroup = this.uniformsGroup[shaderStage];
-        if (uniformsGroup === void 0) {
+
+        if (uniformsGroup === undefined) {
           uniformsGroup = new WebGPUNodeUniformsGroup(shaderStage);
           this.uniformsGroup[shaderStage] = uniformsGroup;
           bindings.push(uniformsGroup);
         }
-        if (type === "float") {
-          uniformGPU = new WebGPUNodeUniform.FloatNodeUniform(uniformNode);
-        } else if (type === "vec2") {
-          uniformGPU = new WebGPUNodeUniform.Vector2NodeUniform(uniformNode);
-        } else if (type === "vec3") {
-          uniformGPU = new WebGPUNodeUniform.Vector3NodeUniform(uniformNode);
-        } else if (type === "vec4") {
-          uniformGPU = new WebGPUNodeUniform.Vector4NodeUniform(uniformNode);
-        } else if (type === "color") {
-          uniformGPU = new WebGPUNodeUniform.ColorNodeUniform(uniformNode);
-        } else if (type === "mat3") {
-          uniformGPU = new WebGPUNodeUniform.Matrix3NodeUniform(uniformNode);
-        } else if (type === "mat4") {
-          uniformGPU = new WebGPUNodeUniform.Matrix4NodeUniform(uniformNode);
+
+        if (type === 'float') {
+          uniformGPU = new FloatNodeUniform(uniformNode);
+        } else if (type === 'vec2') {
+          uniformGPU = new Vector2NodeUniform(uniformNode);
+        } else if (type === 'vec3') {
+          uniformGPU = new Vector3NodeUniform(uniformNode);
+        } else if (type === 'vec4') {
+          uniformGPU = new Vector4NodeUniform(uniformNode);
+        } else if (type === 'color') {
+          uniformGPU = new ColorNodeUniform(uniformNode);
+        } else if (type === 'mat3') {
+          uniformGPU = new Matrix3NodeUniform(uniformNode);
+        } else if (type === 'mat4') {
+          uniformGPU = new Matrix4NodeUniform(uniformNode);
         } else {
           throw new Error(`Uniform "${type}" not declared.`);
         }
+
         uniformsGroup.addUniform(uniformGPU);
       }
+
       nodeData.uniformGPU = uniformGPU;
-      if (shaderStage === "vertex") {
-        this.bindingsOffset["fragment"] = bindings.length;
+
+      if (shaderStage === 'vertex') {
+        this.bindingsOffset['fragment'] = bindings.length;
       }
     }
+
     return uniformNode;
   }
+
   getAttributesHeaderSnippet(shaderStage) {
-    let snippet = "";
-    if (shaderStage === "vertex") {
+    let snippet = '';
+
+    if (shaderStage === 'vertex') {
       const attributes = this.attributes;
+
       for (let index = 0; index < attributes.length; index++) {
         const attribute = attributes[index];
         snippet += `layout(location = ${index}) in ${attribute.type} ${attribute.name};`;
       }
     }
+
     return snippet;
   }
+
   getVarysHeaderSnippet(shaderStage) {
-    let snippet = "";
+    let snippet = '';
     const varys = this.varys;
-    const ioStage = shaderStage === "vertex" ? "out" : "in";
+    const ioStage = shaderStage === 'vertex' ? 'out' : 'in';
+
     for (let index = 0; index < varys.length; index++) {
       const vary = varys[index];
       snippet += `layout(location = ${index}) ${ioStage} ${vary.type} ${vary.name};`;
     }
+
     return snippet;
   }
+
   getVarysBodySnippet(shaderStage) {
-    let snippet = "";
-    if (shaderStage === "vertex") {
+    let snippet = '';
+
+    if (shaderStage === 'vertex') {
       for (let vary of this.varys) {
         snippet += `${vary.name} = ${vary.snippet};`;
       }
     }
+
     return snippet;
   }
+
   getUniformsHeaderSnippet(shaderStage) {
     const uniforms = this.uniforms[shaderStage];
-    let snippet = "";
-    let groupSnippet = "";
+    let snippet = '';
+    let groupSnippet = '';
     let index = this.bindingsOffset[shaderStage];
+
     for (let uniform of uniforms) {
-      if (uniform.type === "texture") {
+      if (uniform.type === 'texture') {
         snippet += `layout(set = 0, binding = ${index++}) uniform sampler ${uniform.name}_sampler;`;
         snippet += `layout(set = 0, binding = ${index++}) uniform texture2D ${uniform.name};`;
       } else {
@@ -142,23 +206,30 @@ class WebGPUNodeBuilder extends NodeBuilder {
         groupSnippet += `uniform ${vectorType} ${uniform.name};`;
       }
     }
+
     if (groupSnippet) {
       snippet += `layout(set = 0, binding = ${index++}) uniform NodeUniforms { ${groupSnippet} } nodeUniforms;`;
     }
+
     return snippet;
   }
+
   composeShaderCode(code, snippet) {
-    const versionStrIndex = code.indexOf("\n");
-    let finalCode = code.substr(0, versionStrIndex) + "\n\n";
+    // use regex maybe for security?
+    const versionStrIndex = code.indexOf('\n');
+    let finalCode = code.substr(0, versionStrIndex) + '\n\n';
     finalCode += snippet;
     finalCode += code.substr(versionStrIndex);
     return finalCode;
   }
+
   build() {
     super.build();
     this.vertexShader = this.composeShaderCode(this.nativeShader.vertexShader, this.vertexShader);
     this.fragmentShader = this.composeShaderCode(this.nativeShader.fragmentShader, this.fragmentShader);
     return this;
   }
+
 }
-module.exports = WebGPUNodeBuilder;
+
+export default WebGPUNodeBuilder;

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../WebGPUUniform.cjs.js");require("three");class r extends e.FloatUniform{constructor(e){super(e.name,e.value),this.nodeUniform=e}getValue(){return this.nodeUniform.value}}class o extends e.Vector2Uniform{constructor(e){super(e.name,e.value),this.nodeUniform=e}getValue(){return this.nodeUniform.value}}class t extends e.Vector3Uniform{constructor(e){super(e.name,e.value),this.nodeUniform=e}getValue(){return this.nodeUniform.value}}class n extends e.Vector4Uniform{constructor(e){super(e.name,e.value),this.nodeUniform=e}getValue(){return this.nodeUniform.value}}class s extends e.ColorUniform{constructor(e){super(e.name,e.value),this.nodeUniform=e}getValue(){return this.nodeUniform.value}}class i extends e.Matrix3Uniform{constructor(e){super(e.name,e.value),this.nodeUniform=e}getValue(){return this.nodeUniform.value}}class u extends e.Matrix4Uniform{constructor(e){super(e.name,e.value),this.nodeUniform=e}getValue(){return this.nodeUniform.value}}exports.ColorNodeUniform=s,exports.FloatNodeUniform=r,exports.Matrix3NodeUniform=i,exports.Matrix4NodeUniform=u,exports.Vector2NodeUniform=o,exports.Vector3NodeUniform=t,exports.Vector4NodeUniform=n;

package/renderers/webgpu/nodes/WebGPUNodeUniform.js

@@ -1,73 +1,87 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const WebGPUUniform = require("../WebGPUUniform.js");
-class FloatNodeUniform extends WebGPUUniform.FloatUniform {
+import { FloatUniform, Vector2Uniform, Vector3Uniform, Vector4Uniform, ColorUniform, Matrix3Uniform, Matrix4Uniform } from '../WebGPUUniform.js';
+
+class FloatNodeUniform extends FloatUniform {
   constructor(nodeUniform) {
     super(nodeUniform.name, nodeUniform.value);
     this.nodeUniform = nodeUniform;
   }
+
   getValue() {
     return this.nodeUniform.value;
   }
+
 }
-class Vector2NodeUniform extends WebGPUUniform.Vector2Uniform {
+
+class Vector2NodeUniform extends Vector2Uniform {
   constructor(nodeUniform) {
     super(nodeUniform.name, nodeUniform.value);
     this.nodeUniform = nodeUniform;
   }
+
   getValue() {
     return this.nodeUniform.value;
   }
+
 }
-class Vector3NodeUniform extends WebGPUUniform.Vector3Uniform {
+
+class Vector3NodeUniform extends Vector3Uniform {
   constructor(nodeUniform) {
     super(nodeUniform.name, nodeUniform.value);
     this.nodeUniform = nodeUniform;
   }
+
   getValue() {
     return this.nodeUniform.value;
   }
+
 }
-class Vector4NodeUniform extends WebGPUUniform.Vector4Uniform {
+
+class Vector4NodeUniform extends Vector4Uniform {
   constructor(nodeUniform) {
     super(nodeUniform.name, nodeUniform.value);
     this.nodeUniform = nodeUniform;
   }
+
   getValue() {
     return this.nodeUniform.value;
   }
+
 }
-class ColorNodeUniform extends WebGPUUniform.ColorUniform {
+
+class ColorNodeUniform extends ColorUniform {
   constructor(nodeUniform) {
     super(nodeUniform.name, nodeUniform.value);
     this.nodeUniform = nodeUniform;
   }
+
   getValue() {
     return this.nodeUniform.value;
   }
+
 }
-class Matrix3NodeUniform extends WebGPUUniform.Matrix3Uniform {
+
+class Matrix3NodeUniform extends Matrix3Uniform {
   constructor(nodeUniform) {
     super(nodeUniform.name, nodeUniform.value);
     this.nodeUniform = nodeUniform;
   }
+
   getValue() {
     return this.nodeUniform.value;
   }
+
 }
-class Matrix4NodeUniform extends WebGPUUniform.Matrix4Uniform {
+
+class Matrix4NodeUniform extends 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;
+
+export { ColorNodeUniform, FloatNodeUniform, Matrix3NodeUniform, Matrix4NodeUniform, Vector2NodeUniform, Vector3NodeUniform, Vector4NodeUniform };

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

@@ -0,0 +1 @@
+"use strict";var e=require("../WebGPUUniformsGroup.cjs.js");require("../WebGPUBinding.cjs.js"),require("../constants.cjs.js");module.exports=class extends e{constructor(e){let s;super("nodeUniforms"),"vertex"===e?s=GPUShaderStage.VERTEX:"fragment"===e&&(s=GPUShaderStage.FRAGMENT),this.setVisibility(s)}};

package/renderers/webgpu/nodes/WebGPUNodeUniformsGroup.js

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

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

@@ -0,0 +1 @@
+"use strict";var e=require("./WebGPUNodeBuilder.cjs.js"),r=require("../../nodes/core/NodeFrame.cjs.js");require("./WebGPUNodeUniformsGroup.cjs.js"),require("../WebGPUUniformsGroup.cjs.js"),require("../WebGPUBinding.cjs.js"),require("../constants.cjs.js"),require("./WebGPUNodeUniform.cjs.js"),require("../WebGPUUniform.cjs.js"),require("three"),require("../WebGPUSampler.cjs.js"),require("../WebGPUSampledTexture.cjs.js"),require("../../nodes/core/NodeSlot.cjs.js"),require("../../nodes/core/NodeBuilder.cjs.js"),require("../../nodes/core/NodeUniform.cjs.js"),require("../../nodes/core/NodeAttribute.cjs.js"),require("../../nodes/core/NodeVary.cjs.js"),require("../../nodes/core/constants.cjs.js"),require("../../nodes/accessors/ModelViewProjectionNode.cjs.js"),require("../../nodes/core/Node.cjs.js"),require("../../nodes/accessors/CameraNode.cjs.js"),require("@babel/runtime/helpers/defineProperty"),require("../../nodes/inputs/Vector3Node.cjs.js"),require("../../nodes/core/InputNode.cjs.js"),require("../../nodes/inputs/Matrix4Node.cjs.js"),require("../../nodes/accessors/ModelNode.cjs.js"),require("../../nodes/inputs/Matrix3Node.cjs.js"),require("../../nodes/math/OperatorNode.cjs.js"),require("../../nodes/accessors/PositionNode.cjs.js"),require("../../nodes/core/AttributeNode.cjs.js"),require("./ShaderLib.cjs.js");module.exports=class{constructor(e){this.renderer=e,this.nodeFrame=new r,this.builders=new WeakMap}get(r){let s=this.builders.get(r);return void 0===s&&(s=new e(r,this.renderer).build(),this.builders.set(r,s)),s}remove(e){this.builders.delete(e)}updateFrame(){this.nodeFrame.update()}update(e,r){const s=e.material,o=this.get(s),i=this.nodeFrame;i.material=s,i.camera=r,i.object=e;for(let e of o.updateNodes)i.updateNode(e)}dispose(){this.builders=new WeakMap}};

package/renderers/webgpu/nodes/WebGPUNodes.js

@@ -1,26 +1,60 @@
-"use strict";
-const WebGPUNodeBuilder = require("./WebGPUNodeBuilder.js");
-const NodeFrame = require("../../nodes/core/NodeFrame.js");
+import WebGPUNodeBuilder from './WebGPUNodeBuilder.js';
+import NodeFrame from '../../nodes/core/NodeFrame.js';
+import './WebGPUNodeUniformsGroup.js';
+import '../WebGPUUniformsGroup.js';
+import '../WebGPUBinding.js';
+import '../constants.js';
+import './WebGPUNodeUniform.js';
+import '../WebGPUUniform.js';
+import 'three';
+import '../WebGPUSampler.js';
+import '../WebGPUSampledTexture.js';
+import '../../nodes/core/NodeSlot.js';
+import '../../nodes/core/NodeBuilder.js';
+import '../../nodes/core/NodeUniform.js';
+import '../../nodes/core/NodeAttribute.js';
+import '../../nodes/core/NodeVary.js';
+import '../../nodes/core/constants.js';
+import '../../nodes/accessors/ModelViewProjectionNode.js';
+import '../../nodes/core/Node.js';
+import '../../nodes/accessors/CameraNode.js';
+import '@babel/runtime/helpers/esm/defineProperty';
+import '../../nodes/inputs/Vector3Node.js';
+import '../../nodes/core/InputNode.js';
+import '../../nodes/inputs/Matrix4Node.js';
+import '../../nodes/accessors/ModelNode.js';
+import '../../nodes/inputs/Matrix3Node.js';
+import '../../nodes/math/OperatorNode.js';
+import '../../nodes/accessors/PositionNode.js';
+import '../../nodes/core/AttributeNode.js';
+import './ShaderLib.js';
+
 class WebGPUNodes {
   constructor(renderer) {
     this.renderer = renderer;
     this.nodeFrame = new NodeFrame();
-    this.builders = /* @__PURE__ */ new WeakMap();
+    this.builders = new WeakMap();
   }
+
   get(material) {
     let nodeBuilder = this.builders.get(material);
-    if (nodeBuilder === void 0) {
+
+    if (nodeBuilder === undefined) {
       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);
@@ -28,12 +62,16 @@ class WebGPUNodes {
     nodeFrame.material = material;
     nodeFrame.camera = camera;
     nodeFrame.object = object;
+
     for (let node of nodeBuilder.updateNodes) {
       nodeFrame.updateNode(node);
     }
   }
+
   dispose() {
-    this.builders = /* @__PURE__ */ new WeakMap();
+    this.builders = new WeakMap();
   }
+
 }
-module.exports = WebGPUNodes;
+
+export default WebGPUNodes;

package/shaders/ACESFilmicToneMappingShader.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const t={uniforms:{tDiffuse:{value:null},exposure:{value:1}},vertexShader:["varying vec2 vUv;","void main() {","\tvUv = uv;","\tgl_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 ) {","\tvec3 a = v * ( v + 0.0245786 ) - 0.000090537;","\tvec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;","\treturn a / b;","}","vec3 ACESFilmicToneMapping( vec3 color ) {","\tconst mat3 ACESInputMat = mat3(","\t\tvec3( 0.59719, 0.07600, 0.02840 ),","\t\tvec3( 0.35458, 0.90834, 0.13383 ),","\t\tvec3( 0.04823, 0.01566, 0.83777 )","\t);","\tconst mat3 ACESOutputMat = mat3(","\t\tvec3(  1.60475, -0.10208, -0.00327 ),","\t\tvec3( -0.53108,  1.10813, -0.07276 ),","\t\tvec3( -0.07367, -0.00605,  1.07602 )","\t);","\tcolor = ACESInputMat * color;","\tcolor = RRTAndODTFit( color );","\tcolor = ACESOutputMat * color;","\treturn saturate( color );","}","void main() {","\tvec4 tex = texture2D( tDiffuse, vUv );","\ttex.rgb *= exposure / 0.6;","\tgl_FragColor = vec4( ACESFilmicToneMapping( tex.rgb ), tex.a );","}"].join("\n")};exports.ACESFilmicToneMappingShader=t;

package/shaders/ACESFilmicToneMappingShader.js

@@ -1,48 +1,28 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+/**
+ * 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.
+ */
 const ACESFilmicToneMappingShader = {
   uniforms: {
-    tDiffuse: { value: null },
-    exposure: { value: 1 }
+    tDiffuse: {
+      value: null
+    },
+    exposure: {
+      value: 1.0
+    }
   },
-  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 ) {",
-    "	const mat3 ACESInputMat = mat3(",
-    "		vec3( 0.59719, 0.07600, 0.02840 ),",
-    "		vec3( 0.35458, 0.90834, 0.13383 ),",
-    "		vec3( 0.04823, 0.01566, 0.83777 )",
-    "	);",
-    "	const mat3 ACESOutputMat = mat3(",
-    "		vec3(  1.60475, -0.10208, -0.00327 ),",
-    "		vec3( -0.53108,  1.10813, -0.07276 ),",
-    "		vec3( -0.07367, -0.00605,  1.07602 )",
-    "	);",
-    "	color = ACESInputMat * color;",
-    "	color = RRTAndODTFit( color );",
-    "	color = ACESOutputMat * color;",
-    "	return saturate( color );",
-    "}",
-    "void main() {",
-    "	vec4 tex = texture2D( tDiffuse, vUv );",
-    "	tex.rgb *= exposure / 0.6;",
-    "	gl_FragColor = vec4( ACESFilmicToneMapping( tex.rgb ), tex.a );",
-    "}"
-  ].join("\n")
+  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;
+
+export { ACESFilmicToneMappingShader };

package/shaders/AfterimageShader.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const e={uniforms:{damp:{value:.96},tOld:{value:null},tNew:{value:null}},vertexShader:["varying vec2 vUv;","void main() {","\tvUv = uv;","\tgl_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 ) {","\treturn max( sign( x - y ), 0.0 );","}","void main() {","\tvec4 texelOld = texture2D( tOld, vUv );","\tvec4 texelNew = texture2D( tNew, vUv );","\ttexelOld *= damp * when_gt( texelOld, 0.1 );","\tgl_FragColor = max(texelNew, texelOld);","}"].join("\n")};exports.AfterimageShader=e;

package/shaders/AfterimageShader.js

@@ -1,32 +1,22 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+/**
+ * Afterimage shader
+ * I created this effect inspired by a demo on codepen:
+ * https://codepen.io/brunoimbrizi/pen/MoRJaN?page=1&
+ */
 const AfterimageShader = {
   uniforms: {
-    damp: { value: 0.96 },
-    tOld: { value: null },
-    tNew: { value: null }
+    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")
+  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;
+
+export { AfterimageShader };