Clean-up before denoising (#13)

* lots of cleanup and small refactors

* use .rgb

Author: Lucas

src/RayTracingRenderer.js

@@ -10,7 +10,7 @@ const glOptionalExtensions = [
   'OES_texture_float_linear', // enables gl.LINEAR texture filtering for float textures,
 ];
 
-function RayTracingRenderer(params = {}) {
+export function RayTracingRenderer(params = {}) {
   const canvas = params.canvas || document.createElement('canvas');
 
   const gl = canvas.getContext('webgl2', {
@@ -21,10 +21,10 @@ function RayTracingRenderer(params = {}) {
     powerPreference: 'high-performance',
     failIfMajorPerformanceCaveat: true
   });
+
   loadExtensions(gl, glRequiredExtensions);
   const optionalExtensions = loadExtensions(gl, glOptionalExtensions);
 
-  // private properties
   let pipeline = null;
   const size = new THREE.Vector2();
   let renderTime = 22;
@@ -195,5 +195,3 @@ RayTracingRenderer.isSupported = () => {
 
   return true;
 };
-
-export { RayTracingRenderer };

src/constants.js

@@ -1,3 +1,3 @@
 export const ThinMaterial = 1;
 export const ThickMaterial = 2;
-export const ShadowCatcherMaterial = 3;
+export const ShadowCatcherMaterial = 3;

src/main.js

@@ -23,4 +23,4 @@ export {
   EnvironmentLight,
   RayTracingMaterial,
   RayTracingRenderer,
-};
+};

src/renderer/addGeometryIndices.js

@@ -1,4 +1,23 @@
-import { BufferGeometry, BufferAttribute } from 'three';
+import { BufferAttribute } from 'three';
+
+export function addFlatGeometryIndices(geometry) {
+  const position = geometry.getAttribute('position');
+
+  if (!position) {
+    console.warn('No position attribute');
+    return;
+  }
+
+  const index = new Uint32Array(position.count);
+
+  for (let i = 0; i < index.length; i++) {
+    index[i] = i;
+  }
+
+  geometry.setIndex(new BufferAttribute(index, 1, false));
+
+  return geometry;
+}
 
 //TODO: Add UV support
 export function addSmoothGeometryIndices(geometry) {
@@ -39,23 +58,3 @@ export function addSmoothGeometryIndices(geometry) {
 
   return bg;
 }
-
-export function addFlatGeometryIndices(geometry) {
-  const position = geometry.getAttribute('position');
-
-  if (!position) {
-    console.warn('No position attribute');
-    return;
-  }
-
-  const index = new Uint32Array(position.count);
-
-  for (let i = 0; i < index.length; i++) {
-    index[i] = i;
-  }
-
-  geometry.setIndex(new BufferAttribute(index, 1, false));
-
-  return geometry;
-}
-

src/renderer/bvhAccel.js

@@ -5,30 +5,88 @@
 import { Box3, Vector3 }  from 'three';
 import { partition, nthElement } from './bvhUtil';
 
-const size = new Vector3;
+const size = new Vector3();
 
-function maximumExtent(box3) {
-  box3.getSize(size);
-  if (size.x > size.z) {
-    return size.x > size.y ? 'x' : 'y';
-  } else {
-    return size.z > size.y ? 'z' : 'y';
-  }
+export function bvhAccel(geometry, materialIndices) {
+  const primitiveInfo = makePrimitiveInfo(geometry, materialIndices);
+  const node = recursiveBuild(primitiveInfo, 0, primitiveInfo.length);
+
+  return node;
 }
 
-function boxOffset(box3, dim, v) {
-  let offset = v[dim] - box3.min[dim];
+export function flattenBvh(bvh) {
+  const flat = [];
+  const isBounds = [];
 
-  if (box3.max[dim] > box3.min[dim]){
-    offset /= box3.max[dim] - box3.min[dim];
-  }
+  const splitAxisMap = {
+    x: 0,
+    y: 1,
+    z: 2
+  };
 
-  return offset;
-}
+  let maxDepth = 1;
+  const traverse = (node, depth = 1) => {
 
-function surfaceArea(box3) {
-  box3.getSize(size);
-  return 2 * (size.x * size.z + size.x * size.y + size.z * size.y);
+    maxDepth = Math.max(depth, maxDepth);
+
+    if (node.primitives) {
+      for (let i = 0; i < node.primitives.length; i++) {
+        const p = node.primitives[i];
+        flat.push(
+          p.indices[0], p.indices[1], p.indices[2], node.primitives.length,
+          p.faceNormal.x, p.faceNormal.y, p.faceNormal.z, p.materialIndex
+        );
+        isBounds.push(false);
+      }
+    } else {
+      const bounds = node.bounds;
+
+      flat.push(
+        bounds.min.x, bounds.min.y, bounds.min.z, splitAxisMap[node.splitAxis],
+        bounds.max.x, bounds.max.y, bounds.max.z, null // pointer to second shild
+      );
+
+      const i = flat.length - 1;
+      isBounds.push(true);
+
+      traverse(node.child0, depth + 1);
+      flat[i] = flat.length / 4; // pointer to second child
+      traverse(node.child1, depth + 1);
+    }
+  };
+
+  traverse(bvh);
+
+  const buffer = new ArrayBuffer(4 * flat.length);
+  const floatView = new Float32Array(buffer);
+  const intView = new Int32Array(buffer);
+
+  for (let i = 0; i < isBounds.length; i++) {
+    let k = 8 * i;
+
+    if (isBounds[i]) {
+      floatView[k] = flat[k];
+      floatView[k + 1] = flat[k + 1];
+      floatView[k + 2] = flat[k + 2];
+      intView[k + 3] = flat[k + 3];
+    } else {
+      intView[k] = flat[k];
+      intView[k + 1] = flat[k + 1];
+      intView[k + 2] = flat[k + 2];
+      intView[k + 3] = -flat[k + 3]; // negative signals to shader that this node is a triangle
+    }
+
+    floatView[k + 4] = flat[k + 4];
+    floatView[k + 5] = flat[k + 5];
+    floatView[k + 6] = flat[k + 6];
+    intView[k + 7] = flat[k + 7];
+  }
+
+  return {
+    maxDepth,
+    count: flat.length / 4,
+    buffer: floatView
+  };
 }
 
 function makePrimitiveInfo(geometry, materialIndices) {
@@ -68,22 +126,6 @@ function makePrimitiveInfo(geometry, materialIndices) {
   return primitiveInfo;
 }
 
-function makeLeafNode(primitives, bounds) {
-  return {
-    primitives,
-    bounds
-  };
-}
-
-function makeInteriorNode(splitAxis, child0, child1) {
-  return {
-    child0,
-    child1,
-    bounds: new Box3().union(child0.bounds).union(child1.bounds),
-    splitAxis,
-  };
-}
-
 function recursiveBuild(primitiveInfo, start, end) {
   const bounds = new Box3();
   for (let i = start; i < end; i++) {
@@ -177,84 +219,42 @@ function recursiveBuild(primitiveInfo, start, end) {
   }
 }
 
-export function bvhAccel(geometry, materialIndices) {
-  const primitiveInfo = makePrimitiveInfo(geometry, materialIndices);
-  const node = recursiveBuild(primitiveInfo, 0, primitiveInfo.length);
-
-  return node;
-}
-
-export function flattenBvh(bvh) {
-  const flat = [];
-  const isBounds = [];
-
-  const splitAxisMap = {
-    x: 0,
-    y: 1,
-    z: 2
+function makeLeafNode(primitives, bounds) {
+  return {
+    primitives,
+    bounds
   };
+}
 
-  let maxDepth = 1;
-  const traverse = (node, depth = 1) => {
-
-    maxDepth = Math.max(depth, maxDepth);
-
-    if (node.primitives) {
-      for (let i = 0; i < node.primitives.length; i++) {
-        const p = node.primitives[i];
-        flat.push(
-          p.indices[0], p.indices[1], p.indices[2], node.primitives.length,
-          p.faceNormal.x, p.faceNormal.y, p.faceNormal.z, p.materialIndex
-        );
-        isBounds.push(false);
-      }
-    } else {
-      const bounds = node.bounds;
-
-      flat.push(
-        bounds.min.x, bounds.min.y, bounds.min.z, splitAxisMap[node.splitAxis],
-        bounds.max.x, bounds.max.y, bounds.max.z, null // pointer to second shild
-      );
-
-      const i = flat.length - 1;
-      isBounds.push(true);
-
-      traverse(node.child0, depth + 1);
-      flat[i] = flat.length / 4; // pointer to second child
-      traverse(node.child1, depth + 1);
-    }
+function makeInteriorNode(splitAxis, child0, child1) {
+  return {
+    child0,
+    child1,
+    bounds: new Box3().union(child0.bounds).union(child1.bounds),
+    splitAxis,
   };
+}
 
-  traverse(bvh);
-
-  const buffer = new ArrayBuffer(4 * flat.length);
-  const floatView = new Float32Array(buffer);
-  const intView = new Int32Array(buffer);
-
-  for (let i = 0; i < isBounds.length; i++) {
-    let k = 8 * i;
+function maximumExtent(box3) {
+  box3.getSize(size);
+  if (size.x > size.z) {
+    return size.x > size.y ? 'x' : 'y';
+  } else {
+    return size.z > size.y ? 'z' : 'y';
+  }
+}
 
-    if (isBounds[i]) {
-      floatView[k] = flat[k];
-      floatView[k + 1] = flat[k + 1];
-      floatView[k + 2] = flat[k + 2];
-      intView[k + 3] = flat[k + 3];
-    } else {
-      intView[k] = flat[k];
-      intView[k + 1] = flat[k + 1];
-      intView[k + 2] = flat[k + 2];
-      intView[k + 3] = -flat[k + 3]; // negative signals to shader that this node is a triangle
-    }
+function boxOffset(box3, dim, v) {
+  let offset = v[dim] - box3.min[dim];
 
-    floatView[k + 4] = flat[k + 4];
-    floatView[k + 5] = flat[k + 5];
-    floatView[k + 6] = flat[k + 6];
-    intView[k + 7] = flat[k + 7];
+  if (box3.max[dim] > box3.min[dim]){
+    offset /= box3.max[dim] - box3.min[dim];
   }
 
-  return {
-    maxDepth,
-    count: flat.length / 4,
-    buffer: floatView
-  };
+  return offset;
+}
+
+function surfaceArea(box3) {
+  box3.getSize(size);
+  return 2 * (size.x * size.z + size.x * size.y + size.z * size.y);
 }

src/renderer/bvhUtil.js

@@ -1,10 +1,3 @@
-
-function swap(array, a, b) {
-  const x = array[b];
-  array[b] = array[a];
-  array[a] = x;
-}
-
 // Reorders the elements in the range [first, last) in such a way that
 // all elements for which the comparator c returns true
 // precede the elements for which comparator c returns false.
@@ -46,3 +39,9 @@ export function nthElement(array, compare, left = 0, right = array.length, k = M
     }
   }
 }
+
+function swap(array, a, b) {
+  const x = array[b];
+  array[b] = array[a];
+  array[a] = x;
+}

src/renderer/envMapCreation.js

@@ -29,7 +29,7 @@ export function initializeEnvMap(environmentLights) {
     envImage.data = rgbeToFloat(envImage.data);
     envImage.data.forEach((datum, index, arr) => {
       arr[index] = datum * environmentLight.intensity;
-    }); 
+    });
   } else { // initialize blank map
     envImage = generateBlankMap(DEFAULT_MAP_RESOLUTION.width, DEFAULT_MAP_RESOLUTION.height);
   }