@meimu/mutracer 0.1.5 → 0.2.0

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

@@ -11,40 +11,40 @@ fn textureLinear(tex: texture_2d<f32>, _uv: vec2f) -> vec4f {
 
 let size = vec2f(textureDimensions(tex, 0));
 
-let wN = _uv * size - vec2f(0.5);
-let vT = floor(wN);
-let f = fract(wN);
-let vS = vec2i(vT);
+let yq = _uv * size - vec2f(0.5);
+let xI = floor(yq);
+let f = fract(yq);
+let xH = vec2i(xI);
 let maximum = vec2i(size) - vec2i(1);
 
 
-let s1 = textureLoad(tex, clamp(vS + vec2i(0, 0), vec2i(0), maximum), 0);
-let s2 = textureLoad(tex, clamp(vS + vec2i(1, 0), vec2i(0), maximum), 0);
-let s3 = textureLoad(tex, clamp(vS + vec2i(0, 1), vec2i(0), maximum), 0);
-let s4 = textureLoad(tex, clamp(vS + vec2i(1, 1), vec2i(0), maximum), 0);
+let s1 = textureLoad(tex, clamp(xH + vec2i(0, 0), vec2i(0), maximum), 0);
+let s2 = textureLoad(tex, clamp(xH + vec2i(1, 0), vec2i(0), maximum), 0);
+let s3 = textureLoad(tex, clamp(xH + vec2i(0, 1), vec2i(0), maximum), 0);
+let s4 = textureLoad(tex, clamp(xH + vec2i(1, 1), vec2i(0), maximum), 0);
 
 return mix(mix(s1, s2, f.x), mix(s3, s4, f.x), f.y);
 
 }
 
-fn eL(gh: vec3f) -> vec2f {
-var phi = atan2(-gh.z, -gh.x);
+fn eV(gx: vec3f) -> vec2f {
+var phi = atan2(-gx.z, -gx.x);
 if (phi < 0.0) {
 phi += TWOPI;
 }
-let theta = acos(clamp(gh.y, -1.0, 1.0));
+let theta = acos(clamp(gx.y, -1.0, 1.0));
 return vec2f(phi * 0.5 * INVPI, theta * INVPI);
 }
 
-fn jN() -> mat3x3f {
+fn ko() -> mat3x3f {
 return mat3x3f(rtUniform.environmentRotation[0].xyz, rtUniform.environmentRotation[1].xyz, rtUniform.environmentRotation[2].xyz);
 }
 
-fn cY(mP: vec3f) -> vec2f {
-return eL(transpose(jN()) * mP);
+fn dm(nO: vec3f) -> vec2f {
+return eV(transpose(ko()) * nO);
 }
 
-fn qB(u: f32, vOffset: ptr<function, i32>, pdf: ptr<function, vec2f>) -> f32 {
+fn rE(u: f32, vOffset: ptr<function, i32>, pdf: ptr<function, vec2f>) -> f32 {
 let size = vec2i(textureDimensions(envMap, 0));
 
 var left = 0;
@@ -70,7 +70,7 @@ let s1 = textureLoad(envMapDistribution, vec2i(0, *vOffset + 1), 0).xy;
 return (f32(*vOffset) +  (u - s0.x) / (s1.x - s0.x)) / f32(size.y);
 }
 
-fn qA(u: f32, vOffset: i32, pdf: ptr<function, vec2f>) -> f32 {
+fn rD(u: f32, vOffset: i32, pdf: ptr<function, vec2f>) -> f32 {
 let size = vec2i(textureDimensions(envMap, 0));
 
 var left = 0;
@@ -84,51 +84,57 @@ left = mid + 1;
 right = mid;
 }
 }
-let oR = left - 1;
+let pO = left - 1;
 
 
 
-let s0 = textureLoad(envMapDistribution, vec2i(1 + oR, vOffset), 0).xy;
-let s1 = textureLoad(envMapDistribution, vec2i(1 + oR + 1, vOffset), 0).xy;
+let s0 = textureLoad(envMapDistribution, vec2i(1 + pO, vOffset), 0).xy;
+let s1 = textureLoad(envMapDistribution, vec2i(1 + pO + 1, vOffset), 0).xy;
 
 (*pdf).x = s0.y;
 
-return (f32(oR) + (u - s0.x) / (s1.x - s0.x)) / f32(size.x);
+return (f32(pO) + (u - s0.x) / (s1.x - s0.x)) / f32(size.x);
 }
 
 
-fn oL(random: vec2f, uv: ptr<function, vec2f>, pdf: ptr<function, f32>) -> vec3f {
-var he: vec2f;
+
+fn eW(ew: vec2f, v: f32) -> f32 {
+if (!(v > 0.0 && v < 1.0)) { return 0.0; }
+let sinTheta = sin(min(v, 1.0 - v) * PI);
+return ew.x * ew.y * INVPI2 / (2.0 * sinTheta);
+}
+
+
+fn pI(random: vec2f, uv: ptr<function, vec2f>, pdf: ptr<function, f32>) -> vec3f {
+var ew: vec2f;
 var vOffset: i32;
 
-(*uv).y = qB(random.x, &vOffset, &he);
-(*uv).x = qA(random.y, vOffset, &he);
+(*uv).y = rE(random.x, &vOffset, &ew);
+(*uv).x = rD(random.y, vOffset, &ew);
 
 let phi = (*uv).x * TWOPI;
 let theta = (*uv).y * PI;
-let cc = cos(theta);
+let ci = cos(theta);
 let sinTheta = sin(theta);
-let ul = cos(phi);
-let uw = sin(phi);
+let vM = cos(phi);
+let vX = sin(phi);
 
-let dir = vec3f(-sinTheta * ul, cc, -sinTheta * uw);
+let dir = vec3f(-sinTheta * vM, ci, -sinTheta * vX);
 
-*pdf = he.x * he.y * INVPI2 / (2.0 * sinTheta);
+*pdf = eW(ew, (*uv).y);
 
-return jN() * dir;
+return ko() * dir;
 }
 
-fn iB(_uv: vec2f) -> f32 {
+fn iT(_uv: vec2f) -> f32 {
 let size = vec2f(textureDimensions(envMap, 0));
 
-let sinTheta = sin(_uv.y * PI);
-
-let vX = vec2i(_uv * size);
+let xO = clamp(vec2i(_uv * size), vec2i(0), vec2i(size) - vec2i(1));
 
-let sL = textureLoad(envMapDistribution, vec2i(1 + vX.x, vX.y), 0).y;
-let sM = textureLoad(envMapDistribution, vec2i(0, vX.y), 0).y;
+let ub = textureLoad(envMapDistribution, vec2i(1 + xO.x, xO.y), 0).y;
+let uc = textureLoad(envMapDistribution, vec2i(0, xO.y), 0).y;
 
-return sL * sM * INVPI2 / (2.0 * sinTheta);
+return eW(vec2f(ub, uc), _uv.y);
 }
 
 

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

@@ -1 +1 @@
-{"version":3,"file":"envMap.wgsl.js","sourceRoot":"","sources":["../../../../src/renderer/wgsl/chunks/envMap.wgsl.ts"],"names":[],"mappings":"AAAA,qDAAqD;AACrD,sDAAsD;AACtD,kFAAkF;AAElF,sFAAsF;AACtF,uHAAuH;AAEvH,eAAe,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiIzB,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\nexport default /* wgsl */ `\n\nfn textureLinear(tex: texture_2d<f32>, _uv: vec2f) -> vec4f {\n  // #ifdef OES_texture_float_linear\n  //   return texture(map, uv);\n  // #else\n  let size = vec2f(textureDimensions(tex, 0));\n\n  let uv2f = _uv * size - vec2f(0.5);\n  let uvFloor = floor(uv2f);\n  let f = fract(uv2f);\n  let uv2i = vec2i(uvFloor);\n  let maximum = vec2i(size) - vec2i(1);\n\n  // TODO use textureGather\n  let s1 = textureLoad(tex, clamp(uv2i + vec2i(0, 0), vec2i(0), maximum), 0);\n  let s2 = textureLoad(tex, clamp(uv2i + vec2i(1, 0), vec2i(0), maximum), 0);\n  let s3 = textureLoad(tex, clamp(uv2i + vec2i(0, 1), vec2i(0), maximum), 0);\n  let s4 = textureLoad(tex, clamp(uv2i + vec2i(1, 1), vec2i(0), maximum), 0);\n\n  return mix(mix(s1, s2, f.x), mix(s3, s4, f.x), f.y);\n  // #endif\n}\n\nfn cartesianToEquirect(pointOnSphere: vec3f) -> vec2f {\n  var phi = atan2(-pointOnSphere.z, -pointOnSphere.x);\n  if (phi < 0.0) {\n    phi += TWOPI;\n  }\n  let theta = acos(clamp(pointOnSphere.y, -1.0, 1.0));\n  return vec2f(phi * 0.5 * INVPI, theta * INVPI);\n}\n\nfn environmentOrientation() -> mat3x3f {\n  return mat3x3f(rtUniform.environmentRotation[0].xyz, rtUniform.environmentRotation[1].xyz, rtUniform.environmentRotation[2].xyz);\n}\n\nfn environmentUv(worldDirection: vec3f) -> vec2f {\n  return cartesianToEquirect(transpose(environmentOrientation()) * worldDirection);\n}\n\nfn getEnvmapV(u: f32, vOffset: ptr<function, i32>, pdf: ptr<function, vec2f>) -> f32 {\n  let size = vec2i(textureDimensions(envMap, 0));\n\n  var left = 0;\n  var right = size.y + 1; // cdf length is the length of the env map + 1\n  while (left < right) {\n    let mid = (left + right) >> 1;\n    let s = textureLoad(envMapDistribution, vec2i(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  let s0 = textureLoad(envMapDistribution, vec2i(0, *vOffset), 0).xy;\n  let s1 = textureLoad(envMapDistribution, vec2i(0, *vOffset + 1), 0).xy;\n\n  (*pdf).y = s0.y;\n\n  return (f32(*vOffset) +  (u - s0.x) / (s1.x - s0.x)) / f32(size.y);\n}\n\nfn getEnvmapU(u: f32, vOffset: i32, pdf: ptr<function, vec2f>) -> f32 {\n  let size = vec2i(textureDimensions(envMap, 0));\n\n  var left = 0;\n  var right = size.x + 1; // cdf length is the length of the env map + 1\n  while (left < right) {\n    let mid = (left + right) >> 1;\n    let s = textureLoad(envMapDistribution, vec2i(1 + mid, vOffset), 0).x;\n    if (s <= u) {\n      left = mid + 1;\n    } else {\n      right = mid;\n    }\n  }\n  let 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  let s0 = textureLoad(envMapDistribution, vec2i(1 + uOffset, vOffset), 0).xy;\n  let s1 = textureLoad(envMapDistribution, vec2i(1 + uOffset + 1, vOffset), 0).xy;\n\n  (*pdf).x = s0.y;\n\n  return (f32(uOffset) + (u - s0.x) / (s1.x - s0.x)) / f32(size.x);\n}\n\n// Perform two binary searches to find light direction.\nfn sampleEnvmap(random: vec2f, uv: ptr<function, vec2f>, pdf: ptr<function, f32>) -> vec3f {\n  var partialPdf: vec2f;\n  var vOffset: i32;\n\n  (*uv).y = getEnvmapV(random.x, &vOffset, &partialPdf);\n  (*uv).x = getEnvmapU(random.y, vOffset, &partialPdf);\n\n  let phi = (*uv).x * TWOPI;\n  let theta = (*uv).y * PI;\n  let cosTheta = cos(theta);\n  let sinTheta = sin(theta);\n  let cosPhi = cos(phi);\n  let sinPhi = sin(phi);\n\n  let dir = vec3f(-sinTheta * cosPhi, cosTheta, -sinTheta * sinPhi);\n\n  *pdf = partialPdf.x * partialPdf.y * INVPI2 / (2.0 * sinTheta);\n\n  return environmentOrientation() * dir;\n}\n\nfn envMapPdf(_uv: vec2f) -> f32 {\n  let size = vec2f(textureDimensions(envMap, 0));\n\n  let sinTheta = sin(_uv.y * PI);\n\n  let _uv2 = vec2i(_uv * size);\n\n  let partialX = textureLoad(envMapDistribution, vec2i(1 + _uv2.x, _uv2.y), 0).y;\n  let partialY = textureLoad(envMapDistribution, vec2i(0, _uv2.y), 0).y;\n\n  return partialX * partialY * INVPI2 / (2.0 * sinTheta);\n}\n\n\n`;\n"]}
+{"version":3,"file":"envMap.wgsl.js","sourceRoot":"","sources":["../../../../src/renderer/wgsl/chunks/envMap.wgsl.ts"],"names":[],"mappings":"AAAA,qDAAqD;AACrD,sDAAsD;AACtD,kFAAkF;AAElF,sFAAsF;AACtF,uHAAuH;AAEvH,eAAe,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuIzB,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\nexport default /* wgsl */ `\n\nfn textureLinear(tex: texture_2d<f32>, _uv: vec2f) -> vec4f {\n  // #ifdef OES_texture_float_linear\n  //   return texture(map, uv);\n  // #else\n  let size = vec2f(textureDimensions(tex, 0));\n\n  let uv2f = _uv * size - vec2f(0.5);\n  let uvFloor = floor(uv2f);\n  let f = fract(uv2f);\n  let uv2i = vec2i(uvFloor);\n  let maximum = vec2i(size) - vec2i(1);\n\n  // TODO use textureGather\n  let s1 = textureLoad(tex, clamp(uv2i + vec2i(0, 0), vec2i(0), maximum), 0);\n  let s2 = textureLoad(tex, clamp(uv2i + vec2i(1, 0), vec2i(0), maximum), 0);\n  let s3 = textureLoad(tex, clamp(uv2i + vec2i(0, 1), vec2i(0), maximum), 0);\n  let s4 = textureLoad(tex, clamp(uv2i + vec2i(1, 1), vec2i(0), maximum), 0);\n\n  return mix(mix(s1, s2, f.x), mix(s3, s4, f.x), f.y);\n  // #endif\n}\n\nfn cartesianToEquirect(pointOnSphere: vec3f) -> vec2f {\n  var phi = atan2(-pointOnSphere.z, -pointOnSphere.x);\n  if (phi < 0.0) {\n    phi += TWOPI;\n  }\n  let theta = acos(clamp(pointOnSphere.y, -1.0, 1.0));\n  return vec2f(phi * 0.5 * INVPI, theta * INVPI);\n}\n\nfn environmentOrientation() -> mat3x3f {\n  return mat3x3f(rtUniform.environmentRotation[0].xyz, rtUniform.environmentRotation[1].xyz, rtUniform.environmentRotation[2].xyz);\n}\n\nfn environmentUv(worldDirection: vec3f) -> vec2f {\n  return cartesianToEquirect(transpose(environmentOrientation()) * worldDirection);\n}\n\nfn getEnvmapV(u: f32, vOffset: ptr<function, i32>, pdf: ptr<function, vec2f>) -> f32 {\n  let size = vec2i(textureDimensions(envMap, 0));\n\n  var left = 0;\n  var right = size.y + 1; // cdf length is the length of the env map + 1\n  while (left < right) {\n    let mid = (left + right) >> 1;\n    let s = textureLoad(envMapDistribution, vec2i(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  let s0 = textureLoad(envMapDistribution, vec2i(0, *vOffset), 0).xy;\n  let s1 = textureLoad(envMapDistribution, vec2i(0, *vOffset + 1), 0).xy;\n\n  (*pdf).y = s0.y;\n\n  return (f32(*vOffset) +  (u - s0.x) / (s1.x - s0.x)) / f32(size.y);\n}\n\nfn getEnvmapU(u: f32, vOffset: i32, pdf: ptr<function, vec2f>) -> f32 {\n  let size = vec2i(textureDimensions(envMap, 0));\n\n  var left = 0;\n  var right = size.x + 1; // cdf length is the length of the env map + 1\n  while (left < right) {\n    let mid = (left + right) >> 1;\n    let s = textureLoad(envMapDistribution, vec2i(1 + mid, vOffset), 0).x;\n    if (s <= u) {\n      left = mid + 1;\n    } else {\n      right = mid;\n    }\n  }\n  let 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  let s0 = textureLoad(envMapDistribution, vec2i(1 + uOffset, vOffset), 0).xy;\n  let s1 = textureLoad(envMapDistribution, vec2i(1 + uOffset + 1, vOffset), 0).xy;\n\n  (*pdf).x = s0.y;\n\n  return (f32(uOffset) + (u - s0.x) / (s1.x - s0.x)) / f32(size.x);\n}\n\n// The lat-long Jacobian is undefined at either pole. In f32, sin(PI) can\n// also be negative, which makes MIS amplify a BSDF hit instead of weighting it.\nfn envMapSolidAnglePdf(partialPdf: vec2f, v: f32) -> f32 {\n  if (!(v > 0.0 && v < 1.0)) { return 0.0; }\n  let sinTheta = sin(min(v, 1.0 - v) * PI);\n  return partialPdf.x * partialPdf.y * INVPI2 / (2.0 * sinTheta);\n}\n\n// Perform two binary searches to find light direction.\nfn sampleEnvmap(random: vec2f, uv: ptr<function, vec2f>, pdf: ptr<function, f32>) -> vec3f {\n  var partialPdf: vec2f;\n  var vOffset: i32;\n\n  (*uv).y = getEnvmapV(random.x, &vOffset, &partialPdf);\n  (*uv).x = getEnvmapU(random.y, vOffset, &partialPdf);\n\n  let phi = (*uv).x * TWOPI;\n  let theta = (*uv).y * PI;\n  let cosTheta = cos(theta);\n  let sinTheta = sin(theta);\n  let cosPhi = cos(phi);\n  let sinPhi = sin(phi);\n\n  let dir = vec3f(-sinTheta * cosPhi, cosTheta, -sinTheta * sinPhi);\n\n  *pdf = envMapSolidAnglePdf(partialPdf, (*uv).y);\n\n  return environmentOrientation() * dir;\n}\n\nfn envMapPdf(_uv: vec2f) -> f32 {\n  let size = vec2f(textureDimensions(envMap, 0));\n\n  let _uv2 = clamp(vec2i(_uv * size), vec2i(0), vec2i(size) - vec2i(1));\n\n  let partialX = textureLoad(envMapDistribution, vec2i(1 + _uv2.x, _uv2.y), 0).y;\n  let partialY = textureLoad(envMapDistribution, vec2i(0, _uv2.y), 0).y;\n\n  return envMapSolidAnglePdf(vec2f(partialX, partialY), _uv.y);\n}\n\n\n`;\n"]}

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

@@ -1,6 +1,18 @@
-export default function getIntersectCode({ hasDisplacement, hasAnisotropyDirections, hasCoatNormals, blasLayoutMask }: {
+export declare function createSceneHitQueryWgsl(hasAnisotropyDirections?: boolean): string;
+export declare function createSceneIntersectionsWgsl({ hasDisplacement, hasAnisotropyDirections, hasCoatNormals, blasLayoutMask, closestName, shadowName, bevelName, closestHitHook }: {
     hasDisplacement: boolean;
     hasAnisotropyDirections?: boolean;
     hasCoatNormals?: boolean;
     blasLayoutMask?: number;
+    closestName?: string;
+    shadowName?: string;
+    bevelName?: string;
+    closestHitHook?: string;
+}): string;
+export default function getIntersectCode({ hasDisplacement, hasAnisotropyDirections, hasCoatNormals, blasLayoutMask, sceneIntersections }: {
+    hasDisplacement: boolean;
+    hasAnisotropyDirections?: boolean;
+    hasCoatNormals?: boolean;
+    blasLayoutMask?: number;
+    sceneIntersections?: string;
 }): string;