three-stdlib 2.15.1 → 2.16.0

package/renderers/webgpu/WebGPUSampler.js

@@ -1,19 +1,14 @@
-import WebGPUBinding from './WebGPUBinding.js';
-import { GPUBindingType } from './constants.js';
-
+"use strict";
+const WebGPUBinding = require("./WebGPUBinding.js");
+const constants = require("./constants.js");
 class WebGPUSampler extends WebGPUBinding {
   constructor(name, texture) {
     super(name);
     this.texture = texture;
-    this.type = GPUBindingType.Sampler;
+    this.type = constants.GPUBindingType.Sampler;
     this.visibility = GPUShaderStage.FRAGMENT;
-    this.samplerGPU = null; // set by the renderer
-
-    Object.defineProperty(this, 'isSampler', {
-      value: true
-    });
+    this.samplerGPU = null;
+    Object.defineProperty(this, "isSampler", { value: true });
   }
-
 }
-
-export default WebGPUSampler;
+module.exports = WebGPUSampler;

package/renderers/webgpu/WebGPUSampler.mjs

@@ -0,0 +1,15 @@
+import WebGPUBinding from "./WebGPUBinding.mjs";
+import { GPUBindingType } from "./constants.mjs";
+class WebGPUSampler extends WebGPUBinding {
+  constructor(name, texture) {
+    super(name);
+    this.texture = texture;
+    this.type = GPUBindingType.Sampler;
+    this.visibility = GPUShaderStage.FRAGMENT;
+    this.samplerGPU = null;
+    Object.defineProperty(this, "isSampler", { value: true });
+  }
+}
+export {
+  WebGPUSampler as default
+};

package/renderers/webgpu/WebGPUStorageBuffer.js

@@ -1,19 +1,14 @@
-import WebGPUBinding from './WebGPUBinding.js';
-import { GPUBindingType } from './constants.js';
-
+"use strict";
+const WebGPUBinding = require("./WebGPUBinding.js");
+const constants = require("./constants.js");
 class WebGPUStorageBuffer extends WebGPUBinding {
   constructor(name, attribute) {
     super(name);
-    this.type = GPUBindingType.StorageBuffer;
+    this.type = constants.GPUBindingType.StorageBuffer;
     this.usage = GPUBufferUsage.VERTEX | GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST;
     this.attribute = attribute;
-    this.bufferGPU = null; // set by the renderer
-
-    Object.defineProperty(this, 'isStorageBuffer', {
-      value: true
-    });
+    this.bufferGPU = null;
+    Object.defineProperty(this, "isStorageBuffer", { value: true });
   }
-
 }
-
-export default WebGPUStorageBuffer;
+module.exports = WebGPUStorageBuffer;

package/renderers/webgpu/WebGPUStorageBuffer.mjs

@@ -0,0 +1,15 @@
+import WebGPUBinding from "./WebGPUBinding.mjs";
+import { GPUBindingType } from "./constants.mjs";
+class WebGPUStorageBuffer extends WebGPUBinding {
+  constructor(name, attribute) {
+    super(name);
+    this.type = GPUBindingType.StorageBuffer;
+    this.usage = GPUBufferUsage.VERTEX | GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST;
+    this.attribute = attribute;
+    this.bufferGPU = null;
+    Object.defineProperty(this, "isStorageBuffer", { value: true });
+  }
+}
+export {
+  WebGPUStorageBuffer as default
+};

package/renderers/webgpu/WebGPUTextureRenderer.js

@@ -1,20 +1,16 @@
-import { WebGLRenderTarget } from 'three';
-
+"use strict";
+const THREE = require("three");
 class WebGPUTextureRenderer {
   constructor(renderer, options = {}) {
-    this.renderer = renderer; // @TODO: Consider to introduce WebGPURenderTarget or rename WebGLRenderTarget to just RenderTarget
-
-    this.renderTarget = new WebGLRenderTarget(options);
+    this.renderer = renderer;
+    this.renderTarget = new THREE.WebGLRenderTarget(options);
   }
-
   getTexture() {
     return this.renderTarget.texture;
   }
-
   setSize(width, height) {
     this.renderTarget.setSize(width, height);
   }
-
   render(scene, camera) {
     const renderer = this.renderer;
     const renderTarget = this.renderTarget;
@@ -22,7 +18,5 @@ class WebGPUTextureRenderer {
     renderer.render(scene, camera);
     renderer.setRenderTarget(null);
   }
-
 }
-
-export default WebGPUTextureRenderer;
+module.exports = WebGPUTextureRenderer;

package/renderers/webgpu/WebGPUTextureRenderer.mjs

@@ -0,0 +1,23 @@
+import { WebGLRenderTarget } from "three";
+class WebGPUTextureRenderer {
+  constructor(renderer, options = {}) {
+    this.renderer = renderer;
+    this.renderTarget = new WebGLRenderTarget(options);
+  }
+  getTexture() {
+    return this.renderTarget.texture;
+  }
+  setSize(width, height) {
+    this.renderTarget.setSize(width, height);
+  }
+  render(scene, camera) {
+    const renderer = this.renderer;
+    const renderTarget = this.renderTarget;
+    renderer.setRenderTarget(renderTarget);
+    renderer.render(scene, camera);
+    renderer.setRenderTarget(null);
+  }
+}
+export {
+  WebGPUTextureRenderer as default
+};

package/renderers/webgpu/WebGPUTextureUtils.js

@@ -1,7 +1,5 @@
-import { GPUFilterMode, GPUPrimitiveTopology, GPUIndexFormat } from './constants.js';
-
-// Copyright 2020 Brandon Jones
-
+"use strict";
+const constants = require("./constants.js");
 class WebGPUTextureUtils {
   constructor(device, glslang) {
     this.device = device;
@@ -22,76 +20,70 @@ class WebGPUTextureUtils {
 			void main() {
 				outColor = texture(sampler2D(img, imgSampler), vTex);
 			}`;
-    this.sampler = device.createSampler({
-      minFilter: GPUFilterMode.Linear
-    }); // We'll need a new pipeline for every texture format used.
-
+    this.sampler = device.createSampler({ minFilter: constants.GPUFilterMode.Linear });
     this.pipelines = {};
     this.mipmapVertexShaderModule = device.createShaderModule({
-      code: glslang.compileGLSL(mipmapVertexSource, 'vertex')
+      code: glslang.compileGLSL(mipmapVertexSource, "vertex")
     });
     this.mipmapFragmentShaderModule = device.createShaderModule({
-      code: glslang.compileGLSL(mipmapFragmentSource, 'fragment')
+      code: glslang.compileGLSL(mipmapFragmentSource, "fragment")
     });
   }
-
   getMipmapPipeline(format) {
     let pipeline = this.pipelines[format];
-
-    if (pipeline === undefined) {
+    if (pipeline === void 0) {
       pipeline = this.device.createRenderPipeline({
         vertexStage: {
           module: this.mipmapVertexShaderModule,
-          entryPoint: 'main'
+          entryPoint: "main"
         },
         fragmentStage: {
           module: this.mipmapFragmentShaderModule,
-          entryPoint: 'main'
+          entryPoint: "main"
         },
-        primitiveTopology: GPUPrimitiveTopology.TriangleStrip,
+        primitiveTopology: constants.GPUPrimitiveTopology.TriangleStrip,
         vertexState: {
-          indexFormat: GPUIndexFormat.Uint32
+          indexFormat: constants.GPUIndexFormat.Uint32
         },
-        colorStates: [{
-          format
-        }]
+        colorStates: [{ format }]
       });
       this.pipelines[format] = pipeline;
     }
-
     return pipeline;
   }
-
   generateMipmaps(textureGPU, textureGPUDescriptor) {
     const pipeline = this.getMipmapPipeline(textureGPUDescriptor.format);
     const commandEncoder = this.device.createCommandEncoder({});
-    const bindGroupLayout = pipeline.getBindGroupLayout(0); // @TODO: Consider making this static.
-
+    const bindGroupLayout = pipeline.getBindGroupLayout(0);
     let srcView = textureGPU.createView({
       baseMipLevel: 0,
       mipLevelCount: 1
     });
-
     for (let i = 1; i < textureGPUDescriptor.mipLevelCount; i++) {
       const dstView = textureGPU.createView({
         baseMipLevel: i,
         mipLevelCount: 1
       });
       const passEncoder = commandEncoder.beginRenderPass({
-        colorAttachments: [{
-          attachment: dstView,
-          loadValue: [0, 0, 0, 0]
-        }]
+        colorAttachments: [
+          {
+            attachment: dstView,
+            loadValue: [0, 0, 0, 0]
+          }
+        ]
       });
       const bindGroup = this.device.createBindGroup({
         layout: bindGroupLayout,
-        entries: [{
-          binding: 0,
-          resource: this.sampler
-        }, {
-          binding: 1,
-          resource: srcView
-        }]
+        entries: [
+          {
+            binding: 0,
+            resource: this.sampler
+          },
+          {
+            binding: 1,
+            resource: srcView
+          }
+        ]
       });
       passEncoder.setPipeline(pipeline);
       passEncoder.setBindGroup(0, bindGroup);
@@ -99,10 +91,7 @@ class WebGPUTextureUtils {
       passEncoder.endPass();
       srcView = dstView;
     }
-
     this.device.queue.submit([commandEncoder.finish()]);
   }
-
 }
-
-export default WebGPUTextureUtils;
+module.exports = WebGPUTextureUtils;

package/renderers/webgpu/WebGPUTextureUtils.mjs

@@ -0,0 +1,98 @@
+import { GPUFilterMode, GPUPrimitiveTopology, GPUIndexFormat } from "./constants.mjs";
+class WebGPUTextureUtils {
+  constructor(device, glslang) {
+    this.device = device;
+    const mipmapVertexSource = `#version 450
+			const vec2 pos[4] = vec2[4](vec2(-1.0f, 1.0f), vec2(1.0f, 1.0f), vec2(-1.0f, -1.0f), vec2(1.0f, -1.0f));
+			const vec2 tex[4] = vec2[4](vec2(0.0f, 0.0f), vec2(1.0f, 0.0f), vec2(0.0f, 1.0f), vec2(1.0f, 1.0f));
+			layout(location = 0) out vec2 vTex;
+			void main() {
+				vTex = tex[gl_VertexIndex];
+				gl_Position = vec4(pos[gl_VertexIndex], 0.0, 1.0);
+			}
+		`;
+    const mipmapFragmentSource = `#version 450
+			layout(set = 0, binding = 0) uniform sampler imgSampler;
+			layout(set = 0, binding = 1) uniform texture2D img;
+			layout(location = 0) in vec2 vTex;
+			layout(location = 0) out vec4 outColor;
+			void main() {
+				outColor = texture(sampler2D(img, imgSampler), vTex);
+			}`;
+    this.sampler = device.createSampler({ minFilter: GPUFilterMode.Linear });
+    this.pipelines = {};
+    this.mipmapVertexShaderModule = device.createShaderModule({
+      code: glslang.compileGLSL(mipmapVertexSource, "vertex")
+    });
+    this.mipmapFragmentShaderModule = device.createShaderModule({
+      code: glslang.compileGLSL(mipmapFragmentSource, "fragment")
+    });
+  }
+  getMipmapPipeline(format) {
+    let pipeline = this.pipelines[format];
+    if (pipeline === void 0) {
+      pipeline = this.device.createRenderPipeline({
+        vertexStage: {
+          module: this.mipmapVertexShaderModule,
+          entryPoint: "main"
+        },
+        fragmentStage: {
+          module: this.mipmapFragmentShaderModule,
+          entryPoint: "main"
+        },
+        primitiveTopology: GPUPrimitiveTopology.TriangleStrip,
+        vertexState: {
+          indexFormat: GPUIndexFormat.Uint32
+        },
+        colorStates: [{ format }]
+      });
+      this.pipelines[format] = pipeline;
+    }
+    return pipeline;
+  }
+  generateMipmaps(textureGPU, textureGPUDescriptor) {
+    const pipeline = this.getMipmapPipeline(textureGPUDescriptor.format);
+    const commandEncoder = this.device.createCommandEncoder({});
+    const bindGroupLayout = pipeline.getBindGroupLayout(0);
+    let srcView = textureGPU.createView({
+      baseMipLevel: 0,
+      mipLevelCount: 1
+    });
+    for (let i = 1; i < textureGPUDescriptor.mipLevelCount; i++) {
+      const dstView = textureGPU.createView({
+        baseMipLevel: i,
+        mipLevelCount: 1
+      });
+      const passEncoder = commandEncoder.beginRenderPass({
+        colorAttachments: [
+          {
+            attachment: dstView,
+            loadValue: [0, 0, 0, 0]
+          }
+        ]
+      });
+      const bindGroup = this.device.createBindGroup({
+        layout: bindGroupLayout,
+        entries: [
+          {
+            binding: 0,
+            resource: this.sampler
+          },
+          {
+            binding: 1,
+            resource: srcView
+          }
+        ]
+      });
+      passEncoder.setPipeline(pipeline);
+      passEncoder.setBindGroup(0, bindGroup);
+      passEncoder.draw(4, 1, 0, 0);
+      passEncoder.endPass();
+      srcView = dstView;
+    }
+    this.device.queue.submit([commandEncoder.finish()]);
+  }
+}
+export {
+  WebGPUTextureUtils as default
+};