@meimu/mutracer 0.1.1 → 0.1.2

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

@@ -122,18 +122,18 @@ let cp = bA - f32(dP);
 let cy = aG - f32(aM);
 let ku = bt - f32(cI);
 
-let uk = F(cI, dP * 32 + aM);
-let ul = F(eO, dP * 32 + aM);
-let um = F(cI, dP * 32 + cn);
-let un = F(eO, dP * 32 + cn);
-let uo = F(cI, hB * 32 + aM);
-let uq = F(eO, hB * 32 + aM);
-let ur = F(cI, hB * 32 + cn);
-let us = F(eO, hB * 32 + cn);
-let v00 = mix(uk, uo, cp);
-let v01 = mix(ul, uq, cp);
-let v10 = mix(um, ur, cp);
-let v11 = mix(un, us, cp);
+let ul = F(cI, dP * 32 + aM);
+let um = F(eO, dP * 32 + aM);
+let un = F(cI, dP * 32 + cn);
+let uo = F(eO, dP * 32 + cn);
+let uq = F(cI, hB * 32 + aM);
+let ur = F(eO, hB * 32 + aM);
+let us = F(cI, hB * 32 + cn);
+let ut = F(eO, hB * 32 + cn);
+let v00 = mix(ul, uq, cp);
+let v01 = mix(um, ur, cp);
+let v10 = mix(un, us, cp);
+let v11 = mix(uo, ut, cp);
 return mix(
 mix(v00, v10, cy),
 mix(v01, v11, cy),
@@ -181,18 +181,18 @@ let cp = bA - f32(dP);
 let cy = aG - f32(aM);
 let ku = bt - f32(cI);
 
-let uk = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + aM);
-let ul = F(eO, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + aM);
-let um = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + cn);
-let un = F(eO, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + cn);
-let uo = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + aM);
-let uq = F(eO, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + aM);
-let ur = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + cn);
-let us = F(eO, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + cn);
-let v00 = mix(uk, uo, cp);
-let v01 = mix(ul, uq, cp);
-let v10 = mix(um, ur, cp);
-let v11 = mix(un, us, cp);
+let ul = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + aM);
+let um = F(eO, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + aM);
+let un = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + cn);
+let uo = F(eO, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + dP * 32 + cn);
+let uq = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + aM);
+let ur = F(eO, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + aM);
+let us = F(cI, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + cn);
+let ut = F(eO, ${OPENPBR_DIELECTRIC_ENERGY_LUT_ROW} + hB * 32 + cn);
+let v00 = mix(ul, uq, cp);
+let v01 = mix(um, ur, cp);
+let v10 = mix(un, us, cp);
+let v11 = mix(uo, ut, cp);
 return mix(
 mix(v00, v10, cy),
 mix(v01, v11, cy),
@@ -798,17 +798,17 @@ let material = prepared.material;
 let dielectric = 1.0 - material.baseMetalness;
 let opaque = dielectric * (1.0 - material.transmissionWeight) * (1.0 - material.subsurfaceWeight);
 let sss = dielectric * (1.0 - material.transmissionWeight) * material.subsurfaceWeight;
-let tT = dielectric * material.transmissionWeight;
+let tU = dielectric * material.transmissionWeight;
 let fL = bM(prepared.specularEtaTOverEtaI);
 let kI = bM(1.0 / prepared.transmissionReflectionIor);
-let pw = clamp(opaque * fL + (sss + tT) * kI + material.baseMetalness, 0.0, 1.0);
+let pw = clamp(opaque * fL + (sss + tU) * kI + material.baseMetalness, 0.0, 1.0);
 let ji = mix(1.0, material.specularRoughness, pw);
 let ks = bM(material.coatIor);
 let kr = 1.0 - (1.0 - ks) / (material.coatIor * material.coatIor);
 let k = mix(ks, kr, ji);
 let eb = material.baseMetalness * material.specularWeight * bP(material.baseWeight * material.baseColor, material.specularColor)
 + opaque * mix(material.baseWeight * material.baseColor, vec3f(1.0), fL)
-+ sss * material.subsurfaceColor + vec3f(tT);
++ sss * material.subsurfaceColor + vec3f(tU);
 let qH = vec3f(1.0 - k) / max(vec3f(1.0) - eb * k, vec3f(1e-6));
 return mix(vec3f(1.0), qH, material.coatWeight * material.coatDarkening);
 }
@@ -1108,7 +1108,7 @@ var response = vec3f(0.0);
 *pdf = 0.0;
 var aH = 0.0;
 let lQ = gI < 0;
-let uz = lQ || gI == OPENPBR_LOBE_FUZZ;
+let uB = lQ || gI == OPENPBR_LOBE_FUZZ;
 let sQ = lQ || gI == OPENPBR_LOBE_COAT;
 let rT = lQ || gI == OPENPBR_LOBE_METAL;
 let pT = lQ || gI == OPENPBR_LOBE_SPECULAR;
@@ -1144,17 +1144,17 @@ let wavelengths = vec3f(620.0, 540.0, 450.0);
 
 for (var kH = 0u; kH < (rtUniform.loopUnrollGuard >> 1u); kH++) {
 if (!select(lZ, pX, kH == 1u)) { continue; }
-var wb = vec3f(0.0);
+var wc = vec3f(0.0);
 let L = select(jg, bQ, kH == 1u);
 for (var channel = 0u; channel + 1u < rtUniform.loopUnrollGuard; channel++) {
 var ior = vec2f(prepared.thinFilmBaseIor, 0.0);
 if (kH == 1u) {
 ior = cQ(material.baseWeight * material.baseColor[channel], material.specularColor[channel]);
 }
-wb[channel] = ar(L,
+wc[channel] = ar(L,
 wavelengths[channel], material.thinFilmThickness, prepared.thinFilmExteriorIor, material.thinFilmIor, ior);
 }
-nj[kH] = mix(nj[kH], wb,
+nj[kH] = mix(nj[kH], wc,
 bN(material.thinFilmThickness, material.thinFilmWeight));
 }
 }
@@ -1396,7 +1396,7 @@ response *= max(
 vec3f(0.0),
 vec3f(1.0 - prepared.weights[OPENPBR_LOBE_FUZZ] * qn)
 );
-if (uz) {
+if (uB) {
 response += prepared.weights[OPENPBR_LOBE_FUZZ]${hasCoatNormals ? ' * select(1.0, max(lightLocal.z, 0.0), independentCoat)' : ''} * jP(
 material,
 viewLocal,
@@ -1567,8 +1567,8 @@ else if (bm < cdf[OPENPBR_LOBE_TRANSMISSION]) {
 *aR = u32(OPENPBR_LOBE_TRANSMISSION);
 
 
-let ue = (bm - cdf[OPENPBR_LOBE_SPECULAR]) / max(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION], 1e-12);
-if (prepared.dielectricMsProbability > 0.0 && ue < prepared.dielectricMsProbability) {
+let uf = (bm - cdf[OPENPBR_LOBE_SPECULAR]) / max(prepared.probabilities[OPENPBR_LOBE_TRANSMISSION], 1e-12);
+if (prepared.dielectricMsProbability > 0.0 && uf < prepared.dielectricMsProbability) {
 let iU = prepared.dielectricMsReflectionRatio;
 let lM = cx < iU;
 var z: f32;

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

@@ -1,4 +1,4 @@
 declare const displacementCommon = "\n\n\nstruct MicroTriangleIntersect {\n  barycentric: vec3f,\n  t: f32,\n  normal: vec3f,\n\n}\n\nfn findVT(\n  uu: f32,\n  pARel: vec3f, pBRel: vec3f,\n  eAC: vec3f, eBD: vec3f,\n  rayDir: vec3f,\n  distMin: f32,\n  hitDist: ptr<function, f32>\n) -> bool {\n  if (uu >= 0.0 && uu <= 1.0) {\n    let pAB = mix(pARel, pBRel, uu);\n    let pCD = mix(eAC, eBD, uu);\n    var n = cross(rayDir, pCD);\n    let recDet = 1.0 / dot(n, n);\n    n = cross(n, pAB);\n    let tt = dot(n, pCD) * recDet;\n    let vv = dot(n, rayDir) * recDet;\n    if (vv >= 0.0 && vv <= 1.0 && tt > distMin && tt < *hitDist) {\n      *hitDist = tt;\n      return true;\n    }\n  }\n  return false;\n}\n\nfn testRayVsBilinearPatch(\n  rayOrg: vec3f, rayDir: vec3f, distMin: f32, distMax: f32,\n  pA: vec3f, pB: vec3f, pC: vec3f, pD: vec3f,\n  hitDist: ptr<function, f32>\n) -> bool {\n  let eAB = pB - pA;\n  let eAC = pC - pA;\n  let eBD = pD - pB;\n  let eCD = pD - pC;\n  let pARel = pA - rayOrg;\n  let pBRel = pB - rayOrg;\n\n  var u1: f32;\n  var u2: f32;\n  {\n    let qN = cross(eAB, -eCD);\n    let a = dot(qN, rayDir);\n    var b = dot(cross(pBRel, rayDir), eBD);\n    let c = dot(cross(pARel, rayDir), eAC);\n    b -= a + c;\n\n    let det = b * b - 4.0 * a * c;\n    if (det < 0.0) {\n      return false;\n    }\n\n    if (a == 0.0) {\n      u1 = -c / b;\n      u2 = -1.0;\n    } else {\n      let sqrtDet = sqrt(det);\n      let temp = -0.5 * (b + sign(b) * sqrtDet);\n      u1 = temp / a;\n      u2 = c / temp;\n    }\n  }\n\n  *hitDist = distMax;\n\n  var hit = false;\n\n  hit = findVT(u1, pARel, pBRel, eAC, eBD, rayDir, distMin, hitDist) || \n        findVT(u2, pARel, pBRel, eAC, eBD, rayDir, distMin, hitDist);\n  if (!hit) {\n    return false;\n  }\n\n  return true;\n}\n\nfn intersectPrism(\n  rayOrg: vec3f, rayDir: vec3f, distMin: f32, distMax: f32,\n  pA: vec3f, pB: vec3f, pC: vec3f,\n  pD: vec3f, pE: vec3f, pF: vec3f,\n\n  hitDistMin: ptr<function, f32>,\n  hitDistMax: ptr<function, f32>\n) -> bool {\n  *hitDistMin = INF;\n  *hitDistMax = -INF;\n\n  let maxD = maxDimension(abs(rayDir));\n  let shear = getShear(rayDir, maxD);\n  var tt: f32;\n\n  tt = intersectTriangle(\n    rayOrg, rayDir,\n    Triangle(pC, pB, pA), maxD, shear, INF\n  ).t;\n  if (tt > 0.0) {\n    *hitDistMin = min(*hitDistMin, tt);\n    *hitDistMax = max(*hitDistMax, tt);\n  }\n  tt = intersectTriangle(\n    rayOrg, rayDir,\n    Triangle(pD, pE, pF), maxD, shear, INF\n  ).t;\n  if (tt > 0.0) {\n    *hitDistMin = min(*hitDistMin, tt);\n    *hitDistMax = max(*hitDistMax, tt);\n  }\n  if (testRayVsBilinearPatch(\n    rayOrg, rayDir, -INF, INF,\n    pA, pB, pD, pE,\n    &tt)) {\n    *hitDistMin = min(*hitDistMin, tt);\n    *hitDistMax = max(*hitDistMax, tt);\n  }\n  if (testRayVsBilinearPatch(\n    rayOrg, rayDir, -INF, INF,\n    pB, pC, pE, pF,\n    &tt)) {\n    *hitDistMin = min(*hitDistMin, tt);\n    *hitDistMax = max(*hitDistMax, tt);\n  }\n  if (testRayVsBilinearPatch(\n    rayOrg, rayDir, -INF, INF,\n    pC, pA, pF, pD,\n    &tt)) {\n    *hitDistMin = min(*hitDistMin, tt);\n    *hitDistMax = max(*hitDistMax, tt);\n  }\n\n  *hitDistMin = max(*hitDistMin, distMin);\n  *hitDistMax = min(*hitDistMax, distMax);\n\n  return *hitDistMin <= *hitDistMax && *hitDistMax > 0.0;\n}\n";
-declare const _default: "\n\n\n\n\nstruct MicroTriangleIntersect {\n  barycentric: vec3f,\n  t: f32,\n  normal: vec3f,\n\n}\n\nfn findVT(\n  uu: f32,\n  pARel: vec3f, pBRel: vec3f,\n  eAC: vec3f, eBD: vec3f,\n  rayDir: vec3f,\n  distMin: f32,\n  hitDist: ptr<function, f32>\n) -> bool {\n  if (uu >= 0.0 && uu <= 1.0) {\n    let pAB = mix(pARel, pBRel, uu);\n    let pCD = mix(eAC, eBD, uu);\n    var n = cross(rayDir, pCD);\n    let recDet = 1.0 / dot(n, n);\n    n = cross(n, pAB);\n    let tt = dot(n, pCD) * recDet;\n    let vv = dot(n, rayDir) * recDet;\n    if (vv >= 0.0 && vv <= 1.0 && tt > distMin && tt < *hitDist) {\n      *hitDist = tt;\n      return true;\n    }\n  }\n  return false;\n}\n\nfn testRayVsBilinearPatch(\n  rayOrg: vec3f, rayDir: vec3f, distMin: f32, distMax: f32,\n  pA: vec3f, pB: vec3f, pC: vec3f, pD: vec3f,\n  hitDist: ptr<function, f32>\n) -> bool {\n  let eAB = pB - pA;\n  let eAC = pC - pA;\n  let eBD = pD - pB;\n  let eCD = pD - pC;\n  let pARel = pA - rayOrg;\n  let pBRel = pB - rayOrg;\n\n  var u1: f32;\n  var u2: f32;\n  {\n    let qN = cross(eAB, -eCD);\n    let a = dot(qN, rayDir);\n    var b = dot(cross(pBRel, rayDir), eBD);\n    let c = dot(cross(pARel, rayDir), eAC);\n    b -= a + c;\n\n    let det = b * b - 4.0 * a * c;\n    if (det < 0.0) {\n      return false;\n    }\n\n    if (a == 0.0) {\n      u1 = -c / b;\n      u2 = -1.0;\n    } else {\n      let sqrtDet = sqrt(det);\n      let temp = -0.5 * (b + sign(b) * sqrtDet);\n      u1 = temp / a;\n      u2 = c / temp;\n    }\n  }\n\n  *hitDist = distMax;\n\n  var hit = false;\n\n  hit = findVT(u1, pARel, pBRel, eAC, eBD, rayDir, distMin, hitDist) || \n        findVT(u2, pARel, pBRel, eAC, eBD, rayDir, distMin, hitDist);\n  if (!hit) {\n    return false;\n  }\n\n  return true;\n}\n\nfn intersectPrism(\n  rayOrg: vec3f, rayDir: vec3f, distMin: f32, distMax: f32,\n  pA: vec3f, pB: vec3f, pC: vec3f,\n  pD: vec3f, pE: vec3f, pF: vec3f,\n\n  hitDistMin: ptr<function, f32>,\n  hitDistMax: ptr<function, f32>\n) -> bool {\n  *hitDistMin = INF;\n  *hitDistMax = -INF;\n\n  let maxD = maxDimension(abs(rayDir));\n  let shear = getShear(rayDir, maxD);\n  var tt: f32;\n\n  tt = intersectTriangle(\n    rayOrg, rayDir,\n    Triangle(pC, pB, pA), maxD, shear, INF\n  ).t;\n  if (tt > 0.0) {\n    *hitDistMin = min(*hitDistMin, tt);\n    *hitDistMax = max(*hitDistMax, tt);\n  }\n  tt = intersectTriangle(\n    rayOrg, rayDir,\n    Triangle(pD, pE, pF), maxD, shear, INF\n  ).t;\n  if (tt > 0.0) {\n    *hitDistMin = min(*hitDistMin, tt);\n    *hitDistMax = max(*hitDistMax, tt);\n  }\n  if (testRayVsBilinearPatch(\n    rayOrg, rayDir, -INF, INF,\n    pA, pB, pD, pE,\n    &tt)) {\n    *hitDistMin = min(*hitDistMin, tt);\n    *hitDistMax = max(*hitDistMax, tt);\n  }\n  if (testRayVsBilinearPatch(\n    rayOrg, rayDir, -INF, INF,\n    pB, pC, pE, pF,\n    &tt)) {\n    *hitDistMin = min(*hitDistMin, tt);\n    *hitDistMax = max(*hitDistMax, tt);\n  }\n  if (testRayVsBilinearPatch(\n    rayOrg, rayDir, -INF, INF,\n    pC, pA, pF, pD,\n    &tt)) {\n    *hitDistMin = min(*hitDistMin, tt);\n    *hitDistMax = max(*hitDistMax, tt);\n  }\n\n  *hitDistMin = max(*hitDistMin, distMin);\n  *hitDistMax = min(*hitDistMax, distMax);\n\n  return *hitDistMin <= *hitDistMax && *hitDistMax > 0.0;\n}\n\n\nfn triangleBarycentric(p: vec3f, p0: vec3f, p1: vec3f, p2: vec3f) -> vec3f {\n  let v0 = p1 - p0;\n  let v1 = p2 - p0;\n  let v2 = p - p0;\n\n  let d00 = dot(v0, v0);\n  let d01 = dot(v0, v1);\n  let d11 = dot(v1, v1);\n  let d20 = dot(v2, v0);\n  let d21 = dot(v2, v1);\n\n  let invDenom = 1.0 / (d00 * d11 - d01 * d01);\n  let v = clamp((d11 * d20 - d01 * d21) * invDenom, 0.0, 1.0);\n  let w = clamp((d00 * d21 - d01 * d20) * invDenom, 0.0, 1.0);\n  let u = 1.0 - v - w;\n\n  return vec3f(u, v, w);\n}\n\nfn wrapUv(uv: vec2f) -> vec2f {\n  return (uv % 1.0 + 1.0) % 1.0;\n}\n\n\nfn intersectDisplacement(\n  _rayOrigin: vec3f, _rayDir: vec3f, _tMax: f32,\n  _pA: vec3f, _pB: vec3f, _pC: vec3f,\n  _nA: vec3f, _nB: vec3f, _nC: vec3f,\n  _tcA: vec2f, _tcB: vec2f, _tcC: vec2f,\n\n  heightMapIndex: i32,\n  heightMapSize: vec2f,\n\n  _minH: f32, _maxH: f32,\n  hScale: f32,\n  stepSize: f32,\n  uvProjection: i32,\n  uvScale: vec2f,\n  isShadowHit: bool,\n  isRefraction: bool\n) -> MicroTriangleIntersect {\n\n  let DT = stepSize;\n  let dt = DT / length(_rayDir);\n  let dbx = 0.001;\n  let dby = 0.001;\n\n  var result: MicroTriangleIntersect;\n  result.t = INF;\n\n  var hitDistMin = INF;\n  var hitDistMax = -INF;\n\n  let hSign = sign(hScale);\n  let hScaleAbs = abs(hScale);\n  // Face normal.\n  let faceN = hSign * normalize(cross(_pB - _pA, _pC - _pA));\n\n  // dA, dB, dC are negative if hScale is negative\n  let dA = dot(_nA, faceN);\n  let dB = dot(_nB, faceN);\n  let dC = dot(_nC, faceN);\n\n  var minH = _minH * hScale * min(min(dA, dB), dC);\n  var maxH = _maxH * hScale * max(max(dA, dB), dC);\n\n  // Add gap\n  // 1. Avoid too small height cause ray marching miss.\n  // 2. Make sure the ray start beyond the displaced surface when surface height is same with prism height.\n  let prismHeight = abs(maxH) - abs(minH);\n  minH = sign(minH) * max(abs(minH) - dt * 2.0, 0.0);\n  if (prismHeight < dt * 2.0) {\n    maxH = sign(maxH) * min(abs(maxH) + dt * 2.0, abs(hScale));\n  }\n\n  let pA = _pA + _nA * minH / dA;\n  let pB = _pB + _nB * minH / dB;\n  let pC = _pC + _nC * minH / dC;\n\n  let pD = _pA + _nA * maxH / dA;\n  let pE = _pB + _nB * maxH / dB;\n  let pF = _pC + _nC * maxH / dC;\n\n  if (!intersectPrism(\n    _rayOrigin, _rayDir, 0.0, INF,\n    pA, pB, pC,\n    pD, pE, pF,\n    \n    &hitDistMin, &hitDistMax\n  )) {\n    return result;\n  }\n\n  var testFlag = false;\n  // Ray is inside the prism\n  if (hitDistMax == hitDistMin) {\n    hitDistMin = 0.0;\n  }\n\n  var t = hitDistMin + dt * hashedSample(2u);\n  var s = _rayOrigin + _rayDir * t;\n  var hRay = dot(s - _pA, faceN);\n  var hSurf = select(0.0, INF, hSign < 0.0);\n  // initial scanning triangle\n  var c0 = _pA + _nA * hRay / dA;\n  var c1 = _pB + _nB * hRay / dB;\n  var c2 = _pC + _nC * hRay / dC;\n\n  var projPos: vec3f;\n\n  hRay = abs(hRay);\n\n  var hDiff = hRay - hSurf;\n  var hDiffPrev = hDiff;\n  var step = 0;\n\n  while (true) {\n    // TODO Avoid too long loop\n    let b = triangleBarycentric(s, c0, c1, c2);\n    // Projected point on base triangle\n    projPos = _pA * b.x + _pB * b.y + _pC * b.z;\n    // Height at projected point\n    hRay = distance(projPos, s);\n    // Update scanning point\n    var uv: vec2f;\n    if (uvProjection > 0) {\n      let n = normalize(_nA * b.x + _nB * b.y + _nC * b.z);\n      uv = wrapUv(projectUV(uvProjection, projPos, n) * uvScale);\n    }\n    else {\n      uv = wrapUv(_tcA * b.x + _tcB * b.y + _tcC * b.z);\n    }\n    let h = sampleMap(heightMapIndex, uv).x;\n    // height < dt will be ignored in ray marching\n    hSurf = max(hScaleAbs * h, dt);\n\n    // Advance scanning triangle\n    let dh = dot(faceN, s - c0);\n    c0 = c0 + _nA * dh / dA;\n    c1 = c1 + _nB * dh / dB;\n    c2 = c2 + _nC * dh / dC;\n\n    hDiffPrev = hDiff;\n    hDiff = hRay - hSurf;\n\n    if (!(select(hDiff * hSign, hDiff * hDiffPrev, isRefraction) > 0.0\n      && t < hitDistMax + dt) \n      // Ignore first step\n      && step > 0) {\n      break;\n    }\n\n    step++;\n    t = t + dt;\n    s = s + _rayDir * dt;\n  }\n\n  if (select(hDiff * hSign, hDiff * hDiffPrev, isRefraction) <= 0.0) {\n    let dtt = dt * (abs(hDiff) / (abs(hDiffPrev) + abs(hDiff) + EPS));\n    t = t - dtt;\n    // t = interpolateCrossing(_rayOrigin, _rayDir, projPos, t, dt, hSurf);\n    let pHit = _rayOrigin + _rayDir * t;\n    let b = triangleBarycentric(pHit, c0, c1, c2);\n\n    let N = normalize(_nA * b.x + _nB * b.y + _nC * b.z);\n\n    let p_a = _pA * b.x + _pB * b.y + _pC * b.z;\n    let p_b = _pA * (b.x + dbx) + _pB * b.y + _pC * (b.z - dbx);\n    let p_c = _pA * b.x + _pB * (b.y + dby) + _pC * (b.z - dby);\n\n    var uv_a: vec2f;\n    var uv_b: vec2f;\n    var uv_c: vec2f;\n\n    if (uvProjection > 0) {\n      let NA = normalize(_nA * b.x + _nB * b.y + _nC * b.z);\n      let NB = normalize(_nA * (b.x + dbx) + _nB * b.y + _nC * (b.z - dbx));\n      let NC = normalize(_nA * b.x + _nB * (b.y + dby) + _nC * (b.z - dby));  \n      uv_a = projectUV(uvProjection, p_a, NA) * uvScale;\n      uv_b = projectUV(uvProjection, p_b, NB) * uvScale;\n      uv_c = projectUV(uvProjection, p_c, NC) * uvScale;\n    }\n    else {\n      uv_a = _tcA * b.x + _tcB * b.y + _tcC * b.z;\n      uv_b = _tcA * (b.x + dbx) + _tcB * b.y + _tcC * (b.z - dbx);\n      uv_c = _tcA * b.x + _tcB * (b.y + dby) + _tcC * (b.z - dby);\n    }\n\n    let s_a = p_a + hSign * N * sampleMap(heightMapIndex, wrapUv(uv_a)).x * hScale;\n    let s_b = p_b + hSign * N * sampleMap(heightMapIndex, wrapUv(uv_b)).x * hScale;\n    let s_c = p_c + hSign * N * sampleMap(heightMapIndex, wrapUv(uv_c)).x * hScale;\n\n    let N_s = -hSign * normalize(cross(s_c - s_a, s_b - s_a));\n\n    result.t = t;\n    result.barycentric = b;\n    result.normal = normalize(N_s - faceN + hSign * N);\n  }\n\n  return result;\n\n}\n";
+declare const _default: "\n\n\n\n\nstruct MicroTriangleIntersect {\n  barycentric: vec3f,\n  t: f32,\n  normal: vec3f,\n\n}\n\nfn findVT(\n  uu: f32,\n  pARel: vec3f, pBRel: vec3f,\n  eAC: vec3f, eBD: vec3f,\n  rayDir: vec3f,\n  distMin: f32,\n  hitDist: ptr<function, f32>\n) -> bool {\n  if (uu >= 0.0 && uu <= 1.0) {\n    let pAB = mix(pARel, pBRel, uu);\n    let pCD = mix(eAC, eBD, uu);\n    var n = cross(rayDir, pCD);\n    let recDet = 1.0 / dot(n, n);\n    n = cross(n, pAB);\n    let tt = dot(n, pCD) * recDet;\n    let vv = dot(n, rayDir) * recDet;\n    if (vv >= 0.0 && vv <= 1.0 && tt > distMin && tt < *hitDist) {\n      *hitDist = tt;\n      return true;\n    }\n  }\n  return false;\n}\n\nfn testRayVsBilinearPatch(\n  rayOrg: vec3f, rayDir: vec3f, distMin: f32, distMax: f32,\n  pA: vec3f, pB: vec3f, pC: vec3f, pD: vec3f,\n  hitDist: ptr<function, f32>\n) -> bool {\n  let eAB = pB - pA;\n  let eAC = pC - pA;\n  let eBD = pD - pB;\n  let eCD = pD - pC;\n  let pARel = pA - rayOrg;\n  let pBRel = pB - rayOrg;\n\n  var u1: f32;\n  var u2: f32;\n  {\n    let qN = cross(eAB, -eCD);\n    let a = dot(qN, rayDir);\n    var b = dot(cross(pBRel, rayDir), eBD);\n    let c = dot(cross(pARel, rayDir), eAC);\n    b -= a + c;\n\n    let det = b * b - 4.0 * a * c;\n    if (det < 0.0) {\n      return false;\n    }\n\n    if (a == 0.0) {\n      u1 = -c / b;\n      u2 = -1.0;\n    } else {\n      let sqrtDet = sqrt(det);\n      let temp = -0.5 * (b + sign(b) * sqrtDet);\n      u1 = temp / a;\n      u2 = c / temp;\n    }\n  }\n\n  *hitDist = distMax;\n\n  var hit = false;\n\n  hit = findVT(u1, pARel, pBRel, eAC, eBD, rayDir, distMin, hitDist) || \n        findVT(u2, pARel, pBRel, eAC, eBD, rayDir, distMin, hitDist);\n  if (!hit) {\n    return false;\n  }\n\n  return true;\n}\n\nfn intersectPrism(\n  rayOrg: vec3f, rayDir: vec3f, distMin: f32, distMax: f32,\n  pA: vec3f, pB: vec3f, pC: vec3f,\n  pD: vec3f, pE: vec3f, pF: vec3f,\n\n  hitDistMin: ptr<function, f32>,\n  hitDistMax: ptr<function, f32>\n) -> bool {\n  *hitDistMin = INF;\n  *hitDistMax = -INF;\n\n  let maxD = maxDimension(abs(rayDir));\n  let shear = getShear(rayDir, maxD);\n  var tt: f32;\n\n  tt = intersectTriangle(\n    rayOrg, rayDir,\n    Triangle(pC, pB, pA), maxD, shear, INF\n  ).t;\n  if (tt > 0.0) {\n    *hitDistMin = min(*hitDistMin, tt);\n    *hitDistMax = max(*hitDistMax, tt);\n  }\n  tt = intersectTriangle(\n    rayOrg, rayDir,\n    Triangle(pD, pE, pF), maxD, shear, INF\n  ).t;\n  if (tt > 0.0) {\n    *hitDistMin = min(*hitDistMin, tt);\n    *hitDistMax = max(*hitDistMax, tt);\n  }\n  if (testRayVsBilinearPatch(\n    rayOrg, rayDir, -INF, INF,\n    pA, pB, pD, pE,\n    &tt)) {\n    *hitDistMin = min(*hitDistMin, tt);\n    *hitDistMax = max(*hitDistMax, tt);\n  }\n  if (testRayVsBilinearPatch(\n    rayOrg, rayDir, -INF, INF,\n    pB, pC, pE, pF,\n    &tt)) {\n    *hitDistMin = min(*hitDistMin, tt);\n    *hitDistMax = max(*hitDistMax, tt);\n  }\n  if (testRayVsBilinearPatch(\n    rayOrg, rayDir, -INF, INF,\n    pC, pA, pF, pD,\n    &tt)) {\n    *hitDistMin = min(*hitDistMin, tt);\n    *hitDistMax = max(*hitDistMax, tt);\n  }\n\n  *hitDistMin = max(*hitDistMin, distMin);\n  *hitDistMax = min(*hitDistMax, distMax);\n\n  return *hitDistMin <= *hitDistMax && *hitDistMax > 0.0;\n}\n\n\nfn triangleBarycentric(p: vec3f, p0: vec3f, p1: vec3f, p2: vec3f) -> vec3f {\n  let v0 = p1 - p0;\n  let v1 = p2 - p0;\n  let v2 = p - p0;\n\n  let d00 = dot(v0, v0);\n  let d01 = dot(v0, v1);\n  let d11 = dot(v1, v1);\n  let d20 = dot(v2, v0);\n  let d21 = dot(v2, v1);\n\n  let invDenom = 1.0 / (d00 * d11 - d01 * d01);\n  let v = clamp((d11 * d20 - d01 * d21) * invDenom, 0.0, 1.0);\n  let w = clamp((d00 * d21 - d01 * d20) * invDenom, 0.0, 1.0);\n  let u = 1.0 - v - w;\n\n  return vec3f(u, v, w);\n}\n\nfn wrapUv(uv: vec2f) -> vec2f {\n  return (uv % 1.0 + 1.0) % 1.0;\n}\n\n\nfn intersectDisplacement(\n  _rayOrigin: vec3f, _rayDir: vec3f, _tMax: f32,\n  _pA: vec3f, _pB: vec3f, _pC: vec3f,\n  _nA: vec3f, _nB: vec3f, _nC: vec3f,\n  _tcA: vec2f, _tcB: vec2f, _tcC: vec2f,\n\n  heightMapIndex: i32,\n  heightMapSize: vec2f,\n\n  _minH: f32, _maxH: f32,\n  hScale: f32,\n  hBias: f32,\n  stepSize: f32,\n  uvProjection: i32,\n  uvScale: vec2f,\n  isShadowHit: bool,\n  isRefraction: bool\n) -> MicroTriangleIntersect {\n\n  // Zero keeps marching resolution proportional to the height instead of\n  // letting a fixed local-unit step dominate small displacements.\n  let DT = select(max(abs(hScale) / 32.0, 1e-12), stepSize, stepSize > 0.0);\n  let dt = DT / length(_rayDir);\n  let dbx = 0.001;\n  let dby = 0.001;\n\n  var result: MicroTriangleIntersect;\n  result.t = INF;\n\n  var hitDistMin = INF;\n  var hitDistMax = -INF;\n\n  let hSign = sign(hScale);\n  let hScaleAbs = abs(hScale);\n  // Face normal.\n  let faceN = hSign * normalize(cross(_pB - _pA, _pC - _pA));\n\n  // dA, dB, dC are negative if hScale is negative\n  let dA = dot(_nA, faceN);\n  let dB = dot(_nB, faceN);\n  let dC = dot(_nC, faceN);\n\n  var minH = _minH * hScale * min(min(dA, dB), dC);\n  var maxH = _maxH * hScale * max(max(dA, dB), dC);\n\n  // Add gap\n  // 1. Avoid too small height cause ray marching miss.\n  // 2. Make sure the ray start beyond the displaced surface when surface height is same with prism height.\n  let prismHeight = abs(maxH) - abs(minH);\n  // DT is a local-space length; dt is a ray-parameter increment and changes\n  // when the instance transform scales the ray direction.\n  minH = sign(minH) * max(abs(minH) - DT * 2.0, 0.0);\n  if (prismHeight < DT * 2.0) {\n    maxH = sign(maxH) * min(abs(maxH) + DT * 2.0, abs(hScale));\n  }\n\n  let pA = _pA + _nA * minH / dA;\n  let pB = _pB + _nB * minH / dB;\n  let pC = _pC + _nC * minH / dC;\n\n  let pD = _pA + _nA * maxH / dA;\n  let pE = _pB + _nB * maxH / dB;\n  let pF = _pC + _nC * maxH / dC;\n\n  if (!intersectPrism(\n    _rayOrigin, _rayDir, 0.0, INF,\n    pA, pB, pC,\n    pD, pE, pF,\n    \n    &hitDistMin, &hitDistMax\n  )) {\n    return result;\n  }\n\n  var testFlag = false;\n  // Ray is inside the prism\n  if (hitDistMax == hitDistMin) {\n    hitDistMin = 0.0;\n  }\n\n  var t = hitDistMin + dt * hashedSample(2u);\n  var s = _rayOrigin + _rayDir * t;\n  var hRay = dot(s - _pA, faceN);\n  var hSurf = select(0.0, INF, hSign < 0.0);\n  // initial scanning triangle\n  var c0 = _pA + _nA * hRay / dA;\n  var c1 = _pB + _nB * hRay / dB;\n  var c2 = _pC + _nC * hRay / dC;\n\n  var projPos: vec3f;\n\n  hRay = abs(hRay);\n\n  var hDiff = hRay - hSurf;\n  var hDiffPrev = hDiff;\n  var step = 0;\n\n  while (true) {\n    // TODO Avoid too long loop\n    let b = triangleBarycentric(s, c0, c1, c2);\n    // Projected point on base triangle\n    projPos = _pA * b.x + _pB * b.y + _pC * b.z;\n    // Height at projected point\n    hRay = distance(projPos, s);\n    // Update scanning point\n    var uv: vec2f;\n    if (uvProjection > 0) {\n      let n = normalize(_nA * b.x + _nB * b.y + _nC * b.z);\n      uv = wrapUv(projectUV(uvProjection, projPos - (_nA * b.x + _nB * b.y + _nC * b.z) * hBias, n) * uvScale);\n    }\n    else {\n      uv = wrapUv(_tcA * b.x + _tcB * b.y + _tcC * b.z);\n    }\n    let h = sampleMap(heightMapIndex, uv).x;\n    // Heights are measured in mesh-local units, independently of ray length.\n    hSurf = max(hScaleAbs * h, DT);\n\n    // Advance scanning triangle\n    let dh = dot(faceN, s - c0);\n    c0 = c0 + _nA * dh / dA;\n    c1 = c1 + _nB * dh / dB;\n    c2 = c2 + _nC * dh / dC;\n\n    hDiffPrev = hDiff;\n    hDiff = hRay - hSurf;\n\n    if (!(select(hDiff * hSign, hDiff * hDiffPrev, isRefraction) > 0.0\n      && t < hitDistMax + dt) \n      // Ignore first step\n      && step > 0) {\n      break;\n    }\n\n    step++;\n    t = t + dt;\n    s = s + _rayDir * dt;\n  }\n\n  if (select(hDiff * hSign, hDiff * hDiffPrev, isRefraction) <= 0.0) {\n    let dtt = dt * (abs(hDiff) / (abs(hDiffPrev) + abs(hDiff) + EPS));\n    t = t - dtt;\n    // t = interpolateCrossing(_rayOrigin, _rayDir, projPos, t, dt, hSurf);\n    let pHit = _rayOrigin + _rayDir * t;\n    let b = triangleBarycentric(pHit, c0, c1, c2);\n\n    let N = normalize(_nA * b.x + _nB * b.y + _nC * b.z);\n\n    let p_a = _pA * b.x + _pB * b.y + _pC * b.z;\n    let p_b = _pA * (b.x + dbx) + _pB * b.y + _pC * (b.z - dbx);\n    let p_c = _pA * b.x + _pB * (b.y + dby) + _pC * (b.z - dby);\n\n    var uv_a: vec2f;\n    var uv_b: vec2f;\n    var uv_c: vec2f;\n\n    if (uvProjection > 0) {\n      let NA = normalize(_nA * b.x + _nB * b.y + _nC * b.z);\n      let NB = normalize(_nA * (b.x + dbx) + _nB * b.y + _nC * (b.z - dbx));\n      let NC = normalize(_nA * b.x + _nB * (b.y + dby) + _nC * (b.z - dby));  \n      uv_a = projectUV(uvProjection, p_a - (_nA * b.x + _nB * b.y + _nC * b.z) * hBias, NA) * uvScale;\n      uv_b = projectUV(uvProjection, p_b - (_nA * (b.x + dbx) + _nB * b.y + _nC * (b.z - dbx)) * hBias, NB) * uvScale;\n      uv_c = projectUV(uvProjection, p_c - (_nA * b.x + _nB * (b.y + dby) + _nC * (b.z - dby)) * hBias, NC) * uvScale;\n    }\n    else {\n      uv_a = _tcA * b.x + _tcB * b.y + _tcC * b.z;\n      uv_b = _tcA * (b.x + dbx) + _tcB * b.y + _tcC * (b.z - dbx);\n      uv_c = _tcA * b.x + _tcB * (b.y + dby) + _tcC * (b.z - dby);\n    }\n\n    let s_a = p_a + hSign * N * sampleMap(heightMapIndex, wrapUv(uv_a)).x * hScale;\n    let s_b = p_b + hSign * N * sampleMap(heightMapIndex, wrapUv(uv_b)).x * hScale;\n    let s_c = p_c + hSign * N * sampleMap(heightMapIndex, wrapUv(uv_c)).x * hScale;\n\n    let N_s = -hSign * normalize(cross(s_c - s_a, s_b - s_a));\n\n    result.t = t;\n    result.barycentric = b;\n    result.normal = normalize(N_s - faceN + hSign * N);\n  }\n\n  return result;\n\n}\n";
 export default _default;
 export { displacementCommon };

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

@@ -8,7 +8,7 @@ normal: vec3f,
 
 }
 
-fn uJ(
+fn uL(
 uu: f32,
 tL: vec3f, tM: vec3f,
 eAC: vec3f, eBD: vec3f,
@@ -20,10 +20,10 @@ if (uu >= 0.0 && uu <= 1.0) {
 let pAB = mix(tL, tM, uu);
 let pCD = mix(eAC, eBD, uu);
 var n = cross(iI, pCD);
-let vj = 1.0 / dot(n, n);
+let vl = 1.0 / dot(n, n);
 n = cross(n, pAB);
-let tt = dot(n, pCD) * vj;
-let vv = dot(n, iI) * vj;
+let tt = dot(n, pCD) * vl;
+let vv = dot(n, iI) * vl;
 if (vv >= 0.0 && vv <= 1.0 && tt > pL && tt < *pN) {
 *pN = tt;
 return true;
@@ -62,10 +62,10 @@ if (a == 0.0) {
 u1 = -c / b;
 u2 = -1.0;
 } else {
-let vD = sqrt(det);
-let wu = -0.5 * (b + sign(b) * vD);
-u1 = wu / a;
-u2 = c / wu;
+let vE = sqrt(det);
+let wv = -0.5 * (b + sign(b) * vE);
+u1 = wv / a;
+u2 = c / wv;
 }
 }
 
@@ -73,8 +73,8 @@ u2 = c / wu;
 
 var hit = false;
 
-hit = uJ(u1, tL, tM, eAC, eBD, iI, pL, pN) || 
-uJ(u2, tL, tM, eAC, eBD, iI, pL, pN);
+hit = uL(u1, tL, tM, eAC, eBD, iI, pL, pN) || 
+uL(u2, tL, tM, eAC, eBD, iI, pL, pN);
 if (!hit) {
 return false;
 }
@@ -93,13 +93,13 @@ bS: ptr<function, f32>
 *bT = INF;
 *bS = -INF;
 
-let vQ = maxDimension(abs(iI));
-let gJ = mg(iI, vQ);
+let vR = maxDimension(abs(iI));
+let gJ = mg(iI, vR);
 var tt: f32;
 
 tt = fI(
 pt, iI,
-fu(pC, pB, pA), vQ, gJ, INF
+fu(pC, pB, pA), vR, gJ, INF
 ).t;
 if (tt > 0.0) {
 *bT = min(*bT, tt);
@@ -107,7 +107,7 @@ if (tt > 0.0) {
 }
 tt = fI(
 pt, iI,
-fu(pD, pE, pF), vQ, gJ, INF
+fu(pD, pE, pF), vR, gJ, INF
 ).t;
 if (tt > 0.0) {
 *bT = min(*bT, tt);
@@ -170,24 +170,27 @@ return (uv % 1.0 + 1.0) % 1.0;
 
 
 fn oP(
-qf: vec3f, qA: vec3f, wB: f32,
+qf: vec3f, qA: vec3f, wC: f32,
 _pA: vec3f, _pB: vec3f, _pC: vec3f,
 _nA: vec3f, _nB: vec3f, _nC: vec3f,
-vq: vec2f, vs: vec2f, vt: vec2f,
+vs: vec2f, vt: vec2f, vu: vec2f,
 
 jH: i32,
-vp: vec2f,
+vq: vec2f,
 
-vW: f32, vV: f32,
+vX: f32, vW: f32,
 hScale: f32,
-vm: f32,
+ux: f32,
+tT: f32,
 uvProjection: i32,
 uvScale: vec2f,
-vI: bool,
+vJ: bool,
 qQ: bool
 ) -> jv {
 
-let DT = vm;
+
+
+let DT = select(max(abs(hScale) / 32.0, 1e-12), tT, tT > 0.0);
 let dt = DT / length(qA);
 let dbx = 0.001;
 let dby = 0.001;
@@ -199,7 +202,7 @@ var bT = INF;
 var bS = -INF;
 
 let qO = sign(hScale);
-let uB = abs(hScale);
+let uD = abs(hScale);
 
 let sS = qO * normalize(cross(_pB - _pA, _pC - _pA));
 
@@ -208,16 +211,18 @@ let dA = dot(_nA, sS);
 let dB = dot(_nB, sS);
 let dC = dot(_nC, sS);
 
-var minH = vW * hScale * min(min(dA, dB), dC);
-var maxH = vV * hScale * max(max(dA, dB), dC);
+var minH = vX * hScale * min(min(dA, dB), dC);
+var maxH = vW * hScale * max(max(dA, dB), dC);
 
 
 
 
 let tN = abs(maxH) - abs(minH);
-minH = sign(minH) * max(abs(minH) - dt * 2.0, 0.0);
-if (tN < dt * 2.0) {
-maxH = sign(maxH) * min(abs(maxH) + dt * 2.0, abs(hScale));
+
+
+minH = sign(minH) * max(abs(minH) - DT * 2.0, 0.0);
+if (tN < DT * 2.0) {
+maxH = sign(maxH) * min(abs(maxH) + DT * 2.0, abs(hScale));
 }
 
 let pA = _pA + _nA * minH / dA;
@@ -238,7 +243,7 @@ pD, pE, pF,
 return result;
 }
 
-var wv = false;
+var ww = false;
 
 if (bS == bT) {
 bT = 0.0;
@@ -247,7 +252,7 @@ bT = 0.0;
 var t = bT + dt * eo(2u);
 var s = qf + qA * t;
 var tG = dot(s - _pA, sS);
-var uP = select(0.0, INF, qO < 0.0);
+var uR = select(0.0, INF, qO < 0.0);
 
 var c0 = _pA + _nA * tG / dA;
 var c1 = _pB + _nB * tG / dB;
@@ -257,7 +262,7 @@ var tn: vec3f;
 
 tG = abs(tG);
 
-var qM = tG - uP;
+var qM = tG - uR;
 var pM = qM;
 var step = 0;
 
@@ -272,14 +277,14 @@ tG = distance(tn, s);
 var uv: vec2f;
 if (uvProjection > 0) {
 let n = normalize(_nA * b.x + _nB * b.y + _nC * b.z);
-uv = sJ(gz(uvProjection, tn, n) * uvScale);
+uv = sJ(gz(uvProjection, tn - (_nA * b.x + _nB * b.y + _nC * b.z) * ux, n) * uvScale);
 }
 else {
-uv = sJ(vq * b.x + vs * b.y + vt * b.z);
+uv = sJ(vs * b.x + vt * b.y + vu * b.z);
 }
 let h = sampleMap(jH, uv).x;
 
-uP = max(uB * h, dt);
+uR = max(uD * h, DT);
 
 
 let dh = dot(sS, s - c0);
@@ -288,7 +293,7 @@ c1 = c1 + _nB * dh / dB;
 c2 = c2 + _nC * dh / dC;
 
 pM = qM;
-qM = tG - uP;
+qM = tG - uR;
 
 if (!(select(qM * qO, qM * pM, qQ) > 0.0
 && t < bS + dt) 
@@ -306,8 +311,8 @@ if (select(qM * qO, qM * pM, qQ) <= 0.0) {
 let dtt = dt * (abs(qM) / (abs(pM) + abs(qM) + EPS));
 t = t - dtt;
 
-let wx = qf + qA * t;
-let b = lD(wx, c0, c1, c2);
+let wy = qf + qA * t;
+let b = lD(wy, c0, c1, c2);
 
 let N = normalize(_nA * b.x + _nB * b.y + _nC * b.z);
 
@@ -315,27 +320,27 @@ let p_a = _pA * b.x + _pB * b.y + _pC * b.z;
 let p_b = _pA * (b.x + dbx) + _pB * b.y + _pC * (b.z - dbx);
 let p_c = _pA * b.x + _pB * (b.y + dby) + _pC * (b.z - dby);
 
-var vS: vec2f;
 var vT: vec2f;
 var vU: vec2f;
+var vV: vec2f;
 
 if (uvProjection > 0) {
 let NA = normalize(_nA * b.x + _nB * b.y + _nC * b.z);
 let NB = normalize(_nA * (b.x + dbx) + _nB * b.y + _nC * (b.z - dbx));
 let NC = normalize(_nA * b.x + _nB * (b.y + dby) + _nC * (b.z - dby));  
-vS = gz(uvProjection, p_a, NA) * uvScale;
-vT = gz(uvProjection, p_b, NB) * uvScale;
-vU = gz(uvProjection, p_c, NC) * uvScale;
+vT = gz(uvProjection, p_a - (_nA * b.x + _nB * b.y + _nC * b.z) * ux, NA) * uvScale;
+vU = gz(uvProjection, p_b - (_nA * (b.x + dbx) + _nB * b.y + _nC * (b.z - dbx)) * ux, NB) * uvScale;
+vV = gz(uvProjection, p_c - (_nA * b.x + _nB * (b.y + dby) + _nC * (b.z - dby)) * ux, NC) * uvScale;
 }
 else {
-vS = vq * b.x + vs * b.y + vt * b.z;
-vT = vq * (b.x + dbx) + vs * b.y + vt * (b.z - dbx);
-vU = vq * b.x + vs * (b.y + dby) + vt * (b.z - dby);
+vT = vs * b.x + vt * b.y + vu * b.z;
+vU = vs * (b.x + dbx) + vt * b.y + vu * (b.z - dbx);
+vV = vs * b.x + vt * (b.y + dby) + vu * (b.z - dby);
 }
 
-let s_a = p_a + qO * N * sampleMap(jH, sJ(vS)).x * hScale;
-let s_b = p_b + qO * N * sampleMap(jH, sJ(vT)).x * hScale;
-let s_c = p_c + qO * N * sampleMap(jH, sJ(vU)).x * hScale;
+let s_a = p_a + qO * N * sampleMap(jH, sJ(vT)).x * hScale;
+let s_b = p_b + qO * N * sampleMap(jH, sJ(vU)).x * hScale;
+let s_c = p_c + qO * N * sampleMap(jH, sJ(vV)).x * hScale;
 
 let N_s = -qO * normalize(cross(s_c - s_a, s_b - s_a));
 

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

@@ -1 +1 @@
-{"version":3,"file":"pdm_displacement.wgsl.js","sourceRoot":"","sources":["../../../../src/renderer/wgsl/chunks/pdm_displacement.wgsl.ts"],"names":[],"mappings":"AAAA,MAAM,kBAAkB,GAAG,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8InC,CAAC;AAEF,eAAe,UAAU,CAAC;;EAExB,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4MnB,CAAC;AAEF,OAAO,EAAE,kBAAkB,EAAE,CAAC","sourcesContent":["const displacementCommon = /*wgsl*/ `\n\n\nstruct MicroTriangleIntersect {\n  barycentric: vec3f,\n  t: f32,\n  normal: vec3f,\n\n}\n\nfn findVT(\n  uu: f32,\n  pARel: vec3f, pBRel: vec3f,\n  eAC: vec3f, eBD: vec3f,\n  rayDir: vec3f,\n  distMin: f32,\n  hitDist: ptr<function, f32>\n) -> bool {\n  if (uu >= 0.0 && uu <= 1.0) {\n    let pAB = mix(pARel, pBRel, uu);\n    let pCD = mix(eAC, eBD, uu);\n    var n = cross(rayDir, pCD);\n    let recDet = 1.0 / dot(n, n);\n    n = cross(n, pAB);\n    let tt = dot(n, pCD) * recDet;\n    let vv = dot(n, rayDir) * recDet;\n    if (vv >= 0.0 && vv <= 1.0 && tt > distMin && tt < *hitDist) {\n      *hitDist = tt;\n      return true;\n    }\n  }\n  return false;\n}\n\nfn testRayVsBilinearPatch(\n  rayOrg: vec3f, rayDir: vec3f, distMin: f32, distMax: f32,\n  pA: vec3f, pB: vec3f, pC: vec3f, pD: vec3f,\n  hitDist: ptr<function, f32>\n) -> bool {\n  let eAB = pB - pA;\n  let eAC = pC - pA;\n  let eBD = pD - pB;\n  let eCD = pD - pC;\n  let pARel = pA - rayOrg;\n  let pBRel = pB - rayOrg;\n\n  var u1: f32;\n  var u2: f32;\n  {\n    let qN = cross(eAB, -eCD);\n    let a = dot(qN, rayDir);\n    var b = dot(cross(pBRel, rayDir), eBD);\n    let c = dot(cross(pARel, rayDir), eAC);\n    b -= a + c;\n\n    let det = b * b - 4.0 * a * c;\n    if (det < 0.0) {\n      return false;\n    }\n\n    if (a == 0.0) {\n      u1 = -c / b;\n      u2 = -1.0;\n    } else {\n      let sqrtDet = sqrt(det);\n      let temp = -0.5 * (b + sign(b) * sqrtDet);\n      u1 = temp / a;\n      u2 = c / temp;\n    }\n  }\n\n  *hitDist = distMax;\n\n  var hit = false;\n\n  hit = findVT(u1, pARel, pBRel, eAC, eBD, rayDir, distMin, hitDist) || \n        findVT(u2, pARel, pBRel, eAC, eBD, rayDir, distMin, hitDist);\n  if (!hit) {\n    return false;\n  }\n\n  return true;\n}\n\nfn intersectPrism(\n  rayOrg: vec3f, rayDir: vec3f, distMin: f32, distMax: f32,\n  pA: vec3f, pB: vec3f, pC: vec3f,\n  pD: vec3f, pE: vec3f, pF: vec3f,\n\n  hitDistMin: ptr<function, f32>,\n  hitDistMax: ptr<function, f32>\n) -> bool {\n  *hitDistMin = INF;\n  *hitDistMax = -INF;\n\n  let maxD = maxDimension(abs(rayDir));\n  let shear = getShear(rayDir, maxD);\n  var tt: f32;\n\n  tt = intersectTriangle(\n    rayOrg, rayDir,\n    Triangle(pC, pB, pA), maxD, shear, INF\n  ).t;\n  if (tt > 0.0) {\n    *hitDistMin = min(*hitDistMin, tt);\n    *hitDistMax = max(*hitDistMax, tt);\n  }\n  tt = intersectTriangle(\n    rayOrg, rayDir,\n    Triangle(pD, pE, pF), maxD, shear, INF\n  ).t;\n  if (tt > 0.0) {\n    *hitDistMin = min(*hitDistMin, tt);\n    *hitDistMax = max(*hitDistMax, tt);\n  }\n  if (testRayVsBilinearPatch(\n    rayOrg, rayDir, -INF, INF,\n    pA, pB, pD, pE,\n    &tt)) {\n    *hitDistMin = min(*hitDistMin, tt);\n    *hitDistMax = max(*hitDistMax, tt);\n  }\n  if (testRayVsBilinearPatch(\n    rayOrg, rayDir, -INF, INF,\n    pB, pC, pE, pF,\n    &tt)) {\n    *hitDistMin = min(*hitDistMin, tt);\n    *hitDistMax = max(*hitDistMax, tt);\n  }\n  if (testRayVsBilinearPatch(\n    rayOrg, rayDir, -INF, INF,\n    pC, pA, pF, pD,\n    &tt)) {\n    *hitDistMin = min(*hitDistMin, tt);\n    *hitDistMax = max(*hitDistMax, tt);\n  }\n\n  *hitDistMin = max(*hitDistMin, distMin);\n  *hitDistMax = min(*hitDistMax, distMax);\n\n  return *hitDistMin <= *hitDistMax && *hitDistMax > 0.0;\n}\n`;\n\nexport default /* wgsl */ `\n\n${displacementCommon}\n\nfn triangleBarycentric(p: vec3f, p0: vec3f, p1: vec3f, p2: vec3f) -> vec3f {\n  let v0 = p1 - p0;\n  let v1 = p2 - p0;\n  let v2 = p - p0;\n\n  let d00 = dot(v0, v0);\n  let d01 = dot(v0, v1);\n  let d11 = dot(v1, v1);\n  let d20 = dot(v2, v0);\n  let d21 = dot(v2, v1);\n\n  let invDenom = 1.0 / (d00 * d11 - d01 * d01);\n  let v = clamp((d11 * d20 - d01 * d21) * invDenom, 0.0, 1.0);\n  let w = clamp((d00 * d21 - d01 * d20) * invDenom, 0.0, 1.0);\n  let u = 1.0 - v - w;\n\n  return vec3f(u, v, w);\n}\n\nfn wrapUv(uv: vec2f) -> vec2f {\n  return (uv % 1.0 + 1.0) % 1.0;\n}\n\n\nfn intersectDisplacement(\n  _rayOrigin: vec3f, _rayDir: vec3f, _tMax: f32,\n  _pA: vec3f, _pB: vec3f, _pC: vec3f,\n  _nA: vec3f, _nB: vec3f, _nC: vec3f,\n  _tcA: vec2f, _tcB: vec2f, _tcC: vec2f,\n\n  heightMapIndex: i32,\n  heightMapSize: vec2f,\n\n  _minH: f32, _maxH: f32,\n  hScale: f32,\n  stepSize: f32,\n  uvProjection: i32,\n  uvScale: vec2f,\n  isShadowHit: bool,\n  isRefraction: bool\n) -> MicroTriangleIntersect {\n\n  let DT = stepSize;\n  let dt = DT / length(_rayDir);\n  let dbx = 0.001;\n  let dby = 0.001;\n\n  var result: MicroTriangleIntersect;\n  result.t = INF;\n\n  var hitDistMin = INF;\n  var hitDistMax = -INF;\n\n  let hSign = sign(hScale);\n  let hScaleAbs = abs(hScale);\n  // Face normal.\n  let faceN = hSign * normalize(cross(_pB - _pA, _pC - _pA));\n\n  // dA, dB, dC are negative if hScale is negative\n  let dA = dot(_nA, faceN);\n  let dB = dot(_nB, faceN);\n  let dC = dot(_nC, faceN);\n\n  var minH = _minH * hScale * min(min(dA, dB), dC);\n  var maxH = _maxH * hScale * max(max(dA, dB), dC);\n\n  // Add gap\n  // 1. Avoid too small height cause ray marching miss.\n  // 2. Make sure the ray start beyond the displaced surface when surface height is same with prism height.\n  let prismHeight = abs(maxH) - abs(minH);\n  minH = sign(minH) * max(abs(minH) - dt * 2.0, 0.0);\n  if (prismHeight < dt * 2.0) {\n    maxH = sign(maxH) * min(abs(maxH) + dt * 2.0, abs(hScale));\n  }\n\n  let pA = _pA + _nA * minH / dA;\n  let pB = _pB + _nB * minH / dB;\n  let pC = _pC + _nC * minH / dC;\n\n  let pD = _pA + _nA * maxH / dA;\n  let pE = _pB + _nB * maxH / dB;\n  let pF = _pC + _nC * maxH / dC;\n\n  if (!intersectPrism(\n    _rayOrigin, _rayDir, 0.0, INF,\n    pA, pB, pC,\n    pD, pE, pF,\n    \n    &hitDistMin, &hitDistMax\n  )) {\n    return result;\n  }\n\n  var testFlag = false;\n  // Ray is inside the prism\n  if (hitDistMax == hitDistMin) {\n    hitDistMin = 0.0;\n  }\n\n  var t = hitDistMin + dt * hashedSample(2u);\n  var s = _rayOrigin + _rayDir * t;\n  var hRay = dot(s - _pA, faceN);\n  var hSurf = select(0.0, INF, hSign < 0.0);\n  // initial scanning triangle\n  var c0 = _pA + _nA * hRay / dA;\n  var c1 = _pB + _nB * hRay / dB;\n  var c2 = _pC + _nC * hRay / dC;\n\n  var projPos: vec3f;\n\n  hRay = abs(hRay);\n\n  var hDiff = hRay - hSurf;\n  var hDiffPrev = hDiff;\n  var step = 0;\n\n  while (true) {\n    // TODO Avoid too long loop\n    let b = triangleBarycentric(s, c0, c1, c2);\n    // Projected point on base triangle\n    projPos = _pA * b.x + _pB * b.y + _pC * b.z;\n    // Height at projected point\n    hRay = distance(projPos, s);\n    // Update scanning point\n    var uv: vec2f;\n    if (uvProjection > 0) {\n      let n = normalize(_nA * b.x + _nB * b.y + _nC * b.z);\n      uv = wrapUv(projectUV(uvProjection, projPos, n) * uvScale);\n    }\n    else {\n      uv = wrapUv(_tcA * b.x + _tcB * b.y + _tcC * b.z);\n    }\n    let h = sampleMap(heightMapIndex, uv).x;\n    // height < dt will be ignored in ray marching\n    hSurf = max(hScaleAbs * h, dt);\n\n    // Advance scanning triangle\n    let dh = dot(faceN, s - c0);\n    c0 = c0 + _nA * dh / dA;\n    c1 = c1 + _nB * dh / dB;\n    c2 = c2 + _nC * dh / dC;\n\n    hDiffPrev = hDiff;\n    hDiff = hRay - hSurf;\n\n    if (!(select(hDiff * hSign, hDiff * hDiffPrev, isRefraction) > 0.0\n      && t < hitDistMax + dt) \n      // Ignore first step\n      && step > 0) {\n      break;\n    }\n\n    step++;\n    t = t + dt;\n    s = s + _rayDir * dt;\n  }\n\n  if (select(hDiff * hSign, hDiff * hDiffPrev, isRefraction) <= 0.0) {\n    let dtt = dt * (abs(hDiff) / (abs(hDiffPrev) + abs(hDiff) + EPS));\n    t = t - dtt;\n    // t = interpolateCrossing(_rayOrigin, _rayDir, projPos, t, dt, hSurf);\n    let pHit = _rayOrigin + _rayDir * t;\n    let b = triangleBarycentric(pHit, c0, c1, c2);\n\n    let N = normalize(_nA * b.x + _nB * b.y + _nC * b.z);\n\n    let p_a = _pA * b.x + _pB * b.y + _pC * b.z;\n    let p_b = _pA * (b.x + dbx) + _pB * b.y + _pC * (b.z - dbx);\n    let p_c = _pA * b.x + _pB * (b.y + dby) + _pC * (b.z - dby);\n\n    var uv_a: vec2f;\n    var uv_b: vec2f;\n    var uv_c: vec2f;\n\n    if (uvProjection > 0) {\n      let NA = normalize(_nA * b.x + _nB * b.y + _nC * b.z);\n      let NB = normalize(_nA * (b.x + dbx) + _nB * b.y + _nC * (b.z - dbx));\n      let NC = normalize(_nA * b.x + _nB * (b.y + dby) + _nC * (b.z - dby));  \n      uv_a = projectUV(uvProjection, p_a, NA) * uvScale;\n      uv_b = projectUV(uvProjection, p_b, NB) * uvScale;\n      uv_c = projectUV(uvProjection, p_c, NC) * uvScale;\n    }\n    else {\n      uv_a = _tcA * b.x + _tcB * b.y + _tcC * b.z;\n      uv_b = _tcA * (b.x + dbx) + _tcB * b.y + _tcC * (b.z - dbx);\n      uv_c = _tcA * b.x + _tcB * (b.y + dby) + _tcC * (b.z - dby);\n    }\n\n    let s_a = p_a + hSign * N * sampleMap(heightMapIndex, wrapUv(uv_a)).x * hScale;\n    let s_b = p_b + hSign * N * sampleMap(heightMapIndex, wrapUv(uv_b)).x * hScale;\n    let s_c = p_c + hSign * N * sampleMap(heightMapIndex, wrapUv(uv_c)).x * hScale;\n\n    let N_s = -hSign * normalize(cross(s_c - s_a, s_b - s_a));\n\n    result.t = t;\n    result.barycentric = b;\n    result.normal = normalize(N_s - faceN + hSign * N);\n  }\n\n  return result;\n\n}\n`;\n\nexport { displacementCommon };\n"]}
+{"version":3,"file":"pdm_displacement.wgsl.js","sourceRoot":"","sources":["../../../../src/renderer/wgsl/chunks/pdm_displacement.wgsl.ts"],"names":[],"mappings":"AAAA,MAAM,kBAAkB,GAAG,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8InC,CAAC;AAEF,eAAe,UAAU,CAAC;;EAExB,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiNnB,CAAC;AAEF,OAAO,EAAE,kBAAkB,EAAE,CAAC","sourcesContent":["const displacementCommon = /*wgsl*/ `\n\n\nstruct MicroTriangleIntersect {\n  barycentric: vec3f,\n  t: f32,\n  normal: vec3f,\n\n}\n\nfn findVT(\n  uu: f32,\n  pARel: vec3f, pBRel: vec3f,\n  eAC: vec3f, eBD: vec3f,\n  rayDir: vec3f,\n  distMin: f32,\n  hitDist: ptr<function, f32>\n) -> bool {\n  if (uu >= 0.0 && uu <= 1.0) {\n    let pAB = mix(pARel, pBRel, uu);\n    let pCD = mix(eAC, eBD, uu);\n    var n = cross(rayDir, pCD);\n    let recDet = 1.0 / dot(n, n);\n    n = cross(n, pAB);\n    let tt = dot(n, pCD) * recDet;\n    let vv = dot(n, rayDir) * recDet;\n    if (vv >= 0.0 && vv <= 1.0 && tt > distMin && tt < *hitDist) {\n      *hitDist = tt;\n      return true;\n    }\n  }\n  return false;\n}\n\nfn testRayVsBilinearPatch(\n  rayOrg: vec3f, rayDir: vec3f, distMin: f32, distMax: f32,\n  pA: vec3f, pB: vec3f, pC: vec3f, pD: vec3f,\n  hitDist: ptr<function, f32>\n) -> bool {\n  let eAB = pB - pA;\n  let eAC = pC - pA;\n  let eBD = pD - pB;\n  let eCD = pD - pC;\n  let pARel = pA - rayOrg;\n  let pBRel = pB - rayOrg;\n\n  var u1: f32;\n  var u2: f32;\n  {\n    let qN = cross(eAB, -eCD);\n    let a = dot(qN, rayDir);\n    var b = dot(cross(pBRel, rayDir), eBD);\n    let c = dot(cross(pARel, rayDir), eAC);\n    b -= a + c;\n\n    let det = b * b - 4.0 * a * c;\n    if (det < 0.0) {\n      return false;\n    }\n\n    if (a == 0.0) {\n      u1 = -c / b;\n      u2 = -1.0;\n    } else {\n      let sqrtDet = sqrt(det);\n      let temp = -0.5 * (b + sign(b) * sqrtDet);\n      u1 = temp / a;\n      u2 = c / temp;\n    }\n  }\n\n  *hitDist = distMax;\n\n  var hit = false;\n\n  hit = findVT(u1, pARel, pBRel, eAC, eBD, rayDir, distMin, hitDist) || \n        findVT(u2, pARel, pBRel, eAC, eBD, rayDir, distMin, hitDist);\n  if (!hit) {\n    return false;\n  }\n\n  return true;\n}\n\nfn intersectPrism(\n  rayOrg: vec3f, rayDir: vec3f, distMin: f32, distMax: f32,\n  pA: vec3f, pB: vec3f, pC: vec3f,\n  pD: vec3f, pE: vec3f, pF: vec3f,\n\n  hitDistMin: ptr<function, f32>,\n  hitDistMax: ptr<function, f32>\n) -> bool {\n  *hitDistMin = INF;\n  *hitDistMax = -INF;\n\n  let maxD = maxDimension(abs(rayDir));\n  let shear = getShear(rayDir, maxD);\n  var tt: f32;\n\n  tt = intersectTriangle(\n    rayOrg, rayDir,\n    Triangle(pC, pB, pA), maxD, shear, INF\n  ).t;\n  if (tt > 0.0) {\n    *hitDistMin = min(*hitDistMin, tt);\n    *hitDistMax = max(*hitDistMax, tt);\n  }\n  tt = intersectTriangle(\n    rayOrg, rayDir,\n    Triangle(pD, pE, pF), maxD, shear, INF\n  ).t;\n  if (tt > 0.0) {\n    *hitDistMin = min(*hitDistMin, tt);\n    *hitDistMax = max(*hitDistMax, tt);\n  }\n  if (testRayVsBilinearPatch(\n    rayOrg, rayDir, -INF, INF,\n    pA, pB, pD, pE,\n    &tt)) {\n    *hitDistMin = min(*hitDistMin, tt);\n    *hitDistMax = max(*hitDistMax, tt);\n  }\n  if (testRayVsBilinearPatch(\n    rayOrg, rayDir, -INF, INF,\n    pB, pC, pE, pF,\n    &tt)) {\n    *hitDistMin = min(*hitDistMin, tt);\n    *hitDistMax = max(*hitDistMax, tt);\n  }\n  if (testRayVsBilinearPatch(\n    rayOrg, rayDir, -INF, INF,\n    pC, pA, pF, pD,\n    &tt)) {\n    *hitDistMin = min(*hitDistMin, tt);\n    *hitDistMax = max(*hitDistMax, tt);\n  }\n\n  *hitDistMin = max(*hitDistMin, distMin);\n  *hitDistMax = min(*hitDistMax, distMax);\n\n  return *hitDistMin <= *hitDistMax && *hitDistMax > 0.0;\n}\n`;\n\nexport default /* wgsl */ `\n\n${displacementCommon}\n\nfn triangleBarycentric(p: vec3f, p0: vec3f, p1: vec3f, p2: vec3f) -> vec3f {\n  let v0 = p1 - p0;\n  let v1 = p2 - p0;\n  let v2 = p - p0;\n\n  let d00 = dot(v0, v0);\n  let d01 = dot(v0, v1);\n  let d11 = dot(v1, v1);\n  let d20 = dot(v2, v0);\n  let d21 = dot(v2, v1);\n\n  let invDenom = 1.0 / (d00 * d11 - d01 * d01);\n  let v = clamp((d11 * d20 - d01 * d21) * invDenom, 0.0, 1.0);\n  let w = clamp((d00 * d21 - d01 * d20) * invDenom, 0.0, 1.0);\n  let u = 1.0 - v - w;\n\n  return vec3f(u, v, w);\n}\n\nfn wrapUv(uv: vec2f) -> vec2f {\n  return (uv % 1.0 + 1.0) % 1.0;\n}\n\n\nfn intersectDisplacement(\n  _rayOrigin: vec3f, _rayDir: vec3f, _tMax: f32,\n  _pA: vec3f, _pB: vec3f, _pC: vec3f,\n  _nA: vec3f, _nB: vec3f, _nC: vec3f,\n  _tcA: vec2f, _tcB: vec2f, _tcC: vec2f,\n\n  heightMapIndex: i32,\n  heightMapSize: vec2f,\n\n  _minH: f32, _maxH: f32,\n  hScale: f32,\n  hBias: f32,\n  stepSize: f32,\n  uvProjection: i32,\n  uvScale: vec2f,\n  isShadowHit: bool,\n  isRefraction: bool\n) -> MicroTriangleIntersect {\n\n  // Zero keeps marching resolution proportional to the height instead of\n  // letting a fixed local-unit step dominate small displacements.\n  let DT = select(max(abs(hScale) / 32.0, 1e-12), stepSize, stepSize > 0.0);\n  let dt = DT / length(_rayDir);\n  let dbx = 0.001;\n  let dby = 0.001;\n\n  var result: MicroTriangleIntersect;\n  result.t = INF;\n\n  var hitDistMin = INF;\n  var hitDistMax = -INF;\n\n  let hSign = sign(hScale);\n  let hScaleAbs = abs(hScale);\n  // Face normal.\n  let faceN = hSign * normalize(cross(_pB - _pA, _pC - _pA));\n\n  // dA, dB, dC are negative if hScale is negative\n  let dA = dot(_nA, faceN);\n  let dB = dot(_nB, faceN);\n  let dC = dot(_nC, faceN);\n\n  var minH = _minH * hScale * min(min(dA, dB), dC);\n  var maxH = _maxH * hScale * max(max(dA, dB), dC);\n\n  // Add gap\n  // 1. Avoid too small height cause ray marching miss.\n  // 2. Make sure the ray start beyond the displaced surface when surface height is same with prism height.\n  let prismHeight = abs(maxH) - abs(minH);\n  // DT is a local-space length; dt is a ray-parameter increment and changes\n  // when the instance transform scales the ray direction.\n  minH = sign(minH) * max(abs(minH) - DT * 2.0, 0.0);\n  if (prismHeight < DT * 2.0) {\n    maxH = sign(maxH) * min(abs(maxH) + DT * 2.0, abs(hScale));\n  }\n\n  let pA = _pA + _nA * minH / dA;\n  let pB = _pB + _nB * minH / dB;\n  let pC = _pC + _nC * minH / dC;\n\n  let pD = _pA + _nA * maxH / dA;\n  let pE = _pB + _nB * maxH / dB;\n  let pF = _pC + _nC * maxH / dC;\n\n  if (!intersectPrism(\n    _rayOrigin, _rayDir, 0.0, INF,\n    pA, pB, pC,\n    pD, pE, pF,\n    \n    &hitDistMin, &hitDistMax\n  )) {\n    return result;\n  }\n\n  var testFlag = false;\n  // Ray is inside the prism\n  if (hitDistMax == hitDistMin) {\n    hitDistMin = 0.0;\n  }\n\n  var t = hitDistMin + dt * hashedSample(2u);\n  var s = _rayOrigin + _rayDir * t;\n  var hRay = dot(s - _pA, faceN);\n  var hSurf = select(0.0, INF, hSign < 0.0);\n  // initial scanning triangle\n  var c0 = _pA + _nA * hRay / dA;\n  var c1 = _pB + _nB * hRay / dB;\n  var c2 = _pC + _nC * hRay / dC;\n\n  var projPos: vec3f;\n\n  hRay = abs(hRay);\n\n  var hDiff = hRay - hSurf;\n  var hDiffPrev = hDiff;\n  var step = 0;\n\n  while (true) {\n    // TODO Avoid too long loop\n    let b = triangleBarycentric(s, c0, c1, c2);\n    // Projected point on base triangle\n    projPos = _pA * b.x + _pB * b.y + _pC * b.z;\n    // Height at projected point\n    hRay = distance(projPos, s);\n    // Update scanning point\n    var uv: vec2f;\n    if (uvProjection > 0) {\n      let n = normalize(_nA * b.x + _nB * b.y + _nC * b.z);\n      uv = wrapUv(projectUV(uvProjection, projPos - (_nA * b.x + _nB * b.y + _nC * b.z) * hBias, n) * uvScale);\n    }\n    else {\n      uv = wrapUv(_tcA * b.x + _tcB * b.y + _tcC * b.z);\n    }\n    let h = sampleMap(heightMapIndex, uv).x;\n    // Heights are measured in mesh-local units, independently of ray length.\n    hSurf = max(hScaleAbs * h, DT);\n\n    // Advance scanning triangle\n    let dh = dot(faceN, s - c0);\n    c0 = c0 + _nA * dh / dA;\n    c1 = c1 + _nB * dh / dB;\n    c2 = c2 + _nC * dh / dC;\n\n    hDiffPrev = hDiff;\n    hDiff = hRay - hSurf;\n\n    if (!(select(hDiff * hSign, hDiff * hDiffPrev, isRefraction) > 0.0\n      && t < hitDistMax + dt) \n      // Ignore first step\n      && step > 0) {\n      break;\n    }\n\n    step++;\n    t = t + dt;\n    s = s + _rayDir * dt;\n  }\n\n  if (select(hDiff * hSign, hDiff * hDiffPrev, isRefraction) <= 0.0) {\n    let dtt = dt * (abs(hDiff) / (abs(hDiffPrev) + abs(hDiff) + EPS));\n    t = t - dtt;\n    // t = interpolateCrossing(_rayOrigin, _rayDir, projPos, t, dt, hSurf);\n    let pHit = _rayOrigin + _rayDir * t;\n    let b = triangleBarycentric(pHit, c0, c1, c2);\n\n    let N = normalize(_nA * b.x + _nB * b.y + _nC * b.z);\n\n    let p_a = _pA * b.x + _pB * b.y + _pC * b.z;\n    let p_b = _pA * (b.x + dbx) + _pB * b.y + _pC * (b.z - dbx);\n    let p_c = _pA * b.x + _pB * (b.y + dby) + _pC * (b.z - dby);\n\n    var uv_a: vec2f;\n    var uv_b: vec2f;\n    var uv_c: vec2f;\n\n    if (uvProjection > 0) {\n      let NA = normalize(_nA * b.x + _nB * b.y + _nC * b.z);\n      let NB = normalize(_nA * (b.x + dbx) + _nB * b.y + _nC * (b.z - dbx));\n      let NC = normalize(_nA * b.x + _nB * (b.y + dby) + _nC * (b.z - dby));  \n      uv_a = projectUV(uvProjection, p_a - (_nA * b.x + _nB * b.y + _nC * b.z) * hBias, NA) * uvScale;\n      uv_b = projectUV(uvProjection, p_b - (_nA * (b.x + dbx) + _nB * b.y + _nC * (b.z - dbx)) * hBias, NB) * uvScale;\n      uv_c = projectUV(uvProjection, p_c - (_nA * b.x + _nB * (b.y + dby) + _nC * (b.z - dby)) * hBias, NC) * uvScale;\n    }\n    else {\n      uv_a = _tcA * b.x + _tcB * b.y + _tcC * b.z;\n      uv_b = _tcA * (b.x + dbx) + _tcB * b.y + _tcC * (b.z - dbx);\n      uv_c = _tcA * b.x + _tcB * (b.y + dby) + _tcC * (b.z - dby);\n    }\n\n    let s_a = p_a + hSign * N * sampleMap(heightMapIndex, wrapUv(uv_a)).x * hScale;\n    let s_b = p_b + hSign * N * sampleMap(heightMapIndex, wrapUv(uv_b)).x * hScale;\n    let s_c = p_c + hSign * N * sampleMap(heightMapIndex, wrapUv(uv_c)).x * hScale;\n\n    let N_s = -hSign * normalize(cross(s_c - s_a, s_b - s_a));\n\n    result.t = t;\n    result.barycentric = b;\n    result.normal = normalize(N_s - faceN + hSign * N);\n  }\n\n  return result;\n\n}\n`;\n\nexport { displacementCommon };\n"]}

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

@@ -10,7 +10,7 @@ s0 = vec4u(p, u32(frame), u32(p.x) + u32(p.y));
 }
 
 
-fn vg() {
+fn vj() {
 s0 = s0 * 1664525u + 1013904223u;
 s0.x += s0.y*s0.w; s0.y += s0.z*s0.x; s0.z += s0.x*s0.y; s0.w += s0.y*s0.z;
 s0 = s0 ^ (s0>>vec4(16u));
@@ -18,7 +18,7 @@ s0.x += s0.y*s0.w; s0.y += s0.z*s0.x; s0.z += s0.x*s0.y; s0.w += s0.y*s0.z;
 }
 
 fn rand() -> f32 {
-vg(); return f32(s0.x)/f32(0xffffffffu);
+vj(); return f32(s0.x)/f32(0xffffffffu);
 }
 
 `;

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

@@ -303,10 +303,10 @@ if (light.v.y > 1e-6) {
 tD = smoothstep(light.v.x, light.v.x + light.v.y, cc);
 }
 if (tD <= 0.0 || light.textureIndex < 0.0) { return tD; }
-let tW = light.iesReference;
-let vn = cross(axis, tW);
+let tX = light.iesReference;
+let vo = cross(axis, tX);
 let vertical = acos(clamp(cc, -1.0, 1.0));
-let horizontal = atan2(dot(dJ, vn), dot(dJ, tW));
+let horizontal = atan2(dot(dJ, vo), dot(dJ, tX));
 return tD * kF(i32(light.textureIndex), vec2f(vertical / PI, horizontal / TWOPI + 0.5));
 }
 

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

@@ -262,11 +262,11 @@ fm: vec3f,
 iT: vec2f,
 lightSample: ptr<function, LightSampleRec>
 ) {
-let vl = sqrt(iT.x);
+let vn = sqrt(iT.x);
 let barycentric = vec3f(
-1.0 - vl,
-vl * (1.0 - iT.y),
-vl * iT.y
+1.0 - vn,
+vn * (1.0 - iT.y),
+vn * iT.y
 );
 let sN =
 barycentric.x * triangle.p0 +

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

@@ -230,9 +230,9 @@ ${hasCoatNormals ? /* wgsl */ `
 
 fn fB(input: vec3f, tc: vec3f, view: vec3f) -> vec3f {
 let qL = dot(tc, view) >= 0.0;
-let ub = select(-tc, tc, qL);
+let uc = select(-tc, tc, qL);
 let qK = select(-input, input, qL);
-if (dot(input, tc) <= 0.0 || dot(qK, view) <= 1e-6) { return ub; }
+if (dot(input, tc) <= 0.0 || dot(qK, view) <= 1e-6) { return uc; }
 return qK;
 }
 ` : ''}
@@ -364,11 +364,11 @@ var aT = false;
 var bE = true;
 var aR = u32(OPENPBR_LOBE_DIFFUSE);
 var qw = 0.0;
-let ud = vec3f(fk(cv(BSDF_DIRECTION)), dz(cv(BSDF_LOBE)));
+let ue = vec3f(fk(cv(BSDF_DIRECTION)), dz(cv(BSDF_LOBE)));
 var gR = vec3f(0.0);
 let f = dv(
 prepared,
-ud,
+ue,
 &cF,
 &scatteringPdf,
 &isNextRefraction,

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

@@ -6,11 +6,11 @@ export default /*wgsl*/ `
 fn aQ(view: vec3f, alpha: vec2f, samplePoint: vec2f) -> vec3f {
 let qY = vec3f(alpha, 1.0);
 let ge = normalize(qY * view);
-let tU = min(ge.z, 1.0);
-let qD = 1.0 + tU;
+let tV = min(ge.z, 1.0);
+let qD = 1.0 + tV;
 let qT = (1.0 - samplePoint.y) * qD;
 let rE = samplePoint.y * qD;
-let st = qT + (1.0 - tU);
+let st = qT + (1.0 - tV);
 let fi = sqrt(max(0.0, st * rE));
 let br = TWOPI * samplePoint.x;
 let lt = vec3f(

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

@@ -44,7 +44,7 @@ var r = reverseBits(ki);
 ${sobolD1Steps.map(([shift, mask]) => `r ^= (r << ${shift}u) & 0x${mask.toString(16)}u;`).join("\n  ")}
 return r;
 }
-fn vC(index: u32, ie: u32) -> vec2f {
+fn vD(index: u32, ie: u32) -> vec2f {
 let i = sv(index, aq(ie, 0u));
 let x = reverseBits(iA(i, aq(ie, 1u)));
 let y = sv(qX(i), aq(ie, 2u));
@@ -66,9 +66,9 @@ return (word >> ((tm & 3u) * 8u)) & 255u;
 }
 fn pK(kB: u32, dim: u32, logSPP: u32) -> u32 {
 let odd = logSPP & 1u;
-let tZ = 8u + ((logSPP + 1u) >> 1u);
+let ua = 8u + ((logSPP + 1u) >> 1u);
 var result = 0u;
-for (var digit = i32(tZ) - 1; digit >= i32(odd); digit--) {
+for (var digit = i32(ua) - 1; digit >= i32(odd); digit--) {
 let shift = 2u*u32(digit) - odd;
 
 var sd = 0u;

package/lib/renderer/wgsl/compose.frag.wgsl.js

@@ -172,8 +172,8 @@ var eM = gS(background.rgb / max(background.a, 0.000001) * exposure);
 eM *= 1.0 - toneMappingParams.y * kj;
 if (!hx) { eM = cH(eM); }
 let lY = select(pow(max(eM, vec3f(0.0)), vec3f(1.0 / 2.2)), fJ(eM), hx);
-let tX = select(vec3f(0.0), max(backgroundColor - lY, vec3f(0.0)), bloomIntensity > 0.0);
-backgroundColor = fJ(max(flatBackgroundColor.rgb, vec3f(0.0))) + tX;
+let tY = select(vec3f(0.0), max(backgroundColor - lY, vec3f(0.0)), bloomIntensity > 0.0);
+backgroundColor = fJ(max(flatBackgroundColor.rgb, vec3f(0.0))) + tY;
 }
 
 

package/lib/renderer/wgsl/customDenoise.wgsl.js

@@ -8,10 +8,10 @@ let background = load_backgroundTex(uv, 0);
 var me = foreground;
 var mc = background;
 if (any(filtered != original)) {
-let uj = abs(original) > vec3f(0.000001);
-let ap = select(vec3f(1.0), original, uj);
-let scale = select(vec3f(1.0), filtered / ap, uj);
-let tP = select(filtered - original, vec3f(0.0), uj);
+let uk = abs(original) > vec3f(0.000001);
+let ap = select(vec3f(1.0), original, uk);
+let scale = select(vec3f(1.0), filtered / ap, uk);
+let tP = select(filtered - original, vec3f(0.0), uk);
 me = vec4f(foreground.rgb * scale + tP, foreground.a);
 
 mc = vec4f(background.rgb * scale + tP * background.a, background.a);