@meimu/mutracer 0.0.0-stage → 0.1.0

package/lib/renderer/geometryBvh.js

@@ -0,0 +1,24 @@
+const configurations = new WeakMap();
+export function geometryBvhConfigMatches(geometry, config) {
+    const bvh = getGeometryBvh(geometry);
+    const previous = configurations.get(geometry) ?? (bvh ? { builder: bvh.builder ?? 'builtin', layout: bvh.layout ?? 'bvh2', spatialSplits: false } : undefined);
+    return !!previous && previous.builder === config.builder && previous.layout === config.layout && previous.spatialSplits === config.spatialSplits;
+}
+const geometryBvhs = new WeakMap();
+export function getGeometryBvh(geometry) {
+    return geometryBvhs.get(geometry);
+}
+export function setGeometryBvh(geometry, bvh, config) {
+    if (bvh) {
+        geometryBvhs.set(geometry, bvh);
+        if (config)
+            configurations.set(geometry, { ...config });
+        else
+            configurations.delete(geometry);
+    }
+    else {
+        geometryBvhs.delete(geometry);
+        configurations.delete(geometry);
+    }
+}
+//# sourceMappingURL=geometryBvh.js.map

package/lib/renderer/geometryBvh.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometryBvh.js","sourceRoot":"","sources":["../../src/renderer/geometryBvh.ts"],"names":[],"mappings":"AAKA,MAAM,cAAc,GAAG,IAAI,OAAO,EAA4B,CAAC;AAC/D,MAAM,UAAU,wBAAwB,CAAC,QAAkB,EAAE,MAAsB;IACjF,MAAM,GAAG,GAAG,cAAc,CAAC,QAAQ,CAAC,CAAC;IACrC,MAAM,QAAQ,GAAG,cAAc,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,GAAG,CAAC,OAAO,IAAI,SAAS,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,IAAI,MAAM,EAAE,aAAa,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IAC/J,OAAO,CAAC,CAAC,QAAQ,IAAI,QAAQ,CAAC,OAAO,KAAK,MAAM,CAAC,OAAO,IAAI,QAAQ,CAAC,MAAM,KAAK,MAAM,CAAC,MAAM,IAAI,QAAQ,CAAC,aAAa,KAAK,MAAM,CAAC,aAAa,CAAC;AACnJ,CAAC;AAED,MAAM,YAAY,GAAG,IAAI,OAAO,EAAyB,CAAC;AAE1D,MAAM,UAAU,cAAc,CAAC,QAAkB;IAC/C,OAAO,YAAY,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;AACpC,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,QAAkB,EAAE,GAA4B,EAAE,MAAuB;IACtG,IAAI,GAAG,EAAE,CAAC;QACR,YAAY,CAAC,GAAG,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;QAChC,IAAI,MAAM;YAAE,cAAc,CAAC,GAAG,CAAC,QAAQ,EAAE,EAAE,GAAG,MAAM,EAAE,CAAC,CAAC;;YACnD,cAAc,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IACvC,CAAC;SAAM,CAAC;QAAC,YAAY,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAAC,cAAc,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAAC,CAAC;AAC5E,CAAC","sourcesContent":["import type { TinyBvhLayout } from '../tinybvh/TinyBvhBuilder.js';\nimport type Geometry from '../scene/Geometry.js';\nimport type { FlattendBVH } from './bvhAccel.js';\n\nexport interface BvhBuildConfig { builder: 'builtin' | 'tinybvh'; layout: TinyBvhLayout; spatialSplits: boolean }\nconst configurations = new WeakMap<Geometry, BvhBuildConfig>();\nexport function geometryBvhConfigMatches(geometry: Geometry, config: BvhBuildConfig) {\n  const bvh = getGeometryBvh(geometry);\n  const previous = configurations.get(geometry) ?? (bvh ? { builder: bvh.builder ?? 'builtin', layout: bvh.layout ?? 'bvh2', spatialSplits: false } : undefined);\n  return !!previous && previous.builder === config.builder && previous.layout === config.layout && previous.spatialSplits === config.spatialSplits;\n}\n\nconst geometryBvhs = new WeakMap<Geometry, FlattendBVH>();\n\nexport function getGeometryBvh(geometry: Geometry) {\n  return geometryBvhs.get(geometry);\n}\n\nexport function setGeometryBvh(geometry: Geometry, bvh: FlattendBVH | undefined, config?: BvhBuildConfig) {\n  if (bvh) {\n    geometryBvhs.set(geometry, bvh);\n    if (config) configurations.set(geometry, { ...config });\n    else configurations.delete(geometry);\n  } else { geometryBvhs.delete(geometry); configurations.delete(geometry); }\n}\n"]}

package/lib/renderer/geometryUpdates.d.ts

@@ -0,0 +1,28 @@
+import Geometry from '../scene/Geometry.js';
+import { type FlattendBVH } from './bvhAccel.js';
+import { updateMeshInstances } from './prepareMeshBVH.js';
+import Mesh from '../scene/Mesh.js';
+type Prepared = ReturnType<typeof updateMeshInstances>;
+/** Displaced geometry must be prepared as a whole. */
+export declare function canUpdateGeometries(prepared: Prepared, geometries: readonly Geometry[]): boolean;
+/** Constant-time topology detection; markUpdated also covers in-place index edits. */
+export declare function geometryTopologyChanged(prepared: Prepared | undefined, source: Geometry): boolean;
+/** Refits/rebuilds changed BLASes and refreshes all shared instances' cached bounds. */
+export declare function updatePreparedGeometries(prepared: Prepared, changed: ReadonlySet<Geometry>): {
+    vertices: {
+        first: number;
+        count: number;
+        topologyChanged: boolean;
+        deformationOnly: boolean;
+    }[];
+    blases: {
+        blas: FlattendBVH;
+        offset: number;
+    }[];
+    meshes: Set<Mesh>;
+    resized: boolean;
+    relocated: boolean;
+};
+/** Packs the same interleaved vertex layout for full and partial GPU uploads. */
+export declare function packVertexAttributes(geometry: Geometry, output: Float32Array, stride: number, offsets: readonly number[], first: number, count: number, includeMaterialIndex?: boolean, deformationOnly?: boolean): void;
+export {};

package/lib/renderer/geometryUpdates.js

@@ -0,0 +1,131 @@
+import { getGeometryBvh, setGeometryBvh } from './geometryBvh.js';
+import { writeMaterialIndices } from './materialIndices.js';
+import { isDeformationUpdate } from '../scene/geometryChanges.js';
+import { hasGeneratedVertexTangents } from '../util/geometry.js';
+import { buildBLAS, refitBLAS } from './bvhAccel.js';
+import { getBvhBounds } from './prepareMeshBVH.js';
+const vertexAttributes = ['position', 'normal', 'uv', 'uv1', 'color', 'tangent', 'materialIndex'];
+const bindingIndices = new WeakMap();
+function indices(prepared) {
+    let maps = bindingIndices.get(prepared);
+    if (!maps) {
+        maps = { source: new Map(), prepared: new Map() };
+        for (const binding of prepared.instanceBindings) {
+            for (const [map, geometry] of [[maps.source, binding.mesh.geometry], [maps.prepared, binding.geometry]]) {
+                let bindings = map.get(geometry);
+                if (!bindings)
+                    map.set(geometry, bindings = []);
+                bindings.push(binding);
+            }
+        }
+        bindingIndices.set(prepared, maps);
+    }
+    return maps;
+}
+/** Displaced geometry must be prepared as a whole. */
+export function canUpdateGeometries(prepared, geometries) {
+    return geometries.every(geometry => {
+        const bindings = indices(prepared).source.get(geometry) ?? [];
+        return bindings.length > 0 && bindings.every(b => !b.mesh.materials.some(m => m.displacementMap) &&
+            b.geometry.position.array === geometry.position.array);
+    });
+}
+/** Rewrites only a geometry's existing region, preserving global material indices. */
+function copyRegion(source, merged, region, topologyChanged, deformationOnly) {
+    const { vertexOffset, indexOffset, materialIndices } = region;
+    const count = source.vertexCount;
+    for (const name of vertexAttributes) {
+        if (name === 'materialIndex' || deformationOnly && name !== 'position' && name !== 'normal' && name !== 'tangent')
+            continue;
+        const target = merged[name];
+        if (!target)
+            continue;
+        const attribute = name === 'uv1' ? source.uv1 ?? source.uv : source[name];
+        const offset = vertexOffset * target.itemSize;
+        if (attribute && attribute.itemSize !== target.itemSize) {
+            for (let v = 0; v < count; v++)
+                for (let c = 0; c < target.itemSize; c++) {
+                    target.array[offset + v * target.itemSize + c] = c < attribute.itemSize ? attribute.array[v * attribute.itemSize + c] : name === 'tangent' && !hasGeneratedVertexTangents(source) ? 2 : 0;
+                }
+        }
+        else if (attribute)
+            target.array.set(attribute.array, offset);
+        else
+            target.array.fill(0, offset, offset + count * target.itemSize);
+    }
+    if (!topologyChanged)
+        return;
+    writeMaterialIndices(source, materialIndices, merged.materialIndex.array, vertexOffset);
+    for (let i = 0; i < source.indices.array.length; i++)
+        merged.indices.array[indexOffset + i] = source.indices.array[i] + vertexOffset;
+}
+/** Constant-time topology detection; markUpdated also covers in-place index edits. */
+export function geometryTopologyChanged(prepared, source) {
+    const state = prepared?.geometryStates.get(source);
+    return !!state && (state.topologyVersion !== source.topologyVersion ||
+        state.indices !== source.indices.array || state.indexCount !== source.indices.array.length);
+}
+/** Refits/rebuilds changed BLASes and refreshes all shared instances' cached bounds. */
+export function updatePreparedGeometries(prepared, changed) {
+    const vertices = [];
+    const blases = [];
+    const meshes = new Set();
+    let resized = false, relocated = false, offset = 0;
+    const updated = new Map();
+    prepared.geometries.forEach((geometry, i) => {
+        const source = indices(prepared).prepared.get(geometry)?.[0].mesh.geometry ?? geometry;
+        const previous = prepared.blases[i].bvh;
+        if (changed.has(source)) {
+            const region = prepared.geometryRegions.get(geometry);
+            const topologyChanged = geometryTopologyChanged(prepared, source);
+            const deformationOnly = !topologyChanged && isDeformationUpdate(source);
+            let bvh = updated.get(source);
+            if (!bvh) {
+                bvh = getGeometryBvh(source);
+                if (topologyChanged || !bvh || source.dynamic && bvh.builder !== 'builtin' || !refitBLAS(bvh, source)) {
+                    bvh = buildBLAS(source);
+                }
+                setGeometryBvh(source, bvh);
+                updated.set(source, bvh);
+            }
+            setGeometryBvh(geometry, bvh);
+            geometry.version = source.version;
+            prepared.blases[i].bvh = bvh;
+            resized ||= previous.buffer.byteLength !== bvh.buffer.byteLength;
+            relocated ||= previous.buffer.byteLength !== bvh.buffer.byteLength || previous.layout !== bvh.layout;
+            copyRegion(source, prepared.geometry, region, topologyChanged, deformationOnly);
+            const count = source.vertexCount, previousVertices = vertices[vertices.length - 1];
+            if (previousVertices && previousVertices.first + previousVertices.count === region.vertexOffset && previousVertices.topologyChanged === topologyChanged && previousVertices.deformationOnly === deformationOnly)
+                previousVertices.count += count;
+            else
+                vertices.push({ first: region.vertexOffset, count, topologyChanged, deformationOnly });
+            blases.push({ blas: bvh, offset });
+            for (const binding of indices(prepared).prepared.get(geometry) ?? []) {
+                binding.bvhBounds = getBvhBounds(geometry);
+                meshes.add(binding.mesh);
+            }
+        }
+        offset += prepared.blases[i].bvh.buffer.byteLength;
+    });
+    for (const source of changed)
+        prepared.geometryStates.set(source, { topologyVersion: source.topologyVersion,
+            indices: source.indices.array, indexCount: source.indices.array.length });
+    return { vertices, blases, meshes, resized, relocated };
+}
+/** Packs the same interleaved vertex layout for full and partial GPU uploads. */
+export function packVertexAttributes(geometry, output, stride, offsets, first, count, includeMaterialIndex = true, deformationOnly = false) {
+    for (let k = 0; k < vertexAttributes.length; k++) {
+        if (k === 6 && !includeMaterialIndex || deformationOnly && k >= 2 && k <= 4)
+            continue;
+        const attribute = geometry[vertexAttributes[k]];
+        if (!attribute)
+            continue;
+        const array = attribute.array, size = attribute.itemSize;
+        let destination = first * stride + offsets[k], source = first * size;
+        for (let i = 0; i < count; i++, destination += stride, source += size) {
+            for (let c = 0; c < size; c++)
+                output[destination + c] = array[source + c];
+        }
+    }
+}
+//# sourceMappingURL=geometryUpdates.js.map

package/lib/renderer/geometryUpdates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometryUpdates.js","sourceRoot":"","sources":["../../src/renderer/geometryUpdates.ts"],"names":[],"mappings":"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","sourcesContent":["import { getGeometryBvh, setGeometryBvh } from './geometryBvh.js';\nimport { writeMaterialIndices } from './materialIndices.js';\nimport { isDeformationUpdate } from '../scene/geometryChanges.js';\nimport Geometry from '../scene/Geometry.js';\nimport { hasGeneratedVertexTangents } from '../util/geometry.js';\nimport { buildBLAS, refitBLAS, type FlattendBVH } from './bvhAccel.js';\nimport { getBvhBounds, updateMeshInstances } from './prepareMeshBVH.js';\nimport Mesh from '../scene/Mesh.js';\n\ntype Prepared = ReturnType<typeof updateMeshInstances>;\nconst vertexAttributes = ['position', 'normal', 'uv', 'uv1', 'color', 'tangent', 'materialIndex'] as const;\nconst bindingIndices = new WeakMap<Prepared, { source: Map<Geometry, Prepared['instanceBindings']>;\n  prepared: Map<Geometry, Prepared['instanceBindings']> }>();\nfunction indices(prepared: Prepared) {\n  let maps = bindingIndices.get(prepared);\n  if (!maps) {\n    maps = { source: new Map(), prepared: new Map() };\n    for (const binding of prepared.instanceBindings) {\n      for (const [map, geometry] of [[maps.source, binding.mesh.geometry], [maps.prepared, binding.geometry]] as const) {\n        let bindings = map.get(geometry);\n        if (!bindings) map.set(geometry, bindings = []);\n        bindings.push(binding);\n      }\n    }\n    bindingIndices.set(prepared, maps);\n  }\n  return maps;\n}\n\n/** Displaced geometry must be prepared as a whole. */\nexport function canUpdateGeometries(prepared: Prepared, geometries: readonly Geometry[]) {\n  return geometries.every(geometry => {\n    const bindings = indices(prepared).source.get(geometry) ?? [];\n    return bindings.length > 0 && bindings.every(b => !b.mesh.materials.some(m => m.displacementMap) &&\n      b.geometry.position.array === geometry.position.array);\n  });\n}\n\n/** Rewrites only a geometry's existing region, preserving global material indices. */\nfunction copyRegion(source: Geometry, merged: Geometry, region: Prepared['geometryRegions'] extends Map<Geometry, infer R> ? R : never, topologyChanged: boolean, deformationOnly: boolean) {\n  const { vertexOffset, indexOffset, materialIndices } = region;\n  const count = source.vertexCount;\n  for (const name of vertexAttributes) {\n    if (name === 'materialIndex' || deformationOnly && name !== 'position' && name !== 'normal' && name !== 'tangent') continue;\n    const target = merged[name]; if (!target) continue;\n    const attribute = name === 'uv1' ? source.uv1 ?? source.uv : source[name];\n    const offset = vertexOffset * target.itemSize;\n    if (attribute && attribute.itemSize !== target.itemSize) {\n      for (let v = 0; v < count; v++) for (let c = 0; c < target.itemSize; c++) {\n        target.array[offset + v * target.itemSize + c] = c < attribute.itemSize ? attribute.array[v * attribute.itemSize + c] : name === 'tangent' && !hasGeneratedVertexTangents(source) ? 2 : 0;\n      }\n    }\n    else if (attribute) target.array.set(attribute.array, offset);\n    else target.array.fill(0, offset, offset + count * target.itemSize);\n  }\n  if (!topologyChanged) return;\n  writeMaterialIndices(source, materialIndices, merged.materialIndex!.array, vertexOffset);\n  for (let i = 0; i < source.indices.array.length; i++) merged.indices.array[indexOffset + i] = source.indices.array[i] + vertexOffset;\n}\n\n/** Constant-time topology detection; markUpdated also covers in-place index edits. */\nexport function geometryTopologyChanged(prepared: Prepared | undefined, source: Geometry) {\n  const state = prepared?.geometryStates.get(source);\n  return !!state && (state.topologyVersion !== source.topologyVersion ||\n    state.indices !== source.indices.array || state.indexCount !== source.indices.array.length);\n}\n\n/** Refits/rebuilds changed BLASes and refreshes all shared instances' cached bounds. */\nexport function updatePreparedGeometries(prepared: Prepared, changed: ReadonlySet<Geometry>) {\n  const vertices: { first: number; count: number; topologyChanged: boolean; deformationOnly: boolean }[] = [];\n  const blases: { blas: FlattendBVH; offset: number }[] = [];\n  const meshes = new Set<Mesh>();\n  let resized = false, relocated = false, offset = 0;\n  const updated = new Map<Geometry, FlattendBVH>();\n  prepared.geometries.forEach((geometry, i) => {\n    const source = indices(prepared).prepared.get(geometry)?.[0].mesh.geometry ?? geometry;\n    const previous = prepared.blases[i].bvh;\n    if (changed.has(source)) {\n      const region = prepared.geometryRegions.get(geometry)!;\n      const topologyChanged = geometryTopologyChanged(prepared, source);\n      const deformationOnly = !topologyChanged && isDeformationUpdate(source);\n      let bvh = updated.get(source);\n      if (!bvh) {\n        bvh = getGeometryBvh(source);\n        if (topologyChanged || !bvh || source.dynamic && bvh.builder !== 'builtin' || !refitBLAS(bvh, source)) {\n          bvh = buildBLAS(source);\n        }\n        setGeometryBvh(source, bvh); updated.set(source, bvh);\n      }\n      setGeometryBvh(geometry, bvh); geometry.version = source.version;\n      prepared.blases[i].bvh = bvh;\n      resized ||= previous.buffer.byteLength !== bvh.buffer.byteLength;\n      relocated ||= previous.buffer.byteLength !== bvh.buffer.byteLength || previous.layout !== bvh.layout;\n      copyRegion(source, prepared.geometry, region, topologyChanged, deformationOnly);\n      const count = source.vertexCount, previousVertices = vertices[vertices.length - 1];\n      if (previousVertices && previousVertices.first + previousVertices.count === region.vertexOffset && previousVertices.topologyChanged === topologyChanged && previousVertices.deformationOnly === deformationOnly) previousVertices.count += count;\n      else vertices.push({first: region.vertexOffset, count, topologyChanged, deformationOnly});\n      blases.push({blas: bvh, offset});\n      for (const binding of indices(prepared).prepared.get(geometry) ?? []) {\n        binding.bvhBounds = getBvhBounds(geometry); meshes.add(binding.mesh);\n      }\n    }\n    offset += prepared.blases[i].bvh.buffer.byteLength;\n  });\n  for (const source of changed) prepared.geometryStates.set(source, { topologyVersion: source.topologyVersion,\n    indices: source.indices.array, indexCount: source.indices.array.length });\n  return { vertices, blases, meshes, resized, relocated };\n}\n\n/** Packs the same interleaved vertex layout for full and partial GPU uploads. */\nexport function packVertexAttributes(geometry: Geometry, output: Float32Array, stride: number,\n  offsets: readonly number[], first: number, count: number, includeMaterialIndex = true, deformationOnly = false) {\n  for (let k = 0; k < vertexAttributes.length; k++) {\n    if (k === 6 && !includeMaterialIndex || deformationOnly && k >= 2 && k <= 4) continue;\n    const attribute = geometry[vertexAttributes[k]];\n    if (!attribute) continue;\n    const array = attribute.array, size = attribute.itemSize;\n    let destination = first * stride + offsets[k], source = first * size;\n    for (let i = 0; i < count; i++, destination += stride, source += size) {\n      for (let c = 0; c < size; c++) output[destination + c] = array[source + c];\n    }\n  }\n}\n"]}

package/lib/renderer/glsl/chunks/cameraRay.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\nRay initCameraRay(vec2 coord) {\n  vec4 origin = viewProjectionInv * vec4(coord * 2.0 - 1.0, -1.0, 1.0);\n  vec4 target = viewProjectionInv * vec4(coord * 2.0 - 1.0, 1.0, 1.0);\n  Ray cam;\n  initRay(cam, origin.xyz / origin.w, normalize(target.xyz * origin.w - origin.xyz * target.w));\n\n  return cam;\n}\n\nvec2 sampleCircle(vec2 p) {\n  p = 2.0 * p - 1.0;\n  bool greater = abs(p.x) > abs(p.y);\n  float r = greater ? p.x : p.y;\n  float theta = greater ? 0.25 * PI * p.y / p.x : PI * (0.5 - 0.25 * p.x / p.y);\n  return r * vec2(cos(theta), sin(theta));\n}\n\nRay primaryCameraRay() {\n  Ray cam = initCameraRay(v_Texcoord + pixelJitter());\n  if (cameraApertureRadius > 0.0) {\n    // Thin lens: the focus plane is perpendicular to the view direction.\n    vec3 eye = viewInv[3].xyz;\n    vec3 forward = -normalize(viewInv[2].xyz);\n    vec3 focusPoint = eye + cam.d * (cameraFocusDistance / dot(cam.d, forward));\n    vec2 lensPoint = cameraApertureRadius * sampleCircle(sample2D(CAMERA_LENS));\n    vec3 origin = vec3(viewInv * vec4(lensPoint, 0.0, 1.0));\n    initRay(cam, origin, normalize(focusPoint - origin));\n  }\n  return cam;\n}\n";
+export default _default;

package/lib/renderer/glsl/chunks/cameraRay.glsl.js

@@ -0,0 +1,37 @@
+// Portions adapted from ray-tracing-renderer@0.10.15
+// (https://github.com/hoverinc/ray-tracing-renderer).
+// Copyright (c) 2019 HOVER, MIT license; see LICENSES/RayTracingRenderer-MIT.txt.
+// Shared primary-ray construction keeps beauty and catcher coverage aligned.
+export default /* glsl */ `
+Ray hz(vec2 fD) {
+vec4 origin = viewProjectionInv * vec4(fD * 2.0 - 1.0, -1.0, 1.0);
+vec4 target = viewProjectionInv * vec4(fD * 2.0 - 1.0, 1.0, 1.0);
+Ray cam;
+iw(cam, origin.xyz / origin.w, normalize(target.xyz * origin.w - origin.xyz * target.w));
+
+return cam;
+}
+
+vec2 oz(vec2 p) {
+p = 2.0 * p - 1.0;
+bool greater = abs(p.x) > abs(p.y);
+float r = greater ? p.x : p.y;
+float theta = greater ? 0.25 * PI * p.y / p.x : PI * (0.5 - 0.25 * p.x / p.y);
+return r * vec2(cos(theta), sin(theta));
+}
+
+Ray nv() {
+Ray cam = hz(v_Texcoord + rN());
+if (cameraApertureRadius > 0.0) {
+
+vec3 eye = viewInv[3].xyz;
+vec3 nV = -normalize(viewInv[2].xyz);
+vec3 qm = eye + cam.d * (cameraFocusDistance / dot(cam.d, nV));
+vec2 ru = cameraApertureRadius * oz(fk(CAMERA_LENS));
+vec3 origin = vec3(viewInv * vec4(ru, 0.0, 1.0));
+iw(cam, origin, normalize(qm - origin));
+}
+return cam;
+}
+`;
+//# sourceMappingURL=cameraRay.glsl.js.map

package/lib/renderer/glsl/chunks/cameraRay.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cameraRay.glsl.js","sourceRoot":"","sources":["../../../../src/renderer/glsl/chunks/cameraRay.glsl.ts"],"names":[],"mappings":"AAAA,qDAAqD;AACrD,sDAAsD;AACtD,kFAAkF;AAElF,6EAA6E;AAC7E,eAAe,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BzB,CAAC","sourcesContent":["// Portions adapted from ray-tracing-renderer@0.10.15\n// (https://github.com/hoverinc/ray-tracing-renderer).\n// Copyright (c) 2019 HOVER, MIT license; see LICENSES/RayTracingRenderer-MIT.txt.\n\n// Shared primary-ray construction keeps beauty and catcher coverage aligned.\nexport default /* glsl */ `\nRay initCameraRay(vec2 coord) {\n  vec4 origin = viewProjectionInv * vec4(coord * 2.0 - 1.0, -1.0, 1.0);\n  vec4 target = viewProjectionInv * vec4(coord * 2.0 - 1.0, 1.0, 1.0);\n  Ray cam;\n  initRay(cam, origin.xyz / origin.w, normalize(target.xyz * origin.w - origin.xyz * target.w));\n\n  return cam;\n}\n\nvec2 sampleCircle(vec2 p) {\n  p = 2.0 * p - 1.0;\n  bool greater = abs(p.x) > abs(p.y);\n  float r = greater ? p.x : p.y;\n  float theta = greater ? 0.25 * PI * p.y / p.x : PI * (0.5 - 0.25 * p.x / p.y);\n  return r * vec2(cos(theta), sin(theta));\n}\n\nRay primaryCameraRay() {\n  Ray cam = initCameraRay(v_Texcoord + pixelJitter());\n  if (cameraApertureRadius > 0.0) {\n    // Thin lens: the focus plane is perpendicular to the view direction.\n    vec3 eye = viewInv[3].xyz;\n    vec3 forward = -normalize(viewInv[2].xyz);\n    vec3 focusPoint = eye + cam.d * (cameraFocusDistance / dot(cam.d, forward));\n    vec2 lensPoint = cameraApertureRadius * sampleCircle(sample2D(CAMERA_LENS));\n    vec3 origin = vec3(viewInv * vec4(lensPoint, 0.0, 1.0));\n    initRay(cam, origin, normalize(focusPoint - origin));\n  }\n  return cam;\n}\n`;\n"]}

package/lib/renderer/glsl/chunks/common.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string;
+export default _default;

package/lib/renderer/glsl/chunks/common.glsl.js

@@ -0,0 +1,17 @@
+// Portions adapted from ray-tracing-renderer@0.10.15
+// (https://github.com/hoverinc/ray-tracing-renderer).
+// Copyright (c) 2019 HOVER, MIT license; see LICENSES/RayTracingRenderer-MIT.txt.
+import { glsl } from '../../shader.js';
+export default glsl `
+#define PI 3.14159265359
+#define TWOPI 6.28318530718
+#define INVPI 0.31830988618
+#define INVPI2 0.10132118364
+#define EPS 0.0005
+#define INF 1.0e999
+#define INV4PI 0.07957747154594766
+
+#define ROUGHNESS_MIN 0.001
+
+`;
+//# sourceMappingURL=common.glsl.js.map

package/lib/renderer/glsl/chunks/common.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.glsl.js","sourceRoot":"","sources":["../../../../src/renderer/glsl/chunks/common.glsl.ts"],"names":[],"mappings":"AAAA,qDAAqD;AACrD,sDAAsD;AACtD,kFAAkF;AAElF,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAEvC,eAAe,IAAI,CAAA;;;;;;;;;;;CAWlB,CAAC","sourcesContent":["// Portions adapted from ray-tracing-renderer@0.10.15\n// (https://github.com/hoverinc/ray-tracing-renderer).\n// Copyright (c) 2019 HOVER, MIT license; see LICENSES/RayTracingRenderer-MIT.txt.\n\nimport { glsl } from '../../shader.js';\n\nexport default glsl`\n#define PI 3.14159265359\n#define TWOPI 6.28318530718\n#define INVPI 0.31830988618\n#define INVPI2 0.10132118364\n#define EPS 0.0005\n#define INF 1.0e999\n#define INV4PI 0.07957747154594766\n\n#define ROUGHNESS_MIN 0.001\n\n`;\n"]}

package/lib/renderer/glsl/chunks/envMap.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../shader.js").ShaderMixin;
+export default _default;

package/lib/renderer/glsl/chunks/envMap.glsl.js

@@ -0,0 +1,192 @@
+// Portions adapted from ray-tracing-renderer@0.10.15
+// (https://github.com/hoverinc/ray-tracing-renderer).
+// Copyright (c) 2019 HOVER, MIT license; see LICENSES/RayTracingRenderer-MIT.txt.
+// Sample the environment map using a cumulative distribution function as described in
+// http://www.pbr-book.org/3ed-2018/Light_Transport_I_Surface_Reflection/Sampling_Light_Sources.html#InfiniteAreaLights
+import { createShaderMixin, glsl, Shader } from '../../shader.js';
+export default createShaderMixin({
+    uniforms: {
+        envMap: Shader.uniform('sampler2D'),
+        envMapDistribution: Shader.uniform('sampler2D'),
+        backgroundMap: Shader.uniform('sampler2D'),
+        groundedBackgroundParams: Shader.uniform('vec4'),
+        groundedBackgroundCenter: Shader.uniform('vec2')
+    },
+    main: glsl `
+vec2 aS(vec3 gb) {
+float phi = mod(atan(-gb.z, -gb.x), TWOPI);
+float theta = acos(gb.y);
+return vec2(phi * 0.5 * INVPI, theta * INVPI);
+}
+
+float qp(float u, out int vOffset, out float pdf) {
+ivec2 size = textureSize(envMap, 0);
+
+int left = 0;
+int right = size.y + 1; 
+while (left < right) {
+int mid = (left + right) >> 1;
+float s = texelFetch(envMapDistribution, ivec2(0, mid), 0).x;
+if (s <= u) {
+left = mid + 1;
+} else {
+right = mid;
+}
+}
+vOffset = left - 1;
+
+
+
+vec2 s0 = texelFetch(envMapDistribution, ivec2(0, vOffset), 0).xy;
+vec2 s1 = texelFetch(envMapDistribution, ivec2(0, vOffset + 1), 0).xy;
+
+pdf = s0.y;
+
+return (float(vOffset) +  (u - s0.x) / (s1.x - s0.x)) / float(size.y);
+}
+
+float qo(float u, int vOffset, out float pdf) {
+ivec2 size = textureSize(envMap, 0);
+
+int left = 0;
+int right = size.x + 1; 
+while (left < right) {
+int mid = (left + right) >> 1;
+float s = texelFetch(envMapDistribution, ivec2(1 + mid, vOffset), 0).x;
+if (s <= u) {
+left = mid + 1;
+} else {
+right = mid;
+}
+}
+int oG = left - 1;
+
+
+
+vec2 s0 = texelFetch(envMapDistribution, ivec2(1 + oG, vOffset), 0).xy;
+vec2 s1 = texelFetch(envMapDistribution, ivec2(1 + oG + 1, vOffset), 0).xy;
+
+pdf = s0.y;
+
+return (float(oG) + (u - s0.x) / (s1.x - s0.x)) / float(size.x);
+}
+
+
+vec3 oA(vec2 random, out vec2 uv, out float pdf) {
+vec2 gY;
+int vOffset;
+
+uv.y = qp(random.x, vOffset, gY.y);
+uv.x = qo(random.y, vOffset, gY.x);
+
+float phi = uv.x * TWOPI;
+float theta = uv.y * PI;
+float cc = cos(theta);
+float sinTheta = sin(theta);
+float tY = cos(phi);
+float ug = sin(phi);
+
+vec3 dir = vec3(-sinTheta * tY, cc, -sinTheta * ug);
+
+pdf = gY.x * gY.y * INVPI2 / (2.0 * sinTheta);
+
+return dir;
+}
+
+float iv(vec2 uv) {
+vec2 size = vec2(textureSize(envMap, 0));
+
+float sinTheta = sin(uv.y * PI);
+
+uv *= size;
+
+float sw = texelFetch(envMapDistribution, ivec2(1.0 + uv.x, uv.y), 0).y;
+float sz = texelFetch(envMapDistribution, ivec2(0, uv.y), 0).y;
+
+return sw * sz * INVPI2 / (2.0 * sinTheta);
+}
+
+float dq(vec3 sA, float height, float radius) {
+float fN = length(sA);
+if (fN < 0.00001) {
+return -radius;
+}
+
+float iC = radius * sA.y / fN;
+float ik = -1.5 * height;
+float ev;
+if (iC >= 0.0) {
+ev = radius;
+} else if (iC < ik) {
+ev = -height * fN / sA.y;
+} else {
+float dW = 1.0
+- iC * iC / (3.0 * ik * ik);
+ev = radius * dW;
+}
+return fN - ev;
+}
+
+vec3 eQ(vec3 origin, vec3 d) {
+#ifdef USE_GROUNDED_BACKGROUND
+float height = groundedBackgroundParams.x;
+float radius = groundedBackgroundParams.y;
+float vA = groundedBackgroundParams.z;
+vec3 bY = normalize(d);
+vec3 bB = origin - vec3(
+groundedBackgroundCenter.x,
+vA + height,
+groundedBackgroundCenter.y
+);
+
+
+
+float eI = dot(bB, bY);
+float ej = eI * eI
+- dot(bB, bB) + radius * radius;
+if (ej > 0.0) {
+float cB = -eI + sqrt(ej);
+if (
+cB > 0.0
+&& dq(bB, height, radius) <= 0.0
+) {
+vec3 nB = bB + bY * cB;
+if (nB.y >= 0.0) {
+return normalize(nB);
+}
+
+if (bY.y < -0.00001 && radius > 1.5 * height) {
+float hQ = (-height - bB.y) / bY.y;
+vec3 nk = bB + bY * hQ;
+float nZ = (2.0 / 3.0)
+* sqrt(radius * radius - 2.25 * height * height);
+if (hQ > 0.0 && length(nk.xz) <= nZ) {
+return normalize(nk);
+}
+}
+
+float cN = 0.0;
+for (int i = 0; i < 14; i++) {
+float fe = (cN + cB) * 0.5;
+vec3 pp = bB + bY * fe;
+if (dq(pp, height, radius) > 0.0) {
+cB = fe;
+} else {
+cN = fe;
+}
+}
+vec3 hit = bB + bY * ((cN + cB) * 0.5);
+return normalize(hit);
+}
+}
+#endif
+return d;
+}
+
+vec4 cw(vec3 origin, vec3 d) {
+d = eQ(origin, d);
+vec2 uv = aS(d);
+return textureLinear(backgroundMap, uv);
+}`
+});
+//# sourceMappingURL=envMap.glsl.js.map

package/lib/renderer/glsl/chunks/envMap.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"envMap.glsl.js","sourceRoot":"","sources":["../../../../src/renderer/glsl/chunks/envMap.glsl.ts"],"names":[],"mappings":"AAAA,qDAAqD;AACrD,sDAAsD;AACtD,kFAAkF;AAElF,sFAAsF;AACtF,uHAAuH;AAEvH,OAAO,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAElE,eAAe,iBAAiB,CAAC;IAC/B,QAAQ,EAAE;QACR,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;QACnC,kBAAkB,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;QAC/C,aAAa,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;QAC1C,wBAAwB,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;QAChD,wBAAwB,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;KACjD;IACD,IAAI,EAAE,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+KV;CACD,CAAC,CAAC","sourcesContent":["// Portions adapted from ray-tracing-renderer@0.10.15\n// (https://github.com/hoverinc/ray-tracing-renderer).\n// Copyright (c) 2019 HOVER, MIT license; see LICENSES/RayTracingRenderer-MIT.txt.\n\n// Sample the environment map using a cumulative distribution function as described in\n// http://www.pbr-book.org/3ed-2018/Light_Transport_I_Surface_Reflection/Sampling_Light_Sources.html#InfiniteAreaLights\n\nimport { createShaderMixin, glsl, Shader } from '../../shader.js';\n\nexport default createShaderMixin({\n  uniforms: {\n    envMap: Shader.uniform('sampler2D'),\n    envMapDistribution: Shader.uniform('sampler2D'),\n    backgroundMap: Shader.uniform('sampler2D'),\n    groundedBackgroundParams: Shader.uniform('vec4'),\n    groundedBackgroundCenter: Shader.uniform('vec2')\n  },\n  main: glsl`\nvec2 cartesianToEquirect(vec3 pointOnSphere) {\n  float phi = mod(atan(-pointOnSphere.z, -pointOnSphere.x), TWOPI);\n  float theta = acos(pointOnSphere.y);\n  return vec2(phi * 0.5 * INVPI, theta * INVPI);\n}\n\nfloat getEnvmapV(float u, out int vOffset, out float pdf) {\n  ivec2 size = textureSize(envMap, 0);\n\n  int left = 0;\n  int right = size.y + 1; // cdf length is the length of the env map + 1\n  while (left < right) {\n    int mid = (left + right) >> 1;\n    float s = texelFetch(envMapDistribution, ivec2(0, mid), 0).x;\n    if (s <= u) {\n      left = mid + 1;\n    } else {\n      right = mid;\n    }\n  }\n  vOffset = left - 1;\n\n  // x channel is cumulative distribution of env map luminance\n  // y channel is partial probability density of env map luminance\n  vec2 s0 = texelFetch(envMapDistribution, ivec2(0, vOffset), 0).xy;\n  vec2 s1 = texelFetch(envMapDistribution, ivec2(0, vOffset + 1), 0).xy;\n\n  pdf = s0.y;\n\n  return (float(vOffset) +  (u - s0.x) / (s1.x - s0.x)) / float(size.y);\n}\n\nfloat getEnvmapU(float u, int vOffset, out float pdf) {\n  ivec2 size = textureSize(envMap, 0);\n\n  int left = 0;\n  int right = size.x + 1; // cdf length is the length of the env map + 1\n  while (left < right) {\n    int mid = (left + right) >> 1;\n    float s = texelFetch(envMapDistribution, ivec2(1 + mid, vOffset), 0).x;\n    if (s <= u) {\n      left = mid + 1;\n    } else {\n      right = mid;\n    }\n  }\n  int uOffset = left - 1;\n\n  // x channel is cumulative distribution of env map luminance\n  // y channel is partial probability density of env map luminance\n  vec2 s0 = texelFetch(envMapDistribution, ivec2(1 + uOffset, vOffset), 0).xy;\n  vec2 s1 = texelFetch(envMapDistribution, ivec2(1 + uOffset + 1, vOffset), 0).xy;\n\n  pdf = s0.y;\n\n  return (float(uOffset) + (u - s0.x) / (s1.x - s0.x)) / float(size.x);\n}\n\n// Perform two binary searches to find light direction.\nvec3 sampleEnvmap(vec2 random, out vec2 uv, out float pdf) {\n  vec2 partialPdf;\n  int vOffset;\n\n  uv.y = getEnvmapV(random.x, vOffset, partialPdf.y);\n  uv.x = getEnvmapU(random.y, vOffset, partialPdf.x);\n\n  float phi = uv.x * TWOPI;\n  float theta = uv.y * PI;\n  float cosTheta = cos(theta);\n  float sinTheta = sin(theta);\n  float cosPhi = cos(phi);\n  float sinPhi = sin(phi);\n\n  vec3 dir = vec3(-sinTheta * cosPhi, cosTheta, -sinTheta * sinPhi);\n\n  pdf = partialPdf.x * partialPdf.y * INVPI2 / (2.0 * sinTheta);\n\n  return dir;\n}\n\nfloat envMapPdf(vec2 uv) {\n  vec2 size = vec2(textureSize(envMap, 0));\n\n  float sinTheta = sin(uv.y * PI);\n\n  uv *= size;\n\n  float partialX = texelFetch(envMapDistribution, ivec2(1.0 + uv.x, uv.y), 0).y;\n  float partialY = texelFetch(envMapDistribution, ivec2(0, uv.y), 0).y;\n\n  return partialX * partialY * INVPI2 / (2.0 * sinTheta);\n}\n\nfloat groundedSurfaceDistance(vec3 point, float height, float radius) {\n  float pointLength = length(point);\n  if (pointLength < 0.00001) {\n    return -radius;\n  }\n\n  float originalY = radius * point.y / pointLength;\n  float transitionY = -1.5 * height;\n  float surfaceRadius;\n  if (originalY >= 0.0) {\n    surfaceRadius = radius;\n  } else if (originalY < transitionY) {\n    surfaceRadius = -height * pointLength / point.y;\n  } else {\n    float factor = 1.0\n      - originalY * originalY / (3.0 * transitionY * transitionY);\n    surfaceRadius = radius * factor;\n  }\n  return pointLength - surfaceRadius;\n}\n\nvec3 groundedBackgroundDirection(vec3 origin, vec3 d) {\n#ifdef USE_GROUNDED_BACKGROUND\n  float height = groundedBackgroundParams.x;\n  float radius = groundedBackgroundParams.y;\n  float groundY = groundedBackgroundParams.z;\n  vec3 rayDirection = normalize(d);\n  vec3 localOrigin = origin - vec3(\n    groundedBackgroundCenter.x,\n    groundY + height,\n    groundedBackgroundCenter.y\n  );\n\n  // The grounded skybox is a deformed sphere. Find the point where the ray\n  // exits that surface so its texture lookup matches the rasterized geometry.\n  float projectedOrigin = dot(localOrigin, rayDirection);\n  float discriminant = projectedOrigin * projectedOrigin\n    - dot(localOrigin, localOrigin) + radius * radius;\n  if (discriminant > 0.0) {\n    float farDistance = -projectedOrigin + sqrt(discriminant);\n    if (\n      farDistance > 0.0\n      && groundedSurfaceDistance(localOrigin, height, radius) <= 0.0\n    ) {\n      vec3 sphereHit = localOrigin + rayDirection * farDistance;\n      if (sphereHit.y >= 0.0) {\n        return normalize(sphereHit);\n      }\n\n      if (rayDirection.y < -0.00001 && radius > 1.5 * height) {\n        float groundDistance = (-height - localOrigin.y) / rayDirection.y;\n        vec3 groundHit = localOrigin + rayDirection * groundDistance;\n        float groundRadius = (2.0 / 3.0)\n          * sqrt(radius * radius - 2.25 * height * height);\n        if (groundDistance > 0.0 && length(groundHit.xz) <= groundRadius) {\n          return normalize(groundHit);\n        }\n      }\n\n      float nearDistance = 0.0;\n      for (int i = 0; i < 14; i++) {\n        float middleDistance = (nearDistance + farDistance) * 0.5;\n        vec3 middlePoint = localOrigin + rayDirection * middleDistance;\n        if (groundedSurfaceDistance(middlePoint, height, radius) > 0.0) {\n          farDistance = middleDistance;\n        } else {\n          nearDistance = middleDistance;\n        }\n      }\n      vec3 hit = localOrigin + rayDirection * ((nearDistance + farDistance) * 0.5);\n      return normalize(hit);\n    }\n  }\n#endif\n  return d;\n}\n\nvec4 sampleBackgroundFromRay(vec3 origin, vec3 d) {\n  d = groundedBackgroundDirection(origin, d);\n  vec2 uv = cartesianToEquirect(d);\n  return textureLinear(backgroundMap, uv);\n}`\n});\n"]}

package/lib/renderer/glsl/chunks/intersect.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../shader.js").ShaderMixin;
+export default _default;