@meimu/mutracer 0.1.3 → 0.1.5

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  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";
+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\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 = projectUV(uvProjection, projPos - (_nA * b.x + _nB * b.y + _nC * b.z) * hBias, n) * uvScale;\n    }\n    else {\n      uv = _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, uv_a).x * hScale;\n    let s_b = p_b + hSign * N * sampleMap(heightMapIndex, uv_b).x * hScale;\n    let s_c = p_c + hSign * N * sampleMap(heightMapIndex, 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

@@ -1,56 +1,56 @@
 const displacementCommon = /*wgsl*/ `
 
 
-struct jx {
+struct jD {
 barycentric: vec3f,
 t: f32,
 normal: vec3f,
 
 }
 
-fn uQ(
+fn uX(
 uu: f32,
-tQ: vec3f, tR: vec3f,
+tX: vec3f, tY: vec3f,
 eAC: vec3f, eBD: vec3f,
-iJ: vec3f,
-pP: f32,
-pR: ptr<function, f32>
+iO: vec3f,
+pX: f32,
+pZ: ptr<function, f32>
 ) -> bool {
 if (uu >= 0.0 && uu <= 1.0) {
-let pAB = mix(tQ, tR, uu);
+let pAB = mix(tX, tY, uu);
 let pCD = mix(eAC, eBD, uu);
-var n = cross(iJ, pCD);
-let vq = 1.0 / dot(n, n);
+var n = cross(iO, pCD);
+let vA = 1.0 / dot(n, n);
 n = cross(n, pAB);
-let tt = dot(n, pCD) * vq;
-let vv = dot(n, iJ) * vq;
-if (vv >= 0.0 && vv <= 1.0 && tt > pP && tt < *pR) {
-*pR = tt;
+let tt = dot(n, pCD) * vA;
+let vv = dot(n, iO) * vA;
+if (vv >= 0.0 && vv <= 1.0 && tt > pX && tt < *pZ) {
+*pZ = tt;
 return true;
 }
 }
 return false;
 }
 
-fn he(
-pH: vec3f, iJ: vec3f, pP: f32, tf: f32,
+fn hj(
+pP: vec3f, iO: vec3f, pX: f32, tn: f32,
 pA: vec3f, pB: vec3f, pC: vec3f, pD: vec3f,
-pR: ptr<function, f32>
+pZ: ptr<function, f32>
 ) -> bool {
 let eAB = pB - pA;
 let eAC = pC - pA;
 let eBD = pD - pB;
 let eCD = pD - pC;
-let tQ = pA - pH;
-let tR = pB - pH;
+let tX = pA - pP;
+let tY = pB - pP;
 
 var u1: f32;
 var u2: f32;
 {
 let qN = cross(eAB, -eCD);
-let a = dot(qN, iJ);
-var b = dot(cross(tR, iJ), eBD);
-let c = dot(cross(tQ, iJ), eAC);
+let a = dot(qN, iO);
+var b = dot(cross(tY, iO), eBD);
+let c = dot(cross(tX, iO), eAC);
 b -= a + c;
 
 let det = b * b - 4.0 * a * c;
@@ -62,19 +62,19 @@ if (a == 0.0) {
 u1 = -c / b;
 u2 = -1.0;
 } else {
-let vJ = sqrt(det);
-let wC = -0.5 * (b + sign(b) * vJ);
-u1 = wC / a;
-u2 = c / wC;
+let vQ = sqrt(det);
+let wL = -0.5 * (b + sign(b) * vQ);
+u1 = wL / a;
+u2 = c / wL;
 }
 }
 
-*pR = tf;
+*pZ = tn;
 
 var hit = false;
 
-hit = uQ(u1, tQ, tR, eAC, eBD, iJ, pP, pR) || 
-uQ(u2, tQ, tR, eAC, eBD, iJ, pP, pR);
+hit = uX(u1, tX, tY, eAC, eBD, iO, pX, pZ) || 
+uX(u2, tX, tY, eAC, eBD, iO, pX, pZ);
 if (!hit) {
 return false;
 }
@@ -82,8 +82,8 @@ return false;
 return true;
 }
 
-fn sl(
-pH: vec3f, iJ: vec3f, pP: f32, tf: f32,
+fn sv(
+pP: vec3f, iO: vec3f, pX: f32, tn: f32,
 pA: vec3f, pB: vec3f, pC: vec3f,
 pD: vec3f, pE: vec3f, pF: vec3f,
 
@@ -93,50 +93,50 @@ bS: ptr<function, f32>
 *bT = INF;
 *bS = -INF;
 
-let vW = maxDimension(abs(iJ));
-let gL = mj(iJ, vW);
+let wd = maxDimension(abs(iO));
+let gQ = mu(iO, wd);
 var tt: f32;
 
-tt = fI(
-pH, iJ,
-fu(pC, pB, pA), vW, gL, INF
+tt = fM(
+pP, iO,
+fB(pC, pB, pA), wd, gQ, INF
 ).t;
 if (tt > 0.0) {
 *bT = min(*bT, tt);
 *bS = max(*bS, tt);
 }
-tt = fI(
-pH, iJ,
-fu(pD, pE, pF), vW, gL, INF
+tt = fM(
+pP, iO,
+fB(pD, pE, pF), wd, gQ, INF
 ).t;
 if (tt > 0.0) {
 *bT = min(*bT, tt);
 *bS = max(*bS, tt);
 }
-if (he(
-pH, iJ, -INF, INF,
+if (hj(
+pP, iO, -INF, INF,
 pA, pB, pD, pE,
 &tt)) {
 *bT = min(*bT, tt);
 *bS = max(*bS, tt);
 }
-if (he(
-pH, iJ, -INF, INF,
+if (hj(
+pP, iO, -INF, INF,
 pB, pC, pE, pF,
 &tt)) {
 *bT = min(*bT, tt);
 *bS = max(*bS, tt);
 }
-if (he(
-pH, iJ, -INF, INF,
+if (hj(
+pP, iO, -INF, INF,
 pC, pA, pF, pD,
 &tt)) {
 *bT = min(*bT, tt);
 *bS = max(*bS, tt);
 }
 
-*bT = max(*bT, pP);
-*bS = min(*bS, tf);
+*bT = max(*bT, pX);
+*bS = min(*bS, tn);
 
 return *bT <= *bS && *bS > 0.0;
 }
@@ -145,7 +145,7 @@ export default /* wgsl */ `
 
 ${displacementCommon}
 
-fn lG(p: vec3f, p0: vec3f, p1: vec3f, p2: vec3f) -> vec3f {
+fn lP(p: vec3f, p0: vec3f, p1: vec3f, p2: vec3f) -> vec3f {
 let v0 = p1 - p0;
 let v1 = p2 - p0;
 let v2 = p - p0;
@@ -156,72 +156,69 @@ let d11 = dot(v1, v1);
 let d20 = dot(v2, v0);
 let d21 = dot(v2, v1);
 
-let tM = 1.0 / (d00 * d11 - d01 * d01);
-let v = clamp((d11 * d20 - d01 * d21) * tM, 0.0, 1.0);
-let w = clamp((d00 * d21 - d01 * d20) * tM, 0.0, 1.0);
+let tT = 1.0 / (d00 * d11 - d01 * d01);
+let v = clamp((d11 * d20 - d01 * d21) * tT, 0.0, 1.0);
+let w = clamp((d00 * d21 - d01 * d20) * tT, 0.0, 1.0);
 let u = 1.0 - v - w;
 
 return vec3f(u, v, w);
 }
 
-fn sO(uv: vec2f) -> vec2f {
-return (uv % 1.0 + 1.0) % 1.0;
-}
 
 
-fn oT(
-qj: vec3f, qE: vec3f, wJ: f32,
+fn pc(
+qr: vec3f, qM: vec3f, wQ: f32,
 _pA: vec3f, _pB: vec3f, _pC: vec3f,
 _nA: vec3f, _nB: vec3f, _nC: vec3f,
-vy: vec2f, vA: vec2f, vB: vec2f,
+vG: vec2f, vH: vec2f, vI: vec2f,
 
-jJ: i32,
-vx: vec2f,
+jQ: i32,
+vF: vec2f,
 
-wc: f32, wb: f32,
+wk: f32, wj: f32,
 hScale: f32,
-uC: f32,
-tY: f32,
+uJ: f32,
+uf: f32,
 uvProjection: i32,
 uvScale: vec2f,
-vO: bool,
-qU: bool
-) -> jx {
+vV: bool,
+rc: bool
+) -> jD {
 
 
 
-let DT = select(max(abs(hScale) / 32.0, 1e-12), tY, tY > 0.0);
-let dt = DT / length(qE);
+let DT = select(max(abs(hScale) / 32.0, 1e-12), uf, uf > 0.0);
+let dt = DT / length(qM);
 let dbx = 0.001;
 let dby = 0.001;
 
-var result: jx;
+var result: jD;
 result.t = INF;
 
 var bT = INF;
 var bS = -INF;
 
-let qS = sign(hScale);
-let uI = abs(hScale);
+let ra = sign(hScale);
+let uP = abs(hScale);
 
-let sX = qS * normalize(cross(_pB - _pA, _pC - _pA));
+let te = ra * normalize(cross(_pB - _pA, _pC - _pA));
 
 
-let dA = dot(_nA, sX);
-let dB = dot(_nB, sX);
-let dC = dot(_nC, sX);
+let dA = dot(_nA, te);
+let dB = dot(_nB, te);
+let dC = dot(_nC, te);
 
-var minH = wc * hScale * min(min(dA, dB), dC);
-var maxH = wb * hScale * max(max(dA, dB), dC);
+var minH = wk * hScale * min(min(dA, dB), dC);
+var maxH = wj * hScale * max(max(dA, dB), dC);
 
 
 
 
-let tS = abs(maxH) - abs(minH);
+let tZ = abs(maxH) - abs(minH);
 
 
 minH = sign(minH) * max(abs(minH) - DT * 2.0, 0.0);
-if (tS < DT * 2.0) {
+if (tZ < DT * 2.0) {
 maxH = sign(maxH) * min(abs(maxH) + DT * 2.0, abs(hScale));
 }
 
@@ -233,8 +230,8 @@ let pD = _pA + _nA * maxH / dA;
 let pE = _pB + _nB * maxH / dB;
 let pF = _pC + _nC * maxH / dC;
 
-if (!sl(
-qj, qE, 0.0, INF,
+if (!sv(
+qr, qM, 0.0, INF,
 pA, pB, pC,
 pD, pE, pF,
 
@@ -243,59 +240,59 @@ pD, pE, pF,
 return result;
 }
 
-var wE = false;
+var wM = false;
 
 if (bS == bT) {
 bT = 0.0;
 }
 
 var t = bT + dt * eo(2u);
-var s = qj + qE * t;
-var tL = dot(s - _pA, sX);
-var uW = select(0.0, INF, qS < 0.0);
+var s = qr + qM * t;
+var tS = dot(s - _pA, te);
+var vd = select(0.0, INF, ra < 0.0);
 
-var c0 = _pA + _nA * tL / dA;
-var c1 = _pB + _nB * tL / dB;
-var c2 = _pC + _nC * tL / dC;
+var c0 = _pA + _nA * tS / dA;
+var c1 = _pB + _nB * tS / dB;
+var c2 = _pC + _nC * tS / dC;
 
-var tv: vec3f;
+var tF: vec3f;
 
-tL = abs(tL);
+tS = abs(tS);
 
-var qR = tL - uW;
-var pQ = qR;
+var qZ = tS - vd;
+var pY = qZ;
 var step = 0;
 
 while (true) {
 
-let b = lG(s, c0, c1, c2);
+let b = lP(s, c0, c1, c2);
 
-tv = _pA * b.x + _pB * b.y + _pC * b.z;
+tF = _pA * b.x + _pB * b.y + _pC * b.z;
 
-tL = distance(tv, s);
+tS = distance(tF, s);
 
 var uv: vec2f;
 if (uvProjection > 0) {
 let n = normalize(_nA * b.x + _nB * b.y + _nC * b.z);
-uv = sO(gC(uvProjection, tv - (_nA * b.x + _nB * b.y + _nC * b.z) * uC, n) * uvScale);
+uv = gI(uvProjection, tF - (_nA * b.x + _nB * b.y + _nC * b.z) * uJ, n) * uvScale;
 }
 else {
-uv = sO(vy * b.x + vA * b.y + vB * b.z);
+uv = vG * b.x + vH * b.y + vI * b.z;
 }
-let h = sampleMap(jJ, uv).x;
+let h = sampleMap(jQ, uv).x;
 
-uW = max(uI * h, DT);
+vd = max(uP * h, DT);
 
 
-let dh = dot(sX, s - c0);
+let dh = dot(te, s - c0);
 c0 = c0 + _nA * dh / dA;
 c1 = c1 + _nB * dh / dB;
 c2 = c2 + _nC * dh / dC;
 
-pQ = qR;
-qR = tL - uW;
+pY = qZ;
+qZ = tS - vd;
 
-if (!(select(qR * qS, qR * pQ, qU) > 0.0
+if (!(select(qZ * ra, qZ * pY, rc) > 0.0
 && t < bS + dt) 
 
 && step > 0) {
@@ -304,15 +301,15 @@ break;
 
 step++;
 t = t + dt;
-s = s + qE * dt;
+s = s + qM * dt;
 }
 
-if (select(qR * qS, qR * pQ, qU) <= 0.0) {
-let dtt = dt * (abs(qR) / (abs(pQ) + abs(qR) + EPS));
+if (select(qZ * ra, qZ * pY, rc) <= 0.0) {
+let dtt = dt * (abs(qZ) / (abs(pY) + abs(qZ) + EPS));
 t = t - dtt;
 
-let wG = qj + qE * t;
-let b = lG(wG, c0, c1, c2);
+let wO = qr + qM * t;
+let b = lP(wO, c0, c1, c2);
 
 let N = normalize(_nA * b.x + _nB * b.y + _nC * b.z);
 
@@ -320,33 +317,33 @@ 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 vY: vec2f;
-var vZ: vec2f;
-var wa: vec2f;
+var wg: vec2f;
+var wh: vec2f;
+var wi: 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));  
-vY = gC(uvProjection, p_a - (_nA * b.x + _nB * b.y + _nC * b.z) * uC, NA) * uvScale;
-vZ = gC(uvProjection, p_b - (_nA * (b.x + dbx) + _nB * b.y + _nC * (b.z - dbx)) * uC, NB) * uvScale;
-wa = gC(uvProjection, p_c - (_nA * b.x + _nB * (b.y + dby) + _nC * (b.z - dby)) * uC, NC) * uvScale;
+wg = gI(uvProjection, p_a - (_nA * b.x + _nB * b.y + _nC * b.z) * uJ, NA) * uvScale;
+wh = gI(uvProjection, p_b - (_nA * (b.x + dbx) + _nB * b.y + _nC * (b.z - dbx)) * uJ, NB) * uvScale;
+wi = gI(uvProjection, p_c - (_nA * b.x + _nB * (b.y + dby) + _nC * (b.z - dby)) * uJ, NC) * uvScale;
 }
 else {
-vY = vy * b.x + vA * b.y + vB * b.z;
-vZ = vy * (b.x + dbx) + vA * b.y + vB * (b.z - dbx);
-wa = vy * b.x + vA * (b.y + dby) + vB * (b.z - dby);
+wg = vG * b.x + vH * b.y + vI * b.z;
+wh = vG * (b.x + dbx) + vH * b.y + vI * (b.z - dbx);
+wi = vG * b.x + vH * (b.y + dby) + vI * (b.z - dby);
 }
 
-let s_a = p_a + qS * N * sampleMap(jJ, sO(vY)).x * hScale;
-let s_b = p_b + qS * N * sampleMap(jJ, sO(vZ)).x * hScale;
-let s_c = p_c + qS * N * sampleMap(jJ, sO(wa)).x * hScale;
+let s_a = p_a + ra * N * sampleMap(jQ, wg).x * hScale;
+let s_b = p_b + ra * N * sampleMap(jQ, wh).x * hScale;
+let s_c = p_c + ra * N * sampleMap(jQ, wi).x * hScale;
 
-let N_s = -qS * normalize(cross(s_c - s_a, s_b - s_a));
+let N_s = -ra * normalize(cross(s_c - s_a, s_b - s_a));
 
 result.t = t;
 result.barycentric = b;
-result.normal = normalize(N_s - sX + qS * N);
+result.normal = normalize(N_s - te + ra * N);
 }
 
 return result;

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"]}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8MnB,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\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 = projectUV(uvProjection, projPos - (_nA * b.x + _nB * b.y + _nC * b.z) * hBias, n) * uvScale;\n    }\n    else {\n      uv = _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, uv_a).x * hScale;\n    let s_b = p_b + hSign * N * sampleMap(heightMapIndex, uv_b).x * hScale;\n    let s_c = p_c + hSign * N * sampleMap(heightMapIndex, 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

@@ -4,13 +4,13 @@
 export default /* wgsl */ `
 var<private> s0: vec4u;
 
-fn ka(p: vec2u, frame: i32) {
+fn kh(p: vec2u, frame: i32) {
 
 s0 = vec4u(p, u32(frame), u32(p.x) + u32(p.y));
 }
 
 
-fn vo() {
+fn vx() {
 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 {
-vo(); return f32(s0.x)/f32(0xffffffffu);
+vx(); return f32(s0.x)/f32(0xffffffffu);
 }
 
 `;