@meimu/mutracer 0.1.5 → 0.3.0

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+NjB,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#ifdef HAS_EMISSIVE_LIGHTS\n  sampleEmissiveSceneLight(shadingPoint,randomSampleValue,result);return;\n#endif\n  result.sourceType=0;result.sourceIndex=-1;\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>>): string;
 declare const _default: string;
 export default _default;

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

@@ -1,42 +1,57 @@
 // 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 mT(ad si, J mat, ag prepared, inout Path aa, vec3 ffnormal, bool gF) {
-float mC = 1.0;
-vec3 ln = vec3(fp(cw(LIGHT_POSITION)), dz(cw(LIGHT_SELECT)));
+export function createSampleMaterialGlsl(fragments = {}) {
+    return glsl `
+float emissiveHitMisWeight(SurfaceInteraction si,Path path) {
+
+float ys=dot(si.faceNormal,-path.ray.d);
+if(ys<=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 aF(path.scatteringPdf,value/emissiveWeightTotal*d*d/cosine);}
+}
+#endif
+return 1.0;
+}
+
+vec3 sX(SurfaceInteraction si, OpenPbrResolvedMaterial mat, OpenPbrPreparedBsdf prepared, inout Path path, vec3 ffnormal, bool isSurface) {
+float lH = 1.0;
+vec3 mZ = vec3(sample2D(bE(LIGHT_POSITION)), sample1D(bE(LIGHT_SELECT)));
 
 LightSampleRec lightSample;
-sampleLight(si.position, ln, lightSample, false);
-lightSample.emission = ai(lightSample.emission, bf);
+sampleLight(si.position, mZ, lightSample, false);${fragments['sample0'] ?? ''}
+lightSample.emission = sampling_spectral_rgb_filter(lightSample.emission, pathChannel);
 
 vec3 lightDir = lightSample.direction;
-vec3 oS = -aa.ray.d;
-float fg = lightSample.pdf;
+vec3 qR = -path.ray.d;
+float lightPdf = lightSample.pdf;
 
 
 
 
 float cosThetaL = dot(ffnormal, lightDir);
 #ifdef USE_COAT_NORMAL_FRAMES
-if (gF && mat.coatNormalEnabled) { cosThetaL = dot(mat.geometricNormal, lightDir); }
+if (isSurface && mat.coatNormalEnabled) { cosThetaL = dot(mat.geometricNormal, lightDir); }
 #endif
 
-if (fg <= 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;
 vec3 f = vec3(0.0);
-if (gF) {
+if (isSurface) {
 if (cosThetaL <= 0.0 && mat.transmissionWeight <= 0.0 && mat.subsurfaceWeight <= 0.0) {
 return vec3(0.0);
 }
-f = bI(prepared, lightDir, scatteringPdf);
+f = openpbr_eval_prepared(prepared, lightDir, scatteringPdf);
 }
 else {
-scatteringPdf = bD(
-dot(oS, lightDir),
+scatteringPdf = bB(
+dot(qR, lightDir),
 si.mediumAnisotropy
 );
 f = vec3(scatteringPdf);
@@ -46,83 +61,89 @@ if (scatteringPdf <= 0.0 || max(max(f.x, f.y), f.z) <= 0.0) {
 return vec3(0.0);
 }
 
-Ray mz;
-vec3 hi = si.position + EPS * lightDir;
-if (gF) {
-const float bZ = 0.1;
-float dr = dot(si.normal, lightDir);
+Ray mY;
+vec3 eO = si.position + EPS * lightDir;
+if (isSurface) {
+const float shadowTerminatorCutoff = 0.1;
+float dj = dot(si.normal, lightDir);
 #ifdef USE_COAT_NORMAL_FRAMES
-if (mat.coatNormalEnabled) { dr = dot(si.faceNormal, lightDir); }
+if (mat.coatNormalEnabled) { dj = dot(si.faceNormal, lightDir); }
 #endif
-vec3 geometricNormal = dr < 0.0 ? -si.faceNormal : si.faceNormal;
-dr = abs(dr);
-float hS = dot(geometricNormal, lightDir);
-float oB = dr < bZ
+vec3 geometricNormal = dj < 0.0 ? -si.faceNormal : si.faceNormal;
+dj = abs(dj);
+float hO = dot(geometricNormal, lightDir);
+float pf = dj < shadowTerminatorCutoff
 ? clamp(
-2.0 - (hS + dr) / bZ,
+2.0 - (hO + dj) / shadowTerminatorCutoff,
 0.0,
 1.0
 )
-: clamp(1.0 - hS / bZ, 0.0, 1.0);
-hi += si.shadowOffset * oB;
+: clamp(1.0 - hO / shadowTerminatorCutoff, 0.0, 1.0);
+eO += si.shadowOffset * pf;
 }
-iC(mz, hi, lightDir);
-if (ex(mz, lightSample.dist - EPS, si.triangleIndex)) {
+float qz=lightSample.dist-EPS;
+vec3 pO=lightDir;
+if(lightSample.sourceType==1){
+vec3 endpoint=si.position+lightDir*lightSample.dist+EPS*lightSample.normal;
+pO=normalize(endpoint-eO);qz=distance(endpoint,eO);
+}
+initRay(mY, eO, pO);
+if (intersectSceneShadow(mY, qz, si.triangleIndex)) {
 return vec3(0.0);
 }
 
 #ifdef USE_ENVMAP
 
 
-if (gF && cosThetaL < 0.0 && ln.z < envLightSelectionPmf) {
-vec4 background = cx(mz.o, lightDir);
-lightSample.emission = ai(background.rgb * background.a, bf);
+if (isSurface && cosThetaL < 0.0 && lightSample.sourceType == 0) {
+vec4 background = cn(mY.o, lightDir);
+lightSample.emission = sampling_spectral_rgb_filter(background.rgb * background.a, pathChannel);
 }
 #endif
 
 
 
-float fa = lightSample.isDelta
+float misWeight = lightSample.isDelta
 ? 1.0
-: aG(fg, scatteringPdf);
-return fa > 0.0
-? fa * lightSample.emission * f / fg
+: aF(lightPdf, scatteringPdf);
+${fragments['sample1'] ?? ''}  return misWeight > 0.0
+? misWeight * lightSample.emission * f / lightPdf
 : vec3(0.0);
 }
 
 #ifdef USE_COAT_NORMAL_FRAMES
-vec3 fF(vec3 pG, vec3 tq, vec3 view) {
-bool qY = dot(tq, view) >= 0.0;
-vec3 uo = qY ? tq : -tq;
-vec3 qX = qY ? pG : -pG;
-if (dot(pG, tq) <= 0.0 || dot(qX, view) <= 1e-6) { return uo; }
-return qX;
+vec3 fE(vec3 ql, vec3 face, vec3 view) {
+bool front = dot(face, view) >= 0.0;
+vec3 wd = front ? face : -face;
+vec3 rY = front ? ql : -ql;
+if (dot(ql, face) <= 0.0 || dot(rY, view) <= 1e-6) { return wd; }
+return rY;
 }
 #endif
-void mb(inout ad si, J mat, inout Path aa) {
-vec3 ur = vec3(fp(cw(BSDF_DIRECTION)), dz(cw(BSDF_LOBE)));
+void mx(inout SurfaceInteraction si, OpenPbrResolvedMaterial mat, inout Path path) {
+vec3 wh = vec3(sample2D(bE(BSDF_DIRECTION)), sample1D(bE(BSDF_LOBE)));
 #ifdef USE_COAT_NORMAL_FRAMES
-vec3 bC = si.faceNormal;
-vec3 mE = si.normal;
+vec3 bA = si.faceNormal;
+vec3 ni = si.normal;
 #endif
-float rN = -dot(si.faceNormal, aa.ray.d);
-float sG = -dot(si.normal, aa.ray.d);
+float sL = -dot(si.faceNormal, path.ray.d);
+float tY = -dot(si.normal, path.ray.d);
 if ((mat.transmissionWeight > 0.0 || mat.subsurfaceWeight > 0.0) && mat.thinWalled) {
 
-if (rN < 0.0) {
+if (sL < 0.0) {
 si.faceNormal = -si.faceNormal;
-rN = -rN;
+sL = -sL;
 }
-if (sG < 0.0) {
+if (tY < 0.0) {
 si.normal = -si.normal;
-sG = -sG;
+tY = -tY;
 }
 }
 
 
-bool pU = rN >= 0.0 && sG < 0.0;
-float ndv = pU ? rN : sG;
-vec3 normal = pU ? si.faceNormal : si.normal;
+bool qE = sL >= 0.0 && tY < 0.0;
+float ndv = qE ? sL : tY;
+vec3 normal = qE ? si.faceNormal : si.normal;
 
 mat.inside = ndv <= 0.0 && !mat.thinWalled;
 
@@ -130,137 +151,137 @@ 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 gb = dot(bC, view);
-mat.geometricNormal = gb >= 0.0 ? bC : -bC;
-ffnormal = fF(mE, bC, view);
-mat.coatNormal = fF(si.coatNormal, bC, view);
-mat.inside = gb <= 0.0 && !mat.thinWalled;
-mat.relativeIor = (gb > 0.0 || mat.thinWalled) ? 1.0 / mat.specularIor : mat.specularIor;
+vec3 view = -path.ray.d;
+float fZ = dot(bA, view);
+mat.geometricNormal = fZ >= 0.0 ? bA : -bA;
+ffnormal = fE(ni, bA, view);
+mat.coatNormal = fE(si.coatNormal, bA, view);
+mat.inside = fZ <= 0.0 && !mat.thinWalled;
+mat.relativeIor = (fZ > 0.0 || mat.thinWalled) ? 1.0 / mat.specularIor : mat.specularIor;
 }
 #endif
 
 
 float scatteringPdf;
-vec3 cG;
-aa.scatteringIsDelta = false;
-bool bl = false;
-bool hn = false;
-ag prepared;
+vec3 df;
+path.scatteringIsDelta = false;
+bool mediumSampled = false;
+bool hj = false;
+OpenPbrPreparedBsdf prepared;
 
 #ifdef HAS_MEDIUM
 int mediumType = si.mediumType;
-float d = distance(si.position, aa.ray.o);
-vec3 nu = aa.ray.o;
+float d = distance(si.position, path.ray.o);
+vec3 od = path.ray.o;
 vec3 extinction = si.mediumExtinction;
 vec3 scattering = min(si.mediumScattering, extinction);
-float sC = max(max(extinction.x, extinction.y), extinction.z);
-if (mediumType > 0 && sC > 0.0) {
+float tU = max(max(extinction.x, extinction.y), extinction.z);
+if (mediumType > 0 && tU > 0.0) {
 
 
 
 
-int nj = min(int(dz(cw(MEDIUM_CHANNEL)) * 3.0), 2);
-float fE = extinction[nj];
-float ih = fE > 0.0
-? min(-log(max(dz(cw(MEDIUM_DISTANCE)), 1e-7)) / fE, d)
+int nX = min(int(sample1D(bE(MEDIUM_CHANNEL)) * 3.0), 2);
+float fD = extinction[nX];
+float ij = fD > 0.0
+? min(-log(max(sample1D(bE(MEDIUM_DISTANCE)), 1e-7)) / fD, d)
 : d;
-bl = ih < d;
-vec3 ew = exp(-extinction * ih);
-vec3 nZ = bl
-? extinction * ew
-: ew;
-float nK = max(
-(nZ.x + nZ.y + nZ.z) / 3.0,
+mediumSampled = ij < d;
+vec3 transmittance = exp(-extinction * ij);
+vec3 oK = mediumSampled
+? extinction * transmittance
+: transmittance;
+float mediumPdf = max(
+(oK.x + oK.y + oK.z) / 3.0,
 1e-8
 );
-if (bl) {
-aa.beta *= ew * scattering / nK;
+if (mediumSampled) {
+path.beta *= transmittance * scattering / mediumPdf;
 
-aa.ray.o = nu + ih * aa.ray.d;
-si.position = aa.ray.o;
-aa.li += mT(si, mat, prepared, aa, ffnormal, false) * aa.beta;
+path.ray.o = od + ij * path.ray.d;
+si.position = path.ray.o;
+path.li += sX(si, mat, prepared, path, ffnormal, false) * path.beta;
 
 
-cG = fq(
--aa.ray.d,
+df = fj(
+-path.ray.d,
 si.mediumAnisotropy,
-fp(cw(PHASE_DIRECTION))
+sample2D(bE(PHASE_DIRECTION))
 );
-scatteringPdf = bD(
-dot(cG, -aa.ray.d),
+scatteringPdf = bB(
+dot(df, -path.ray.d),
 si.mediumAnisotropy
 );
 }
 else {
-aa.beta *= ew / nK;
+path.beta *= transmittance / mediumPdf;
 }
 }
 #endif
 
 
-if (!bl) {
-aa.li += mat.emission * aa.beta;
+if (!mediumSampled) {
+${fragments['sample2'] ?? ''}path.li += emissiveHitMisWeight(si,path) * mat.emission * path.beta;${fragments['sample3'] ?? ''}
 if (mat.materialType == UNLIT) {
-aa.abort = true;
+path.abort = true;
 return;
 }
-vec3 pS = vec3(0.0);
+vec3 qB = vec3(0.0);
 #ifdef USE_TANGENT
-pS = si.tangent;
+qB = si.tangent;
 #endif
 mat.directionTangent = si.directionTangent;
 mat.directionBitangent = si.directionBitangent;
 mat.geometryTangent = si.geometryTangent;
 mat.geometryBitangent = si.geometryBitangent;
-prepared = eH(pS, mat, -aa.ray.d, ffnormal);
-aa.li += mT(si, mat, prepared, aa, ffnormal, true) * aa.beta;
-
+prepared = bV(qB, mat, -path.ray.d, ffnormal);
+path.li += sX(si, mat, prepared, path, ffnormal, true) * path.beta;
+${fragments['sample4'] ?? ''}    
 bool isNextRefraction;
-vec3 f = dv(
+vec3 f = dl(
 prepared,
-ur,
-cG,
+wh,
+df,
 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(cG, cG) < 0.5) {
-aa.scatteringPdf = 0.0;
-aa.abort = true;
+dot(df, df) < 0.5) {
+path.scatteringPdf = 0.0;
+path.abort = true;
 return;
 }
-aa.beta *= f / scatteringPdf;
-hn = !mat.thinWalled &&
+${fragments['sample5'] ?? ''}    path.beta *= f / scatteringPdf;
+hj = !mat.thinWalled &&
 isNextRefraction;
-aa.isNextRefraction = isNextRefraction;
+path.isNextRefraction = isNextRefraction;
 
 
-aa.ray.o = si.position + EPS * cG;
+path.ray.o = si.position + EPS * df;
 #ifdef USE_COAT_NORMAL_FRAMES
-if (mat.coatNormalEnabled) { aa.ray.o = si.position + EPS * (dot(bC, cG) >= 0.0 ? bC : -bC); }
+if (mat.coatNormalEnabled) { path.ray.o = si.position + EPS * (dot(bA, df) >= 0.0 ? bA : -bA); }
 #endif
 }
 
-aa.scatteringPdf = scatteringPdf;
-iC(aa.ray, aa.ray.o, cG);
-if (bl) {
-aa.isNextRefraction = false;
+path.scatteringPdf = scatteringPdf;
+initRay(path.ray, path.ray.o, df);
+if (mediumSampled) {${fragments['sample6'] ?? ''}
+path.isNextRefraction = false;
 }
-aa.fromEye = false;
+path.fromEye = false;
 
 #ifdef HAS_MEDIUM
 
 
-if (!bl && hn && mat.mediumType > 0) {
-if (rN >= 0.0) {
+if (!mediumSampled && hj && mat.mediumType > 0) {
+if (sL >= 0.0) {
 si.mediumType = mat.mediumType;
 si.mediumExtinction = mat.mediumExtinction;
 si.mediumScattering = mat.mediumScattering;
@@ -276,4 +297,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;IAAI,OAAO,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;mDAoB7C,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoFnF,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmHtB,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE,uEAAuE,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE;;;;;;;;;;;;;;;EAe/H,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;EAsB1B,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE;;;;;;;;;;;;;;sBAcJ,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;CAwBjD,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>> = {}) { 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  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  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      // 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    ${fragments['sample2'] ?? ''}path.li += emissiveHitMisWeight(si,path) * mat.emission * 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    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      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

@@ -9,40 +9,43 @@ export default glsl `
 
 
 
+
 const uint SHADOW_CATCHER_LIGHT_SAMPLES = 4u;
 
-uint ky(uint candidate, uint slot) {
-return candidate == 0u ? cw(slot) : cw(9u + (candidate - 1u) * 3u + slot);
+uint kJ(uint candidate, uint slot) {
+return candidate == 0u ? bE(slot) : bE(9u + (candidate - 1u) * 3u + slot);
 }
 
-void sampleShadowCatcher(ad si, int bounce, inout Path aa) {
-vec3 oS = -aa.ray.d;
+
+
+vec2 sampleShadowCatcher(SurfaceInteraction si, int bounce, inout Path path) {
+vec3 qR = -path.ray.d;
+vec2 counts = vec2(0.0);
 
 #if defined(NUM_LIGHTS) || defined(USE_ENVMAP)
-float visibility = 0.0;
 for (uint candidate = 0u; candidate < SHADOW_CATCHER_LIGHT_SAMPLES; candidate++) {
 LightSampleRec lightSample;
-vec3 ln = vec3(
-fp(ky(candidate, LIGHT_POSITION)),
-dz(ky(candidate, LIGHT_SELECT))
+vec3 mZ = vec3(
+sample2D(kJ(candidate, LIGHT_POSITION)),
+sample1D(kJ(candidate, LIGHT_SELECT))
 );
-sampleLight(si.position, ln, lightSample, false);
+sampleLight(si.position, mZ, lightSample, false);
 
 vec3 lightDir = lightSample.direction;
 float cosThetaL = dot(si.normal, lightDir);
-float pM = dot(si.normal, oS) * cosThetaL;
-bool mC = false;
-if (pM >= 0.0) {
+float qt = dot(si.normal, qR) * cosThetaL;
+if (lightSample.pdf > 0.0 && qt >= 0.0) {
+if (dot(lightSample.emission, luminance) * abs(cosThetaL) > 0.0) {
 Ray ray;
-iC(ray, si.position + EPS * lightDir, lightDir);
-mC = ex(ray, lightSample.dist - EPS, si.triangleIndex);
+initRay(ray, si.position + EPS * lightDir, lightDir);
+bool lH = intersectSceneShadow(ray, lightSample.dist - EPS, si.triangleIndex);
+counts += vec2(lH ? 1.0 : 0.0, 1.0);
+}
 }
-visibility += mC ? 0.0 : 1.0;
 }
-
-aa.alpha = visibility / float(SHADOW_CATCHER_LIGHT_SAMPLES);
 #endif
-aa.fromEye = false;
+path.fromEye = false;
+return counts;
 }
 `;
 //# sourceMappingURL=sampleShadowCatcher.glsl.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"sampleShadowCatcher.glsl.js","sourceRoot":"","sources":["../../../../src/renderer/glsl/chunks/sampleShadowCatcher.glsl.ts"],"names":[],"mappings":"AAAA,qDAAqD;AACrD,sDAAsD;AACtD,kFAAkF;AAElF,2EAA2E;AAC3E,iIAAiI;AAEjI,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAEvC,eAAe,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwClB,CAAC","sourcesContent":["// Portions adapted from ray-tracing-renderer@0.10.15\n// (https://github.com/hoverinc/ray-tracing-renderer).\n// Copyright (c) 2019 HOVER, MIT license; see LICENSES/RayTracingRenderer-MIT.txt.\n\n// 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';\n\nexport default glsl`\n// A one-sample binary shadow test leaves scattered fully dark pixels far\n// from the occluder at low sample counts. Averaging a few light samples per\n// primary hit costs only shadow rays and lets the mask settle much sooner.\n// Candidate dimensions match WGSL lightDim().\nconst uint SHADOW_CATCHER_LIGHT_SAMPLES = 4u;\n\nuint shadowCatcherLightDim(uint candidate, uint slot) {\n  return candidate == 0u ? bounceDim(slot) : bounceDim(9u + (candidate - 1u) * 3u + slot);\n}\n\nvoid sampleShadowCatcher(SurfaceInteraction si, int bounce, inout Path path) {\n  vec3 viewDir = -path.ray.d;\n\n#if defined(NUM_LIGHTS) || defined(USE_ENVMAP)\n  float visibility = 0.0;\n  for (uint candidate = 0u; candidate < SHADOW_CATCHER_LIGHT_SAMPLES; candidate++) {\n    LightSampleRec lightSample;\n    vec3 lightRnd = vec3(\n      sample2D(shadowCatcherLightDim(candidate, LIGHT_POSITION)),\n      sample1D(shadowCatcherLightDim(candidate, LIGHT_SELECT))\n    );\n    sampleLight(si.position, lightRnd, lightSample, false);\n\n    vec3 lightDir = lightSample.direction;\n    float cosThetaL = dot(si.normal, lightDir);\n    float orientation = dot(si.normal, viewDir) * cosThetaL;\n    bool occluded = false;\n    if (orientation >= 0.0) {\n      Ray ray;\n      initRay(ray, si.position + EPS * lightDir, lightDir);\n      occluded = intersectSceneShadow(ray, lightSample.dist - EPS, si.triangleIndex);\n    }\n    visibility += occluded ? 0.0 : 1.0;\n  }\n  // WebGL's compose pass converts visibility to shadow opacity.\n  path.alpha = visibility / float(SHADOW_CATCHER_LIGHT_SAMPLES);\n#endif\n  path.fromEye = false;\n}\n`;\n"]}
+{"version":3,"file":"sampleShadowCatcher.glsl.js","sourceRoot":"","sources":["../../../../src/renderer/glsl/chunks/sampleShadowCatcher.glsl.ts"],"names":[],"mappings":"AAAA,qDAAqD;AACrD,sDAAsD;AACtD,kFAAkF;AAElF,2EAA2E;AAC3E,iIAAiI;AAEjI,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAEvC,eAAe,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2ClB,CAAC","sourcesContent":["// Portions adapted from ray-tracing-renderer@0.10.15\n// (https://github.com/hoverinc/ray-tracing-renderer).\n// Copyright (c) 2019 HOVER, MIT license; see LICENSES/RayTracingRenderer-MIT.txt.\n\n// 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';\n\nexport default glsl`\n// A one-sample binary shadow test leaves scattered fully dark pixels far\n// from the occluder at low sample counts. Averaging a few light samples per\n// primary hit costs only shadow rays and lets the mask settle much sooner.\n// Candidate dimensions match WGSL lightDim(). sampleLight() draws only the\n// environment and analytic lights, like WGSL's shadow-catcher table.\nconst uint SHADOW_CATCHER_LIGHT_SAMPLES = 4u;\n\nuint shadowCatcherLightDim(uint candidate, uint slot) {\n  return candidate == 0u ? bounceDim(slot) : bounceDim(9u + (candidate - 1u) * 3u + slot);\n}\n\n// Returns the occluded and the total count of light samples that reach the\n// visible side of this hit; see the WGSL sampleShadowCatcher().\nvec2 sampleShadowCatcher(SurfaceInteraction si, int bounce, inout Path path) {\n  vec3 viewDir = -path.ray.d;\n  vec2 counts = vec2(0.0);\n\n#if defined(NUM_LIGHTS) || defined(USE_ENVMAP)\n  for (uint candidate = 0u; candidate < SHADOW_CATCHER_LIGHT_SAMPLES; candidate++) {\n    LightSampleRec lightSample;\n    vec3 lightRnd = vec3(\n      sample2D(shadowCatcherLightDim(candidate, LIGHT_POSITION)),\n      sample1D(shadowCatcherLightDim(candidate, LIGHT_SELECT))\n    );\n    sampleLight(si.position, lightRnd, lightSample, false);\n\n    vec3 lightDir = lightSample.direction;\n    float cosThetaL = dot(si.normal, lightDir);\n    float orientation = dot(si.normal, viewDir) * cosThetaL;\n    if (lightSample.pdf > 0.0 && orientation >= 0.0) {\n      if (dot(lightSample.emission, luminance) * abs(cosThetaL) > 0.0) {\n        Ray ray;\n        initRay(ray, si.position + EPS * lightDir, lightDir);\n        bool occluded = intersectSceneShadow(ray, lightSample.dist - EPS, si.triangleIndex);\n        counts += vec2(occluded ? 1.0 : 0.0, 1.0);\n      }\n    }\n  }\n#endif\n  path.fromEye = false;\n  return counts;\n}\n`;\n"]}