New FAST renderer on clean WebGPU try: (webgpu.mcraft.fun)

.eslintrc.json

@@ -10,6 +10,7 @@
         "@stylistic"
     ],
     "rules": {
+        "unicorn/no-typeof-undefined": "off",
         // style
         "@stylistic/space-infix-ops": "error",
         "@stylistic/no-multi-spaces": "error",

.npmrc

@@ -1,3 +1,3 @@
 public-hoist-pattern=*
 ignore-workspace-root-check=true
-shell-emulator=true
+shell-emulator=false

.vscode/launch.json

@@ -35,7 +35,25 @@
             "outFiles": [
                 "${workspaceFolder}/dist/**/*.js",
                 // "!${workspaceFolder}/dist/**/*vendors*",
-                "!${workspaceFolder}/dist/**/*mc-data*",
+                "!**/node_modules/**"
+            ],
+            "skipFiles": [
+                // "<node_internals>/**/*vendors*"
+                "<node_internals>/**/*mc-data*"
+            ],
+        },
+        {
+            // not recommended as in most cases it will slower as it launches from extension host so it slows down extension host, not sure why
+            "type": "chrome",
+            "name": "Launch Chrome (playground)",
+            "request": "launch",
+            "url": "http://localhost:9090/",
+            "pathMapping": {
+                "/": "${workspaceFolder}/prismarine-viewer/dist"
+            },
+            "outFiles": [
+                "${workspaceFolder}/prismarine-viewer/dist/**/*.js",
+                // "!${workspaceFolder}/dist/**/*vendors*",
                 "!**/node_modules/**"
             ],
             "skipFiles": [

.vscode/tasks.json

@@ -25,10 +25,20 @@
             },
         },
         {
-            "label": "viewer server+esbuild",
+            "label": "webgl-worker",
+            "type": "shell",
+            "command": "node buildWorkers.mjs -w",
+            "problemMatcher": "$esbuild-watch",
+            "presentation": {
+                "reveal": "silent"
+            },
+        },
+        {
+            "label": "viewer server+esbuild+workers",
             "dependsOn": [
                 "viewer-server",
-                "viewer-esbuild"
+                "viewer-esbuild",
+                "webgl-worker"
             ],
             "dependsOrder": "parallel",
         }

buildWorkers.mjs

@@ -0,0 +1,276 @@
+//@ts-check
+// main worker file intended for computing world geometry is built using prismarine-viewer/buildWorker.mjs
+import { build, context } from 'esbuild'
+import fs from 'fs'
+import path, { join } from 'path'
+import { polyfillNode } from 'esbuild-plugin-polyfill-node'
+import { mesherSharedPlugins } from './scripts/esbuildPlugins.mjs'
+import { fileURLToPath } from 'url'
+import { dynamicMcDataFiles } from './src/integratedServer/workerMcData.mjs'
+
+const watch = process.argv.includes('-w')
+
+const sharedAliases = {
+  'three': './node_modules/three/src/Three.js',
+  events: 'events', // make explicit
+  buffer: 'buffer',
+  'fs': './src/shims/fs.js',
+  http: './src/shims/empty.ts',
+  perf_hooks: './src/shims/perf_hooks_replacement.js',
+  crypto: './src/shims/crypto.js',
+  stream: 'stream-browserify',
+  net: './src/shims/empty.ts',
+  assert: 'assert',
+  dns: './src/shims/empty.ts',
+  '@azure/msal-node': './src/shims/empty.ts',
+  'flying-squid/dist': 'flying-squid/src'
+}
+
+const result = await (watch ? context : build)({
+  bundle: true,
+  platform: 'browser',
+  // entryPoints: ['renderer/playground/webgpuRendererWorker.ts', 'src/worldSaveWorker.ts'],
+  entryPoints: ['./renderer/playground/webgpuRendererWorker.ts'],
+  outdir: 'renderer/dist/',
+  sourcemap: watch ? 'inline' : 'external',
+  minify: !watch,
+  treeShaking: true,
+  logLevel: 'info',
+  alias: sharedAliases,
+  plugins: [
+    {
+      name: 'writeOutput',
+      setup (build) {
+        build.onEnd(({ outputFiles }) => {
+          fs.mkdirSync('renderer/public', { recursive: true })
+          fs.mkdirSync('dist', { recursive: true })
+          for (const file of outputFiles) {
+            for (const dir of ['renderer/dist', 'dist']) {
+              const baseName = path.basename(file.path)
+              fs.mkdirSync(dir, { recursive: true })
+              fs.writeFileSync(path.join(dir, baseName), file.contents)
+            }
+          }
+        })
+      }
+    },
+    {
+      name: 'fix-dynamic-require',
+      setup (build) {
+        build.onResolve({
+          filter: /1\.14\/chunk/,
+        }, async ({ resolveDir, path }) => {
+          if (!resolveDir.includes('prismarine-provider-anvil')) return
+          return {
+            namespace: 'fix-dynamic-require',
+            path,
+            pluginData: {
+              resolvedPath: `${join(resolveDir, path)}.js`,
+              resolveDir
+            },
+          }
+        })
+        build.onLoad({
+          filter: /.+/,
+          namespace: 'fix-dynamic-require',
+        }, async ({ pluginData: { resolvedPath, resolveDir } }) => {
+          const resolvedFile = await fs.promises.readFile(resolvedPath, 'utf8')
+          return {
+            contents: resolvedFile.replace("require(`prismarine-chunk/src/pc/common/BitArray${noSpan ? 'NoSpan' : ''}`)", "noSpan ? require(`prismarine-chunk/src/pc/common/BitArray`) : require(`prismarine-chunk/src/pc/common/BitArrayNoSpan`)"),
+            resolveDir,
+            loader: 'js',
+          }
+        })
+      }
+    },
+    polyfillNode({
+      polyfills: {
+        fs: false,
+        dns: false,
+        crypto: false,
+        events: false,
+        http: false,
+        stream: false,
+        buffer: false,
+        perf_hooks: false,
+        net: false,
+        assert: false,
+      },
+    })
+  ],
+  loader: {
+    '.vert': 'text',
+    '.frag': 'text',
+    '.wgsl': 'text',
+  },
+  mainFields: [
+    'browser', 'module', 'main'
+  ],
+  keepNames: true,
+  write: false,
+})
+
+if (watch) {
+  //@ts-ignore
+  await result.watch()
+}
+
+const allowedBundleFiles = ['legacy', 'versions', 'protocolVersions', 'features']
+
+const __dirname = path.dirname(fileURLToPath(new URL(import.meta.url)))
+
+
+/** @type {import('esbuild').BuildOptions} */
+const integratedServerBuildOptions = {
+  bundle: true,
+  banner: {
+    js: `globalThis.global = globalThis;process = {env: {}, versions: {} };`,
+  },
+  platform: 'browser',
+  entryPoints: [path.join(__dirname, './src/integratedServer/worker.ts')],
+  minify: !watch,
+  logLevel: 'info',
+  drop: !watch ? [
+    'debugger'
+  ] : [],
+  sourcemap: 'linked',
+  // write: false,
+  // metafile: true,
+  // outdir: path.join(__dirname, './dist'),
+  outfile: './dist/integratedServer.js',
+  define: {
+    'process.env.BROWSER': '"true"',
+    'process.versions.node': '"50.0.0"',
+  },
+  alias: sharedAliases,
+  plugins: [
+    ...mesherSharedPlugins,
+    {
+      name: 'custom-plugins',
+      setup (build) {
+        build.onResolve({ filter: /\.json$/ }, args => {
+          const fileName = args.path.split('/').pop().replace('.json', '')
+          if (args.resolveDir.includes('minecraft-data')) {
+            if (args.path.replaceAll('\\', '/').endsWith('bedrock/common/protocolVersions.json')) {
+              return
+            }
+            if (args.path.includes('bedrock')) {
+              return { path: args.path, namespace: 'empty-file', }
+            }
+            if (dynamicMcDataFiles.includes(fileName)) {
+              return {
+                path: args.path,
+                namespace: 'mc-data',
+              }
+            }
+            if (!allowedBundleFiles.includes(fileName)) {
+              return { path: args.path, namespace: 'empty-file', }
+            }
+          }
+        })
+        build.onResolve({
+          filter: /external/,
+        }, ({ path, importer }) => {
+          importer = importer.split('\\').join('/')
+          if (importer.endsWith('flying-squid/dist/lib/modules/index.js')) {
+            return {
+              path,
+              namespace: 'empty-file-object',
+            }
+          }
+        })
+        build.onLoad({
+          filter: /.*/,
+          namespace: 'empty-file',
+        }, () => {
+          return { contents: 'module.exports = undefined', loader: 'js' }
+        })
+        build.onLoad({
+          filter: /.*/,
+          namespace: 'empty-file-object',
+        }, () => {
+          return { contents: 'module.exports = {}', loader: 'js' }
+        })
+        build.onLoad({
+          namespace: 'mc-data',
+          filter: /.*/,
+        }, async ({ path }) => {
+          const fileName = path.split(/[\\\/]/).pop().replace('.json', '')
+          return {
+            contents: `module.exports = globalThis.mcData["${fileName}"]`,
+            loader: 'js',
+            resolveDir: process.cwd(),
+          }
+        })
+        build.onResolve({
+          filter: /^esbuild-data$/,
+        }, () => {
+          return {
+            path: 'esbuild-data',
+            namespace: 'esbuild-data',
+          }
+        })
+        build.onLoad({
+          filter: /.*/,
+          namespace: 'esbuild-data',
+        }, () => {
+          const data = {
+            // todo always use latest
+            tints: 'require("minecraft-data/minecraft-data/data/pc/1.16.2/tints.json")'
+          }
+          return {
+            contents: `module.exports = {${Object.entries(data).map(([key, code]) => `${key}: ${code}`).join(', ')}}`,
+            loader: 'js',
+            resolveDir: process.cwd(),
+          }
+        })
+
+        build.onResolve({
+          filter: /minecraft-protocol$/,
+        }, async (args) => {
+          return {
+            ...await build.resolve('minecraft-protocol/src/index.js', { kind: args.kind, importer: args.importer, resolveDir: args.resolveDir }),
+          }
+        })
+
+        // build.onEnd(({ metafile, outputFiles }) => {
+        //   if (!metafile) return
+        //   fs.mkdirSync(path.join(__dirname, './dist'), { recursive: true })
+        //   fs.writeFileSync(path.join(__dirname, './dist/metafile.json'), JSON.stringify(metafile))
+        //   for (const outDir of ['../dist/', './dist/']) {
+        //     for (const outputFile of outputFiles) {
+        //       if (outDir === '../dist/' && outputFile.path.endsWith('.map')) {
+        //         // skip writing & browser loading sourcemap there, worker debugging should be done in playground
+        //         // continue
+        //       }
+        //       const writePath = path.join(__dirname, outDir, path.basename(outputFile.path))
+        //       fs.mkdirSync(path.dirname(writePath), { recursive: true })
+        //       fs.writeFileSync(writePath, outputFile.text)
+        //     }
+        //   }
+        // })
+      }
+    },
+    polyfillNode({
+      polyfills: {
+        fs: false,
+        dns: false,
+        crypto: false,
+        events: false,
+        http: false,
+        stream: false,
+        buffer: false,
+        perf_hooks: false,
+        net: false,
+        assert: false,
+      },
+    }),
+  ],
+}
+
+if (watch) {
+  const ctx = await context(integratedServerBuildOptions)
+  await ctx.watch()
+} else {
+  await build(integratedServerBuildOptions)
+}

config.json

@@ -2,7 +2,7 @@
   "version": 1,
   "defaultHost": "<from-proxy>",
   "defaultProxy": "https://proxy.mcraft.fun",
-  "mapsProvider": "https://maps.mcraft.fun/",
+  "mapsProvider": "https://maps.mcraft.fun/?label=webgpu",
   "peerJsServer": "",
   "peerJsServerFallback": "https://p2p.mcraft.fun",
   "promoteServers": [

cypress/e2e/performance.spec.ts

@@ -0,0 +1,25 @@
+import { cleanVisit, setOptions } from './shared'
+
+it('Loads & renders singleplayer', () => {
+  cleanVisit('/?singleplayer=1')
+  setOptions({
+    renderDistance: 2
+  })
+  // wait for .initial-loader to disappear
+  cy.get('.initial-loader', { timeout: 20_000 }).should('not.exist')
+  cy.window()
+    .its('performance')
+    .invoke('mark', 'worldLoad')
+
+  cy.document().then({ timeout: 20_000 }, doc => {
+    return new Cypress.Promise(resolve => {
+      doc.addEventListener('cypress-world-ready', resolve)
+    })
+  }).then(() => {
+    const duration = cy.window()
+      .its('performance')
+      .invoke('measure', 'modalOpen')
+      .its('duration')
+    cy.log('Duration', duration)
+  })
+})