@meimu/mutracer 0.1.3 → 0.1.5

package/lib/renderer/scratchSampling.js

@@ -4,18 +4,18 @@ export function scratchWGSLFunctions(textures, samplers, scratch = false) {
 fn ${name}Region() -> vec2u {
 return ${scratch ? `imageRegions[${index}].xy` : `textureDimensions(${name})`};
 }
-fn load_${name}(fM: vec2i, level: i32) -> vec4f {
-${scratch ? `if (any(fM < vec2i(0)) || any(fM >= vec2i(${name}Region()))) { return vec4f(0.0); }` : ''}
-return textureLoad(${name}, fM, level);
+fn load_${name}(fQ: vec2i, level: i32) -> vec4f {
+${scratch ? `if (any(fQ < vec2i(0)) || any(fQ >= vec2i(${name}Region()))) { return vec4f(0.0); }` : ''}
+return textureLoad(${name}, fQ, level);
 }
 ${samplers.map(sampler => /* wgsl */ `
-fn sample_${name}_${sampler}(fD: vec2f) -> vec4f {
+fn sample_${name}_${sampler}(fH: vec2f) -> vec4f {
 ${scratch ? /* wgsl */ `
-let jV = textureDimensions(${name});
-if (all(jV == ${name}Region())) { return textureSampleLevel(${name}, ${sampler}, fD, 0.0); }
-let fM = clamp(fD * vec2f(${name}Region()), vec2f(0.5), vec2f(${name}Region()) - vec2f(0.5));
-return textureSampleLevel(${name}, ${sampler}, fM / vec2f(jV), 0.0);`
-        : `return textureSample(${name}, ${sampler}, fD);`}
+let kc = textureDimensions(${name});
+if (all(kc == ${name}Region())) { return textureSampleLevel(${name}, ${sampler}, fH, 0.0); }
+let fQ = clamp(fH * vec2f(${name}Region()), vec2f(0.5), vec2f(${name}Region()) - vec2f(0.5));
+return textureSampleLevel(${name}, ${sampler}, fQ / vec2f(kc), 0.0);`
+        : `return textureSample(${name}, ${sampler}, fH);`}
 }`).join('')}`).join('');
 }
 export function scratchGLSLFunctions(textures, scratch = false) {
@@ -23,17 +23,17 @@ export function scratchGLSLFunctions(textures, scratch = false) {
 ivec2 ${name}Region() {
 return ${scratch ? `${name}RegionSize` : `textureSize(${name}, 0)`};
 }
-vec4 load_${name}(ivec2 fM, int level) {
-${scratch ? `if (any(lessThan(fM, ivec2(0))) || any(greaterThanEqual(fM, ${name}Region()))) return vec4(0.0);` : ''}
-return texelFetch(${name}, fM, level);
+vec4 load_${name}(ivec2 fQ, int level) {
+${scratch ? `if (any(lessThan(fQ, ivec2(0))) || any(greaterThanEqual(fQ, ${name}Region()))) return vec4(0.0);` : ''}
+return texelFetch(${name}, fQ, level);
 }
-vec4 sample_${name}(vec2 fD) {
+vec4 sample_${name}(vec2 fH) {
 ${scratch ? /* glsl */ `
-ivec2 jV = textureSize(${name}, 0);
-if (all(equal(jV, ${name}Region()))) return texture(${name}, fD);
-vec2 fM = clamp(fD * vec2(${name}Region()), vec2(0.5), vec2(${name}Region()) - vec2(0.5));
-return texture(${name}, fM / vec2(jV));`
-        : `return texture(${name}, fD);`}
+ivec2 kc = textureSize(${name}, 0);
+if (all(equal(kc, ${name}Region()))) return texture(${name}, fH);
+vec2 fQ = clamp(fH * vec2(${name}Region()), vec2(0.5), vec2(${name}Region()) - vec2(0.5));
+return texture(${name}, fQ / vec2(kc));`
+        : `return texture(${name}, fH);`}
 }`).join('');
 }
 //# sourceMappingURL=scratchSampling.js.map

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

@@ -11,12 +11,12 @@ const ROUGHNESS_MIN = 0.001;
 
 
 
-fn rI(position: vec3f, geometricNormal: vec3f, direction: vec3f) -> vec3f {
+fn rQ(position: vec3f, geometricNormal: vec3f, direction: vec3f) -> vec3f {
 let normal = select(-geometricNormal, geometricNormal, dot(geometricNormal, direction) >= 0.0);
-let qc = vec3i(256.0 * normal);
+let qk = vec3i(256.0 * normal);
 let bits = bitcast<vec3i>(position);
-let vH = bitcast<vec3f>(bits + select(qc, -qc, position < vec3f(0.0)));
-return select(vH, position + normal / 65536.0, abs(position) < vec3f(1.0 / 32.0));
+let vO = bitcast<vec3f>(bits + select(qk, -qk, position < vec3f(0.0)));
+return select(vO, position + normal / 65536.0, abs(position) < vec3f(1.0 / 32.0));
 }
 
 `;

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

@@ -1,2 +1,2 @@
-declare const _default: "\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(pointOnSphere.y);\n  return vec2f(phi * 0.5 * INVPI, theta * INVPI);\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 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";
+declare const _default: "\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";
 export default _default;

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

@@ -11,32 +11,40 @@ fn textureLinear(tex: texture_2d<f32>, _uv: vec2f) -> vec4f {
 
 let size = vec2f(textureDimensions(tex, 0));
 
-let wF = _uv * size - vec2f(0.5);
-let vM = floor(wF);
-let f = fract(wF);
-let vL = vec2i(vM);
+let wN = _uv * size - vec2f(0.5);
+let vT = floor(wN);
+let f = fract(wN);
+let vS = vec2i(vT);
 let maximum = vec2i(size) - vec2i(1);
 
 
-let s1 = textureLoad(tex, clamp(vL + vec2i(0, 0), vec2i(0), maximum), 0);
-let s2 = textureLoad(tex, clamp(vL + vec2i(1, 0), vec2i(0), maximum), 0);
-let s3 = textureLoad(tex, clamp(vL + vec2i(0, 1), vec2i(0), maximum), 0);
-let s4 = textureLoad(tex, clamp(vL + vec2i(1, 1), vec2i(0), maximum), 0);
+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);
 
 return mix(mix(s1, s2, f.x), mix(s3, s4, f.x), f.y);
 
 }
 
-fn aS(gc: vec3f) -> vec2f {
-var phi = atan2(-gc.z, -gc.x);
+fn eL(gh: vec3f) -> vec2f {
+var phi = atan2(-gh.z, -gh.x);
 if (phi < 0.0) {
 phi += TWOPI;
 }
-let theta = acos(gc.y);
+let theta = acos(clamp(gh.y, -1.0, 1.0));
 return vec2f(phi * 0.5 * INVPI, theta * INVPI);
 }
 
-fn qt(u: f32, vOffset: ptr<function, i32>, pdf: ptr<function, vec2f>) -> f32 {
+fn jN() -> 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 qB(u: f32, vOffset: ptr<function, i32>, pdf: ptr<function, vec2f>) -> f32 {
 let size = vec2i(textureDimensions(envMap, 0));
 
 var left = 0;
@@ -62,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 qs(u: f32, vOffset: i32, pdf: ptr<function, vec2f>) -> f32 {
+fn qA(u: f32, vOffset: i32, pdf: ptr<function, vec2f>) -> f32 {
 let size = vec2i(textureDimensions(envMap, 0));
 
 var left = 0;
@@ -76,51 +84,51 @@ left = mid + 1;
 right = mid;
 }
 }
-let oJ = left - 1;
+let oR = left - 1;
 
 
 
-let s0 = textureLoad(envMapDistribution, vec2i(1 + oJ, vOffset), 0).xy;
-let s1 = textureLoad(envMapDistribution, vec2i(1 + oJ + 1, vOffset), 0).xy;
+let s0 = textureLoad(envMapDistribution, vec2i(1 + oR, vOffset), 0).xy;
+let s1 = textureLoad(envMapDistribution, vec2i(1 + oR + 1, vOffset), 0).xy;
 
 (*pdf).x = s0.y;
 
-return (f32(oJ) + (u - s0.x) / (s1.x - s0.x)) / f32(size.x);
+return (f32(oR) + (u - s0.x) / (s1.x - s0.x)) / f32(size.x);
 }
 
 
-fn oD(random: vec2f, uv: ptr<function, vec2f>, pdf: ptr<function, f32>) -> vec3f {
-var gZ: vec2f;
+fn oL(random: vec2f, uv: ptr<function, vec2f>, pdf: ptr<function, f32>) -> vec3f {
+var he: vec2f;
 var vOffset: i32;
 
-(*uv).y = qt(random.x, &vOffset, &gZ);
-(*uv).x = qs(random.y, vOffset, &gZ);
+(*uv).y = qB(random.x, &vOffset, &he);
+(*uv).x = qA(random.y, vOffset, &he);
 
 let phi = (*uv).x * TWOPI;
 let theta = (*uv).y * PI;
 let cc = cos(theta);
 let sinTheta = sin(theta);
-let ue = cos(phi);
-let um = sin(phi);
+let ul = cos(phi);
+let uw = sin(phi);
 
-let dir = vec3f(-sinTheta * ue, cc, -sinTheta * um);
+let dir = vec3f(-sinTheta * ul, cc, -sinTheta * uw);
 
-*pdf = gZ.x * gZ.y * INVPI2 / (2.0 * sinTheta);
+*pdf = he.x * he.y * INVPI2 / (2.0 * sinTheta);
 
-return dir;
+return jN() * dir;
 }
 
-fn iv(_uv: vec2f) -> f32 {
+fn iB(_uv: vec2f) -> f32 {
 let size = vec2f(textureDimensions(envMap, 0));
 
 let sinTheta = sin(_uv.y * PI);
 
-let vQ = vec2i(_uv * size);
+let vX = vec2i(_uv * size);
 
-let sD = textureLoad(envMapDistribution, vec2i(1 + vQ.x, vQ.y), 0).y;
-let sE = textureLoad(envMapDistribution, vec2i(0, vQ.y), 0).y;
+let sL = textureLoad(envMapDistribution, vec2i(1 + vX.x, vX.y), 0).y;
+let sM = textureLoad(envMapDistribution, vec2i(0, vX.y), 0).y;
 
-return sD * sE * INVPI2 / (2.0 * sinTheta);
+return sL * sM * INVPI2 / (2.0 * sinTheta);
 }
 
 

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyHzB,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(pointOnSphere.y);\n  return vec2f(phi * 0.5 * INVPI, theta * INVPI);\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 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"]}