@meimu/mutracer 0.1.3 → 0.1.5

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

@@ -1 +1 @@
-{"version":3,"file":"sampleMaterial.glsl.js","sourceRoot":"","sources":["../../../../src/renderer/glsl/chunks/sampleMaterial.glsl.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,iIAAiI;AAEjI,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,eAAe,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkRlB,CAAC","sourcesContent":["// Estimate the direct lighting integral using multiple importance sampling\n// http://www.pbr-book.org/3ed-2018/Light_Transport_I_Surface_Reflection/Direct_Lighting.html#EstimatingtheDirectLightingIntegral\n\nimport { glsl } from '../../shader.js';\nexport default glsl`\nvec3 DirectLight(SurfaceInteraction si, OpenPbrResolvedMaterial mat, OpenPbrPreparedBsdf prepared, inout Path path, vec3 ffnormal, bool isSurface) {\n  float occluded = 1.0;\n  vec3 lightRnd = vec3(sample2D(bounceDim(LIGHT_POSITION)), sample1D(bounceDim(LIGHT_SELECT)));\n\n  LightSampleRec lightSample;\n  sampleLight(si.position, lightRnd, lightSample, false);\n  lightSample.emission = sampling_spectral_rgb_filter(lightSample.emission, pathWavelength);\n\n  vec3 lightDir = lightSample.direction;\n  vec3 viewDir = -path.ray.d;\n  float lightPdf = lightSample.pdf;\n  // Opaque surfaces are rendered two-sided by the core renderer. Use the\n  // face-forward shading normal here as well, otherwise the early-out rejects\n  // every direct-light sample seen from the back of a triangle (for example\n  // the inside of an imported room wall).\n  float cosThetaL = dot(ffnormal, lightDir);\n#ifdef NUM_COAT_NORMAL_MAPS\n  if (isSurface && mat.coatNormalEnabled) { cosThetaL = dot(mat.geometricNormal, lightDir); }\n#endif\n\n  if (lightPdf <= 0.0 || max(max(lightSample.emission.x, lightSample.emission.y), lightSample.emission.z) <= 0.0) {\n    return vec3(0.0);\n  }\n\n  float scatteringPdf = 0.0;\n  vec3 f = vec3(0.0);\n  if (isSurface) {\n    if (cosThetaL <= 0.0 && mat.transmissionWeight <= 0.0 && mat.subsurfaceWeight <= 0.0) {\n      return vec3(0.0);\n    }\n    f = openpbr_eval_prepared(prepared, lightDir, scatteringPdf);\n  }\n  else {\n    scatteringPdf = sampling_henyey_greenstein_phase(\n      dot(viewDir, lightDir),\n      si.mediumAnisotropy\n    );\n    f = vec3(scatteringPdf);\n  }\n\n  if (scatteringPdf <= 0.0 || max(max(f.x, f.y), f.z) <= 0.0) {\n    return vec3(0.0);\n  }\n\n  Ray lightRay;\n  vec3 shadowOrigin = si.position + EPS * lightDir;\n  if (isSurface) {\n    const float shadowTerminatorCutoff = 0.1;\n    float normalLight = dot(si.normal, lightDir);\n#ifdef NUM_COAT_NORMAL_MAPS\n    if (mat.coatNormalEnabled) { normalLight = dot(si.faceNormal, lightDir); }\n#endif\n    vec3 geometricNormal = normalLight < 0.0 ? -si.faceNormal : si.faceNormal;\n    normalLight = abs(normalLight);\n    float geometricLight = dot(geometricNormal, lightDir);\n    float offsetAmount = normalLight < shadowTerminatorCutoff\n      ? clamp(\n          2.0 - (geometricLight + normalLight) / shadowTerminatorCutoff,\n          0.0,\n          1.0\n        )\n      : clamp(1.0 - geometricLight / shadowTerminatorCutoff, 0.0, 1.0);\n    shadowOrigin += si.shadowOffset * offsetAmount;\n  }\n  initRay(lightRay, shadowOrigin, lightDir);\n  if (intersectSceneShadow(lightRay, lightSample.dist - EPS, si.triangleIndex)) {\n    return vec3(0.0);\n  }\n\n#ifdef USE_ENVMAP\n  // Match the endpoint used by a BSDF-sampled surface transmission, including\n  // a separately displayed or grounded background and its coverage.\n  if (isSurface && cosThetaL < 0.0 && lightRnd.z < envLightSelectionPmf) {\n    vec4 background = sampleBackgroundFromRay(lightRay.o, lightDir);\n    lightSample.emission = sampling_spectral_rgb_filter(background.rgb * background.a, pathWavelength);\n  }\n#endif\n\n  // Delta lights cannot be sampled by the BSDF strategy, so their MIS weight\n  // is exactly one even when their light-selection PMF is small.\n  float misWeight = lightSample.isDelta\n    ? 1.0\n    : sampling_power_heuristic(lightPdf, scatteringPdf);\n  return misWeight > 0.0\n    ? misWeight * lightSample.emission * f / lightPdf\n    : vec3(0.0);\n}\n\n#ifdef NUM_COAT_NORMAL_MAPS\nvec3 coat_frame_normal(vec3 inputNormal, vec3 face, vec3 view) {\n  bool front = dot(face, view) >= 0.0;\n  vec3 ffFace = front ? face : -face;\n  vec3 ffInput = front ? inputNormal : -inputNormal;\n  if (dot(inputNormal, face) <= 0.0 || dot(ffInput, view) <= 1e-6) { return ffFace; }\n  return ffInput;\n}\n#endif\nvoid SampleMaterial(inout SurfaceInteraction si, OpenPbrResolvedMaterial mat, inout Path path) {\n  vec3 matRnd = vec3(sample2D(bounceDim(BSDF_DIRECTION)), sample1D(bounceDim(BSDF_LOBE)));\n#ifdef NUM_COAT_NORMAL_MAPS\n  vec3 originalFace = si.faceNormal;\n  vec3 originalNormal = si.normal;\n#endif\n  float ndv1 = -dot(si.faceNormal, path.ray.d);\n  float ndv2 = -dot(si.normal, path.ray.d);\n  if ((mat.transmissionWeight > 0.0 || mat.subsurfaceWeight > 0.0) && mat.thinWalled) {\n    // Always treat thin material as entering medium\n    if (ndv1 < 0.0) {\n      si.faceNormal = -si.faceNormal;\n      ndv1 = -ndv1;\n    }\n    if (ndv2 < 0.0) {\n      si.normal = -si.normal;\n      ndv2 = -ndv2;\n    }\n  }\n  // In same edge cases normal is not torwards the camera while we can still see the face.\n  // We need to choose faceNormal in this case.\n  bool useFaceN = ndv1 >= 0.0 && ndv2 < 0.0;\n  float ndv = useFaceN ? ndv1 : ndv2;\n  vec3 normal = useFaceN ? si.faceNormal : si.normal;\n\n  mat.inside = ndv <= 0.0 && !mat.thinWalled;\n  // In or out\n  mat.relativeIor = ndv > 0.0 ? (1.0 / mat.specularIor) : mat.specularIor;\n  vec3 ffnormal = ndv >= 0.0 ? normal : -normal;\n#ifdef NUM_COAT_NORMAL_MAPS\n  if (mat.coatNormalEnabled) {\n    vec3 view = -path.ray.d;\n    float geometricView = dot(originalFace, view);\n    mat.geometricNormal = geometricView >= 0.0 ? originalFace : -originalFace;\n    ffnormal = coat_frame_normal(originalNormal, originalFace, view);\n    mat.coatNormal = coat_frame_normal(si.coatNormal, originalFace, view);\n    mat.inside = geometricView <= 0.0 && !mat.thinWalled;\n    mat.relativeIor = (geometricView > 0.0 || mat.thinWalled) ? 1.0 / mat.specularIor : mat.specularIor;\n  }\n#endif\n\n\n  float scatteringPdf;\n  vec3 scatterDir;\n  path.scatteringIsDelta = false;\n  bool mediumSampled = false;\n  bool crossedBoundary = false;\n  OpenPbrPreparedBsdf prepared;\n\n#ifdef HAS_MEDIUM\n  int mediumType = si.mediumType;\n  float d = distance(si.position, path.ray.o);\n  vec3 segmentOrigin = path.ray.o;\n  vec3 extinction = si.mediumExtinction;\n  vec3 scattering = min(si.mediumScattering, extinction);\n  float majorant = max(max(extinction.x, extinction.y), extinction.z);\n  if (mediumType > 0 && majorant > 0.0) {\n    // Sample one RGB extinction channel and divide by the mixture PDF. This\n    // is the homogeneous-medium estimator used by PBRT and avoids the very\n    // large exp((majorant - extinction) * distance) weights produced by\n    // majorant tracking when OpenPBR SSS radii differ strongly by channel.\n    int mediumChannel = min(int(sample1D(bounceDim(MEDIUM_CHANNEL)) * 3.0), 2);\n    float channelExtinction = extinction[mediumChannel];\n    float scatterDist = channelExtinction > 0.0\n      ? min(-log(max(sample1D(bounceDim(MEDIUM_DISTANCE)), 1e-7)) / channelExtinction, d)\n      : d;\n    mediumSampled = scatterDist < d;\n    vec3 transmittance = exp(-extinction * scatterDist);\n    vec3 density = mediumSampled\n      ? extinction * transmittance\n      : transmittance;\n    float mediumPdf = max(\n      (density.x + density.y + density.z) / 3.0,\n      1e-8\n    );\n    if (mediumSampled) {\n      path.beta *= transmittance * scattering / mediumPdf;\n      // Move from the start of the segment, not from its end surface.\n      path.ray.o = segmentOrigin + scatterDist * path.ray.d;\n      si.position = path.ray.o;\n      path.li += DirectLight(si, mat, prepared, path, ffnormal, false) * path.beta;\n\n      // Pick a new direction based on the phase function\n      scatterDir = sampling_henyey_greenstein(\n        -path.ray.d,\n        si.mediumAnisotropy,\n        sample2D(bounceDim(PHASE_DIRECTION))\n      );\n      scatteringPdf = sampling_henyey_greenstein_phase(\n        dot(scatterDir, -path.ray.d),\n        si.mediumAnisotropy\n      );\n    }\n    else {\n      path.beta *= transmittance / mediumPdf;\n    }\n  }\n#endif\n\n  // Direct lighting\n  if (!mediumSampled) {\n    path.li += mat.emission * path.beta;\n    if (mat.materialType == UNLIT) {\n      path.abort = true;\n      return;\n    }\n    vec3 surfaceTangent = vec3(0.0);\n#ifdef USE_TANGENT\n    surfaceTangent = si.tangent;\n#endif\n    mat.directionTangent = si.directionTangent;\n    mat.directionBitangent = si.directionBitangent;\n    mat.geometryTangent = si.geometryTangent;\n    mat.geometryBitangent = si.geometryBitangent;\n    prepared = openpbr_prepare(surfaceTangent, mat, -path.ray.d, ffnormal);\n    path.li += DirectLight(si, mat, prepared, path, ffnormal, true) * path.beta;\n    // Sample BSDF for color and outgoing direction\n    bool isNextRefraction;\n    vec3 f = openpbr_sample_prepared(\n      prepared,\n      matRnd,\n      scatterDir,\n      scatteringPdf,\n      isNextRefraction\n    );\n    // Null-boundary transmission is discrete and has no NEE competitor.\n    path.scatteringIsDelta = !prepared.material.thinWalled &&\n      abs(prepared.material.relativeIor - 1.0) <= 1e-6 &&\n      prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] >= 1.0 - 1e-6;\n    // Match WebGPU: rejected VNDF/refraction proposals have no continuation.\n    // Tracing their fallback direction with the incoming throughput invents\n    // light paths, especially after total internal reflection inside glass.\n    if (!(scatteringPdf > 0.0) || any(isnan(f)) || any(isinf(f)) ||\n        dot(scatterDir, scatterDir) < 0.5) {\n      path.scatteringPdf = 0.0;\n      path.abort = true;\n      return;\n    }\n    path.beta *= f / scatteringPdf;\n    crossedBoundary = !mat.thinWalled &&\n      isNextRefraction;\n    path.isNextRefraction = isNextRefraction;\n    // TODO prefer the opaque surface when transmission surface and opaque surface are overlapped.\n    // Or the ray go out from transmission material will miss the opque surface.\n    path.ray.o = si.position + EPS * scatterDir;\n#ifdef NUM_COAT_NORMAL_MAPS\n    if (mat.coatNormalEnabled) { path.ray.o = si.position + EPS * (dot(originalFace, scatterDir) >= 0.0 ? originalFace : -originalFace); }\n#endif\n  }\n\n  path.scatteringPdf = scatteringPdf;\n  initRay(path.ray, path.ray.o, scatterDir);\n  if (mediumSampled) {\n    path.isNextRefraction = false;\n  }\n  path.fromEye = false;\n\n#ifdef HAS_MEDIUM\n  // A reflected ray stays in its current medium. Only a sampled transmission\n  // event crosses the boundary of a medium-bearing closed mesh.\n  if (!mediumSampled && crossedBoundary && mat.mediumType > 0) {\n    if (ndv1 >= 0.0) {\n      si.mediumType = mat.mediumType;\n      si.mediumExtinction = mat.mediumExtinction;\n      si.mediumScattering = mat.mediumScattering;\n      si.mediumAnisotropy = mat.mediumAnisotropy;\n    }\n    else {\n      si.mediumType = 0;\n      si.mediumExtinction = vec3(0.0);\n      si.mediumScattering = vec3(0.0);\n      si.mediumAnisotropy = 0.0;\n    }\n  }\n#endif\n}\n`;\n"]}
+{"version":3,"file":"sampleMaterial.glsl.js","sourceRoot":"","sources":["../../../../src/renderer/glsl/chunks/sampleMaterial.glsl.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,iIAAiI;AAEjI,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,eAAe,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkRlB,CAAC","sourcesContent":["// Estimate the direct lighting integral using multiple importance sampling\n// http://www.pbr-book.org/3ed-2018/Light_Transport_I_Surface_Reflection/Direct_Lighting.html#EstimatingtheDirectLightingIntegral\n\nimport { glsl } from '../../shader.js';\nexport default glsl`\nvec3 DirectLight(SurfaceInteraction si, OpenPbrResolvedMaterial mat, OpenPbrPreparedBsdf prepared, inout Path path, vec3 ffnormal, bool isSurface) {\n  float occluded = 1.0;\n  vec3 lightRnd = vec3(sample2D(bounceDim(LIGHT_POSITION)), sample1D(bounceDim(LIGHT_SELECT)));\n\n  LightSampleRec lightSample;\n  sampleLight(si.position, lightRnd, lightSample, false);\n  lightSample.emission = sampling_spectral_rgb_filter(lightSample.emission, pathWavelength);\n\n  vec3 lightDir = lightSample.direction;\n  vec3 viewDir = -path.ray.d;\n  float lightPdf = lightSample.pdf;\n  // Opaque surfaces are rendered two-sided by the core renderer. Use the\n  // face-forward shading normal here as well, otherwise the early-out rejects\n  // every direct-light sample seen from the back of a triangle (for example\n  // the inside of an imported room wall).\n  float cosThetaL = dot(ffnormal, lightDir);\n#ifdef USE_COAT_NORMAL_FRAMES\n  if (isSurface && mat.coatNormalEnabled) { cosThetaL = dot(mat.geometricNormal, lightDir); }\n#endif\n\n  if (lightPdf <= 0.0 || max(max(lightSample.emission.x, lightSample.emission.y), lightSample.emission.z) <= 0.0) {\n    return vec3(0.0);\n  }\n\n  float scatteringPdf = 0.0;\n  vec3 f = vec3(0.0);\n  if (isSurface) {\n    if (cosThetaL <= 0.0 && mat.transmissionWeight <= 0.0 && mat.subsurfaceWeight <= 0.0) {\n      return vec3(0.0);\n    }\n    f = openpbr_eval_prepared(prepared, lightDir, scatteringPdf);\n  }\n  else {\n    scatteringPdf = sampling_henyey_greenstein_phase(\n      dot(viewDir, lightDir),\n      si.mediumAnisotropy\n    );\n    f = vec3(scatteringPdf);\n  }\n\n  if (scatteringPdf <= 0.0 || max(max(f.x, f.y), f.z) <= 0.0) {\n    return vec3(0.0);\n  }\n\n  Ray lightRay;\n  vec3 shadowOrigin = si.position + EPS * lightDir;\n  if (isSurface) {\n    const float shadowTerminatorCutoff = 0.1;\n    float normalLight = dot(si.normal, lightDir);\n#ifdef USE_COAT_NORMAL_FRAMES\n    if (mat.coatNormalEnabled) { normalLight = dot(si.faceNormal, lightDir); }\n#endif\n    vec3 geometricNormal = normalLight < 0.0 ? -si.faceNormal : si.faceNormal;\n    normalLight = abs(normalLight);\n    float geometricLight = dot(geometricNormal, lightDir);\n    float offsetAmount = normalLight < shadowTerminatorCutoff\n      ? clamp(\n          2.0 - (geometricLight + normalLight) / shadowTerminatorCutoff,\n          0.0,\n          1.0\n        )\n      : clamp(1.0 - geometricLight / shadowTerminatorCutoff, 0.0, 1.0);\n    shadowOrigin += si.shadowOffset * offsetAmount;\n  }\n  initRay(lightRay, shadowOrigin, lightDir);\n  if (intersectSceneShadow(lightRay, lightSample.dist - EPS, si.triangleIndex)) {\n    return vec3(0.0);\n  }\n\n#ifdef USE_ENVMAP\n  // Match the endpoint used by a BSDF-sampled surface transmission, including\n  // a separately displayed or grounded background and its coverage.\n  if (isSurface && cosThetaL < 0.0 && lightRnd.z < envLightSelectionPmf) {\n    vec4 background = sampleBackgroundFromRay(lightRay.o, lightDir);\n    lightSample.emission = sampling_spectral_rgb_filter(background.rgb * background.a, pathWavelength);\n  }\n#endif\n\n  // Delta lights cannot be sampled by the BSDF strategy, so their MIS weight\n  // is exactly one even when their light-selection PMF is small.\n  float misWeight = lightSample.isDelta\n    ? 1.0\n    : sampling_power_heuristic(lightPdf, scatteringPdf);\n  return misWeight > 0.0\n    ? misWeight * lightSample.emission * f / lightPdf\n    : vec3(0.0);\n}\n\n#ifdef USE_COAT_NORMAL_FRAMES\nvec3 coat_frame_normal(vec3 inputNormal, vec3 face, vec3 view) {\n  bool front = dot(face, view) >= 0.0;\n  vec3 ffFace = front ? face : -face;\n  vec3 ffInput = front ? inputNormal : -inputNormal;\n  if (dot(inputNormal, face) <= 0.0 || dot(ffInput, view) <= 1e-6) { return ffFace; }\n  return ffInput;\n}\n#endif\nvoid SampleMaterial(inout SurfaceInteraction si, OpenPbrResolvedMaterial mat, inout Path path) {\n  vec3 matRnd = vec3(sample2D(bounceDim(BSDF_DIRECTION)), sample1D(bounceDim(BSDF_LOBE)));\n#ifdef USE_COAT_NORMAL_FRAMES\n  vec3 originalFace = si.faceNormal;\n  vec3 originalNormal = si.normal;\n#endif\n  float ndv1 = -dot(si.faceNormal, path.ray.d);\n  float ndv2 = -dot(si.normal, path.ray.d);\n  if ((mat.transmissionWeight > 0.0 || mat.subsurfaceWeight > 0.0) && mat.thinWalled) {\n    // Always treat thin material as entering medium\n    if (ndv1 < 0.0) {\n      si.faceNormal = -si.faceNormal;\n      ndv1 = -ndv1;\n    }\n    if (ndv2 < 0.0) {\n      si.normal = -si.normal;\n      ndv2 = -ndv2;\n    }\n  }\n  // In same edge cases normal is not torwards the camera while we can still see the face.\n  // We need to choose faceNormal in this case.\n  bool useFaceN = ndv1 >= 0.0 && ndv2 < 0.0;\n  float ndv = useFaceN ? ndv1 : ndv2;\n  vec3 normal = useFaceN ? si.faceNormal : si.normal;\n\n  mat.inside = ndv <= 0.0 && !mat.thinWalled;\n  // In or out\n  mat.relativeIor = ndv > 0.0 ? (1.0 / mat.specularIor) : mat.specularIor;\n  vec3 ffnormal = ndv >= 0.0 ? normal : -normal;\n#ifdef USE_COAT_NORMAL_FRAMES\n  if (mat.coatNormalEnabled) {\n    vec3 view = -path.ray.d;\n    float geometricView = dot(originalFace, view);\n    mat.geometricNormal = geometricView >= 0.0 ? originalFace : -originalFace;\n    ffnormal = coat_frame_normal(originalNormal, originalFace, view);\n    mat.coatNormal = coat_frame_normal(si.coatNormal, originalFace, view);\n    mat.inside = geometricView <= 0.0 && !mat.thinWalled;\n    mat.relativeIor = (geometricView > 0.0 || mat.thinWalled) ? 1.0 / mat.specularIor : mat.specularIor;\n  }\n#endif\n\n\n  float scatteringPdf;\n  vec3 scatterDir;\n  path.scatteringIsDelta = false;\n  bool mediumSampled = false;\n  bool crossedBoundary = false;\n  OpenPbrPreparedBsdf prepared;\n\n#ifdef HAS_MEDIUM\n  int mediumType = si.mediumType;\n  float d = distance(si.position, path.ray.o);\n  vec3 segmentOrigin = path.ray.o;\n  vec3 extinction = si.mediumExtinction;\n  vec3 scattering = min(si.mediumScattering, extinction);\n  float majorant = max(max(extinction.x, extinction.y), extinction.z);\n  if (mediumType > 0 && majorant > 0.0) {\n    // Sample one RGB extinction channel and divide by the mixture PDF. This\n    // is the homogeneous-medium estimator used by PBRT and avoids the very\n    // large exp((majorant - extinction) * distance) weights produced by\n    // majorant tracking when OpenPBR SSS radii differ strongly by channel.\n    int mediumChannel = min(int(sample1D(bounceDim(MEDIUM_CHANNEL)) * 3.0), 2);\n    float channelExtinction = extinction[mediumChannel];\n    float scatterDist = channelExtinction > 0.0\n      ? min(-log(max(sample1D(bounceDim(MEDIUM_DISTANCE)), 1e-7)) / channelExtinction, d)\n      : d;\n    mediumSampled = scatterDist < d;\n    vec3 transmittance = exp(-extinction * scatterDist);\n    vec3 density = mediumSampled\n      ? extinction * transmittance\n      : transmittance;\n    float mediumPdf = max(\n      (density.x + density.y + density.z) / 3.0,\n      1e-8\n    );\n    if (mediumSampled) {\n      path.beta *= transmittance * scattering / mediumPdf;\n      // Move from the start of the segment, not from its end surface.\n      path.ray.o = segmentOrigin + scatterDist * path.ray.d;\n      si.position = path.ray.o;\n      path.li += DirectLight(si, mat, prepared, path, ffnormal, false) * path.beta;\n\n      // Pick a new direction based on the phase function\n      scatterDir = sampling_henyey_greenstein(\n        -path.ray.d,\n        si.mediumAnisotropy,\n        sample2D(bounceDim(PHASE_DIRECTION))\n      );\n      scatteringPdf = sampling_henyey_greenstein_phase(\n        dot(scatterDir, -path.ray.d),\n        si.mediumAnisotropy\n      );\n    }\n    else {\n      path.beta *= transmittance / mediumPdf;\n    }\n  }\n#endif\n\n  // Direct lighting\n  if (!mediumSampled) {\n    path.li += mat.emission * path.beta;\n    if (mat.materialType == UNLIT) {\n      path.abort = true;\n      return;\n    }\n    vec3 surfaceTangent = vec3(0.0);\n#ifdef USE_TANGENT\n    surfaceTangent = si.tangent;\n#endif\n    mat.directionTangent = si.directionTangent;\n    mat.directionBitangent = si.directionBitangent;\n    mat.geometryTangent = si.geometryTangent;\n    mat.geometryBitangent = si.geometryBitangent;\n    prepared = openpbr_prepare(surfaceTangent, mat, -path.ray.d, ffnormal);\n    path.li += DirectLight(si, mat, prepared, path, ffnormal, true) * path.beta;\n    // Sample BSDF for color and outgoing direction\n    bool isNextRefraction;\n    vec3 f = openpbr_sample_prepared(\n      prepared,\n      matRnd,\n      scatterDir,\n      scatteringPdf,\n      isNextRefraction\n    );\n    // Null-boundary transmission is discrete and has no NEE competitor.\n    path.scatteringIsDelta = !prepared.material.thinWalled &&\n      abs(prepared.material.relativeIor - 1.0) <= 1e-6 &&\n      prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] >= 1.0 - 1e-6;\n    // Match WebGPU: rejected VNDF/refraction proposals have no continuation.\n    // Tracing their fallback direction with the incoming throughput invents\n    // light paths, especially after total internal reflection inside glass.\n    if (!(scatteringPdf > 0.0) || any(isnan(f)) || any(isinf(f)) ||\n        dot(scatterDir, scatterDir) < 0.5) {\n      path.scatteringPdf = 0.0;\n      path.abort = true;\n      return;\n    }\n    path.beta *= f / scatteringPdf;\n    crossedBoundary = !mat.thinWalled &&\n      isNextRefraction;\n    path.isNextRefraction = isNextRefraction;\n    // TODO prefer the opaque surface when transmission surface and opaque surface are overlapped.\n    // Or the ray go out from transmission material will miss the opque surface.\n    path.ray.o = si.position + EPS * scatterDir;\n#ifdef USE_COAT_NORMAL_FRAMES\n    if (mat.coatNormalEnabled) { path.ray.o = si.position + EPS * (dot(originalFace, scatterDir) >= 0.0 ? originalFace : -originalFace); }\n#endif\n  }\n\n  path.scatteringPdf = scatteringPdf;\n  initRay(path.ray, path.ray.o, scatterDir);\n  if (mediumSampled) {\n    path.isNextRefraction = false;\n  }\n  path.fromEye = false;\n\n#ifdef HAS_MEDIUM\n  // A reflected ray stays in its current medium. Only a sampled transmission\n  // event crosses the boundary of a medium-bearing closed mesh.\n  if (!mediumSampled && crossedBoundary && mat.mediumType > 0) {\n    if (ndv1 >= 0.0) {\n      si.mediumType = mat.mediumType;\n      si.mediumExtinction = mat.mediumExtinction;\n      si.mediumScattering = mat.mediumScattering;\n      si.mediumAnisotropy = mat.mediumAnisotropy;\n    }\n    else {\n      si.mediumType = 0;\n      si.mediumExtinction = vec3(0.0);\n      si.mediumScattering = vec3(0.0);\n      si.mediumAnisotropy = 0.0;\n    }\n  }\n#endif\n}\n`;\n"]}

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

@@ -11,33 +11,33 @@ export default glsl `
 
 const uint SHADOW_CATCHER_LIGHT_SAMPLES = 4u;
 
-uint ko(uint candidate, uint slot) {
+uint ky(uint candidate, uint slot) {
 return candidate == 0u ? cw(slot) : cw(9u + (candidate - 1u) * 3u + slot);
 }
 
 void sampleShadowCatcher(ad si, int bounce, inout Path aa) {
-vec3 oK = -aa.ray.d;
+vec3 oS = -aa.ray.d;
 
 #if defined(NUM_LIGHTS) || defined(USE_ENVMAP)
 float visibility = 0.0;
 for (uint candidate = 0u; candidate < SHADOW_CATCHER_LIGHT_SAMPLES; candidate++) {
 LightSampleRec lightSample;
-vec3 lc = vec3(
-fk(ko(candidate, LIGHT_POSITION)),
-dz(ko(candidate, LIGHT_SELECT))
+vec3 ln = vec3(
+fp(ky(candidate, LIGHT_POSITION)),
+dz(ky(candidate, LIGHT_SELECT))
 );
-sampleLight(si.position, lc, lightSample, false);
+sampleLight(si.position, ln, lightSample, false);
 
 vec3 lightDir = lightSample.direction;
 float cosThetaL = dot(si.normal, lightDir);
-float pv = dot(si.normal, oK) * cosThetaL;
-bool mt = false;
-if (pv >= 0.0) {
+float pM = dot(si.normal, oS) * cosThetaL;
+bool mC = false;
+if (pM >= 0.0) {
 Ray ray;
-iw(ray, si.position + EPS * lightDir, lightDir);
-mt = ex(ray, lightSample.dist - EPS, si.triangleIndex);
+iC(ray, si.position + EPS * lightDir, lightDir);
+mC = ex(ray, lightSample.dist - EPS, si.triangleIndex);
 }
-visibility += mt ? 0.0 : 1.0;
+visibility += mC ? 0.0 : 1.0;
 }
 
 aa.alpha = visibility / float(SHADOW_CATCHER_LIGHT_SAMPLES);

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

@@ -5,70 +5,70 @@ export default glsl `
 
 
 vec3 aQ(vec3 view, vec2 alpha, vec2 samplePoint) {
-vec3 rc = vec3(alpha, 1.0);
-vec3 gf = normalize(rc * view);
-float ua = min(gf.z, 1.0);
-float qH = 1.0 + ua;
-float qX = (1.0 - samplePoint.y) * qH;
-float rJ = samplePoint.y * qH;
-float sA = qX + (1.0 - ua);
-float fi = sqrt(max(0.0, sA * rJ));
+vec3 rm = vec3(alpha, 1.0);
+vec3 gk = normalize(rm * view);
+float uh = min(gk.z, 1.0);
+float qQ = 1.0 + uh;
+float rh = (1.0 - samplePoint.y) * qQ;
+float rR = samplePoint.y * qQ;
+float sI = rh + (1.0 - uh);
+float fl = sqrt(max(0.0, sI * rR));
 float br = TWOPI * samplePoint.x;
-vec3 lw = vec3(
-gf.x + fi * cos(br),
-gf.y + fi * sin(br),
-qX
+vec3 lI = vec3(
+gk.x + fl * cos(br),
+gk.y + fl * sin(br),
+rh
 );
-return normalize(rc * lw);
+return normalize(rm * lI);
 }
 
-float gG(vec3 od, vec2 alpha) {
-vec3 hm = vec3(
-od.x / alpha.x,
-od.y / alpha.y,
-od.z
+float gL(vec3 oo, vec2 alpha) {
+vec3 hr = vec3(
+oo.x / alpha.x,
+oo.y / alpha.y,
+oo.z
 );
-float ap = dot(hm, hm);
+float ap = dot(hr, hr);
 return 1.0 / (
 PI * alpha.x * alpha.y * ap * ap
 );
 }
 
 float bk(vec3 direction, vec2 alpha) {
-float eE = abs(direction.z);
-if (eE <= 1e-8) {
+float eF = abs(direction.z);
+if (eF <= 1e-8) {
 return 0.0;
 }
-vec2 hY = alpha * direction.xy;
-float lA = dot(hY, hY)
-/ (eE * eE);
-return 2.0 / (1.0 + sqrt(1.0 + lA));
+vec2 ic = alpha * direction.xy;
+float lJ = dot(ic, ic)
+/ (eF * eF);
+return 2.0 / (1.0 + sqrt(1.0 + lJ));
 }
 
 float aE(float au) {
-float dg = clamp(1.0 - au, 0.0, 1.0);
-return pow(dg, 5.0);
+float di = clamp(1.0 - au, 0.0, 1.0);
+return pow(di, 5.0);
 }
 
 float cu(float L, float cJ) {
-float iu = clamp(abs(L), 0.0, 1.0);
-float ke = cJ * cJ
-* max(0.0, 1.0 - iu * iu);
-if (ke >= 1.0) {
+float iA = clamp(abs(L), 0.0, 1.0);
+float kl = cJ * cJ
+* max(0.0, 1.0 - iA * iA);
+if (kl >= 1.0) {
 return 1.0;
 }
 
-float lK = sqrt(max(0.0, 1.0 - ke));
-float ba = (iu - cJ * lK)
-/ max(iu + cJ * lK, 1e-8);
-float pw = (cJ * iu - lK)
-/ max(cJ * iu + lK, 1e-8);
+float lT = sqrt(max(0.0, 1.0 - kl));
+float ba = (iA - cJ * lT)
+/ max(iA + cJ * lT, 1e-8);
+float pN = (cJ * iA - lT)
+/ max(cJ * iA + lT, 1e-8);
 return 0.5 * (
-ba * ba + pw * pw
+ba * ba + pN * pN
 );
 }
 
-vec2 gd(vec2 samplePoint) {
+vec2 gi(vec2 samplePoint) {
 vec2 offset = 2.0 * samplePoint - vec2(1.0);
 if (offset.x == 0.0 && offset.y == 0.0) {
 return vec2(0.0);
@@ -88,35 +88,35 @@ return radius * vec2(cos(angle), sin(angle));
 }
 
 vec3 bi(vec2 samplePoint) {
-vec2 kx = gd(samplePoint);
+vec2 kF = gi(samplePoint);
 return vec3(
-kx,
-sqrt(max(0.0, 1.0 - dot(kx, kx)))
+kF,
+sqrt(max(0.0, 1.0 - dot(kF, kF)))
 );
 }
 
-float aG(float pi, float nD) {
-float scale = max(pi, nD);
+float aG(float pr, float nN) {
+float scale = max(pr, nN);
 if (scale <= 0.0) {
 return 0.0;
 }
-vec2 normalized = vec2(pi, nD) / scale;
-vec2 oG = normalized * normalized;
-return oG.x / (oG.x + oG.y);
+vec2 normalized = vec2(pr, nN) / scale;
+vec2 oO = normalized * normalized;
+return oO.x / (oO.x + oO.y);
 }
 
 void aL(in vec3 normal, out vec3 tangent, out vec3 bitangent) {
-float ie = normal.z >= 0.0 ? 1.0 : -1.0;
-float dW = -1.0 / (ie + normal.z);
+float ik = normal.z >= 0.0 ? 1.0 : -1.0;
+float dW = -1.0 / (ik + normal.z);
 float xy = normal.x * normal.y * dW;
 tangent = vec3(
-1.0 + ie * normal.x * normal.x * dW,
-ie * xy,
--ie * normal.x
+1.0 + ik * normal.x * normal.x * dW,
+ik * xy,
+-ik * normal.x
 );
 bitangent = vec3(
 xy,
-ie + normal.y * normal.y * dW,
+ik + normal.y * normal.y * dW,
 -normal.y
 );
 }
@@ -125,40 +125,40 @@ vec3 ai(vec3 rgb, float wavelength) {
 if (wavelength == 0.0) {
 return rgb;
 }
-vec3 tG = wavelength > 600.0
+vec3 tN = wavelength > 600.0
 ? vec3(1.0, 0.0, 0.0)
 : wavelength > 500.0
 ? vec3(0.0, 1.0, 0.0)
 : vec3(0.0, 0.0, 1.0);
-return rgb * tG;
+return rgb * tN;
 }
 
-float eK(
+float eN(
 float wavelength,
-float hb,
-float hk,
-float qk
+float hh,
+float hp,
+float qs
 ) {
-if (wavelength == 0.0 || hk <= 0.0) {
-return hb;
+if (wavelength == 0.0 || hp <= 0.0) {
+return hh;
 }
 
 const float FRAUNHOFER_C = 656.3;
 const float FRAUNHOFER_D = 587.6;
 const float FRAUNHOFER_F = 486.1;
-float jK = 1.0 / (
+float jR = 1.0 / (
 1.0 / (FRAUNHOFER_F * FRAUNHOFER_F)
 - 1.0 / (FRAUNHOFER_C * FRAUNHOFER_C)
 );
-float mT = max(qk / hk, 1e-6);
-float qI = (hb - 1.0) * jK / mT;
-float td = hb
-- qI / (FRAUNHOFER_D * FRAUNHOFER_D);
-return td + qI / (wavelength * wavelength);
+float ng = max(qs / hp, 1e-6);
+float qR = (hh - 1.0) * jR / ng;
+float tl = hh
+- qR / (FRAUNHOFER_D * FRAUNHOFER_D);
+return tl + qR / (wavelength * wavelength);
 }
 
-vec3 fl(
-vec3 gu,
+vec3 fq(
+vec3 gz,
 float anisotropy,
 vec2 samplePoint
 ) {
@@ -167,21 +167,21 @@ if (abs(anisotropy) < 0.001) {
 au = 1.0 - 2.0 * samplePoint.y;
 }
 else {
-float iV = (1.0 - anisotropy * anisotropy)
+float ja = (1.0 - anisotropy * anisotropy)
 / (1.0 + anisotropy - 2.0 * anisotropy * samplePoint.y);
 au = (
-iV * iV - 1.0 - anisotropy * anisotropy
+ja * ja - 1.0 - anisotropy * anisotropy
 ) / (2.0 * anisotropy);
 }
 
-float tW = sqrt(max(0.0, 1.0 - au * au));
+float ud = sqrt(max(0.0, 1.0 - au * au));
 float br = TWOPI * samplePoint.x;
 vec3 tangent;
 vec3 bitangent;
-aL(gu, tangent, bitangent);
-return tangent * (tW * cos(br))
-+ bitangent * (tW * sin(br))
-+ gu * au;
+aL(gz, tangent, bitangent);
+return tangent * (ud * cos(br))
++ bitangent * (ud * sin(br))
++ gz * au;
 }
 
 float bD(float au, float anisotropy) {

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

@@ -28,8 +28,8 @@ uvec2 bc;
 uint bd;
 uint cF = 0u;
 uint em = 0u;
-uint eg(uint kk) {
-uint x = kk;
+uint eg(uint kt) {
+uint x = kt;
 x ^= x >> 16u; x *= 0x7feb352du;
 x ^= x >> 15u; x *= 0x846ca68bu;
 return x ^ (x >> 16u);
@@ -37,28 +37,28 @@ return x ^ (x >> 16u);
 uint aq(uint a, uint b) {
 return eg(a ^ eg(b + 0x9e3779b9u));
 }
-uint iA(uint kk, uint ic) {
-uint x = kk + ic;
+uint iE(uint kt, uint ij) {
+uint x = kt + ij;
 x ^= x * 0x6c50b47cu; x ^= x * 0xb82f1e52u;
 x ^= x * 0xc7afe638u; x ^= x * 0x8d22f6e6u;
 return x;
 }
-uint sC(uint x, uint ic) {
-return reverseBits(iA(reverseBits(x), ic));
+uint sK(uint x, uint ij) {
+return reverseBits(iE(reverseBits(x), ij));
 }
 
-uint rb(uint kk) {
-uint r = reverseBits(kk);
+uint rl(uint kt) {
+uint r = reverseBits(kt);
 ${sobolD1Steps.map(([shift, mask]) => `r ^= (r << ${shift}u) & 0x${mask.toString(16)}u;`).join("\n  ")}
 return r;
 }
-vec2 vI(uint index, uint ic) {
-uint i = sC(index, aq(ic, 0u));
-uint x = reverseBits(iA(i, aq(ic, 1u)));
-uint y = sC(rb(i), aq(ic, 2u));
+vec2 vP(uint index, uint ij) {
+uint i = sK(index, aq(ij, 0u));
+uint x = reverseBits(iE(i, aq(ij, 1u)));
+uint y = sK(rl(i), aq(ij, 2u));
 return vec2(float(x >> 8u), float(y >> 8u)) * (1.0 / 16777216.0);
 }
-uint tp(uvec2 p) {
+uint tB(uvec2 p) {
 uvec2 v = p & uvec2(255u);
 v = (v | (v << uvec2(4u))) & uvec2(0x0f0fu);
 v = (v | (v << uvec2(2u))) & uvec2(0x3333u);
@@ -66,27 +66,27 @@ v = (v | (v << uvec2(1u))) & uvec2(0x5555u);
 return v.x | (v.y << 1u);
 }
 ${zSobolPackedPermutations.map((v, i) => `const uint Z_PERM_${i} = ${v}u;`).join("\n")}
-uint km(uint tu) {
-uint group = tu >> 2u;
+uint kw(uint tE) {
+uint group = tE >> 2u;
 uint word = Z_PERM_5;
 ${[0, 1, 2, 3, 4].map(i => `word = group == ${i}u ? Z_PERM_${i} : word;`).join("\n  ")}
-return (word >> ((tu & 3u) * 8u)) & 255u;
+return (word >> ((tE & 3u) * 8u)) & 255u;
 }
-uint pO(uint kE, uint dim, uint logSPP) {
+uint pW(uint kN, uint dim, uint logSPP) {
 uint odd = logSPP & 1u;
-uint uf = 8u + ((logSPP + 1u) >> 1u);
+uint um = 8u + ((logSPP + 1u) >> 1u);
 uint result = 0u;
-for (int digit = int(uf) - 1; digit >= int(odd); digit--) {
+for (int digit = int(um) - 1; digit >= int(odd); digit--) {
 uint shift = 2u*uint(digit) - odd;
 
-uint sj = 0u;
-if (shift < 30u) { sj = kE >> (shift + 2u); }
-uint tu = (eg(sj ^ (0x55555555u * dim)) >> 24u) % 24u;
-uint d = (kE >> shift) & 3u;
-result |= ((km(tu) >> (2u*d)) & 3u) << shift;
+uint st = 0u;
+if (shift < 30u) { st = kN >> (shift + 2u); }
+uint tE = (eg(st ^ (0x55555555u * dim)) >> 24u) % 24u;
+uint d = (kN >> shift) & 3u;
+result |= ((kw(tE) >> (2u*d)) & 3u) << shift;
 }
 if (odd != 0u) {
-result |= (kE & 1u) ^ (eg((kE >> 1u) ^ (0x55555555u * dim)) & 1u);
+result |= (kN & 1u) ^ (eg((kN >> 1u) ^ (0x55555555u * dim)) & 1u);
 }
 return result;
 }
@@ -97,62 +97,62 @@ uint cw(uint slot) {
 return CAMERA_BEVEL_BASE + uint(BEVEL_SAMPLES) + cF * BOUNCE_STRIDE + slot;
 }
 
-uvec4 hh;
-uint hi;
-bool fv = false;
-bool df = false;
-uint dE;
-uint gq;
-vec2 eN;
+uvec4 hl;
+uint hm;
+bool fC = false;
+bool dg = false;
+uint dF;
+uint gv;
+vec2 eQ;
 void dw(uint dim) {
 
-uint jW = bc.x + bc.y * uint(round(1.0 / pixelSize.x));
-uvec4 key = uvec4(dim, bd, jW, uint(sequenceSeed));
-if (fv && all(equal(hh, key)) && hi == uint(zSobolLogSPP)) { return; }
-hh = key; hi = uint(zSobolLogSPP);
-fv = true; df = false;
-uint ic = aq(aq(jW, dim), uint(sequenceSeed));
+uint kd = bc.x + bc.y * uint(round(1.0 / pixelSize.x));
+uvec4 key = uvec4(dim, bd, kd, uint(sequenceSeed));
+if (fC && all(equal(hl, key)) && hm == uint(zSobolLogSPP)) { return; }
+hl = key; hm = uint(zSobolLogSPP);
+fC = true; dg = false;
+uint ij = aq(aq(kd, dim), uint(sequenceSeed));
 uint index = bd;
 if (samplingPattern == 1) {
 uint logSPP = uint(zSobolLogSPP);
 if (index == 0u) { logSPP = 0u; }
 else { index -= 1u; }
 
-uint iW = index >> logSPP;
+uint jb = index >> logSPP;
 uint mask = (1u << logSPP) - 1u;
-uint kE = (tp(bc) << logSPP) | (index & mask);
-index = pO(kE, dim, logSPP);
+uint kN = (tB(bc) << logSPP) | (index & mask);
+index = pW(kN, dim, logSPP);
 uvec2 tile = bc >> uvec2(8u);
-ic = aq(aq(dim, uint(sequenceSeed)), aq(tile.x, tile.y));
+ij = aq(aq(dim, uint(sequenceSeed)), aq(tile.x, tile.y));
 
-if (bd != 0u) { iW += 1u; }
-ic = aq(ic, iW);
+if (bd != 0u) { jb += 1u; }
+ij = aq(ij, jb);
 }
-dE = sC(index, aq(ic, 0u));
-gq = ic;
-uint x = reverseBits(iA(dE, aq(ic, 1u)));
-eN.x = float(x >> 8u) * (1.0 / 16777216.0);
+dF = sK(index, aq(ij, 0u));
+gv = ij;
+uint x = reverseBits(iE(dF, aq(ij, 1u)));
+eQ.x = float(x >> 8u) * (1.0 / 16777216.0);
 }
-vec2 kJ(uint dim) {
+vec2 kS(uint dim) {
 dw(dim);
-if (!df) {
-uint y = sC(rb(dE), aq(gq, 2u));
-eN.y = float(y >> 8u) * (1.0 / 16777216.0);
-df = true;
+if (!dg) {
+uint y = sK(rl(dF), aq(gv, 2u));
+eQ.y = float(y >> 8u) * (1.0 / 16777216.0);
+dg = true;
 }
-return EPS + (1.0 - 2.0*EPS) * eN;
+return EPS + (1.0 - 2.0*EPS) * eQ;
 }
 float dz(uint dim) {
 if (samplingPattern == 2) { return EPS + (1.0 - 2.0*EPS)*rand(); }
 dw(dim);
-return EPS + (1.0 - 2.0*EPS) * eN.x;
+return EPS + (1.0 - 2.0*EPS) * eQ.x;
 }
-vec2 fk(uint dim) {
+vec2 fp(uint dim) {
 if (samplingPattern == 2) {
 float x = dz(dim); float y = dz(dim);
 return vec2(x,y);
 }
-return kJ(dim);
+return kS(dim);
 }
 
 float eo(uint slot) {
@@ -160,10 +160,10 @@ uint dim = aq(aq(cF, slot), em) | 0x80000000u;
 em += 1u;
 if (samplingPattern == 2) { return EPS + (1.0 - 2.0*EPS)*rand(); }
 
-uint jW = bc.x + bc.y * uint(round(1.0 / pixelSize.x));
-uint ic = aq(aq(jW, dim), uint(sequenceSeed));
-uint i = sC(bd, aq(ic, 0u));
-uint x = reverseBits(iA(i, aq(ic, 1u)));
+uint kd = bc.x + bc.y * uint(round(1.0 / pixelSize.x));
+uint ij = aq(aq(kd, dim), uint(sequenceSeed));
+uint i = sK(bd, aq(ij, 0u));
+uint x = reverseBits(iE(i, aq(ij, 1u)));
 return EPS + (1.0 - 2.0*EPS) * (float(x >> 8u) * (1.0 / 16777216.0));
 }
 `;

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

@@ -9,16 +9,16 @@ vec4 textureLinear(sampler2D map, vec2 uv) {
 return texture(map, uv);
 #else
 vec2 size = vec2(textureSize(map, 0));
-vec2 pS = 1.0 / size;
+vec2 qa = 1.0 / size;
 
 uv = uv * size - 0.5;
 vec2 f = fract(uv);
 uv = floor(uv) + 0.5;
 
-vec4 s1 = texture(map, (uv + vec2(0, 0)) * pS);
-vec4 s2 = texture(map, (uv + vec2(1, 0)) * pS);
-vec4 s3 = texture(map, (uv + vec2(0, 1)) * pS);
-vec4 s4 = texture(map, (uv + vec2(1, 1)) * pS);
+vec4 s1 = texture(map, (uv + vec2(0, 0)) * qa);
+vec4 s2 = texture(map, (uv + vec2(1, 0)) * qa);
+vec4 s3 = texture(map, (uv + vec2(0, 1)) * qa);
+vec4 s4 = texture(map, (uv + vec2(1, 1)) * qa);
 
 return mix(mix(s1, s2, f.x), mix(s3, s4, f.x), f.y);
 #endif

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

@@ -8,12 +8,12 @@ float phi = acos(n.y) / PI;
 return vec2(theta, 1.0 - phi);
 }
 
-vec2 iM(vec3 pos, vec3 normal, vec2 uvScale) {
-vec3 dm = abs(normal);
+vec2 iR(vec3 pos, vec3 normal, vec2 uvScale) {
+vec3 dn = abs(normal);
 vec2 uv = vec2(0.0);
-if (dm.x > dm.y && dm.x > dm.z) {
+if (dn.x > dn.y && dn.x > dn.z) {
 uv = pos.yz;
-} else if (dm.y > dm.x && dm.y > dm.z) {
+} else if (dn.y > dn.x && dn.y > dn.z) {
 uv = pos.xz;
 } else {
 uv = pos.xy;
@@ -53,18 +53,18 @@ return fract(uv * uvScale);
 
 
 
-vec2 hz(vec3 pos, vec3 normal) {
+vec2 hD(vec3 pos, vec3 normal) {
 float theta = atan(pos.z, pos.x) / (2.0 * PI) + 0.5;
 return vec2(theta, pos.y);
 }
 
-vec2 gC(int fh, vec3 pos, vec3 normal, vec2 uvScale) {
-if (fh == ${uvProjectionConstants.triplanar + ''}) {
-return iM(pos, normal, uvScale);
-} else if (fh == ${uvProjectionConstants.spherical + ''}) {
+vec2 gI(int fk, vec3 pos, vec3 normal, vec2 uvScale) {
+if (fk == ${uvProjectionConstants.triplanar + ''}) {
+return iR(pos, normal, uvScale);
+} else if (fk == ${uvProjectionConstants.spherical + ''}) {
 return sphericalProjection(pos) * uvScale;
-} else if (fh == ${uvProjectionConstants.cylindrical + ''}) {
-return hz(pos, normal) * uvScale;
+} else if (fk == ${uvProjectionConstants.cylindrical + ''}) {
+return hD(pos, normal) * uvScale;
 }
 return vec2(0.0);
 }

package/lib/renderer/glsl/depthQuery.frag.js

@@ -33,18 +33,18 @@ if (any(lessThan(uv, vec2(0.0))) || any(greaterThan(uv, vec2(1.0)))) return;
 vec4 origin = viewProjectionInv * vec4(uv * 2.0 - 1.0, -1.0, 1.0);
 vec4 target = viewProjectionInv * vec4(uv * 2.0 - 1.0, 1.0, 1.0);
 Ray ray;
-iw(ray, origin.xyz / origin.w, normalize(target.xyz * origin.w - origin.xyz * target.w));
+iC(ray, origin.xyz / origin.w, normalize(target.xyz * origin.w - origin.xyz * target.w));
 vec3 eye = viewInv[3].xyz;
-vec3 nY = -normalize(viewInv[2].xyz);
+vec3 oj = -normalize(viewInv[2].xyz);
 ad si;
 si.triangleIndex = -1;
 for (int layer = 0; layer < 32; layer++) {
-cY(ray, si, false);
+cZ(ray, si, false);
 if (!si.hit) return;
 J material;
-eT(material, si.materialIndex, si.uv, si.uv1, si.instanceIndex);
+eX(material, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
 if (material.materialType != SHADOW_CATCHER && material.alpha > 0.0) {
-out_depth.r = max(dot(si.position - eye, nY), 0.0);
+out_depth.r = max(dot(si.position - eye, oj), 0.0);
 return;
 }
 ray.o = si.position + ray.d * (EPS * 0.02);

package/lib/renderer/glsl/depthQuery.frag.js.map

@@ -1 +1 @@
-{"version":3,"file":"depthQuery.frag.js","sourceRoot":"","sources":["../../../src/renderer/glsl/depthQuery.frag.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,MAAM,MAAM,yBAAyB,CAAC;AAC7C,OAAO,IAAI,MAAM,+BAA+B,CAAC;AACjD,OAAO,SAAS,MAAM,iCAAiC,CAAC;AACxD,OAAO,SAAS,MAAM,4BAA4B,CAAC;AACnD,OAAO,YAAY,MAAM,+BAA+B,CAAC;AACzD,OAAO,MAAM,MAAM,yBAAyB,CAAC;AAC7C,OAAO,IAAI,MAAM,uBAAuB,CAAC;AAEzC,eAAe,IAAI,cAAc,CAAC;IAChC,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE,CAAC,OAAO,CAAC;IACtC,OAAO,EAAE,EAAE,gBAAgB,EAAE,IAAI,EAAE;IACnC,QAAQ,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,CAAC;IAC9C,QAAQ,EAAE;QACR,SAAS,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;QACjC,iBAAiB,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;QACzC,OAAO,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;KAChC;IACD,IAAI,EAAE,UAAU,CAAC;EACjB,MAAM;EACN,IAAI;EACJ,MAAM,CAAC,IAAI;EACX,IAAI,CAAC,IAAI;EACT,YAAY;EACZ,SAAS,CAAC,IAAI;EACd,SAAS,CAAC,IAAI;;;yCAG2B,iBAAiB,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;CAwB/D;CACA,CAAC,CAAC","sourcesContent":["import { FragmentShader, Shader } from '../shader.js';\nimport { DEPTH_SAMPLE_GRID } from '../depthQuery.js';\nimport common from './chunks/common.glsl.js';\nimport core from './chunks/rayTraceCore.glsl.js';\nimport materials from './chunks/materialBuffer.glsl.js';\nimport intersect from './chunks/intersect.glsl.js';\nimport uvProjection from './chunks/uvProjection.glsl.js';\nimport random from './chunks/random.glsl.js';\nimport rand from './chunks/rand.glsl.js';\n\nexport default new FragmentShader({\n  name: 'depthQuery', outputs: ['depth'],\n  defines: { DEPTH_QUERY_MODE: true },\n  includes: [core, materials, intersect, random],\n  uniforms: {\n    depthArea: Shader.uniform('vec4'),\n    viewProjectionInv: Shader.uniform('mat4'),\n    viewInv: Shader.uniform('mat4')\n  },\n  main: /* glsl */ `\n${common}\n${rand}\n${random.main}\n${core.main}\n${uvProjection}\n${materials.main}\n${intersect.main}\n\nvoid main() {\n  vec2 offset = floor(gl_FragCoord.xy) / ${DEPTH_SAMPLE_GRID - 1}.0 * 2.0 - 1.0;\n  vec2 uv = depthArea.xy + depthArea.zw * offset * vec2(1.0, -1.0);\n  out_depth = vec4(0.0);\n  if (any(lessThan(uv, vec2(0.0))) || any(greaterThan(uv, vec2(1.0)))) return;\n  vec4 origin = viewProjectionInv * vec4(uv * 2.0 - 1.0, -1.0, 1.0);\n  vec4 target = viewProjectionInv * vec4(uv * 2.0 - 1.0, 1.0, 1.0);\n  Ray ray;\n  initRay(ray, origin.xyz / origin.w, normalize(target.xyz * origin.w - origin.xyz * target.w));\n  vec3 eye = viewInv[3].xyz;\n  vec3 forward = -normalize(viewInv[2].xyz);\n  SurfaceInteraction si;\n  si.triangleIndex = -1;\n  for (int layer = 0; layer < 32; layer++) {\n    intersectScene(ray, si, false);\n    if (!si.hit) return;\n    OpenPbrResolvedMaterial material;\n    getMaterial(material, si.materialIndex, si.uv, si.uv1, si.instanceIndex);\n    if (material.materialType != SHADOW_CATCHER && material.alpha > 0.0) {\n      out_depth.r = max(dot(si.position - eye, forward), 0.0);\n      return;\n    }\n    ray.o = si.position + ray.d * (EPS * 0.02);\n  }\n}\n`\n});\n"]}
+{"version":3,"file":"depthQuery.frag.js","sourceRoot":"","sources":["../../../src/renderer/glsl/depthQuery.frag.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,MAAM,MAAM,yBAAyB,CAAC;AAC7C,OAAO,IAAI,MAAM,+BAA+B,CAAC;AACjD,OAAO,SAAS,MAAM,iCAAiC,CAAC;AACxD,OAAO,SAAS,MAAM,4BAA4B,CAAC;AACnD,OAAO,YAAY,MAAM,+BAA+B,CAAC;AACzD,OAAO,MAAM,MAAM,yBAAyB,CAAC;AAC7C,OAAO,IAAI,MAAM,uBAAuB,CAAC;AAEzC,eAAe,IAAI,cAAc,CAAC;IAChC,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE,CAAC,OAAO,CAAC;IACtC,OAAO,EAAE,EAAE,gBAAgB,EAAE,IAAI,EAAE;IACnC,QAAQ,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,CAAC;IAC9C,QAAQ,EAAE;QACR,SAAS,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;QACjC,iBAAiB,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;QACzC,OAAO,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;KAChC;IACD,IAAI,EAAE,UAAU,CAAC;EACjB,MAAM;EACN,IAAI;EACJ,MAAM,CAAC,IAAI;EACX,IAAI,CAAC,IAAI;EACT,YAAY;EACZ,SAAS,CAAC,IAAI;EACd,SAAS,CAAC,IAAI;;;yCAG2B,iBAAiB,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;CAwB/D;CACA,CAAC,CAAC","sourcesContent":["import { FragmentShader, Shader } from '../shader.js';\nimport { DEPTH_SAMPLE_GRID } from '../depthQuery.js';\nimport common from './chunks/common.glsl.js';\nimport core from './chunks/rayTraceCore.glsl.js';\nimport materials from './chunks/materialBuffer.glsl.js';\nimport intersect from './chunks/intersect.glsl.js';\nimport uvProjection from './chunks/uvProjection.glsl.js';\nimport random from './chunks/random.glsl.js';\nimport rand from './chunks/rand.glsl.js';\n\nexport default new FragmentShader({\n  name: 'depthQuery', outputs: ['depth'],\n  defines: { DEPTH_QUERY_MODE: true },\n  includes: [core, materials, intersect, random],\n  uniforms: {\n    depthArea: Shader.uniform('vec4'),\n    viewProjectionInv: Shader.uniform('mat4'),\n    viewInv: Shader.uniform('mat4')\n  },\n  main: /* glsl */ `\n${common}\n${rand}\n${random.main}\n${core.main}\n${uvProjection}\n${materials.main}\n${intersect.main}\n\nvoid main() {\n  vec2 offset = floor(gl_FragCoord.xy) / ${DEPTH_SAMPLE_GRID - 1}.0 * 2.0 - 1.0;\n  vec2 uv = depthArea.xy + depthArea.zw * offset * vec2(1.0, -1.0);\n  out_depth = vec4(0.0);\n  if (any(lessThan(uv, vec2(0.0))) || any(greaterThan(uv, vec2(1.0)))) return;\n  vec4 origin = viewProjectionInv * vec4(uv * 2.0 - 1.0, -1.0, 1.0);\n  vec4 target = viewProjectionInv * vec4(uv * 2.0 - 1.0, 1.0, 1.0);\n  Ray ray;\n  initRay(ray, origin.xyz / origin.w, normalize(target.xyz * origin.w - origin.xyz * target.w));\n  vec3 eye = viewInv[3].xyz;\n  vec3 forward = -normalize(viewInv[2].xyz);\n  SurfaceInteraction si;\n  si.triangleIndex = -1;\n  for (int layer = 0; layer < 32; layer++) {\n    intersectScene(ray, si, false);\n    if (!si.hit) return;\n    OpenPbrResolvedMaterial material;\n    getMaterial(material, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);\n    if (material.materialType != SHADOW_CATCHER && material.alpha > 0.0) {\n      out_depth.r = max(dot(si.position - eye, forward), 0.0);\n      return;\n    }\n    ray.o = si.position + ray.d * (EPS * 0.02);\n  }\n}\n`\n});\n"]}