Home Explore Help
Register Sign In
zhangyupeng
/
Babylon.js
1
0
Fork 0
Files Issues 0 Pull Requests 0 Wiki
Browse Source

Local Dev Setup

Sebastien Vandenberghe 6 years ago
parent
d0419d4911
commit
b2faf09590
4 changed files with 324 additions and 148 deletions
Unified View Show Diff Stats
  1. 3 0
      .gitignore
  2. 9 1
      Tools/DevLoader/BabylonLoader.js
  3. 152 0
      localDevWebGPU/index.html
  4. 160 147
      src/LibDeclarations/webgpu.d.ts

+ 3 - 0
.gitignore
View File 

@@ -180,6 +180,9 @@ localDev/src/*
 
 package-lock.json

 package-lock.json

 dist/preview release/package/

 dist/preview release/package/

 

 

+# local dev WebGPU

+localDevWebGPU/src/*

+

 # viewer dist files

 # viewer dist files

 /Viewer/dist/viewer.js

 /Viewer/dist/viewer.js

 /Viewer/dist/viewer.min.js

 /Viewer/dist/viewer.min.js

+ 9 - 1
Tools/DevLoader/BabylonLoader.js
View File 

@@ -36,6 +36,8 @@ var BABYLONDEVTOOLS;
 
         var min;

         var min;

         var babylonJSPath;

         var babylonJSPath;

 

 

+        var coreOnly;

+

         var localDevES6FolderName;

         var localDevES6FolderName;

         var localDevUMDFolderName;

         var localDevUMDFolderName;

 

 

@@ -47,6 +49,7 @@ var BABYLONDEVTOOLS;
 
             min = (document.location.href.toLowerCase().indexOf('dist=min') > 0);

             min = (document.location.href.toLowerCase().indexOf('dist=min') > 0);

             useDist = (min || useDist || document.location.href.toLowerCase().indexOf('dist=true') > 0);

             useDist = (min || useDist || document.location.href.toLowerCase().indexOf('dist=true') > 0);

             babylonJSPath = '';

             babylonJSPath = '';

+            coreOnly = false;

         }

         }

 

 

         Loader.prototype.debugShortcut = function(engine) {

         Loader.prototype.debugShortcut = function(engine) {

@@ -200,7 +203,7 @@ var BABYLONDEVTOOLS;
 
                 if (!useDist && module.isCore) {

                 if (!useDist && module.isCore) {

                     this.loadCoreDev();

                     this.loadCoreDev();

                 }

                 }

-                else {

+                else if (!coreOnly || module.isCore) {

                     this.loadLibrary(moduleName, module.libraries[i], module);

                     this.loadLibrary(moduleName, module.libraries[i], module);

                 }

                 }

             }

             }

@@ -231,6 +234,11 @@ var BABYLONDEVTOOLS;
 
             }

             }

         }

         }

 

 

+        Loader.prototype.loadCoreOnly = function() {

+            coreOnly = true;

+            return this;

+        }

+

         Loader.prototype.load = function(newCallback) {

         Loader.prototype.load = function(newCallback) {

             var self = this;

             var self = this;

             if (newCallback) {

             if (newCallback) {

+ 152 - 0
localDevWebGPU/index.html
View File 

@@ -0,0 +1,152 @@
 
+<!DOCTYPE html>
 
+<html xmlns="http://www.w3.org/1999/xhtml">
 
+
 
+<head>
 
+    <title>Local Development</title>
 
+
 
+    <script src="https://code.jquery.com/pep/0.4.2/pep.min.js"></script>
 
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/dat-gui/0.6.2/dat.gui.min.js"></script>
 
+    <script src="../dist/preview%20release/cannon.js"></script>
 
+    <script src="../dist/preview%20release/Oimo.js"></script>
 
+    <script src="../dist/preview%20release/ammo.js"></script>
 
+    <script src="../dist/preview%20release/gltf_validator.js"></script>
 
+    <script src="../Tools/DevLoader/BabylonLoader.js"></script>
 
+    <script src="../dist/preview%20release/shaderc/shaderc.js"></script>
 
+
 
+    <style>
 
+        html,
 
+        body {
 
+            width: 100%;
 
+            height: 100%;
 
+            padding: 0;
 
+            margin: 0;
 
+            overflow: hidden;
 
+        }
 
+
 
+        #renderCanvas {
 
+            width: 1024px;
 
+            height: 768px;
 
+            display: block;
 
+            font-size: 0;
 
+        }
 
+
 
+        #fps {
 
+            position: absolute;
 
+            background-color: black;
 
+            border: 2px solid red;
 
+            text-align: center;
 
+            font-size: 16px;
 
+            color: white;
 
+            top: 15px;
 
+            right: 10px;
 
+            width: 60px;
 
+            height: 20px;
 
+        }
 
+
 
+        @font-face {
 
+            font-family: BabylonJSglyphs;
 
+           /* src: url("http://www.killer-squid.com/fonts/BabylonJSglyphs.otf"); */
 
+            src: local("BabylonJSglyphs");
 
+        }
 
+        
+    </style>
 
+</head>
 
+
 
+<body>
 
+    <div id="fps">0</div>
 
+    <canvas id="renderCanvas" touch-action="none" width="1024" height="768"></canvas>
 
+
 
+    <script>
 
+        var canvas = document.getElementById("renderCanvas");
 
+        var divFps = document.getElementById("fps");
 
+
 
+        // Global to simulate PG.
 
+        var engine = null;
 
+
 
+        // Allow querystring to navigate easily in debug in local samples.
 
+        var indexjs = 'src/index';
 
+        var sampleSearch = /sample=([0-9]+)/i;
 
+        var matches = null;
 
+        if ((matches = sampleSearch.exec(window.location)) !== null) {
 
+            indexjs += '.';
 
+            indexjs += matches[1];
 
+        }
 
+        indexjs += '.js';
 
+
 
+        // Load the scripts + map file to allow vscode debug.
 
+        BABYLONDEVTOOLS.Loader
 
+            .loadCoreOnly()
 
+            .require(indexjs)
 
+            .load(function() {
 
+                if (BABYLON.Engine.isSupported()) {
 
+                    var onLoad = () => {
 
+                        // call the scene creation from the js.
 
+                        if (typeof delayCreateScene !== "undefined") {
 
+                            var scene = delayCreateScene();
 
+
 
+                            if (scene) {
 
+                                // Register a render loop to repeatedly render the scene
 
+
 
+                                engine.runRenderLoop(function() {
 
+                                    if (scene.activeCamera) {
 
+                                        scene.render();
 
+                                    }
 
+                                    divFps.innerHTML = engine.getFps().toFixed() + " fps";
 
+                                });
 
+                            }
 
+                        }
 
+                        else {
 
+                            var scene = createScene();
 
+
 
+                            if (scene) {
 
+
 
+                                var processCurrentScene = function(scene) {
 
+                                    engine.runRenderLoop(function() {
 
+                                        scene.render();
 
+                                        divFps.innerHTML = engine.getFps().toFixed() + " fps";
 
+                                    });
 
+                                }
 
+
 
+                                if (scene.then) {
 
+                                    // Handle if createScene returns a promise
 
+                                    scene.then(function(currentScene) {
 
+                                        processCurrentScene(currentScene);
 
+                                    }).catch(function(e) {
 
+                                        console.error(e);
 
+                                        onError();
 
+                                    });
 
+                                } else {
 
+                                    // Register a render loop to repeatedly render the scene
 
+                                    processCurrentScene(scene);
 
+                                }
 
+                            }
 
+                        }
 
+
 
+                        // // Resize
 
+                        // window.addEventListener("resize", function() {
 
+                        //     engine.resize();
 
+                        // });
 
+                    }
 
+
 
+                    var shadercOptions = { 
+                        wasmBinaryFile: "/dist/preview release/Shaderc/shaderc.wasm"
 
+                    };
 
+
 
+                    if (typeof createEngine !== "undefined") {
 
+                        engine = createEngine();
 
+                        engine.initEngineAsync(shadercOptions).then(() => onLoad());
 
+                    } else {
 
+                        engine = new BABYLON.WebGPUEngine(canvas);
 
+                        engine.initEngineAsync(shadercOptions).then(() => onLoad());
 
+                    }
 
+
 
+                    // BABYLONDEVTOOLS.Loader.debugShortcut(engine);                    
+                }
 
+                else {
 
+                    alert('BabylonJS is not supported.')
 
+                }
 
+            });
 
+    </script>
 
+</body>
 
+
 
+</html>

+ 160 - 147
src/LibDeclarations/webgpu.d.ts
View File 

@@ -1,23 +1,23 @@
 
 /* tslint:disable */
 
 /* tslint:disable */
 
 // https://github.com/gpuweb/gpuweb/blob/9d7622bf366be74e0599122d8c4d0fd1128ae484/design/sketch.webidl
 
 // https://github.com/gpuweb/gpuweb/blob/9d7622bf366be74e0599122d8c4d0fd1128ae484/design/sketch.webidl
 
 
 
-export type u64 = number;
 
+type u64 = number;
 
 
 
-export type GPUBindingResource = GPUSampler | GPUTextureView | GPUBufferBinding;
 
+type GPUBindingResource = GPUSampler | GPUTextureView | GPUBufferBinding;
 
 
 
-export type GPUAddressMode =
 
+type GPUAddressMode =
 
   | "clamp-to-edge"
 
   | "clamp-to-edge"
 
   | "repeat"
 
   | "repeat"
 
   | "mirror-repeat"
 
   | "mirror-repeat"
 
   | "clamp-to-border-color";
 
   | "clamp-to-border-color";
 
-export type GPUBindingType =
 
+type GPUBindingType =
 
   | "uniform-buffer"
 
   | "uniform-buffer"
 
   | "dynamic-uniform-buffer"
 
   | "dynamic-uniform-buffer"
 
   | "sampler"
 
   | "sampler"
 
   | "sampled-texture"
 
   | "sampled-texture"
 
   | "storage-buffer"
 
   | "storage-buffer"
 
   | "dynamic-storage-buffer";
 
   | "dynamic-storage-buffer";
 
-export type GPUBlendFactor =
 
+type GPUBlendFactor =
 
   | "zero"
 
   | "zero"
 
   | "one"
 
   | "one"
 
   | "src-color"
 
   | "src-color"
 
@@ -31,17 +31,17 @@ export type GPUBlendFactor =
 
   | "src-alpha-saturated"
 
   | "src-alpha-saturated"
 
   | "blend-color"
 
   | "blend-color"
 
   | "one-minus-blend-color";
 
   | "one-minus-blend-color";
 
-export type GPUBlendOperation =
 
+type GPUBlendOperation =
 
   | "add"
 
   | "add"
 
   | "subtract"
 
   | "subtract"
 
   | "reverse-subtract"
 
   | "reverse-subtract"
 
   | "min"
 
   | "min"
 
   | "max";
 
   | "max";
 
-export type GPUBorderColor =
 
+type GPUBorderColor =
 
   | "transparent-black"
 
   | "transparent-black"
 
   | "opaque-black"
 
   | "opaque-black"
 
   | "opaque-white";
 
   | "opaque-white";
 
-export type GPUCompareFunction =
 
+type GPUCompareFunction =
 
   | "never"
 
   | "never"
 
   | "less"
 
   | "less"
 
   | "equal"
 
   | "equal"
 
@@ -50,32 +50,32 @@ export type GPUCompareFunction =
 
   | "notEqual"
 
   | "notEqual"
 
   | "greaterEqual"
 
   | "greaterEqual"
 
   | "always";
 
   | "always";
 
-export type GPUCullMode =
 
+type GPUCullMode =
 
   | "none"
 
   | "none"
 
   | "front"
 
   | "front"
 
   | "back";
 
   | "back";
 
-export type GPUFilterMode =
 
+type GPUFilterMode =
 
   | "nearest"
 
   | "nearest"
 
   | "linear";
 
   | "linear";
 
-export type GPUFrontFace =
 
+type GPUFrontFace =
 
   | "ccw"
 
   | "ccw"
 
   | "cw";
 
   | "cw";
 
-export type GPUIndexFormat =
 
+type GPUIndexFormat =
 
   | "uint16"
 
   | "uint16"
 
   | "uint32";
 
   | "uint32";
 
-export type GPUInputStepMode =
 
+type GPUInputStepMode =
 
   | "vertex"
 
   | "vertex"
 
   | "instance";
 
   | "instance";
 
-export type GPULoadOp =
 
+type GPULoadOp =
 
   | "clear"
 
   | "clear"
 
   | "load";
 
   | "load";
 
-export type GPUPrimitiveTopology =
 
+type GPUPrimitiveTopology =
 
   | "point-list"
 
   | "point-list"
 
   | "line-list"
 
   | "line-list"
 
   | "line-strip"
 
   | "line-strip"
 
   | "triangle-list"
 
   | "triangle-list"
 
   | "triangle-strip";
 
   | "triangle-strip";
 
-export type GPUStencilOperation =
 
+type GPUStencilOperation =
 
   | "keep"
 
   | "keep"
 
   | "zero"
 
   | "zero"
 
   | "replace"
 
   | "replace"
 
@@ -84,18 +84,20 @@ export type GPUStencilOperation =
 
   | "decrement-clamp"
 
   | "decrement-clamp"
 
   | "increment-wrap"
 
   | "increment-wrap"
 
   | "decrement-wrap";
 
   | "decrement-wrap";
 
-export type GPUStoreOp =
 
+type GPUStoreOp =
 
   | "store";
 
   | "store";
 
-export type GPUTextureDimension =
 
+type GPUTextureDimension =
 
   | "1d"
 
   | "1d"
 
   | "2d"
 
   | "2d"
 
   | "3d";
 
   | "3d";
 
-export type GPUTextureFormat =
 
+type GPUTextureFormat =
 
+  /* Normal 8 bit formats */
 
   | "r8unorm"
 
   | "r8unorm"
 
   | "r8unorm-srgb"
 
   | "r8unorm-srgb"
 
   | "r8snorm"
 
   | "r8snorm"
 
   | "r8uint"
 
   | "r8uint"
 
   | "r8sint"
 
   | "r8sint"
 
+  /* Normal 16 bit formats */
 
   | "r16unorm"
 
   | "r16unorm"
 
   | "r16snorm"
 
   | "r16snorm"
 
   | "r16uint"
 
   | "r16uint"
 
@@ -106,7 +108,9 @@ export type GPUTextureFormat =
 
   | "rg8snorm"
 
   | "rg8snorm"
 
   | "rg8uint"
 
   | "rg8uint"
 
   | "rg8sint"
 
   | "rg8sint"
 
+  /* Packed 16 bit formats */
 
   | "b5g6r5unorm"
 
   | "b5g6r5unorm"
 
+  /* Normal 32 bit formats */
 
   | "r32uint"
 
   | "r32uint"
 
   | "r32sint"
 
   | "r32sint"
 
   | "r32float"
 
   | "r32float"
 
@@ -122,8 +126,10 @@ export type GPUTextureFormat =
 
   | "rgba8sint"
 
   | "rgba8sint"
 
   | "bgra8unorm"
 
   | "bgra8unorm"
 
   | "bgra8unorm-srgb"
 
   | "bgra8unorm-srgb"
 
+  /* Packed 32 bit formats */
 
   | "rgb10a2unorm"
 
   | "rgb10a2unorm"
 
   | "rg11b10float"
 
   | "rg11b10float"
 
+  /* Normal 64 bit formats */
 
   | "rg32uint"
 
   | "rg32uint"
 
   | "rg32sint"
 
   | "rg32sint"
 
   | "rg32float"
 
   | "rg32float"
 
@@ -132,17 +138,23 @@ export type GPUTextureFormat =
 
   | "rgba16uint"
 
   | "rgba16uint"
 
   | "rgba16sint"
 
   | "rgba16sint"
 
   | "rgba16float"
 
   | "rgba16float"
 
+  /* Normal 128 bit formats */
 
   | "rgba32uint"
 
   | "rgba32uint"
 
   | "rgba32sint"
 
   | "rgba32sint"
 
-  | "rgba32float";
 
-export type GPUTextureViewDimension =
 
+  | "rgba32float"
 
+  /* Depth and Stencil formats */
 
+  | "depth32float"
 
+  | "depth32float-stencil8";
 
+
 
+type GPUTextureViewDimension =
 
   | "1d"
 
   | "1d"
 
   | "2d"
 
   | "2d"
 
   | "2d-array"
 
   | "2d-array"
 
   | "cube"
 
   | "cube"
 
   | "cube-array"
 
   | "cube-array"
 
   | "3d";
 
   | "3d";
 
-export type GPUVertexFormat =
 
+  
+type GPUVertexFormat =
 
   | "uchar"
 
   | "uchar"
 
   | "uchar2"
 
   | "uchar2"
 
   | "uchar3"
 
   | "uchar3"
 
@@ -193,81 +205,81 @@ export type GPUVertexFormat =
 
   | "int3"
 
   | "int3"
 
   | "int4";
 
   | "int4";
 
 
 
-export type GPUBufferUsageFlags = number;
 
-export const enum GPUBufferUsage {
 
-  NONE = 0,
 
-  MAP_READ = 1,
 
-  MAP_WRITE = 2,
 
-  TRANSFER_SRC = 4,
 
-  TRANSFER_DST = 8,
 
-  INDEX = 16,
 
-  VERTEX = 32,
 
-  UNIFORM = 64,
 
-  STORAGE = 128,
 
-}
 
-
 
-export type GPUColorWriteFlags = number;
 
-export const enum GPUColorWriteBits {
 
-  NONE = 0,
 
-  RED = 1,
 
-  GREEN = 2,
 
-  BLUE = 4,
 
-  ALPHA = 8,
 
-  ALL = 15,
 
-}
 
-
 
-export type GPUShaderStageFlags = number;
 
-export const enum GPUShaderStageBit {
 
-  NONE = 0,
 
-  VERTEX = 1,
 
-  FRAGMENT = 2,
 
-  COMPUTE = 4,
 
-}
 
-
 
-export type GPUTextureAspectFlags = number;
 
-export const enum GPUTextureAspect {
 
-  COLOR = 1,
 
-  DEPTH = 2,
 
-  STENCIL = 4,
 
-}
 
-
 
-export type GPUTextureUsageFlags = number;
 
-export const enum GPUTextureUsage {
 
-  NONE = 0,
 
-  TRANSFER_SRC = 1,
 
-  TRANSFER_DST = 2,
 
-  SAMPLED = 4,
 
-  STORAGE = 8,
 
-  OUTPUT_ATTACHMENT = 16,
 
-}
 
-
 
-export interface GPUBindGroupBinding {
 
+type GPUBufferUsageFlags = number;
 
+// const enum GPUBufferUsage {
 
+//   NONE = 0,
 
+//   MAP_READ = 1,
 
+//   MAP_WRITE = 2,
 
+//   TRANSFER_SRC = 4,
 
+//   TRANSFER_DST = 8,
 
+//   INDEX = 16,
 
+//   VERTEX = 32,
 
+//   UNIFORM = 64,
 
+//   STORAGE = 128,
 
+// }
 
+
 
+type GPUColorWriteFlags = number;
 
+// const enum GPUColorWriteBits {
 
+//   NONE = 0,
 
+//   RED = 1,
 
+//   GREEN = 2,
 
+//   BLUE = 4,
 
+//   ALPHA = 8,
 
+//   ALL = 15,
 
+// }
 
+
 
+type GPUShaderStageFlags = number;
 
+// const enum GPUShaderStageBit {
 
+//   NONE = 0,
 
+//   VERTEX = 1,
 
+//   FRAGMENT = 2,
 
+//   COMPUTE = 4,
 
+// }
 
+
 
+type GPUTextureAspectFlags = number;
 
+// const enum GPUTextureAspect {
 
+//   COLOR = 1,
 
+//   DEPTH = 2,
 
+//   STENCIL = 4,
 
+// }
 
+
 
+type GPUTextureUsageFlags = number;
 
+// const enum GPUTextureUsage {
 
+//   NONE = 0,
 
+//   TRANSFER_SRC = 1,
 
+//   TRANSFER_DST = 2,
 
+//   SAMPLED = 4,
 
+//   STORAGE = 8,
 
+//   OUTPUT_ATTACHMENT = 16,
 
+// }
 
+
 
+interface GPUBindGroupBinding {
 
   binding?: number;
 
   binding?: number;
 
   resource?: GPUBindingResource;
 
   resource?: GPUBindingResource;
 
 }
 
 }
 
 
 
-export interface GPUBindGroupDescriptor {
 
+interface GPUBindGroupDescriptor {
 
   bindings?: GPUBindGroupBinding[];
 
   bindings?: GPUBindGroupBinding[];
 
   layout?: GPUBindGroupLayout;
 
   layout?: GPUBindGroupLayout;
 
 }
 
 }
 
 
 
-export interface GPUBindGroupLayoutBinding {
 
+interface GPUBindGroupLayoutBinding {
 
   binding?: number;
 
   binding?: number;
 
   type?: GPUBindingType;
 
   type?: GPUBindingType;
 
   visibility?: GPUShaderStageFlags;
 
   visibility?: GPUShaderStageFlags;
 
 }
 
 }
 
 
 
-export interface GPUBindGroupLayoutDescriptor {
 
+interface GPUBindGroupLayoutDescriptor {
 
   bindings?: GPUBindGroupLayoutBinding[];
 
   bindings?: GPUBindGroupLayoutBinding[];
 
 }
 
 }
 
 
 
-export interface GPUBlendDescriptor {
 
+interface GPUBlendDescriptor {
 
   dstFactor?: GPUBlendFactor;
 
   dstFactor?: GPUBlendFactor;
 
   operation?: GPUBlendOperation;
 
   operation?: GPUBlendOperation;
 
   srcFactor?: GPUBlendFactor;
 
   srcFactor?: GPUBlendFactor;
 
 }
 
 }
 
 
 
-export interface GPUColorStateDescriptor {
 
+interface GPUColorStateDescriptor {
 
     format?: GPUTextureFormat;
 
     format?: GPUTextureFormat;
 
 
 
     alphaBlend?: GPUBlendDescriptor;
 
     alphaBlend?: GPUBlendDescriptor;
 
@@ -275,47 +287,47 @@ export interface GPUColorStateDescriptor {
 
     writeMask?: GPUColorWriteFlags;
 
     writeMask?: GPUColorWriteFlags;
 
 }
 
 }
 
 
 
-export interface GPUBlendStateDescriptor {
 
+interface GPUBlendStateDescriptor {
 
   alpha?: GPUBlendDescriptor;
 
   alpha?: GPUBlendDescriptor;
 
   blendEnabled?: boolean;
 
   blendEnabled?: boolean;
 
   color?: GPUBlendDescriptor;
 
   color?: GPUBlendDescriptor;
 
   writeMask?: GPUColorWriteFlags;
 
   writeMask?: GPUColorWriteFlags;
 
 }
 
 }
 
 
 
-export interface GPUBufferBinding {
 
+interface GPUBufferBinding {
 
   buffer?: GPUBuffer;
 
   buffer?: GPUBuffer;
 
   offset?: number;
 
   offset?: number;
 
   size?: number;
 
   size?: number;
 
 }
 
 }
 
 
 
-export interface GPUBufferCopyView {
 
+interface GPUBufferCopyView {
 
   buffer?: GPUBuffer;
 
   buffer?: GPUBuffer;
 
   imageHeight?: number;
 
   imageHeight?: number;
 
   offset?: number;
 
   offset?: number;
 
   rowPitch?: number;
 
   rowPitch?: number;
 
 }
 
 }
 
 
 
-export interface GPUBufferDescriptor {
 
+interface GPUBufferDescriptor {
 
   size?: number;
 
   size?: number;
 
   usage?: GPUBufferUsageFlags;
 
   usage?: GPUBufferUsageFlags;
 
 }
 
 }
 
 
 
-export interface GPUColor {
 
+interface GPUColor {
 
   a?: number;
 
   a?: number;
 
   b?: number;
 
   b?: number;
 
   g?: number;
 
   g?: number;
 
   r?: number;
 
   r?: number;
 
 }
 
 }
 
 
 
-export interface GPUCommandEncoderDescriptor {
 
+interface GPUCommandEncoderDescriptor {
 
   label?: string;
 
   label?: string;
 
 }
 
 }
 
 
 
-export interface GPUComputePipelineDescriptor extends GPUPipelineDescriptorBase {
 
+interface GPUComputePipelineDescriptor extends GPUPipelineDescriptorBase {
 
   computeStage?: GPUPipelineStageDescriptor;
 
   computeStage?: GPUPipelineStageDescriptor;
 
 }
 
 }
 
 
 
-export interface GPUDepthStencilStateDescriptor {
 
+interface GPUDepthStencilStateDescriptor {
 
   stencilBack?: GPUStencilStateFaceDescriptor;
 
   stencilBack?: GPUStencilStateFaceDescriptor;
 
   depthCompare?: GPUCompareFunction;
 
   depthCompare?: GPUCompareFunction;
 
   depthWriteEnabled?: boolean;
 
   depthWriteEnabled?: boolean;
 
@@ -325,57 +337,57 @@ export interface GPUDepthStencilStateDescriptor {
 
   format?: GPUTextureFormat;
 
   format?: GPUTextureFormat;
 
 }
 
 }
 
 
 
-export interface GPUDeviceDescriptor {
 
+interface GPUDeviceDescriptor {
 
   extensions?: GPUExtensions;
 
   extensions?: GPUExtensions;
 
 }
 
 }
 
 
 
-export interface GPUExtensions {
 
+interface GPUExtensions {
 
   anisotropicFiltering?: boolean;
 
   anisotropicFiltering?: boolean;
 
 }
 
 }
 
 
 
-export interface GPUExtent3D {
 
+interface GPUExtent3D {
 
   width: number;
 
   width: number;
 
   height: number;
 
   height: number;
 
   depth: number;
 
   depth: number;
 
 }
 
 }
 
 
 
-export interface GPUFenceDescriptor {
 
+interface GPUFenceDescriptor {
 
   initialValue?: u64;
 
   initialValue?: u64;
 
   label?: string;
 
   label?: string;
 
   signalQueue?: GPUQueue;
 
   signalQueue?: GPUQueue;
 
 }
 
 }
 
 
 
-export interface GPUInputStateDescriptor {
 
+interface GPUInputStateDescriptor {
 
   attributes?: GPUVertexAttributeDescriptor[];
 
   attributes?: GPUVertexAttributeDescriptor[];
 
   indexFormat?: GPUIndexFormat;
 
   indexFormat?: GPUIndexFormat;
 
   inputs?: GPUVertexInputDescriptor[];
 
   inputs?: GPUVertexInputDescriptor[];
 
 }
 
 }
 
 
 
-export interface GPULimits {
 
+interface GPULimits {
 
   maxBindGroups?: number;
 
   maxBindGroups?: number;
 
 }
 
 }
 
 
 
-export interface GPUOrigin3D {
 
+interface GPUOrigin3D {
 
   x?: number;
 
   x?: number;
 
   y?: number;
 
   y?: number;
 
   z?: number;
 
   z?: number;
 
 }
 
 }
 
 
 
-export interface GPUPipelineDescriptorBase {
 
+interface GPUPipelineDescriptorBase {
 
   label?: string;
 
   label?: string;
 
   layout?: GPUPipelineLayout;
 
   layout?: GPUPipelineLayout;
 
 }
 
 }
 
 
 
-export interface GPUPipelineLayoutDescriptor {
 
+interface GPUPipelineLayoutDescriptor {
 
   bindGroupLayouts?: GPUBindGroupLayout[];
 
   bindGroupLayouts?: GPUBindGroupLayout[];
 
 }
 
 }
 
 
 
-export interface GPUPipelineStageDescriptor {
 
+interface GPUPipelineStageDescriptor {
 
   entryPoint?: string;
 
   entryPoint?: string;
 
   module?: GPUShaderModule;
 
   module?: GPUShaderModule;
 
 }
 
 }
 
 
 
-export interface GPURasterizationStateDescriptor {
 
+interface GPURasterizationStateDescriptor {
 
   cullMode?: GPUCullMode;
 
   cullMode?: GPUCullMode;
 
   depthBias?: number;
 
   depthBias?: number;
 
   depthBiasClamp?: number;
 
   depthBiasClamp?: number;
 
@@ -383,7 +395,7 @@ export interface GPURasterizationStateDescriptor {
 
   frontFace?: GPUFrontFace;
 
   frontFace?: GPUFrontFace;
 
 }
 
 }
 
 
 
-export interface GPURenderPassColorAttachmentDescriptor {
 
+interface GPURenderPassColorAttachmentDescriptor {
 
   attachment?: GPUTextureView;
 
   attachment?: GPUTextureView;
 
   clearColor?: GPUColor;
 
   clearColor?: GPUColor;
 
   loadOp?: GPULoadOp;
 
   loadOp?: GPULoadOp;
 
@@ -391,7 +403,7 @@ export interface GPURenderPassColorAttachmentDescriptor {
 
   storeOp?: GPUStoreOp;
 
   storeOp?: GPUStoreOp;
 
 }
 
 }
 
 
 
-export interface GPURenderPassDepthStencilAttachmentDescriptor {
 
+interface GPURenderPassDepthStencilAttachmentDescriptor {
 
   attachment?: GPUTextureView;
 
   attachment?: GPUTextureView;
 
   clearDepth?: number;
 
   clearDepth?: number;
 
   clearStencil?: number;
 
   clearStencil?: number;
 
@@ -401,24 +413,24 @@ export interface GPURenderPassDepthStencilAttachmentDescriptor {
 
   stencilStoreOp?: GPUStoreOp;
 
   stencilStoreOp?: GPUStoreOp;
 
 }
 
 }
 
 
 
-export interface GPURenderPassDescriptor {
 
+interface GPURenderPassDescriptor {
 
   colorAttachments?: GPURenderPassColorAttachmentDescriptor[];
 
   colorAttachments?: GPURenderPassColorAttachmentDescriptor[];
 
   depthStencilAttachment?: GPURenderPassDepthStencilAttachmentDescriptor;
 
   depthStencilAttachment?: GPURenderPassDepthStencilAttachmentDescriptor;
 
 }
 
 }
 
 
 
-export interface GPURenderPipelineDescriptor extends GPUPipelineDescriptorBase {
 
+interface GPURenderPipelineDescriptor extends GPUPipelineDescriptorBase {
 
   colorStates?: GPUColorStateDescriptor[];
 
   colorStates?: GPUColorStateDescriptor[];
 
   blendStates?: GPUBlendStateDescriptor[];
 
   blendStates?: GPUBlendStateDescriptor[];
 
   depthStencilState?: GPUDepthStencilStateDescriptor;
 
   depthStencilState?: GPUDepthStencilStateDescriptor;
 
   fragmentStage?: GPUPipelineStageDescriptor;
 
   fragmentStage?: GPUPipelineStageDescriptor;
 
-  inputState?: GPUInputStateDescriptor;
 
+  vertexInput?: GPUInputStateDescriptor;
 
   primitiveTopology?: GPUPrimitiveTopology;
 
   primitiveTopology?: GPUPrimitiveTopology;
 
   rasterizationState?: GPURasterizationStateDescriptor;
 
   rasterizationState?: GPURasterizationStateDescriptor;
 
   sampleCount?: number;
 
   sampleCount?: number;
 
   vertexStage?: GPUPipelineStageDescriptor;
 
   vertexStage?: GPUPipelineStageDescriptor;
 
 }
 
 }
 
 
 
-export interface GPUSamplerDescriptor {
 
+interface GPUSamplerDescriptor {
 
   borderColor?: GPUBorderColor;
 
   borderColor?: GPUBorderColor;
 
   compareFunction?: GPUCompareFunction;
 
   compareFunction?: GPUCompareFunction;
 
   lodMaxClamp?: number;
 
   lodMaxClamp?: number;
 
@@ -432,32 +444,32 @@ export interface GPUSamplerDescriptor {
 
   tAddressMode?: GPUAddressMode;
 
   tAddressMode?: GPUAddressMode;
 
 }
 
 }
 
 
 
-export interface GPUShaderModuleDescriptor {
 
+interface GPUShaderModuleDescriptor {
 
   code: ArrayBuffer | string;
 
   code: ArrayBuffer | string;
 
   label?: string;
 
   label?: string;
 
 }
 
 }
 
 
 
-export interface GPUStencilStateFaceDescriptor {
 
+interface GPUStencilStateFaceDescriptor {
 
   compare?: GPUCompareFunction;
 
   compare?: GPUCompareFunction;
 
   depthFailOp?: GPUStencilOperation;
 
   depthFailOp?: GPUStencilOperation;
 
   passOp?: GPUStencilOperation;
 
   passOp?: GPUStencilOperation;
 
   failOp?: GPUStencilOperation;
 
   failOp?: GPUStencilOperation;
 
 }
 
 }
 
 
 
-export interface GPUSwapChainDescriptor {
 
+interface GPUSwapChainDescriptor {
 
   context?: GPUCanvasContext ;
 
   context?: GPUCanvasContext ;
 
   format?: GPUTextureFormat;
 
   format?: GPUTextureFormat;
 
   usage?: GPUTextureUsageFlags;
 
   usage?: GPUTextureUsageFlags;
 
 }
 
 }
 
 
 
-export interface GPUTextureCopyView {
 
+interface GPUTextureCopyView {
 
   texture: GPUTexture;
 
   texture: GPUTexture;
 
   mipLevel?: number;
 
   mipLevel?: number;
 
   arrayLayer?: number;
 
   arrayLayer?: number;
 
   origin: GPUOrigin3D;
 
   origin: GPUOrigin3D;
 
 }
 
 }
 
 
 
-export interface GPUTextureDescriptor {
 
+interface GPUTextureDescriptor {
 
   size: GPUExtent3D;
 
   size: GPUExtent3D;
 
   arrayLayerCount?: number;
 
   arrayLayerCount?: number;
 
   mipLevelCount?: number;
 
   mipLevelCount?: number;
 
@@ -467,7 +479,7 @@ export interface GPUTextureDescriptor {
 
   usage: GPUTextureUsageFlags;
 
   usage: GPUTextureUsageFlags;
 
 }
 
 }
 
 
 
-export interface GPUTextureViewDescriptor {
 
+interface GPUTextureViewDescriptor {
 
   aspect?: GPUTextureAspectFlags;
 
   aspect?: GPUTextureAspectFlags;
 
   baseArrayLayer?: number;
 
   baseArrayLayer?: number;
 
   baseMipLevel?: number;
 
   baseMipLevel?: number;
 
@@ -477,32 +489,32 @@ export interface GPUTextureViewDescriptor {
 
   mipLevelCount?: number;
 
   mipLevelCount?: number;
 
 }
 
 }
 
 
 
-export interface GPUVertexAttributeDescriptor {
 
+interface GPUVertexAttributeDescriptor {
 
   format?: GPUVertexFormat;
 
   format?: GPUVertexFormat;
 
   inputSlot?: number;
 
   inputSlot?: number;
 
   offset?: number;
 
   offset?: number;
 
   shaderLocation?: number;
 
   shaderLocation?: number;
 
 }
 
 }
 
 
 
-export interface GPUVertexInputDescriptor {
 
+interface GPUVertexInputDescriptor {
 
   inputSlot?: number;
 
   inputSlot?: number;
 
   stepMode?: GPUInputStepMode;
 
   stepMode?: GPUInputStepMode;
 
   stride?: number;
 
   stride?: number;
 
 }
 
 }
 
 
 
-export interface GPUAdapter {
 
+interface GPUAdapter {
 
   readonly extensions: GPUExtensions;
 
   readonly extensions: GPUExtensions;
 
   readonly name: string;
 
   readonly name: string;
 
-  requestDevice(descriptor: GPUDeviceDescriptor): Promise<GPUDevice>;
 
+  requestDevice(descriptor?: GPUDeviceDescriptor): Promise<GPUDevice>;
 
 }
 
 }
 
 
 
-export interface GPUBindGroup extends GPUDebugLabel {
 
+interface GPUBindGroup extends GPUDebugLabel {
 
 }
 
 }
 
 
 
-export interface GPUBindGroupLayout extends GPUDebugLabel {
 
+interface GPUBindGroupLayout extends GPUDebugLabel {
 
 }
 
 }
 
 
 
-export interface GPUBuffer extends GPUDebugLabel {
 
+interface GPUBuffer extends GPUDebugLabel {
 
   //readonly mapping: ArrayBuffer | null;
 
   //readonly mapping: ArrayBuffer | null;
 
   destroy(): void;
 
   destroy(): void;
 
   unmap(): void;
 
   unmap(): void;
 
@@ -512,7 +524,7 @@ export interface GPUBuffer extends GPUDebugLabel {
 
   setSubData(offset: number, ab: ArrayBuffer): void;
 
   setSubData(offset: number, ab: ArrayBuffer): void;
 
 }
 
 }
 
 
 
-export interface GPUCommandEncoder extends GPUDebugLabel {
 
+interface GPUCommandEncoder extends GPUDebugLabel {
 
   beginComputePass(): GPUComputePassEncoder;
 
   beginComputePass(): GPUComputePassEncoder;
 
   beginRenderPass(descriptor: GPURenderPassDescriptor): GPURenderPassEncoder;
 
   beginRenderPass(descriptor: GPURenderPassDescriptor): GPURenderPassEncoder;
 
   copyBufferToBuffer(src: GPUBuffer, srcOffset: number, dst: GPUBuffer, dstOffset: number, size: number): void;
 
   copyBufferToBuffer(src: GPUBuffer, srcOffset: number, dst: GPUBuffer, dstOffset: number, size: number): void;
 
@@ -522,26 +534,26 @@ export interface GPUCommandEncoder extends GPUDebugLabel {
 
   finish(): GPUCommandBuffer;
 
   finish(): GPUCommandBuffer;
 
 }
 
 }
 
 
 
-export interface GPUCommandBuffer extends GPUDebugLabel {
 
+interface GPUCommandBuffer extends GPUDebugLabel {
 
 }
 
 }
 
 
 
-export interface GPUComputePassEncoder extends GPUProgrammablePassEncoder {
 
+interface GPUComputePassEncoder extends GPUProgrammablePassEncoder {
 
   setPipeline(pipeline: GPUComputePipeline): void;
 
   setPipeline(pipeline: GPUComputePipeline): void;
 
   dispatch(x: number, y: number, z: number): void;
 
   dispatch(x: number, y: number, z: number): void;
 
 }
 
 }
 
 
 
-export interface GPUComputePipeline extends GPUDebugLabel {
 
+interface GPUComputePipeline extends GPUDebugLabel {
 
 }
 
 }
 
 
 
-export interface GPUDebugLabel {
 
+interface GPUDebugLabel {
 
   label: string | undefined;
 
   label: string | undefined;
 
 }
 
 }
 
 
 
 // SwapChain / CanvasContext
 
 // SwapChain / CanvasContext
 
-export interface GPUCanvasContext {
 
+interface GPUCanvasContext {
 
 }
 
 }
 
 
 
-export interface GPUDevice {
 
+interface GPUDevice {
 
   readonly adapter: GPUAdapter;
 
   readonly adapter: GPUAdapter;
 
   readonly extensions: GPUExtensions;
 
   readonly extensions: GPUExtensions;
 
   readonly limits: GPULimits;
 
   readonly limits: GPULimits;
 
@@ -568,20 +580,20 @@ export interface GPUDevice {
 
   getSwapChainPreferredFormat(context: GPUCanvasContext): Promise<GPUTextureFormat> ;
 
   getSwapChainPreferredFormat(context: GPUCanvasContext): Promise<GPUTextureFormat> ;
 
 }
 
 }
 
 
 
-export interface GPUFence extends GPUDebugLabel {
 
+interface GPUFence extends GPUDebugLabel {
 
   getCompletedValue(): u64;
 
   getCompletedValue(): u64;
 
   onCompletion(completionValue: u64): Promise<void>;
 
   onCompletion(completionValue: u64): Promise<void>;
 
 }
 
 }
 
 
 
-export interface GPULogEntryEvent extends Event {
 
+interface GPULogEntryEvent extends Event {
 
   readonly object: any;
 
   readonly object: any;
 
   readonly reason: string;
 
   readonly reason: string;
 
 }
 
 }
 
 
 
-export interface GPUPipelineLayout extends GPUDebugLabel {
 
+interface GPUPipelineLayout extends GPUDebugLabel {
 
 }
 
 }
 
 
 
-export interface GPUProgrammablePassEncoder extends GPUDebugLabel {
 
+interface GPUProgrammablePassEncoder extends GPUDebugLabel {
 
   endPass(): void;
 
   endPass(): void;
 
   insertDebugMarker(markerLabel: string): void;
 
   insertDebugMarker(markerLabel: string): void;
 
   popDebugGroup(): void;
 
   popDebugGroup(): void;
 
@@ -589,13 +601,13 @@ export interface GPUProgrammablePassEncoder extends GPUDebugLabel {
 
   setBindGroup(index: number, bindGroup: GPUBindGroup): void;
 
   setBindGroup(index: number, bindGroup: GPUBindGroup): void;
 
 }
 
 }
 
 
 
-export interface GPUQueue extends GPUDebugLabel {
 
+interface GPUQueue extends GPUDebugLabel {
 
   signal(fence: GPUFence, signalValue: u64): void;
 
   signal(fence: GPUFence, signalValue: u64): void;
 
   submit(buffers: GPUCommandBuffer[]): void;
 
   submit(buffers: GPUCommandBuffer[]): void;
 
   createFence(descriptor: GPUFenceDescriptor): GPUFence ;
 
   createFence(descriptor: GPUFenceDescriptor): GPUFence ;
 
 }
 
 }
 
 
 
-export interface GPURenderPassEncoder extends GPUProgrammablePassEncoder {
 
+interface GPURenderPassEncoder extends GPUProgrammablePassEncoder {
 
   setPipeline(pipeline: GPURenderPipeline): void;
 
   setPipeline(pipeline: GPURenderPipeline): void;
 
   draw(vertexCount: number, instanceCount: number, firstVertex: number, firstInstance: number): void;
 
   draw(vertexCount: number, instanceCount: number, firstVertex: number, firstInstance: number): void;
 
   drawIndexed(indexCount: number, instanceCount: number, firstIndex: number, baseVertex: number, firstInstance: number): void;
 
   drawIndexed(indexCount: number, instanceCount: number, firstIndex: number, baseVertex: number, firstInstance: number): void;
 
@@ -607,36 +619,37 @@ export interface GPURenderPassEncoder extends GPUProgrammablePassEncoder {
 
   setViewport(x: number, y: number, width: number, height: number, minDepth: number, maxDepth: number): void;
 
   setViewport(x: number, y: number, width: number, height: number, minDepth: number, maxDepth: number): void;
 
 }
 
 }
 
 
 
-export interface GPURenderPipeline extends GPUDebugLabel {
 
+interface GPURenderPipeline extends GPUDebugLabel {
 
 }
 
 }
 
 
 
-export interface GPUSampler extends GPUDebugLabel {
 
+interface GPUSampler extends GPUDebugLabel {
 
 }
 
 }
 
 
 
-export interface GPUShaderModule extends GPUDebugLabel {
 
+interface GPUShaderModule extends GPUDebugLabel {
 
 }
 
 }
 
 
 
-export interface GPUSwapChain {
 
+interface GPUSwapChain {
 
   getCurrentTexture(): GPUTexture;
 
   getCurrentTexture(): GPUTexture;
 
 }
 
 }
 
 
 
-export interface GPUTexture extends GPUDebugLabel {
 
+interface GPUTexture extends GPUDebugLabel {
 
   createDefaultView(): GPUTextureView;
 
   createDefaultView(): GPUTextureView;
 
   createView(desc: GPUTextureViewDescriptor): GPUTextureView;
 
   createView(desc: GPUTextureViewDescriptor): GPUTextureView;
 
   destroy(): void;
 
   destroy(): void;
 
 }
 
 }
 
 
 
-export interface GPUTextureView extends GPUDebugLabel {
 
+interface GPUTextureView extends GPUDebugLabel {
 
 }
 
 }
 
 
 
-export type GPUPowerPreference =
 
+type GPUPowerPreference =
 
   | "low-power"
 
   | "low-power"
 
   | "high-performance";
 
   | "high-performance";
 
-export interface GPURequestAdapterOptions {
 
+
 
+interface GPURequestAdapterOptions {
 
   powerPreference?: GPUPowerPreference;
 
   powerPreference?: GPUPowerPreference;
 
 }
 
 }
 
 
 
-export interface GPU {
 
+interface GPU {
 
   requestAdapter(options?: GPURequestAdapterOptions): Promise<GPUAdapter>;
 
   requestAdapter(options?: GPURequestAdapterOptions): Promise<GPUAdapter>;
 
 }
 
 }
 
 
 
@@ -644,19 +657,19 @@ export interface GPU {
 
 // ERROR SCOPES
 
 // ERROR SCOPES
 
 // ****************************************************************************
 
 // ****************************************************************************
 
 
 
-export type GPUErrorFilter = "none"
 
+type GPUErrorFilter = "none"
 
     | "out-of-memory"
 
     | "out-of-memory"
 
     | "validation";
 
     | "validation";
 
 
 
-export interface GPUOutOfMemoryError { }
 
+interface GPUOutOfMemoryError { }
 
 
 
-export interface GPUValidationError {
 
+interface GPUValidationError {
 
     readonly message: string;
 
     readonly message: string;
 
 }
 
 }
 
 
 
-export type GPUError = GPUOutOfMemoryError | GPUValidationError;
 
+type GPUError = GPUOutOfMemoryError | GPUValidationError;
 
 
 
-export interface GPUDevice {
 
+interface GPUDevice {
 
     pushErrorScope(filter: GPUErrorFilter): void;
 
     pushErrorScope(filter: GPUErrorFilter): void;
 
     popErrorScope(): Promise<GPUError | null>;
 
     popErrorScope(): Promise<GPUError | null>;
 
 }
 
 }
 
@@ -664,24 +677,24 @@ export interface GPUDevice {
 
  // ****************************************************************************
 
  // ****************************************************************************
 
 // TELEMETRY
 
 // TELEMETRY
 
 // ****************************************************************************
 
 // ****************************************************************************
 
-export interface GPUUncapturedErrorEvent extends Event {
 
+interface GPUUncapturedErrorEvent extends Event {
 
     readonly error: GPUError;
 
     readonly error: GPUError;
 
 }
 
 }
 
 
 
-export interface GPUUncapturedErrorEventInit extends EventInit {
 
+interface GPUUncapturedErrorEventInit extends EventInit {
 
     message: string;
 
     message: string;
 
 }
 
 }
 
 
 
- // TODO: is it possible to expose the EventTarget only on the main thread?
 
- export interface GPUDevice extends EventTarget {
 
+// TODO: is it possible to expose the EventTarget only on the main thread?
 
+interface GPUDevice extends EventTarget {
 
     onuncapturederror: Event;
 
     onuncapturederror: Event;
 
 }
 
 }
 
 
 
-export interface GPU {
 
+interface GPU {
 
     // May reject with DOMException  // TODO: DOMException("OperationError")?
 
     // May reject with DOMException  // TODO: DOMException("OperationError")?
 
     requestAdapter(options?: GPURequestAdapterOptions): Promise<GPUAdapter>;
 
     requestAdapter(options?: GPURequestAdapterOptions): Promise<GPUAdapter>;
 
 }
 
 }
 
 
 
-export interface Navigator {
 
+interface Navigator {
 
     readonly gpu: GPU | undefined;
 
     readonly gpu: GPU | undefined;
 
 }
 
 }