Remove worker

Author: Avaer Kazmer

index.html

@@ -1651,289 +1651,12 @@
 })();
 scene.add(gridMesh); */
 
-worker = (() => {
-  let cbs = [];
-  const worker = new Worker('mc-worker.js');
-  worker.onmessage = e => {
-    const {data} = e;
-    const {error, result} = data;
-    cbs.shift()(error, result);
-  };
-  worker.onerror = err => {
-    console.warn(err);
-  };
-  worker.request = (req, transfers) => new Promise((accept, reject) => {
-    worker.postMessage(req, transfers);
-
-    cbs.push((err, result) => {
-      if (!err) {
-        accept(result);
-      } else {
-        reject(err);
-      }
-    });
-  });
-  return worker;
-})();
 const _makeMiningPlaceholderMesh = (x, z, owner) => {
-  // console.log('make text mesh', token);
-  const mesh = _makeTextMesh('Parcel ' + x + ' : ' + z + ' owned by ' + owner, 30);
-  mesh.position.set(x * PARCEL_SIZE, 1, z * PARCEL_SIZE);
-  // mesh.token = token;
-  mesh.update = () => {
-    // XXX
-  };
-  mesh.intersect = () => null;
-  mesh.destroy = () => {
-    // XXX
-  };
+  const mesh = new THREE.Object3D();
   return mesh;
 };
-const _makeMiningMesh = (x, z/*, token*/) => {
-  const terrainVsh = `
-    varying vec3 vViewPosition;
-    void main() {
-      vec4 mvPosition = modelMatrix * vec4( position.xyz, 1.0 );
-      gl_Position = projectionMatrix * modelViewMatrix * vec4( position.xyz, 1.0 );
-      vViewPosition = mvPosition.xyz;
-    }
-  `;
-  const terrainFsh = `
-    uniform vec3 uSelect;
-    varying vec3 vViewPosition;
-    vec4 color = vec4(${new THREE.Color(0x9ccc65).toArray().map(n => n.toFixed(8)).join(',')}, 1.0);
-    vec4 color2 = vec4(${new THREE.Color(0xec407a).toArray().map(n => n.toFixed(8)).join(',')}, 1.0);
-    bool inRange(vec3 pos, vec3 minPos, vec3 maxPos) {
-      return pos.x >= minPos.x &&
-        pos.y >= minPos.y &&
-        pos.z >= minPos.z &&
-        pos.x <= maxPos.x &&
-        pos.y <= maxPos.y &&
-        pos.z <= maxPos.z;
-    }
-    void main() {
-      vec3 fdx = vec3( dFdx( -vViewPosition.x ), dFdx( -vViewPosition.y ), dFdx( -vViewPosition.z ) );
-      vec3 fdy = vec3( dFdy( -vViewPosition.x ), dFdy( -vViewPosition.y ), dFdy( -vViewPosition.z ) );
-      vec3 normal = normalize( cross( fdx, fdy ) );
-      float dotNL = saturate( dot( normal, normalize(vec3(1.0, 1.0, 1.0))) );
-
-      float range = 1.01;
-      // float range = 2.01;
-      vec3 minPos = uSelect - range;
-      vec3 maxPos = minPos + (range*2.);
-      if (inRange(vViewPosition, minPos, maxPos)) {
-        gl_FragColor = color2;
-      } else {
-        gl_FragColor = color;
-      }
-      gl_FragColor.rgb += dotNL * 0.5;
-    }
-  `;
-
-  const geometry = new THREE.BufferGeometry();
-  const material = new THREE.ShaderMaterial({
-    uniforms: {
-      uSelect: {
-        type: 'v3',
-        value: new THREE.Vector3(NaN, NaN, NaN),
-      },
-    },
-    vertexShader: terrainVsh,
-    fragmentShader: terrainFsh,
-    extensions: {
-      derivatives: true,
-    },
-  });
-  const mesh = new THREE.Mesh(geometry, material);
-  mesh.frustumCulled = false;
-  mesh.visible = false;
-  // mesh.token = token;
-
-  const size = PARCEL_SIZE;
-  const dims = Float32Array.from([size, size, size]);
-  const potential = new Float32Array(size*size*size);
-  potential.fill(1);
-  for (let x = 0; x < size; x++) {
-    for (let y = 0; y < size; y++) {
-      for (let z = 0; z < size; z++) {
-        if (
-          x === 0 || y === 0 || z === 0 ||
-          x === (size-1) || y === (size-1) || z === (size-1)
-        ) {
-          potential[x + y*size + z*size*size] = 0;
-        }
-      }
-    }
-  }
-  const shift = Float32Array.from([(x-0.5)*size, 0, (z-0.5)*size]);
-
-  mesh.x = x;
-  mesh.z = z;
-  mesh.potential = potential;
-  mesh.shift = shift;
-  mesh.contains = pos =>
-    pos.x >= shift[0] &&
-    pos.y >= shift[1] &&
-    pos.z >= shift[2] &&
-    pos.x < shift[0] + size &&
-    pos.y < shift[1] + size &&
-    pos.z < shift[2] + size;
-  mesh.getPotential = pos => {
-    const x = pos.x - shift[0];
-    const y = pos.y - shift[1];
-    const z = pos.z - shift[2];
-    return potential[x + y*size*size + z*size];
-  };
-  mesh.mine = pos => {
-    const x = Math.floor(pos.x - shift[0]);
-    const y = Math.floor(pos.y - shift[1]);
-    const z = Math.floor(pos.z - shift[2]);
-    const factor = 2;
-    const max = Math.sqrt(factor*factor*3);
-    for (let dx = -factor; dx <= factor; dx++) {
-      for (let dz = -factor; dz <= factor; dz++) {
-        for (let dy = -factor; dy <= factor; dy++) {
-          const ax = x + dx;
-          const ay = y + dy;
-          const az = z + dz;
-          if (
-            ax >= 0 &&
-            ay >= 0 &&
-            az >= 0 &&
-            ax < size &&
-            ay < size &&
-            az < size
-          ) {
-            const index = ax + ay*size*size + az*size;
-            const d = (max - Math.sqrt(dx*dx + dy*dy + dz*dz)) / max * 2;
-            potential[index] = Math.max(potential[index] - d, 0);
-          }
-        }
-      }
-    }
-    worker.request({
-      method: 'march',
-      dims,
-      potential,
-      shift,
-    }).then(res => {
-      geometry.addAttribute('position', new THREE.BufferAttribute(res.positions, 3));
-      geometry.setIndex(new THREE.BufferAttribute(res.faces, 1));
-
-      if (potential.every(n => n <= 0)) {
-        const {x, z} = mesh;
-        fetch('https://djj7y2i5p8.execute-api.us-west-1.amazonaws.com/default/Webaverse', {
-          method: 'POST',
-          body: JSON.stringify({
-            addr: window.web3.eth.defaultAccount,
-            x,
-            y: z,
-          }),
-        })
-          .then(res => res.json())
-          .then(o => {
-            const {v, r, s} = o;
-            const addr = window.web3.eth.defaultAccount;
-            console.log('mintTokenFromSignature', {addr, x, z, v, r, s});
-            return user.execute({
-              method: 'mintTokenFromSignature',
-              data: {
-                addr,
-                x,
-                y: z,
-                v,
-                r,
-                s,
-              },
-            });
-          })
-          .then(() => {
-            console.log('mined', {x, z});
-
-            for (;;) {
-              const index = sceneMeshes.findIndex(sceneMesh => sceneMesh.token.coords.some(coord => coord[0] === x && coord[1] === z));
-              if (index !== -1) {
-                const sceneMesh = sceneMeshes[index];
-                sceneMesh.destroy();
-                scene.remove(sceneMesh);
-                sceneMeshes.splice(index, 1);
-              } else {
-                break;
-              }
-            }
-
-            const sceneMesh = _makeSceneObjectMesh();
-            sceneMesh.token = {
-              id: 0,
-              coords: [[x, z]],
-              apps: [],
-              owner: _getUserAddress(),
-            };
-            scene.add(sceneMesh);
-            sceneMeshes.push(sceneMesh);
-
-            selectedSceneToken = null;
-
-            lastSceneCoords[0] = NaN;
-            lastSceneCoords[1] = NaN;
-          });
-      }
-    });
-  };
-  mesh.destroy = () => {
-    geometry.dispose();
-    material.dispose();
-  };
-  let colliding = false;
-  mesh.update = () => {
-    if (!colliding && geometry.attributes.position) {
-      colliding = true;
-
-      const controllerMesh = controllerMeshes[1]; // XXX make this work for all controllers
-      worker.request({
-        method: 'collide',
-        positions: geometry.attributes.position.array,
-        indices: geometry.index.array,
-        origin: controllerMesh.ray.origin.toArray(new Float32Array(3)),
-        direction: controllerMesh.ray.direction.toArray(new Float32Array(3)),
-      })
-        .then(collision => {
-          material.uniforms.uSelect.value.fromArray(collision);
-        })
-        .catch(err => {
-          console.warn(err.stack);
-        })
-        .finally(() => {
-          colliding = false;
-        });
-    }
-  };
-  mesh.intersect = ray => {
-    if (isFinite(material.uniforms.uSelect.value.x)) {
-      const intersectionPoint = material.uniforms.uSelect.value.clone();
-      const distance = ray.origin.distanceTo(intersectionPoint);
-      return {
-        type: 'mine',
-        mesh,
-        intersectionPoint,
-        distance,
-      };
-    } else {
-      return null;
-    }
-  };
-
-  worker.request({
-    method: 'march',
-    dims,
-    potential,
-    shift,
-  }).then(res => {
-    geometry.addAttribute('position', new THREE.BufferAttribute(res.positions, 3));
-    geometry.setIndex(new THREE.BufferAttribute(res.faces, 1));
-    mesh.visible = true;
-  });
-
+const _makeMiningMesh = (x, z) => {
+  const mesh = new THREE.Object3D();
   return mesh;
 };
 let data;