@meimu/mutracer 0.1.5 → 0.2.0

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

@@ -2,41 +2,41 @@
 // 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)));
+vec3 ta(SurfaceInteraction si, OpenPbrResolvedMaterial mat, ag prepared, inout Path aa, vec3 ffnormal, bool eM) {
+float lY = 1.0;
+vec3 lV = vec3(dZ(cE(LIGHT_POSITION)), dp(cE(LIGHT_SELECT)));
 
 LightSampleRec lightSample;
-sampleLight(si.position, ln, lightSample, false);
-lightSample.emission = ai(lightSample.emission, bf);
+sampleLight(si.position, lV, lightSample, false);
+lightSample.emission = aj(lightSample.emission, bp);
 
 vec3 lightDir = lightSample.direction;
-vec3 oS = -aa.ray.d;
-float fg = lightSample.pdf;
+vec3 qY = -aa.ray.d;
+float fA = lightSample.pdf;
 
 
 
 
 float cosThetaL = dot(ffnormal, lightDir);
 #ifdef USE_COAT_NORMAL_FRAMES
-if (gF && mat.coatNormalEnabled) { cosThetaL = dot(mat.geometricNormal, lightDir); }
+if (eM && 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 (fA <= 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 (eM) {
 if (cosThetaL <= 0.0 && mat.transmissionWeight <= 0.0 && mat.subsurfaceWeight <= 0.0) {
 return vec3(0.0);
 }
-f = bI(prepared, lightDir, scatteringPdf);
+f = bO(prepared, lightDir, scatteringPdf);
 }
 else {
-scatteringPdf = bD(
-dot(oS, lightDir),
+scatteringPdf = bL(
+dot(qY, lightDir),
 si.mediumAnisotropy
 );
 f = vec3(scatteringPdf);
@@ -46,83 +46,83 @@ 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 ns;
+vec3 hw = si.position + EPS * lightDir;
+if (eM) {
+const float ch = 0.1;
+float dL = dot(si.normal, lightDir);
 #ifdef USE_COAT_NORMAL_FRAMES
-if (mat.coatNormalEnabled) { dr = dot(si.faceNormal, lightDir); }
+if (mat.coatNormalEnabled) { dL = 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 = dL < 0.0 ? -si.faceNormal : si.faceNormal;
+dL = abs(dL);
+float iq = dot(geometricNormal, lightDir);
+float pq = dL < ch
 ? clamp(
-2.0 - (hS + dr) / bZ,
+2.0 - (iq + dL) / ch,
 0.0,
 1.0
 )
-: clamp(1.0 - hS / bZ, 0.0, 1.0);
-hi += si.shadowOffset * oB;
+: clamp(1.0 - iq / ch, 0.0, 1.0);
+hw += si.shadowOffset * pq;
 }
-iC(mz, hi, lightDir);
-if (ex(mz, lightSample.dist - EPS, si.triangleIndex)) {
+gC(ns, hw, lightDir);
+if (intersectSceneShadow(ns, lightSample.dist - EPS, 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 (eM && cosThetaL < 0.0 && lV.z < envLightSelectionPmf) {
+vec4 background = cG(ns.o, lightDir);
+lightSample.emission = aj(background.rgb * background.a, bp);
 }
 #endif
 
 
 
-float fa = lightSample.isDelta
+float fl = lightSample.isDelta
 ? 1.0
-: aG(fg, scatteringPdf);
-return fa > 0.0
-? fa * lightSample.emission * f / fg
+: aK(fA, scatteringPdf);
+return fl > 0.0
+? fl * lightSample.emission * f / fA
 : 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 fT(vec3 qt, vec3 face, vec3 view) {
+bool front = dot(face, view) >= 0.0;
+vec3 vP = front ? face : -face;
+vec3 sc = front ? qt : -qt;
+if (dot(qt, face) <= 0.0 || dot(sc, view) <= 1e-6) { return vP; }
+return sc;
 }
 #endif
-void mb(inout ad si, J mat, inout Path aa) {
-vec3 ur = vec3(fp(cw(BSDF_DIRECTION)), dz(cw(BSDF_LOBE)));
+void mL(inout SurfaceInteraction si, OpenPbrResolvedMaterial mat, inout Path aa) {
+vec3 vR = vec3(dZ(cE(BSDF_DIRECTION)), dp(cE(BSDF_LOBE)));
 #ifdef USE_COAT_NORMAL_FRAMES
-vec3 bC = si.faceNormal;
-vec3 mE = si.normal;
+vec3 bK = si.faceNormal;
+vec3 nB = si.normal;
 #endif
-float rN = -dot(si.faceNormal, aa.ray.d);
-float sG = -dot(si.normal, aa.ray.d);
+float sO = -dot(si.faceNormal, aa.ray.d);
+float tV = -dot(si.normal, aa.ray.d);
 if ((mat.transmissionWeight > 0.0 || mat.subsurfaceWeight > 0.0) && mat.thinWalled) {
 
-if (rN < 0.0) {
+if (sO < 0.0) {
 si.faceNormal = -si.faceNormal;
-rN = -rN;
+sO = -sO;
 }
-if (sG < 0.0) {
+if (tV < 0.0) {
 si.normal = -si.normal;
-sG = -sG;
+tV = -tV;
 }
 }
 
 
-bool pU = rN >= 0.0 && sG < 0.0;
-float ndv = pU ? rN : sG;
-vec3 normal = pU ? si.faceNormal : si.normal;
+bool qM = sO >= 0.0 && tV < 0.0;
+float ndv = qM ? sO : tV;
+vec3 normal = qM ? si.faceNormal : si.normal;
 
 mat.inside = ndv <= 0.0 && !mat.thinWalled;
 
@@ -131,96 +131,96 @@ 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;
+float gp = dot(bK, view);
+mat.geometricNormal = gp >= 0.0 ? bK : -bK;
+ffnormal = fT(nB, bK, view);
+mat.coatNormal = fT(si.coatNormal, bK, view);
+mat.inside = gp <= 0.0 && !mat.thinWalled;
+mat.relativeIor = (gp > 0.0 || mat.thinWalled) ? 1.0 / mat.specularIor : mat.specularIor;
 }
 #endif
 
 
 float scatteringPdf;
-vec3 cG;
+vec3 dH;
 aa.scatteringIsDelta = false;
-bool bl = false;
-bool hn = false;
+bool bs = false;
+bool hC = false;
 ag prepared;
 
 #ifdef HAS_MEDIUM
 int mediumType = si.mediumType;
 float d = distance(si.position, aa.ray.o);
-vec3 nu = aa.ray.o;
+vec3 os = aa.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 tR = max(max(extinction.x, extinction.y), extinction.z);
+if (mediumType > 0 && tR > 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 oi = min(int(dp(cE(MEDIUM_CHANNEL)) * 3.0), 2);
+float fS = extinction[oi];
+float iH = fS > 0.0
+? min(-log(max(dp(cE(MEDIUM_DISTANCE)), 1e-7)) / fS, d)
 : 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,
+bs = iH < d;
+vec3 transmittance = exp(-extinction * iH);
+vec3 oU = bs
+? extinction * transmittance
+: transmittance;
+float oE = max(
+(oU.x + oU.y + oU.z) / 3.0,
 1e-8
 );
-if (bl) {
-aa.beta *= ew * scattering / nK;
+if (bs) {
+aa.beta *= transmittance * scattering / oE;
 
-aa.ray.o = nu + ih * aa.ray.d;
+aa.ray.o = os + iH * aa.ray.d;
 si.position = aa.ray.o;
-aa.li += mT(si, mat, prepared, aa, ffnormal, false) * aa.beta;
+aa.li += ta(si, mat, prepared, aa, ffnormal, false) * aa.beta;
 
 
-cG = fq(
+dH = fH(
 -aa.ray.d,
 si.mediumAnisotropy,
-fp(cw(PHASE_DIRECTION))
+dZ(cE(PHASE_DIRECTION))
 );
-scatteringPdf = bD(
-dot(cG, -aa.ray.d),
+scatteringPdf = bL(
+dot(dH, -aa.ray.d),
 si.mediumAnisotropy
 );
 }
 else {
-aa.beta *= ew / nK;
+aa.beta *= transmittance / oE;
 }
 }
 #endif
 
 
-if (!bl) {
+if (!bs) {
 aa.li += mat.emission * aa.beta;
 if (mat.materialType == UNLIT) {
 aa.abort = true;
 return;
 }
-vec3 pS = vec3(0.0);
+vec3 qJ = vec3(0.0);
 #ifdef USE_TANGENT
-pS = si.tangent;
+qJ = 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 = ds(qJ, mat, -aa.ray.d, ffnormal);
+aa.li += ta(si, mat, prepared, aa, ffnormal, true) * aa.beta;
 
 bool isNextRefraction;
-vec3 f = dv(
+vec3 f = eN(
 prepared,
-ur,
-cG,
+vR,
+dH,
 scatteringPdf,
 isNextRefraction
 );
@@ -232,26 +232,26 @@ prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] >= 1.0 - 1e-6;
 
 
 if (!(scatteringPdf > 0.0) || any(isnan(f)) || any(isinf(f)) ||
-dot(cG, cG) < 0.5) {
+dot(dH, dH) < 0.5) {
 aa.scatteringPdf = 0.0;
 aa.abort = true;
 return;
 }
 aa.beta *= f / scatteringPdf;
-hn = !mat.thinWalled &&
+hC = !mat.thinWalled &&
 isNextRefraction;
 aa.isNextRefraction = isNextRefraction;
 
 
-aa.ray.o = si.position + EPS * cG;
+aa.ray.o = si.position + EPS * dH;
 #ifdef USE_COAT_NORMAL_FRAMES
-if (mat.coatNormalEnabled) { aa.ray.o = si.position + EPS * (dot(bC, cG) >= 0.0 ? bC : -bC); }
+if (mat.coatNormalEnabled) { aa.ray.o = si.position + EPS * (dot(bK, dH) >= 0.0 ? bK : -bK); }
 #endif
 }
 
 aa.scatteringPdf = scatteringPdf;
-iC(aa.ray, aa.ray.o, cG);
-if (bl) {
+gC(aa.ray, aa.ray.o, dH);
+if (bs) {
 aa.isNextRefraction = false;
 }
 aa.fromEye = false;
@@ -259,8 +259,8 @@ aa.fromEye = false;
 #ifdef HAS_MEDIUM
 
 
-if (!bl && hn && mat.mediumType > 0) {
-if (rN >= 0.0) {
+if (!bs && hC && mat.mediumType > 0) {
+if (sO >= 0.0) {
 si.mediumType = mat.mediumType;
 si.mediumExtinction = mat.mediumExtinction;
 si.mediumScattering = mat.mediumScattering;

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 lc(uint candidate, uint slot) {
+return candidate == 0u ? cE(slot) : cE(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 aa) {
+vec3 qY = -aa.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 lV = vec3(
+dZ(lc(candidate, LIGHT_POSITION)),
+dp(lc(candidate, LIGHT_SELECT))
 );
-sampleLight(si.position, ln, lightSample, false);
+sampleLight(si.position, lV, 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 qB = dot(si.normal, qY) * cosThetaL;
+if (lightSample.pdf > 0.0 && qB >= 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);
+gC(ray, si.position + EPS * lightDir, lightDir);
+bool lY = intersectSceneShadow(ray, lightSample.dist - EPS, si.triangleIndex);
+counts += vec2(lY ? 1.0 : 0.0, 1.0);
+}
 }
-visibility += mC ? 0.0 : 1.0;
 }
-
-aa.alpha = visibility / float(SHADOW_CATCHER_LIGHT_SAMPLES);
 #endif
 aa.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"]}