@meimu/mutracer 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,254 @@
+import { glsl } from '../../shader.js';
+export default glsl `
+#ifdef NUM_LIGHTS
+void eJ(
+in Light light,
+in vec3 shadingPoint,
+in vec2 samplePoint,
+inout LightSampleRec result
+) {
+vec3 nE = light.position - shadingPoint;
+float aj = length(nE);
+if (light.radius <= 0.0) {
+if (aj <= 1e-6) {
+result.direction = vec3(0.0, 0.0, 1.0);
+result.normal = vec3(0.0, 0.0, -1.0);
+result.dist = 0.0;
+result.pdf = 1.0;
+result.emission = vec3(0.0);
+result.isDelta = true;
+return;
+}
+result.direction = nE / aj;
+result.normal = -result.direction;
+result.dist = aj;
+result.pdf = 1.0;
+result.emission = light.emission / max(aj * aj, 1e-8);
+result.isDelta = true;
+return;
+}
+float radius = max(light.radius, 1e-6);
+result.isDelta = false;
+vec3 direction;
+
+if (aj <= radius) {
+float z = 1.0 - 2.0 * samplePoint.x;
+float fi = sqrt(max(0.0, 1.0 - z * z));
+float br = TWOPI * samplePoint.y;
+direction = vec3(fi * cos(br), fi * sin(br), z);
+result.pdf = INV4PI;
+}
+else {
+vec3 axis = nE / aj;
+float rG = min(
+1.0,
+radius * radius / (aj * aj)
+);
+float rJ = sqrt(max(0.0, 1.0 - rG));
+float au = mix(1.0, rJ, samplePoint.x);
+float tR = sqrt(max(0.0, 1.0 - au * au));
+float br = TWOPI * samplePoint.y;
+vec3 tangent;
+vec3 bitangent;
+aK(axis, tangent, bitangent);
+direction = axis * au
++ tangent * (tR * cos(br))
++ bitangent * (tR * sin(br));
+result.pdf = 1.0 / max(TWOPI * (1.0 - rJ), 1e-8);
+}
+
+float iZ = dot(direction, nE);
+float ej = iZ * iZ
+- dot(nE, nE) + radius * radius;
+float wt = sqrt(max(0.0, ej));
+float cN = iZ - wt;
+float cB = iZ + wt;
+result.dist = cN > 1e-6 ? cN : cB;
+result.direction = direction;
+vec3 surfacePoint = shadingPoint + direction * result.dist;
+result.normal = normalize(surfacePoint - light.position);
+result.emission = light.emission;
+}
+
+void cZ(
+in Light light,
+in vec3 surfacePoint,
+in vec3 lowerLeft,
+inout LightSampleRec result
+) {
+#ifdef NUM_MAPS
+if (light.textureIndex >= 0) {
+float width = length(light.u);
+float height = length(light.v);
+vec3 hY = surfacePoint - lowerLeft;
+vec2 uv = vec2(
+dot(hY, light.u / width) / width,
+dot(hY, light.v / height) / height
+);
+result.emission *= sampleMap(light.textureIndex, uv).rgb;
+}
+#endif
+}
+
+void jJ(
+in Light light,
+in vec3 shadingPoint,
+in vec2 samplePoint,
+inout LightSampleRec result
+) {
+vec3 normal = normalize(cross(light.u, light.v));
+vec3 lowerLeft = light.position - 0.5 * (light.u + light.v);
+float spread = clamp(light.spread, 0.0, 1.0);
+
+if (spread <= 0.001) {
+float ga = dot(normal, shadingPoint - light.position);
+vec3 surfacePoint = shadingPoint - normal * ga;
+vec3 hY = surfacePoint - lowerLeft;
+float width = length(light.u);
+float height = length(light.v);
+vec2 uv = vec2(
+dot(hY, light.u / width) / width,
+dot(hY, light.v / height) / height
+);
+if (ga <= 0.0 || any(lessThan(uv, vec2(0.0)))
+|| any(greaterThan(uv, vec2(1.0)))) {
+result.emission = vec3(0.0);
+result.pdf = 0.0;
+return;
+}
+result.direction = -normal;
+result.dist = ga;
+result.normal = normal;
+result.emission = light.emission;
+result.pdf = 1.0;
+result.isDelta = true;
+cZ(light, surfacePoint, lowerLeft, result);
+return;
+}
+
+vec3 surfacePoint = lowerLeft
++ light.u * samplePoint.x
++ light.v * samplePoint.y;
+vec3 offset = surfacePoint - shadingPoint;
+float hl = dot(offset, offset);
+result.dist = sqrt(hl);
+result.direction = offset / result.dist;
+result.normal = normal;
+float fV = dot(-result.direction, normal);
+float oC = cos(0.5 * PI * spread);
+if (fV <= 0.0 || fV < oC) {
+result.emission = vec3(0.0);
+result.pdf = 0.0;
+return;
+}
+result.emission = light.emission;
+result.pdf = hl / max(light.area * fV, 1e-8);
+cZ(light, surfacePoint, lowerLeft, result);
+}
+
+void fX(
+in Light light,
+in vec3 shadingPoint,
+inout LightSampleRec result
+) {
+result.direction = normalize(-light.u);
+result.normal = -result.direction;
+result.emission = light.emission;
+result.dist = INF;
+result.pdf = 1.0;
+result.isDelta = true;
+}
+
+void jK(
+in Light light,
+in vec3 shadingPoint,
+in vec2 samplePoint,
+inout LightSampleRec result
+) {
+eJ(light, shadingPoint, samplePoint, result);
+vec3 surfacePoint = shadingPoint + result.direction * result.dist;
+result.emission *= bL(
+light,
+normalize(shadingPoint - surfacePoint)
+);
+}
+
+void iK(
+in Light light,
+in vec3 shadingPoint,
+in vec2 samplePoint,
+inout LightSampleRec result
+) {
+int dO = int(light.type);
+#ifdef HAS_RECT_LIGHTS
+if (dO == RECT_LIGHT) {
+jJ(light, shadingPoint, samplePoint, result);
+return;
+}
+#endif
+#ifdef HAS_SPHERE_LIGHTS
+if (dO == SPHERE_LIGHT) {
+eJ(light, shadingPoint, samplePoint, result);
+return;
+}
+#endif
+#ifdef HAS_SPOT_LIGHTS
+if (dO == SPOT_LIGHT) {
+jK(light, shadingPoint, samplePoint, result);
+return;
+}
+#endif
+#ifdef HAS_DIRECTIONAL_LIGHTS
+if (dO == DIRECTIONAL_LIGHT) {
+fX(light, shadingPoint, result);
+}
+#endif
+}
+#endif
+
+void mu(in vec2 samplePoint, inout LightSampleRec result) {
+vec2 uv;
+result.direction = oA(samplePoint, uv, result.pdf);
+result.emission = textureLinear(envMap, uv).rgb;
+result.dist = INF;
+}
+
+void sampleLight(
+in vec3 shadingPoint,
+in vec3 randomSampleValue,
+inout LightSampleRec result,
+bool rP
+) {
+result.isDelta = false;
+float tQ = randomSampleValue.z;
+bool ko = false;
+#ifdef USE_ENVMAP
+ko = tQ < envLightSelectionPmf;
+if (ko) {
+mu(randomSampleValue.xy, result);
+result.pdf *= envLightSelectionPmf;
+}
+#endif
+
+#ifdef NUM_LIGHTS
+if (!ko) {
+int kQ = NUM_LIGHTS - 1;
+for (int index = 0; index < NUM_LIGHTS; index++) {
+if (tQ < ql(index).selectionCdf) {
+kQ = index;
+break;
+}
+}
+Light qb = ql(kQ);
+iK(
+qb,
+shadingPoint,
+randomSampleValue.xy,
+result
+);
+result.pdf *= qb.selectionPmf;
+}
+#endif
+}
+`;
+//# sourceMappingURL=sampleLight.glsl.js.map

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

@@ -0,0 +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"]}

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

@@ -0,0 +1,2 @@
+declare const _default: string;
+export default _default;

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

@@ -0,0 +1,279 @@
+// 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 mG(ad si, J mat, ag prepared, inout Path aa, vec3 ffnormal, bool gw) {
+float mp = 1.0;
+vec3 kZ = vec3(fk(cv(LIGHT_POSITION)), dz(cv(LIGHT_SELECT)));
+
+LightSampleRec lightSample;
+sampleLight(si.position, kZ, lightSample, false);
+lightSample.emission = ai(lightSample.emission, bf);
+
+vec3 lightDir = lightSample.direction;
+vec3 oH = -aa.ray.d;
+float fd = lightSample.pdf;
+
+
+
+
+float cosThetaL = dot(ffnormal, lightDir);
+#ifdef NUM_COAT_NORMAL_MAPS
+if (gw && mat.coatNormalEnabled) { cosThetaL = dot(mat.geometricNormal, lightDir); }
+#endif
+
+if (fd <= 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 (gw) {
+if (cosThetaL <= 0.0 && mat.transmissionWeight <= 0.0 && mat.subsurfaceWeight <= 0.0) {
+return vec3(0.0);
+}
+f = bI(prepared, lightDir, scatteringPdf);
+}
+else {
+scatteringPdf = bD(
+dot(oH, lightDir),
+si.mediumAnisotropy
+);
+f = vec3(scatteringPdf);
+}
+
+if (scatteringPdf <= 0.0 || max(max(f.x, f.y), f.z) <= 0.0) {
+return vec3(0.0);
+}
+
+Ray ml;
+vec3 hc = si.position + EPS * lightDir;
+if (gw) {
+const float bZ = 0.1;
+float dr = dot(si.normal, lightDir);
+#ifdef NUM_COAT_NORMAL_MAPS
+if (mat.coatNormalEnabled) { dr = dot(si.faceNormal, lightDir); }
+#endif
+vec3 geometricNormal = dr < 0.0 ? -si.faceNormal : si.faceNormal;
+dr = abs(dr);
+float hP = dot(geometricNormal, lightDir);
+float oo = dr < bZ
+? clamp(
+2.0 - (hP + dr) / bZ,
+0.0,
+1.0
+)
+: clamp(1.0 - hP / bZ, 0.0, 1.0);
+hc += si.shadowOffset * oo;
+}
+iw(ml, hc, lightDir);
+if (ex(ml, lightSample.dist - EPS, si.triangleIndex)) {
+return vec3(0.0);
+}
+
+#ifdef USE_ENVMAP
+
+
+if (gw && cosThetaL < 0.0 && kZ.z < envLightSelectionPmf) {
+vec4 background = cw(ml.o, lightDir);
+lightSample.emission = ai(background.rgb * background.a, bf);
+}
+#endif
+
+
+
+float eW = lightSample.isDelta
+? 1.0
+: aF(fd, scatteringPdf);
+return eW > 0.0
+? eW * lightSample.emission * f / fd
+: vec3(0.0);
+}
+
+#ifdef NUM_COAT_NORMAL_MAPS
+vec3 fB(vec3 pk, vec3 tc, vec3 view) {
+bool qL = dot(tc, view) >= 0.0;
+vec3 ub = qL ? tc : -tc;
+vec3 qK = qL ? pk : -pk;
+if (dot(pk, tc) <= 0.0 || dot(qK, view) <= 1e-6) { return ub; }
+return qK;
+}
+#endif
+void lO(inout ad si, J mat, inout Path aa) {
+vec3 ud = vec3(fk(cv(BSDF_DIRECTION)), dz(cv(BSDF_LOBE)));
+#ifdef NUM_COAT_NORMAL_MAPS
+vec3 bC = si.faceNormal;
+vec3 mr = si.normal;
+#endif
+float rA = -dot(si.faceNormal, aa.ray.d);
+float sq = -dot(si.normal, aa.ray.d);
+if ((mat.transmissionWeight > 0.0 || mat.subsurfaceWeight > 0.0) && mat.thinWalled) {
+
+if (rA < 0.0) {
+si.faceNormal = -si.faceNormal;
+rA = -rA;
+}
+if (sq < 0.0) {
+si.normal = -si.normal;
+sq = -sq;
+}
+}
+
+
+bool pI = rA >= 0.0 && sq < 0.0;
+float ndv = pI ? rA : sq;
+vec3 normal = pI ? si.faceNormal : si.normal;
+
+mat.inside = ndv <= 0.0 && !mat.thinWalled;
+
+mat.relativeIor = ndv > 0.0 ? (1.0 / mat.specularIor) : mat.specularIor;
+vec3 ffnormal = ndv >= 0.0 ? normal : -normal;
+#ifdef NUM_COAT_NORMAL_MAPS
+if (mat.coatNormalEnabled) {
+vec3 view = -aa.ray.d;
+float fW = dot(bC, view);
+mat.geometricNormal = fW >= 0.0 ? bC : -bC;
+ffnormal = fB(mr, bC, view);
+mat.coatNormal = fB(si.coatNormal, bC, view);
+mat.inside = fW <= 0.0 && !mat.thinWalled;
+mat.relativeIor = (fW > 0.0 || mat.thinWalled) ? 1.0 / mat.specularIor : mat.specularIor;
+}
+#endif
+
+
+float scatteringPdf;
+vec3 cF;
+aa.scatteringIsDelta = false;
+bool bl = false;
+bool hj = false;
+ag prepared;
+
+#ifdef HAS_MEDIUM
+int mediumType = si.mediumType;
+float d = distance(si.position, aa.ray.o);
+vec3 ne = aa.ray.o;
+vec3 extinction = si.mediumExtinction;
+vec3 scattering = min(si.mediumScattering, extinction);
+float sl = max(max(extinction.x, extinction.y), extinction.z);
+if (mediumType > 0 && sl > 0.0) {
+
+
+
+
+int mT = min(int(dz(cv(MEDIUM_CHANNEL)) * 3.0), 2);
+float fA = extinction[mT];
+float ic = fA > 0.0
+? min(-log(max(dz(cv(MEDIUM_DISTANCE)), 1e-7)) / fA, d)
+: d;
+bl = ic < d;
+vec3 ew = exp(-extinction * ic);
+vec3 nM = bl
+? extinction * ew
+: ew;
+float nt = max(
+(nM.x + nM.y + nM.z) / 3.0,
+1e-8
+);
+if (bl) {
+aa.beta *= ew * scattering / nt;
+
+aa.ray.o = ne + ic * aa.ray.d;
+si.position = aa.ray.o;
+aa.li += mG(si, mat, prepared, aa, ffnormal, false) * aa.beta;
+
+
+cF = fl(
+-aa.ray.d,
+si.mediumAnisotropy,
+fk(cv(PHASE_DIRECTION))
+);
+scatteringPdf = bD(
+dot(cF, -aa.ray.d),
+si.mediumAnisotropy
+);
+}
+else {
+aa.beta *= ew / nt;
+}
+}
+#endif
+
+
+if (!bl) {
+aa.li += mat.emission * aa.beta;
+if (mat.materialType == UNLIT) {
+aa.abort = true;
+return;
+}
+vec3 pG = vec3(0.0);
+#ifdef USE_TANGENT
+pG = si.tangent;
+#endif
+mat.directionTangent = si.directionTangent;
+mat.directionBitangent = si.directionBitangent;
+mat.geometryTangent = si.geometryTangent;
+mat.geometryBitangent = si.geometryBitangent;
+prepared = eG(pG, mat, -aa.ray.d, ffnormal);
+aa.li += mG(si, mat, prepared, aa, ffnormal, true) * aa.beta;
+
+bool isNextRefraction;
+vec3 f = dv(
+prepared,
+ud,
+cF,
+scatteringPdf,
+isNextRefraction
+);
+
+aa.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(cF, cF) < 0.5) {
+aa.scatteringPdf = 0.0;
+aa.abort = true;
+return;
+}
+aa.beta *= f / scatteringPdf;
+hj = !mat.thinWalled &&
+isNextRefraction;
+aa.isNextRefraction = isNextRefraction;
+
+
+aa.ray.o = si.position + EPS * cF;
+#ifdef NUM_COAT_NORMAL_MAPS
+if (mat.coatNormalEnabled) { aa.ray.o = si.position + EPS * (dot(bC, cF) >= 0.0 ? bC : -bC); }
+#endif
+}
+
+aa.scatteringPdf = scatteringPdf;
+iw(aa.ray, aa.ray.o, cF);
+if (bl) {
+aa.isNextRefraction = false;
+}
+aa.fromEye = false;
+
+#ifdef HAS_MEDIUM
+
+
+if (!bl && hj && mat.mediumType > 0) {
+if (rA >= 0.0) {
+si.mediumType = mat.mediumType;
+si.mediumExtinction = mat.mediumExtinction;
+si.mediumScattering = mat.mediumScattering;
+si.mediumAnisotropy = mat.mediumAnisotropy;
+}
+else {
+si.mediumType = 0;
+si.mediumExtinction = vec3(0.0);
+si.mediumScattering = vec3(0.0);
+si.mediumAnisotropy = 0.0;
+}
+}
+#endif
+}
+`;
+//# sourceMappingURL=sampleMaterial.glsl.js.map

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

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

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

@@ -0,0 +1,2 @@
+declare const _default: string;
+export default _default;

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

@@ -0,0 +1,48 @@
+// Portions adapted from ray-tracing-renderer@0.10.15
+// (https://github.com/hoverinc/ray-tracing-renderer).
+// Copyright (c) 2019 HOVER, MIT license; see LICENSES/RayTracingRenderer-MIT.txt.
+// 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 `
+
+
+
+
+const uint SHADOW_CATCHER_LIGHT_SAMPLES = 4u;
+
+uint km(uint candidate, uint slot) {
+return candidate == 0u ? cv(slot) : cv(9u + (candidate - 1u) * 3u + slot);
+}
+
+void sampleShadowCatcher(ad si, int bounce, inout Path aa) {
+vec3 oH = -aa.ray.d;
+
+#if defined(NUM_LIGHTS) || defined(USE_ENVMAP)
+float visibility = 0.0;
+for (uint candidate = 0u; candidate < SHADOW_CATCHER_LIGHT_SAMPLES; candidate++) {
+LightSampleRec lightSample;
+vec3 kZ = vec3(
+fk(km(candidate, LIGHT_POSITION)),
+dz(km(candidate, LIGHT_SELECT))
+);
+sampleLight(si.position, kZ, lightSample, false);
+
+vec3 lightDir = lightSample.direction;
+float cosThetaL = dot(si.normal, lightDir);
+float pq = dot(si.normal, oH) * cosThetaL;
+bool mp = false;
+if (pq >= 0.0) {
+Ray ray;
+iw(ray, si.position + EPS * lightDir, lightDir);
+mp = ex(ray, lightSample.dist - EPS, si.triangleIndex);
+}
+visibility += mp ? 0.0 : 1.0;
+}
+
+aa.alpha = visibility / float(SHADOW_CATCHER_LIGHT_SAMPLES);
+#endif
+aa.fromEye = false;
+}
+`;
+//# sourceMappingURL=sampleShadowCatcher.glsl.js.map

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

@@ -0,0 +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"]}

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

@@ -0,0 +1,2 @@
+declare const _default: string;
+export default _default;