@meimu/mutracer 0.2.0 → 0.3.1

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

@@ -1 +1 @@
-{"version":3,"file":"sampleLight.glsl.js","sourceRoot":"","sources":["../../../../src/renderer/glsl/chunks/sampleLight.glsl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAEvC,eAAe,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2PlB,CAAC","sourcesContent":["import { glsl } from '../../shader.js';\n\nexport default glsl`\n#ifdef NUM_LIGHTS\nvoid light_sample_sphere(\n  in Light light,\n  in vec3 shadingPoint,\n  in vec2 samplePoint,\n  inout LightSampleRec result\n) {\n  vec3 toCenter = light.position - shadingPoint;\n  float centerDistance = length(toCenter);\n  if (light.radius <= 0.0) {\n    if (centerDistance <= 1e-6) {\n      result.direction = vec3(0.0, 0.0, 1.0);\n      result.normal = vec3(0.0, 0.0, -1.0);\n      result.dist = 0.0;\n      result.pdf = 1.0;\n      result.emission = vec3(0.0);\n      result.isDelta = true;\n      return;\n    }\n    result.direction = toCenter / centerDistance;\n    result.normal = -result.direction;\n    result.dist = centerDistance;\n    result.pdf = 1.0;\n    result.emission = light.emission / max(centerDistance * centerDistance, 1e-8);\n    result.isDelta = true;\n    return;\n  }\n  float radius = max(light.radius, 1e-6);\n  result.isDelta = false;\n  vec3 direction;\n\n  if (centerDistance <= radius) {\n    float z = 1.0 - 2.0 * samplePoint.x;\n    float radial = sqrt(max(0.0, 1.0 - z * z));\n    float azimuth = TWOPI * samplePoint.y;\n    direction = vec3(radial * cos(azimuth), radial * sin(azimuth), z);\n    result.pdf = INV4PI;\n  }\n  else {\n    vec3 axis = toCenter / centerDistance;\n    float sineLimitSquared = min(\n      1.0,\n      radius * radius / (centerDistance * centerDistance)\n    );\n    float cosineLimit = sqrt(max(0.0, 1.0 - sineLimitSquared));\n    float cosine = mix(1.0, cosineLimit, samplePoint.x);\n    float sine = sqrt(max(0.0, 1.0 - cosine * cosine));\n    float azimuth = TWOPI * samplePoint.y;\n    vec3 tangent;\n    vec3 bitangent;\n    sampling_orthonormal_basis(axis, tangent, bitangent);\n    direction = axis * cosine\n      + tangent * (sine * cos(azimuth))\n      + bitangent * (sine * sin(azimuth));\n    result.pdf = 1.0 / max(TWOPI * (1.0 - cosineLimit), 1e-8);\n  }\n\n  float projectedCenter = dot(direction, toCenter);\n  float discriminant = projectedCenter * projectedCenter\n    - dot(toCenter, toCenter) + radius * radius;\n  float root = sqrt(max(0.0, discriminant));\n  float nearDistance = projectedCenter - root;\n  float farDistance = projectedCenter + root;\n  result.dist = nearDistance > 1e-6 ? nearDistance : farDistance;\n  result.direction = direction;\n  vec3 surfacePoint = shadingPoint + direction * result.dist;\n  result.normal = normalize(surfacePoint - light.position);\n  result.emission = light.emission;\n}\n\nvoid light_apply_rect_texture(\n  in Light light,\n  in vec3 surfacePoint,\n  in vec3 lowerLeft,\n  inout LightSampleRec result\n) {\n#ifdef NUM_MAPS\n  if (light.textureIndex >= 0) {\n    float width = length(light.u);\n    float height = length(light.v);\n    vec3 relative = surfacePoint - lowerLeft;\n    vec2 uv = vec2(\n      dot(relative, light.u / width) / width,\n      dot(relative, light.v / height) / height\n    );\n    result.emission *= sampleMap(light.textureIndex, uv).rgb;\n  }\n#endif\n}\n\nvoid light_sample_rect(\n  in Light light,\n  in vec3 shadingPoint,\n  in vec2 samplePoint,\n  inout LightSampleRec result\n) {\n  vec3 normal = normalize(cross(light.u, light.v));\n  vec3 lowerLeft = light.position - 0.5 * (light.u + light.v);\n  float spread = clamp(light.spread, 0.0, 1.0);\n\n  if (spread <= 0.001) {\n    float planeDistance = dot(normal, shadingPoint - light.position);\n    vec3 surfacePoint = shadingPoint - normal * planeDistance;\n    vec3 relative = surfacePoint - lowerLeft;\n    float width = length(light.u);\n    float height = length(light.v);\n    vec2 uv = vec2(\n      dot(relative, light.u / width) / width,\n      dot(relative, light.v / height) / height\n    );\n    if (planeDistance <= 0.0 || any(lessThan(uv, vec2(0.0)))\n      || any(greaterThan(uv, vec2(1.0)))) {\n      result.emission = vec3(0.0);\n      result.pdf = 0.0;\n      return;\n    }\n    result.direction = -normal;\n    result.dist = planeDistance;\n    result.normal = normal;\n    result.emission = light.emission;\n    result.pdf = 1.0;\n    result.isDelta = true;\n    light_apply_rect_texture(light, surfacePoint, lowerLeft, result);\n    return;\n  }\n\n  vec3 surfacePoint = lowerLeft\n    + light.u * samplePoint.x\n    + light.v * samplePoint.y;\n  vec3 offset = surfacePoint - shadingPoint;\n  float distanceSquared = dot(offset, offset);\n  result.dist = sqrt(distanceSquared);\n  result.direction = offset / result.dist;\n  result.normal = normal;\n  float emitterCosine = dot(-result.direction, normal);\n  float spreadCosine = cos(0.5 * PI * spread);\n  if (emitterCosine <= 0.0 || emitterCosine < spreadCosine) {\n    result.emission = vec3(0.0);\n    result.pdf = 0.0;\n    return;\n  }\n  result.emission = light.emission;\n  result.pdf = distanceSquared / max(light.area * emitterCosine, 1e-8);\n  light_apply_rect_texture(light, surfacePoint, lowerLeft, result);\n}\n\nvoid light_sample_directional(\n  in Light light,\n  in vec3 shadingPoint,\n  inout LightSampleRec result\n) {\n  result.direction = normalize(-light.u);\n  result.normal = -result.direction;\n  result.emission = light.emission;\n  result.dist = INF;\n  result.pdf = 1.0;\n  result.isDelta = true;\n}\n\nvoid light_sample_spot(\n  in Light light,\n  in vec3 shadingPoint,\n  in vec2 samplePoint,\n  inout LightSampleRec result\n) {\n  light_sample_sphere(light, shadingPoint, samplePoint, result);\n  vec3 surfacePoint = shadingPoint + result.direction * result.dist;\n  result.emission *= evaluateSpotEmissionMultiplier(\n    light,\n    normalize(shadingPoint - surfacePoint)\n  );\n}\n\nvoid sampleAnalyticLight(\n  in Light light,\n  in vec3 shadingPoint,\n  in vec2 samplePoint,\n  inout LightSampleRec result\n) {\n  int lightType = int(light.type);\n#ifdef HAS_RECT_LIGHTS\n  if (lightType == RECT_LIGHT) {\n    light_sample_rect(light, shadingPoint, samplePoint, result);\n    return;\n  }\n#endif\n#ifdef HAS_SPHERE_LIGHTS\n  if (lightType == SPHERE_LIGHT) {\n    light_sample_sphere(light, shadingPoint, samplePoint, result);\n    return;\n  }\n#endif\n#ifdef HAS_SPOT_LIGHTS\n  if (lightType == SPOT_LIGHT) {\n    light_sample_spot(light, shadingPoint, samplePoint, result);\n    return;\n  }\n#endif\n#ifdef HAS_DIRECTIONAL_LIGHTS\n  if (lightType == DIRECTIONAL_LIGHT) {\n    light_sample_directional(light, shadingPoint, result);\n  }\n#endif\n}\n#endif\n\nvoid sampleEnvLight(in vec2 samplePoint, inout LightSampleRec result) {\n  vec2 uv;\n  result.direction = sampleEnvmap(samplePoint, uv, result.pdf);\n  result.emission = textureLinear(envMap, uv).rgb;\n  result.dist = INF;\n}\n\nvoid sampleLight(\n  in vec3 shadingPoint,\n  in vec3 randomSampleValue,\n  inout LightSampleRec result,\n  bool distByIntensity\n) {\n  result.isDelta = false;\n  float selector = randomSampleValue.z;\n  bool choseEnvironment = false;\n#ifdef USE_ENVMAP\n  choseEnvironment = selector < envLightSelectionPmf;\n  if (choseEnvironment) {\n    sampleEnvLight(randomSampleValue.xy, result);\n    result.pdf *= envLightSelectionPmf;\n  }\n#endif\n\n#ifdef NUM_LIGHTS\n  if (!choseEnvironment) {\n    int selectedIndex = NUM_LIGHTS - 1;\n    for (int index = 0; index < NUM_LIGHTS; index++) {\n      if (selector < fetchLight(index).selectionCdf) {\n        selectedIndex = index;\n        break;\n      }\n    }\n    Light selectedLight = fetchLight(selectedIndex);\n    sampleAnalyticLight(\n      selectedLight,\n      shadingPoint,\n      randomSampleValue.xy,\n      result\n    );\n    result.pdf *= selectedLight.selectionPmf;\n  }\n#endif\n}\n`;\n"]}
+{"version":3,"file":"sampleLight.glsl.js","sourceRoot":"","sources":["../../../../src/renderer/glsl/chunks/sampleLight.glsl.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,yBAAyB,CAAC;AAC/C,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAEvC,eAAe,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2NjB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6CT,CAAC","sourcesContent":["import emissive from './emissiveLight.glsl.js';\nimport { glsl } from '../../shader.js';\n\nexport default glsl`\n#ifdef NUM_LIGHTS\nvoid light_sample_sphere(\n  in Light light,\n  in vec3 shadingPoint,\n  in vec2 samplePoint,\n  inout LightSampleRec result\n) {\n  vec3 toCenter = light.position - shadingPoint;\n  float centerDistance = length(toCenter);\n  if (light.radius <= 0.0) {\n    if (centerDistance <= 1e-6) {\n      result.direction = vec3(0.0, 0.0, 1.0);\n      result.normal = vec3(0.0, 0.0, -1.0);\n      result.dist = 0.0;\n      result.pdf = 1.0;\n      result.emission = vec3(0.0);\n      result.isDelta = true;\n      return;\n    }\n    result.direction = toCenter / centerDistance;\n    result.normal = -result.direction;\n    result.dist = centerDistance;\n    result.pdf = 1.0;\n    result.emission = light.emission / max(centerDistance * centerDistance, 1e-8);\n    result.isDelta = true;\n    return;\n  }\n  float radius = max(light.radius, 1e-6);\n  result.isDelta = false;\n  vec3 direction;\n\n  if (centerDistance <= radius) {\n    float z = 1.0 - 2.0 * samplePoint.x;\n    float radial = sqrt(max(0.0, 1.0 - z * z));\n    float azimuth = TWOPI * samplePoint.y;\n    direction = vec3(radial * cos(azimuth), radial * sin(azimuth), z);\n    result.pdf = INV4PI;\n  }\n  else {\n    vec3 axis = toCenter / centerDistance;\n    float sineLimitSquared = min(\n      1.0,\n      radius * radius / (centerDistance * centerDistance)\n    );\n    float cosineLimit = sqrt(max(0.0, 1.0 - sineLimitSquared));\n    // Keep the small solid angle and sampled sine without subtracting\n    // nearly equal floats; otherwise small emitters produce irradiance bands.\n    float oneMinusCosineLimit = sineLimitSquared / (1.0 + cosineLimit);\n    float oneMinusCosine = samplePoint.x * oneMinusCosineLimit;\n    float cosine = 1.0 - oneMinusCosine;\n    float sine = sqrt(max(0.0, oneMinusCosine * (2.0 - oneMinusCosine)));\n    float azimuth = TWOPI * samplePoint.y;\n    vec3 tangent;\n    vec3 bitangent;\n    sampling_orthonormal_basis(axis, tangent, bitangent);\n    direction = axis * cosine\n      + tangent * (sine * cos(azimuth))\n      + bitangent * (sine * sin(azimuth));\n    result.pdf = 1.0 / max(TWOPI * oneMinusCosineLimit, 1e-8);\n  }\n\n  float projectedCenter = dot(direction, toCenter);\n  float discriminant = projectedCenter * projectedCenter\n    - dot(toCenter, toCenter) + radius * radius;\n  float root = sqrt(max(0.0, discriminant));\n  float nearDistance = projectedCenter - root;\n  float farDistance = projectedCenter + root;\n  result.dist = nearDistance > 1e-6 ? nearDistance : farDistance;\n  result.direction = direction;\n  vec3 surfacePoint = shadingPoint + direction * result.dist;\n  result.normal = normalize(surfacePoint - light.position);\n  result.emission = light.emission;\n}\n\nvoid light_apply_rect_texture(\n  in Light light,\n  in vec3 surfacePoint,\n  in vec3 lowerLeft,\n  inout LightSampleRec result\n) {\n#ifdef NUM_MAPS\n  if (light.textureIndex >= 0) {\n    float width = length(light.u);\n    float height = length(light.v);\n    vec3 relative = surfacePoint - lowerLeft;\n    vec2 uv = vec2(\n      dot(relative, light.u / width) / width,\n      dot(relative, light.v / height) / height\n    );\n    result.emission *= sampleMap(light.textureIndex, uv).rgb;\n  }\n#endif\n}\n\nvoid light_sample_rect(\n  in Light light,\n  in vec3 shadingPoint,\n  in vec2 samplePoint,\n  inout LightSampleRec result\n) {\n  vec3 normal = normalize(cross(light.u, light.v));\n  vec3 lowerLeft = light.position - 0.5 * (light.u + light.v);\n  float spread = clamp(light.spread, 0.0, 1.0);\n\n  if (spread <= 0.001) {\n    float planeDistance = dot(normal, shadingPoint - light.position);\n    vec3 surfacePoint = shadingPoint - normal * planeDistance;\n    vec3 relative = surfacePoint - lowerLeft;\n    float width = length(light.u);\n    float height = length(light.v);\n    vec2 uv = vec2(\n      dot(relative, light.u / width) / width,\n      dot(relative, light.v / height) / height\n    );\n    if (planeDistance <= 0.0 || any(lessThan(uv, vec2(0.0)))\n      || any(greaterThan(uv, vec2(1.0)))) {\n      result.emission = vec3(0.0);\n      result.pdf = 0.0;\n      return;\n    }\n    result.direction = -normal;\n    result.dist = planeDistance;\n    result.normal = normal;\n    result.emission = light.emission;\n    result.pdf = 1.0;\n    result.isDelta = true;\n    light_apply_rect_texture(light, surfacePoint, lowerLeft, result);\n    return;\n  }\n\n  vec3 surfacePoint = lowerLeft\n    + light.u * samplePoint.x\n    + light.v * samplePoint.y;\n  vec3 offset = surfacePoint - shadingPoint;\n  float distanceSquared = dot(offset, offset);\n  result.dist = sqrt(distanceSquared);\n  result.direction = offset / result.dist;\n  result.normal = normal;\n  float emitterCosine = dot(-result.direction, normal);\n  float spreadCosine = cos(0.5 * PI * spread);\n  if (emitterCosine <= 0.0 || emitterCosine < spreadCosine) {\n    result.emission = vec3(0.0);\n    result.pdf = 0.0;\n    return;\n  }\n  result.emission = light.emission;\n  result.pdf = distanceSquared / max(light.area * emitterCosine, 1e-8);\n  light_apply_rect_texture(light, surfacePoint, lowerLeft, result);\n}\n\nvoid light_sample_directional(\n  in Light light,\n  in vec3 shadingPoint,\n  inout LightSampleRec result\n) {\n  result.direction = normalize(-light.u);\n  result.normal = -result.direction;\n  result.emission = light.emission;\n  result.dist = INF;\n  result.pdf = 1.0;\n  result.isDelta = true;\n}\n\nvoid light_sample_spot(\n  in Light light,\n  in vec3 shadingPoint,\n  in vec2 samplePoint,\n  inout LightSampleRec result\n) {\n  light_sample_sphere(light, shadingPoint, samplePoint, result);\n  vec3 surfacePoint = shadingPoint + result.direction * result.dist;\n  result.emission *= evaluateSpotEmissionMultiplier(\n    light,\n    normalize(shadingPoint - surfacePoint)\n  );\n}\n\nvoid sampleAnalyticLight(\n  in Light light,\n  in vec3 shadingPoint,\n  in vec2 samplePoint,\n  inout LightSampleRec result\n) {\n  int lightType = int(light.type);\n#ifdef HAS_RECT_LIGHTS\n  if (lightType == RECT_LIGHT) {\n    light_sample_rect(light, shadingPoint, samplePoint, result);\n    return;\n  }\n#endif\n#ifdef HAS_SPHERE_LIGHTS\n  if (lightType == SPHERE_LIGHT) {\n    light_sample_sphere(light, shadingPoint, samplePoint, result);\n    return;\n  }\n#endif\n#ifdef HAS_SPOT_LIGHTS\n  if (lightType == SPOT_LIGHT) {\n    light_sample_spot(light, shadingPoint, samplePoint, result);\n    return;\n  }\n#endif\n#ifdef HAS_DIRECTIONAL_LIGHTS\n  if (lightType == DIRECTIONAL_LIGHT) {\n    light_sample_directional(light, shadingPoint, result);\n  }\n#endif\n}\n#endif\n\nvoid sampleEnvLight(in vec2 samplePoint, inout LightSampleRec result) {\n  vec2 uv;\n  result.direction = sampleEnvmap(samplePoint, uv, result.pdf);\n  result.emission = textureLinear(envMap, uv).rgb;\n  result.dist = INF;\n}\n\n#ifdef HAS_EMISSIVE_LIGHTS\n${emissive}\n#endif\n\nvoid sampleLight(\n  in vec3 shadingPoint,\n  in vec3 randomSampleValue,\n  inout LightSampleRec result,\n  bool distByIntensity\n) {\n#ifdef HAS_EMISSIVE_LIGHTS\n  sampleEmissiveSceneLight(shadingPoint,randomSampleValue,result);return;\n#endif\n  result.sourceType=0;result.sourceIndex=-1;\n  result.isDelta = false;\n  float selector = randomSampleValue.z;\n  bool choseEnvironment = false;\n#ifdef USE_ENVMAP\n  choseEnvironment = selector < envLightSelectionPmf;\n  if (choseEnvironment) {\n    sampleEnvLight(randomSampleValue.xy, result);\n    result.pdf *= envLightSelectionPmf;\n  }\n#endif\n\n#ifdef NUM_LIGHTS\n  if (!choseEnvironment) {\n    int selectedIndex = NUM_LIGHTS - 1;\n    for (int index = 0; index < NUM_LIGHTS; index++) {\n      if (selector < fetchLight(index).selectionCdf) {\n        selectedIndex = index;\n        break;\n      }\n    }\n    result.sourceType=2;result.sourceIndex=selectedIndex;\n    Light selectedLight = fetchLight(selectedIndex);\n    sampleAnalyticLight(\n      selectedLight,\n      shadingPoint,\n      randomSampleValue.xy,\n      result\n    );\n    result.pdf *= selectedLight.selectionPmf;\n  }\n#endif\n}\n`;\n"]}

package/lib/renderer/glsl/chunks/sampleMaterial.glsl.d.ts

@@ -1,2 +1,3 @@
+export declare function createSampleMaterialGlsl(fragments?: Readonly<Record<string, string>>, channelIndependentLight?: boolean): string;
 declare const _default: string;
 export default _default;

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

@@ -1,42 +1,64 @@
 // Estimate the direct lighting integral using multiple importance sampling
 // http://www.pbr-book.org/3ed-2018/Light_Transport_I_Surface_Reflection/Direct_Lighting.html#EstimatingtheDirectLightingIntegral
 import { glsl } from '../../shader.js';
-export default glsl `
-vec3 ta(SurfaceInteraction si, OpenPbrResolvedMaterial mat, ag prepared, inout Path aa, vec3 ffnormal, bool eM) {
-float lY = 1.0;
-vec3 lV = vec3(dZ(cE(LIGHT_POSITION)), dp(cE(LIGHT_SELECT)));
+export function createSampleMaterialGlsl(fragments = {}, channelIndependentLight = false) {
+    return glsl `
+float emissiveHitMisWeight(SurfaceInteraction si,Path path) {
+
+float Ar=dot(si.faceNormal,-path.ray.d);
+if(Ar<=0.0&&fetchMatData(si.materialIndex*MAT_DATA_SIZE+MAT_ROW_ALPHA).z<0.5)return 0.0;
+#ifdef HAS_EMISSIVE_LIGHTS
+if(!path.fromEye && emissiveWeightTotal>0.0) {
+vec3 emission=fetchMatData(si.materialIndex*MAT_DATA_SIZE+MAT_ROW_EMISSION).rgb;
+float value=dot(emission,vec3(.2126,.7152,.0722)),cosine=dot(si.faceNormal,-path.ray.d);
+if(value>0.0&&cosine>0.0){float d=distance(si.position,path.ray.o);return aG(path.scatteringPdf,value/emissiveWeightTotal*d*d/cosine);}
+}
+#endif
+return 1.0;
+}
+
+vec3 qY(SurfaceInteraction si, OpenPbrResolvedMaterial mat, OpenPbrPreparedBsdf prepared, inout Path path, vec3 ffnormal, bool isSurface) {
+float mz = 1.0;
+vec3 ob = vec3(sample2D(aX(LIGHT_POSITION)), sample1D(aX(LIGHT_SELECT)));
 
 LightSampleRec lightSample;
-sampleLight(si.position, lV, lightSample, false);
-lightSample.emission = aj(lightSample.emission, bp);
+sampleLight(si.position, ob, lightSample, false);${fragments['sample0'] ?? ''}
+${channelIndependentLight ? /* glsl */ `  if (dispersionWavelengths == 1) {
+lightSample.emission = sampling_spectral_rgb_filter(lightSample.emission, pathChannel);
+}` : /* glsl */ `  lightSample.emission = sampling_spectral_rgb_filter(lightSample.emission, pathChannel);`}
 
 vec3 lightDir = lightSample.direction;
-vec3 qY = -aa.ray.d;
-float fA = lightSample.pdf;
+vec3 sg = -path.ray.d;
+float lightPdf = lightSample.pdf;
 
 
 
 
 float cosThetaL = dot(ffnormal, lightDir);
 #ifdef USE_COAT_NORMAL_FRAMES
-if (eM && mat.coatNormalEnabled) { cosThetaL = dot(mat.geometricNormal, lightDir); }
+if (isSurface && mat.coatNormalEnabled) { cosThetaL = dot(mat.geometricNormal, lightDir); }
 #endif
 
-if (fA <= 0.0 || max(max(lightSample.emission.x, lightSample.emission.y), lightSample.emission.z) <= 0.0) {
+if (lightPdf <= 0.0 || max(max(lightSample.emission.x, lightSample.emission.y), lightSample.emission.z) <= 0.0) {
 return vec3(0.0);
 }
 
-float scatteringPdf = 0.0;
+${channelIndependentLight ? /* glsl */ `  
+
+if (dispersionWavelengths != 1) {
+lightSample.emission = sampling_spectral_rgb_filter(lightSample.emission, pathChannel);
+}
+` : ''}  float scatteringPdf = 0.0;
 vec3 f = vec3(0.0);
-if (eM) {
+if (isSurface) {
 if (cosThetaL <= 0.0 && mat.transmissionWeight <= 0.0 && mat.subsurfaceWeight <= 0.0) {
 return vec3(0.0);
 }
-f = bO(prepared, lightDir, scatteringPdf);
+f = openpbr_eval_prepared(prepared, lightDir, scatteringPdf);
 }
 else {
-scatteringPdf = bL(
-dot(qY, lightDir),
+scatteringPdf = ba(
+dot(sg, lightDir),
 si.mediumAnisotropy
 );
 f = vec3(scatteringPdf);
@@ -46,83 +68,89 @@ if (scatteringPdf <= 0.0 || max(max(f.x, f.y), f.z) <= 0.0) {
 return vec3(0.0);
 }
 
-Ray ns;
-vec3 hw = si.position + EPS * lightDir;
-if (eM) {
-const float ch = 0.1;
-float dL = dot(si.normal, lightDir);
+Ray oa;
+vec3 eY = si.position + EPS * lightDir;
+if (isSurface) {
+const float shadowTerminatorCutoff = 0.1;
+float dl = dot(si.normal, lightDir);
 #ifdef USE_COAT_NORMAL_FRAMES
-if (mat.coatNormalEnabled) { dL = dot(si.faceNormal, lightDir); }
+if (mat.coatNormalEnabled) { dl = dot(si.faceNormal, lightDir); }
 #endif
-vec3 geometricNormal = dL < 0.0 ? -si.faceNormal : si.faceNormal;
-dL = abs(dL);
-float iq = dot(geometricNormal, lightDir);
-float pq = dL < ch
+vec3 geometricNormal = dl < 0.0 ? -si.faceNormal : si.faceNormal;
+dl = abs(dl);
+float iw = dot(geometricNormal, lightDir);
+float qo = dl < shadowTerminatorCutoff
 ? clamp(
-2.0 - (iq + dL) / ch,
+2.0 - (iw + dl) / shadowTerminatorCutoff,
 0.0,
 1.0
 )
-: clamp(1.0 - iq / ch, 0.0, 1.0);
-hw += si.shadowOffset * pq;
+: clamp(1.0 - iw / shadowTerminatorCutoff, 0.0, 1.0);
+eY += si.shadowOffset * qo;
+}
+float rM=lightSample.dist-EPS;
+vec3 qS=lightDir;
+if(lightSample.sourceType==1){
+vec3 endpoint=si.position+lightDir*lightSample.dist+EPS*lightSample.normal;
+qS=normalize(endpoint-eY);rM=distance(endpoint,eY);
 }
-gC(ns, hw, lightDir);
-if (intersectSceneShadow(ns, lightSample.dist - EPS, si.triangleIndex)) {
+initRay(oa, eY, qS);
+if (intersectSceneShadow(oa, rM, si.triangleIndex)) {
 return vec3(0.0);
 }
 
 #ifdef USE_ENVMAP
 
 
-if (eM && cosThetaL < 0.0 && lV.z < envLightSelectionPmf) {
-vec4 background = cG(ns.o, lightDir);
-lightSample.emission = aj(background.rgb * background.a, bp);
+if (isSurface && cosThetaL < 0.0 && lightSample.sourceType == 0) {
+vec4 background = cq(oa.o, lightDir);
+lightSample.emission = sampling_spectral_rgb_filter(background.rgb * background.a, pathChannel);
 }
 #endif
 
 
 
-float fl = lightSample.isDelta
+float misWeight = lightSample.isDelta
 ? 1.0
-: aK(fA, scatteringPdf);
-return fl > 0.0
-? fl * lightSample.emission * f / fA
+: aG(lightPdf, scatteringPdf);
+${fragments['sample1'] ?? ''}  return misWeight > 0.0
+? misWeight * lightSample.emission * f / lightPdf
 : vec3(0.0);
 }
 
 #ifdef USE_COAT_NORMAL_FRAMES
-vec3 fT(vec3 qt, vec3 face, vec3 view) {
+vec3 fQ(vec3 ru, vec3 face, vec3 view) {
 bool front = dot(face, view) >= 0.0;
-vec3 vP = front ? face : -face;
-vec3 sc = front ? qt : -qt;
-if (dot(qt, face) <= 0.0 || dot(sc, view) <= 1e-6) { return vP; }
-return sc;
+vec3 yc = front ? face : -face;
+vec3 tv = front ? ru : -ru;
+if (dot(ru, face) <= 0.0 || dot(tv, view) <= 1e-6) { return yc; }
+return tv;
 }
 #endif
-void mL(inout SurfaceInteraction si, OpenPbrResolvedMaterial mat, inout Path aa) {
-vec3 vR = vec3(dZ(cE(BSDF_DIRECTION)), dp(cE(BSDF_LOBE)));
+void nB(inout SurfaceInteraction si, OpenPbrResolvedMaterial mat, inout Path path) {
+vec3 yh = vec3(sample2D(aX(BSDF_DIRECTION)), sample1D(aX(BSDF_LOBE)));
 #ifdef USE_COAT_NORMAL_FRAMES
-vec3 bK = si.faceNormal;
-vec3 nB = si.normal;
+vec3 bC = si.faceNormal;
+vec3 oh = si.normal;
 #endif
-float sO = -dot(si.faceNormal, aa.ray.d);
-float tV = -dot(si.normal, aa.ray.d);
+float uk = -dot(si.faceNormal, path.ray.d);
+float vH = -dot(si.normal, path.ray.d);
 if ((mat.transmissionWeight > 0.0 || mat.subsurfaceWeight > 0.0) && mat.thinWalled) {
 
-if (sO < 0.0) {
+if (uk < 0.0) {
 si.faceNormal = -si.faceNormal;
-sO = -sO;
+uk = -uk;
 }
-if (tV < 0.0) {
+if (vH < 0.0) {
 si.normal = -si.normal;
-tV = -tV;
+vH = -vH;
 }
 }
 
 
-bool qM = sO >= 0.0 && tV < 0.0;
-float ndv = qM ? sO : tV;
-vec3 normal = qM ? si.faceNormal : si.normal;
+bool rS = uk >= 0.0 && vH < 0.0;
+float ndv = rS ? uk : vH;
+vec3 normal = rS ? si.faceNormal : si.normal;
 
 mat.inside = ndv <= 0.0 && !mat.thinWalled;
 
@@ -130,140 +158,152 @@ mat.relativeIor = ndv > 0.0 ? (1.0 / mat.specularIor) : mat.specularIor;
 vec3 ffnormal = ndv >= 0.0 ? normal : -normal;
 #ifdef USE_COAT_NORMAL_FRAMES
 if (mat.coatNormalEnabled) {
-vec3 view = -aa.ray.d;
-float gp = dot(bK, view);
-mat.geometricNormal = gp >= 0.0 ? bK : -bK;
-ffnormal = fT(nB, bK, view);
-mat.coatNormal = fT(si.coatNormal, bK, view);
-mat.inside = gp <= 0.0 && !mat.thinWalled;
-mat.relativeIor = (gp > 0.0 || mat.thinWalled) ? 1.0 / mat.specularIor : mat.specularIor;
+vec3 view = -path.ray.d;
+float gr = dot(bC, view);
+mat.geometricNormal = gr >= 0.0 ? bC : -bC;
+ffnormal = fQ(oh, bC, view);
+mat.coatNormal = fQ(si.coatNormal, bC, view);
+mat.inside = gr <= 0.0 && !mat.thinWalled;
+mat.relativeIor = (gr > 0.0 || mat.thinWalled) ? 1.0 / mat.specularIor : mat.specularIor;
 }
 #endif
 
 
 float scatteringPdf;
-vec3 dH;
-aa.scatteringIsDelta = false;
-bool bs = false;
-bool hC = false;
-ag prepared;
+vec3 di;
+path.scatteringIsDelta = false;
+bool mediumSampled = false;
+bool hE = false;
+OpenPbrPreparedBsdf prepared;
 
 #ifdef HAS_MEDIUM
 int mediumType = si.mediumType;
-float d = distance(si.position, aa.ray.o);
-vec3 os = aa.ray.o;
+float d = distance(si.position, path.ray.o);
+vec3 pd = path.ray.o;
 vec3 extinction = si.mediumExtinction;
 vec3 scattering = min(si.mediumScattering, extinction);
-float tR = max(max(extinction.x, extinction.y), extinction.z);
-if (mediumType > 0 && tR > 0.0) {
+float vD = max(max(extinction.x, extinction.y), extinction.z);
+if (mediumType > 0 && vD > 0.0) {
 
 
 
 
-int oi = min(int(dp(cE(MEDIUM_CHANNEL)) * 3.0), 2);
-float fS = extinction[oi];
-float iH = fS > 0.0
-? min(-log(max(dp(cE(MEDIUM_DISTANCE)), 1e-7)) / fS, d)
+int oW = min(int(sample1D(aX(MEDIUM_CHANNEL)) * 3.0), 2);
+float fP = extinction[oW];
+float iO = fP > 0.0
+? min(-log(max(sample1D(aX(MEDIUM_DISTANCE)), 1e-7)) / fP, d)
 : d;
-bs = iH < d;
-vec3 transmittance = exp(-extinction * iH);
-vec3 oU = bs
+mediumSampled = iO < d;
+vec3 transmittance = exp(-extinction * iO);
+vec3 density = mediumSampled
 ? extinction * transmittance
 : transmittance;
-float oE = max(
-(oU.x + oU.y + oU.z) / 3.0,
+float mediumPdf = max(
+(density.x + density.y + density.z) / 3.0,
 1e-8
 );
-if (bs) {
-aa.beta *= transmittance * scattering / oE;
+if (mediumSampled) {
+path.beta *= transmittance * scattering / mediumPdf;
 
-aa.ray.o = os + iH * aa.ray.d;
-si.position = aa.ray.o;
-aa.li += ta(si, mat, prepared, aa, ffnormal, false) * aa.beta;
+if (all(equal(path.beta, vec3(0.0)))) { path.abort = true; return; }
 
+path.ray.o = pd + iO * path.ray.d;
+si.position = path.ray.o;
 
-dH = fH(
--aa.ray.d,
+si.triangleIndex = -1;
+si.instanceIndex = -1;
+path.li += qY(si, mat, prepared, path, ffnormal, false) * path.beta;
+
+
+di = dQ(
+-path.ray.d,
 si.mediumAnisotropy,
-dZ(cE(PHASE_DIRECTION))
+sample2D(aX(PHASE_DIRECTION))
 );
-scatteringPdf = bL(
-dot(dH, -aa.ray.d),
+scatteringPdf = ba(
+dot(di, -path.ray.d),
 si.mediumAnisotropy
 );
 }
 else {
-aa.beta *= transmittance / oE;
+path.beta *= transmittance / mediumPdf;
+
+if (all(equal(path.beta, vec3(0.0)))) { path.abort = true; return; }
 }
 }
 #endif
 
 
-if (!bs) {
-aa.li += mat.emission * aa.beta;
+if (!mediumSampled) {
+
+vec3 surfaceEmission = sampling_spectral_rgb_filter(mat.emission, pathChannel);
+${fragments['sample2'] ?? ''}path.li += emissiveHitMisWeight(si,path) * surfaceEmission * path.beta;${fragments['sample3'] ?? ''}
 if (mat.materialType == UNLIT) {
-aa.abort = true;
+path.abort = true;
 return;
 }
-vec3 qJ = vec3(0.0);
+vec3 rP = vec3(0.0);
 #ifdef USE_TANGENT
-qJ = si.tangent;
+rP = si.tangent;
 #endif
 mat.directionTangent = si.directionTangent;
 mat.directionBitangent = si.directionBitangent;
 mat.geometryTangent = si.geometryTangent;
 mat.geometryBitangent = si.geometryBitangent;
-prepared = ds(qJ, mat, -aa.ray.d, ffnormal);
-aa.li += ta(si, mat, prepared, aa, ffnormal, true) * aa.beta;
-
+prepared = bX(rP, mat, -path.ray.d, ffnormal);
+path.li += qY(si, mat, prepared, path, ffnormal, true) * path.beta;
+${fragments['sample4'] ?? ''}    
 bool isNextRefraction;
-vec3 f = eN(
+vec3 f = dr(
 prepared,
-vR,
-dH,
+yh,
+di,
 scatteringPdf,
 isNextRefraction
 );
 
-aa.scatteringIsDelta = !prepared.material.thinWalled &&
+path.scatteringIsDelta = !prepared.material.thinWalled &&
 abs(prepared.material.relativeIor - 1.0) <= 1e-6 &&
 prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] >= 1.0 - 1e-6;
 
 
 
 if (!(scatteringPdf > 0.0) || any(isnan(f)) || any(isinf(f)) ||
-dot(dH, dH) < 0.5) {
-aa.scatteringPdf = 0.0;
-aa.abort = true;
+dot(di, di) < 0.5) {
+path.scatteringPdf = 0.0;
+path.abort = true;
 return;
 }
-aa.beta *= f / scatteringPdf;
-hC = !mat.thinWalled &&
+${fragments['sample5'] ?? ''}    path.beta *= f / scatteringPdf;
+
+if (all(equal(path.beta, vec3(0.0)))) { path.abort = true; return; }
+hE = !mat.thinWalled &&
 isNextRefraction;
-aa.isNextRefraction = isNextRefraction;
+path.isNextRefraction = isNextRefraction;
 
 
-aa.ray.o = si.position + EPS * dH;
+path.ray.o = si.position + EPS * di;
 #ifdef USE_COAT_NORMAL_FRAMES
-if (mat.coatNormalEnabled) { aa.ray.o = si.position + EPS * (dot(bK, dH) >= 0.0 ? bK : -bK); }
+if (mat.coatNormalEnabled) { path.ray.o = si.position + EPS * (dot(bC, di) >= 0.0 ? bC : -bC); }
 #endif
 }
 
-aa.scatteringPdf = scatteringPdf;
-gC(aa.ray, aa.ray.o, dH);
-if (bs) {
-aa.isNextRefraction = false;
+path.scatteringPdf = scatteringPdf;
+initRay(path.ray, path.ray.o, di);
+if (mediumSampled) {${fragments['sample6'] ?? ''}
+path.isNextRefraction = false;
 }
-aa.fromEye = false;
+path.fromEye = false;
 
 #ifdef HAS_MEDIUM
 
 
-if (!bs && hC && mat.mediumType > 0) {
-if (sO >= 0.0) {
+if (!mediumSampled && hE && mat.mediumType > 0) {
+if (uk >= 0.0) {
 si.mediumType = mat.mediumType;
 si.mediumExtinction = mat.mediumExtinction;
 si.mediumScattering = mat.mediumScattering;
+path.scatteringMediumEntered = path.scatteringMediumEntered || any(greaterThan(mat.mediumScattering, vec3(0.0)));
 si.mediumAnisotropy = mat.mediumAnisotropy;
 }
 else {
@@ -276,4 +316,6 @@ si.mediumAnisotropy = 0.0;
 #endif
 }
 `;
+}
+export default createSampleMaterialGlsl();
 //# sourceMappingURL=sampleMaterial.glsl.js.map

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 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"]}
+{"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,MAAM,UAAU,wBAAwB,CAAC,YAA8C,EAAE,EAAE,uBAAuB,GAAG,KAAK;IAAI,OAAO,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;mDAoB9E,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE;EACnF,uBAAuB,CAAC,CAAC,CAAC,UAAU,CAAC;;EAEnC,CAAC,CAAC,CAAC,UAAU,CAAC,2FAA2F;;;;;;;;;;;;;;;;;;EAkB3G,uBAAuB,CAAC,CAAC,CAAC,UAAU,CAAC;;;;;CAKtC,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiEJ,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4HtB,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE,0EAA0E,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE;;;;;;;;;;;;;;;EAelI,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;EAsB1B,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE;;;;;;;;;;;;;;;;sBAgBJ,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;CAyBjD,CAAC;AACF,CAAC;AACD,eAAe,wBAAwB,EAAE,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 function createSampleMaterialGlsl(fragments: Readonly<Record<string, string>> = {}, channelIndependentLight = false) { return glsl`\nfloat emissiveHitMisWeight(SurfaceInteraction si,Path path) {\n  // Secondary intersections remain two-sided, but one-sided emission does not.\n  float facing=dot(si.faceNormal,-path.ray.d);\n  if(facing<=0.0&&fetchMatData(si.materialIndex*MAT_DATA_SIZE+MAT_ROW_ALPHA).z<0.5)return 0.0;\n#ifdef HAS_EMISSIVE_LIGHTS\n  if(!path.fromEye && emissiveWeightTotal>0.0) {\n    vec3 emission=fetchMatData(si.materialIndex*MAT_DATA_SIZE+MAT_ROW_EMISSION).rgb;\n    float value=dot(emission,vec3(.2126,.7152,.0722)),cosine=dot(si.faceNormal,-path.ray.d);\n    if(value>0.0&&cosine>0.0){float d=distance(si.position,path.ray.o);return sampling_power_heuristic(path.scatteringPdf,value/emissiveWeightTotal*d*d/cosine);}\n  }\n#endif\n  return 1.0;\n}\n\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);${fragments['sample0'] ?? ''}\n${channelIndependentLight ? /* glsl */ `  if (dispersionWavelengths == 1) {\n    lightSample.emission = sampling_spectral_rgb_filter(lightSample.emission, pathChannel);\n  }` : /* glsl */ `  lightSample.emission = sampling_spectral_rgb_filter(lightSample.emission, pathChannel);`}\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${channelIndependentLight ? /* glsl */ `  // Test the full emission before filtering, so black spectral components\n  // still consume the same visibility walk and random stream.\n  if (dispersionWavelengths != 1) {\n    lightSample.emission = sampling_spectral_rgb_filter(lightSample.emission, pathChannel);\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  float shadowDistance=lightSample.dist-EPS;\n  vec3 shadowDirection=lightDir;\n  if(lightSample.sourceType==1){\n    vec3 endpoint=si.position+lightDir*lightSample.dist+EPS*lightSample.normal;\n    shadowDirection=normalize(endpoint-shadowOrigin);shadowDistance=distance(endpoint,shadowOrigin);\n  }\n  initRay(lightRay, shadowOrigin, shadowDirection);\n  if (intersectSceneShadow(lightRay, shadowDistance, 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 && lightSample.sourceType == 0) {\n    vec4 background = sampleBackgroundFromRay(lightRay.o, lightDir);\n    lightSample.emission = sampling_spectral_rgb_filter(background.rgb * background.a, pathChannel);\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${fragments['sample1'] ?? ''}  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      // Zero throughput cannot contribute at subsequent vertices or light connections.\n      if (all(equal(path.beta, vec3(0.0)))) { path.abort = true; return; }\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      // A volume vertex has no originating surface to skip on continuation or shadow rays.\n      si.triangleIndex = -1;\n      si.instanceIndex = -1;\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      // Zero throughput cannot contribute at subsequent vertices or light connections.\n      if (all(equal(path.beta, vec3(0.0)))) { path.abort = true; return; }\n    }\n  }\n#endif\n\n  // Direct lighting\n  if (!mediumSampled) {\n    // Match NEE and background radiance when RGB wavelength passes are added.\n    vec3 surfaceEmission = sampling_spectral_rgb_filter(mat.emission, pathChannel);\n    ${fragments['sample2'] ?? ''}path.li += emissiveHitMisWeight(si,path) * surfaceEmission * path.beta;${fragments['sample3'] ?? ''}\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${fragments['sample4'] ?? ''}    // 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${fragments['sample5'] ?? ''}    path.beta *= f / scatteringPdf;\n    // Zero throughput cannot contribute at subsequent vertices or light connections.\n    if (all(equal(path.beta, vec3(0.0)))) { path.abort = true; return; }\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) {${fragments['sample6'] ?? ''}\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      path.scatteringMediumEntered = path.scatteringMediumEntered || any(greaterThan(mat.mediumScattering, vec3(0.0)));\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}\nexport default createSampleMaterialGlsl();\n"]}

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

@@ -12,39 +12,39 @@ export default glsl `
 
 const uint SHADOW_CATCHER_LIGHT_SAMPLES = 4u;
 
-uint lc(uint candidate, uint slot) {
-return candidate == 0u ? cE(slot) : cE(9u + (candidate - 1u) * 3u + slot);
+uint lA(uint candidate, uint slot) {
+return candidate == 0u ? aX(slot) : aX(9u + (candidate - 1u) * 3u + slot);
 }
 
 
 
-vec2 sampleShadowCatcher(SurfaceInteraction si, int bounce, inout Path aa) {
-vec3 qY = -aa.ray.d;
+vec2 sampleShadowCatcher(SurfaceInteraction si, int bounce, inout Path path) {
+vec3 sg = -path.ray.d;
 vec2 counts = vec2(0.0);
 
 #if defined(NUM_LIGHTS) || defined(USE_ENVMAP)
 for (uint candidate = 0u; candidate < SHADOW_CATCHER_LIGHT_SAMPLES; candidate++) {
 LightSampleRec lightSample;
-vec3 lV = vec3(
-dZ(lc(candidate, LIGHT_POSITION)),
-dp(lc(candidate, LIGHT_SELECT))
+vec3 ob = vec3(
+sample2D(lA(candidate, LIGHT_POSITION)),
+sample1D(lA(candidate, LIGHT_SELECT))
 );
-sampleLight(si.position, lV, lightSample, false);
+sampleLight(si.position, ob, lightSample, false);
 
 vec3 lightDir = lightSample.direction;
 float cosThetaL = dot(si.normal, lightDir);
-float qB = dot(si.normal, qY) * cosThetaL;
-if (lightSample.pdf > 0.0 && qB >= 0.0) {
+float rG = dot(si.normal, sg) * cosThetaL;
+if (lightSample.pdf > 0.0 && rG >= 0.0) {
 if (dot(lightSample.emission, luminance) * abs(cosThetaL) > 0.0) {
 Ray ray;
-gC(ray, si.position + EPS * lightDir, lightDir);
-bool lY = intersectSceneShadow(ray, lightSample.dist - EPS, si.triangleIndex);
-counts += vec2(lY ? 1.0 : 0.0, 1.0);
+initRay(ray, si.position + EPS * lightDir, lightDir);
+bool mz = intersectSceneShadow(ray, lightSample.dist - EPS, si.triangleIndex);
+counts += vec2(mz ? 1.0 : 0.0, 1.0);
 }
 }
 }
 #endif
-aa.fromEye = false;
+path.fromEye = false;
 return counts;
 }
 `;