@meimu/mutracer 0.3.0 → 0.3.1

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

@@ -5,70 +5,70 @@ export default glsl `
 
 
 vec3 aA(vec3 view, vec2 alpha, vec2 samplePoint) {
-vec3 sn = vec3(alpha, 1.0);
-vec3 ce = normalize(sn * view);
-float qG = min(ce.z, 1.0);
-float jN = 1.0 + qG;
-float kf = (1.0 - samplePoint.y) * jN;
-float sR = samplePoint.y * jN;
-float ub = kf + (1.0 - qG);
-float dr = sqrt(max(0.0, ub * sR));
+vec3 qD = vec3(alpha, 1.0);
+vec3 cf = normalize(qD * view);
+float rU = min(cf.z, 1.0);
+float ku = 1.0 + rU;
+float kM = (1.0 - samplePoint.y) * ku;
+float ur = samplePoint.y * ku;
+float vK = kM + (1.0 - rU);
+float dw = sqrt(max(0.0, vK * ur));
 float azimuth = TWOPI * samplePoint.x;
-vec3 lX = vec3(
-ce.x + dr * cos(azimuth),
-ce.y + dr * sin(azimuth),
-kf
+vec3 mR = vec3(
+cf.x + dw * cos(azimuth),
+cf.y + dw * sin(azimuth),
+kM
 );
-return normalize(sn * lX);
+return normalize(qD * mR);
 }
 
-float sampling_ggx_ndf(vec3 oU, vec2 alpha) {
-vec3 hl = vec3(
-oU.x / alpha.x,
-oU.y / alpha.y,
-oU.z
+float sampling_ggx_ndf(vec3 qc, vec2 alpha) {
+vec3 hG = vec3(
+qc.x / alpha.x,
+qc.y / alpha.y,
+qc.z
 );
-float ah = dot(hl, hl);
+float ah = dot(hG, hG);
 return 1.0 / (
 PI * alpha.x * alpha.y * ah * ah
 );
 }
 
 float aD(vec3 direction, vec2 alpha) {
-float eB = abs(direction.z);
-if (eB <= 1e-8) {
+float eK = abs(direction.z);
+if (eK <= 1e-8) {
 return 0.0;
 }
-vec2 hZ = alpha * direction.xy;
-float lY = dot(hZ, hZ)
-/ (eB * eB);
-return 2.0 / (1.0 + sqrt(1.0 + lY));
+vec2 iK = alpha * direction.xy;
+float mS = dot(iK, iK)
+/ (eK * eK);
+return 2.0 / (1.0 + sqrt(1.0 + mS));
 }
 
-float aH(float cosine) {
-float cY = clamp(1.0 - cosine, 0.0, 1.0);
-return pow(cY, 5.0);
+float aI(float cosine) {
+float da = clamp(1.0 - cosine, 0.0, 1.0);
+return pow(da, 5.0);
 }
 
-float sampling_dielectric_fresnel(float J, float cE) {
-float iB = clamp(abs(J), 0.0, 1.0);
-float kv = cE * cE
-* max(0.0, 1.0 - iB * iB);
-if (kv >= 1.0) {
+float sampling_dielectric_fresnel(float J, float cH) {
+float ja = clamp(abs(J), 0.0, 1.0);
+float ld = cH * cH
+* max(0.0, 1.0 - ja * ja);
+if (ld >= 1.0) {
 return 1.0;
 }
 
-float ml = sqrt(max(0.0, 1.0 - kv));
-float bd = (iB - cE * ml)
-/ max(iB + cE * ml, 1e-8);
-float qu = (cE * iB - ml)
-/ max(cE * iB + ml, 1e-8);
+float nh = sqrt(max(0.0, 1.0 - ld));
+float bf = (ja - cH * nh)
+/ max(ja + cH * nh, 1e-8);
+float rH = (cH * ja - nh)
+/ max(cH * ja + nh, 1e-8);
 return 0.5 * (
-bd * bd + qu * qu
+bf * bf + rH * rH
 );
 }
 
-vec2 gi(vec2 samplePoint) {
+vec2 gA(vec2 samplePoint) {
 vec2 offset = 2.0 * samplePoint - vec2(1.0);
 if (offset.x == 0.0 && offset.y == 0.0) {
 return vec2(0.0);
@@ -88,35 +88,35 @@ return radius * vec2(cos(angle), sin(angle));
 }
 
 vec3 aM(vec2 samplePoint) {
-vec2 kS = gi(samplePoint);
+vec2 lL = gA(samplePoint);
 return vec3(
-kS,
-sqrt(max(0.0, 1.0 - dot(kS, kS)))
+lL,
+sqrt(max(0.0, 1.0 - dot(lL, lL)))
 );
 }
 
-float aF(float firstPdf, float secondPdf) {
+float aG(float firstPdf, float secondPdf) {
 float scale = max(firstPdf, secondPdf);
 if (scale <= 0.0) {
 return 0.0;
 }
 vec2 normalized = vec2(firstPdf, secondPdf) / scale;
-vec2 pq = normalized * normalized;
-return pq.x / (pq.x + pq.y);
+vec2 qC = normalized * normalized;
+return qC.x / (qC.x + qC.y);
 }
 
 void sampling_orthonormal_basis(in vec3 normal, out vec3 tangent, out vec3 bitangent) {
-float ik = normal.z >= 0.0 ? 1.0 : -1.0;
-float cv = -1.0 / (ik + normal.z);
-float xy = normal.x * normal.y * cv;
+float iP = normal.z >= 0.0 ? 1.0 : -1.0;
+float cA = -1.0 / (iP + normal.z);
+float xy = normal.x * normal.y * cA;
 tangent = vec3(
-1.0 + ik * normal.x * normal.x * cv,
-ik * xy,
--ik * normal.x
+1.0 + iP * normal.x * normal.x * cA,
+iP * xy,
+-iP * normal.x
 );
 bitangent = vec3(
 xy,
-ik + normal.y * normal.y * cv,
+iP + normal.y * normal.y * cA,
 -normal.y
 );
 }
@@ -125,37 +125,37 @@ vec3 sampling_spectral_rgb_filter(vec3 rgb, int channel) {
 if (channel == 0) {
 return rgb;
 }
-vec3 sZ = vec3(0.0);
-sZ[channel - 1] = 1.0;
-return rgb * sZ;
+vec3 uC = vec3(0.0);
+uC[channel - 1] = 1.0;
+return rgb * uC;
 }
 
 float sampling_cauchy_ior(
 float wavelength,
-float ha,
-float hk,
-float rm
+float hy,
+float hF,
+float sD
 ) {
-if (wavelength == 0.0 || hk <= 0.0) {
-return ha;
+if (wavelength == 0.0 || hF <= 0.0) {
+return hy;
 }
 
 const float FRAUNHOFER_C = 656.3;
 const float FRAUNHOFER_D = 587.6;
 const float FRAUNHOFER_F = 486.1;
-float jX = 1.0 / (
+float kD = 1.0 / (
 1.0 / (FRAUNHOFER_F * FRAUNHOFER_F)
 - 1.0 / (FRAUNHOFER_C * FRAUNHOFER_C)
 );
-float nU = max(rm / hk, 1e-6);
-float rR = (ha - 1.0) * jX / nU;
-float uO = ha
-- rR / (FRAUNHOFER_D * FRAUNHOFER_D);
-return uO + rR / (wavelength * wavelength);
+float oT = max(sD / hF, 1e-6);
+float tj = (hy - 1.0) * kD / oT;
+float wx = hy
+- tj / (FRAUNHOFER_D * FRAUNHOFER_D);
+return wx + tj / (wavelength * wavelength);
 }
 
-vec3 fj(
-vec3 gw,
+vec3 dQ(
+vec3 gQ,
 float anisotropy,
 vec2 samplePoint
 ) {
@@ -164,24 +164,24 @@ if (abs(anisotropy) < 0.001) {
 cosine = 1.0 - 2.0 * samplePoint.y;
 }
 else {
-float iZ = (1.0 - anisotropy * anisotropy)
+float fw = (1.0 - anisotropy * anisotropy)
 / (1.0 + anisotropy - 2.0 * anisotropy * samplePoint.y);
 cosine = (
-iZ * iZ - 1.0 - anisotropy * anisotropy
+fw * fw - 1.0 - anisotropy * anisotropy
 ) / (2.0 * anisotropy);
 }
 
-float uC = sqrt(max(0.0, 1.0 - cosine * cosine));
+float wk = sqrt(max(0.0, 1.0 - cosine * cosine));
 float azimuth = TWOPI * samplePoint.x;
 vec3 tangent;
 vec3 bitangent;
-sampling_orthonormal_basis(gw, tangent, bitangent);
-return tangent * (uC * cos(azimuth))
-+ bitangent * (uC * sin(azimuth))
-+ gw * cosine;
+sampling_orthonormal_basis(gQ, tangent, bitangent);
+return tangent * (wk * cos(azimuth))
++ bitangent * (wk * sin(azimuth))
++ gQ * cosine;
 }
 
-float bB(float cosine, float anisotropy) {
+float ba(float cosine, float anisotropy) {
 float ah = 1.0 + anisotropy * anisotropy
 + 2.0 * anisotropy * cosine;
 return INV4PI * (1.0 - anisotropy * anisotropy)

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

@@ -24,41 +24,41 @@ const uint BOUNCE_STRIDE = 64u;
 
 
 
-uvec2 aI;
+uvec2 aJ;
 uint aC;
 uint samplingBounce = 0u;
-uint ca = 0u;
-uint cB(uint kC) {
-uint x = kC;
+uint hashedCounter = 0u;
+uint cD(uint lm) {
+uint x = lm;
 x ^= x >> 16u; x *= 0x7feb352du;
 x ^= x >> 15u; x *= 0x846ca68bu;
 return x ^ (x >> 16u);
 }
 uint ak(uint a, uint b) {
-return cB(a ^ cB(b + 0x9e3779b9u));
+return cD(a ^ cD(b + 0x9e3779b9u));
 }
-uint iD(uint kC, uint seed) {
-uint x = kC + seed;
+uint jc(uint lm, uint seed) {
+uint x = lm + seed;
 x ^= x * 0x6c50b47cu; x ^= x * 0xb82f1e52u;
 x ^= x * 0xc7afe638u; x ^= x * 0x8d22f6e6u;
 return x;
 }
-uint ud(uint x, uint seed) {
-return reverseBits(iD(reverseBits(x), seed));
+uint vN(uint x, uint seed) {
+return reverseBits(jc(reverseBits(x), seed));
 }
 
-uint sm(uint kC) {
-uint r = reverseBits(kC);
+uint tP(uint lm) {
+uint r = reverseBits(lm);
 ${sobolD1Steps.map(([shift, mask]) => `r ^= (r << ${shift}u) & 0x${mask.toString(16)}u;`).join("\n  ")}
 return r;
 }
-vec2 yf(uint index, uint seed) {
-uint i = ud(index, ak(seed, 0u));
-uint x = reverseBits(iD(i, ak(seed, 1u)));
-uint y = ud(sm(i), ak(seed, 2u));
+vec2 Ac(uint index, uint seed) {
+uint i = vN(index, ak(seed, 0u));
+uint x = reverseBits(jc(i, ak(seed, 1u)));
+uint y = vN(tP(i), ak(seed, 2u));
 return vec2(float(x >> 8u), float(y >> 8u)) * (1.0 / 16777216.0);
 }
-uint uX(uvec2 p) {
+uint wL(uvec2 p) {
 uvec2 v = p & uvec2(255u);
 v = (v | (v << uvec2(4u))) & uvec2(0x0f0fu);
 v = (v | (v << uvec2(2u))) & uvec2(0x3333u);
@@ -66,104 +66,104 @@ v = (v | (v << uvec2(1u))) & uvec2(0x5555u);
 return v.x | (v.y << 1u);
 }
 ${zSobolPackedPermutations.map((v, i) => `const uint Z_PERM_${i} = ${v}u;`).join("\n")}
-uint kG(uint va) {
-uint group = va >> 2u;
+uint lq(uint wO) {
+uint group = wO >> 2u;
 uint word = Z_PERM_5;
 ${[0, 1, 2, 3, 4].map(i => `word = group == ${i}u ? Z_PERM_${i} : word;`).join("\n  ")}
-return (word >> ((va & 3u) * 8u)) & 255u;
+return (word >> ((wO & 3u) * 8u)) & 255u;
 }
-uint qJ(uint kY, uint dim, uint logSPP) {
+uint rX(uint lS, uint dim, uint logSPP) {
 uint odd = logSPP & 1u;
-uint wb = 8u + ((logSPP + 1u) >> 1u);
+uint xX = 8u + ((logSPP + 1u) >> 1u);
 uint result = 0u;
-for (int digit = int(wb) - 1; digit >= int(odd); digit--) {
+for (int digit = int(xX) - 1; digit >= int(odd); digit--) {
 uint shift = 2u*uint(digit) - odd;
 
-uint tN = 0u;
-if (shift < 30u) { tN = kY >> (shift + 2u); }
-uint va = (cB(tN ^ (0x55555555u * dim)) >> 24u) % 24u;
-uint d = (kY >> shift) & 3u;
-result |= ((kG(va) >> (2u*d)) & 3u) << shift;
+uint vs = 0u;
+if (shift < 30u) { vs = lS >> (shift + 2u); }
+uint wO = (cD(vs ^ (0x55555555u * dim)) >> 24u) % 24u;
+uint d = (lS >> shift) & 3u;
+result |= ((lq(wO) >> (2u*d)) & 3u) << shift;
 }
 if (odd != 0u) {
-result |= (kY & 1u) ^ (cB((kY >> 1u) ^ (0x55555555u * dim)) & 1u);
+result |= (lS & 1u) ^ (cD((lS >> 1u) ^ (0x55555555u * dim)) & 1u);
 }
 return result;
 }
 
 
 
-uint bE(uint slot) {
+uint aX(uint slot) {
 return CAMERA_BEVEL_BASE + uint(BEVEL_SAMPLES) + samplingBounce * BOUNCE_STRIDE + slot;
 }
 
-uvec4 hg;
-uint hh;
-bool fA = false;
-bool cX = false;
-uint dD;
-uint gt;
-vec2 eJ;
-void dm(uint dim) {
+uvec4 hC;
+uint hD;
+bool fM = false;
+bool cZ = false;
+uint dF;
+uint gM;
+vec2 eT;
+void ds(uint dim) {
 
-uint kl = aI.x + aI.y * uint(round(1.0 / pixelSize.x));
-uvec4 key = uvec4(dim, aC, kl, uint(sequenceSeed));
-if (fA && all(equal(hg, key)) && hh == uint(zSobolLogSPP)) { return; }
-hg = key; hh = uint(zSobolLogSPP);
-fA = true; cX = false;
-uint seed = ak(ak(kl, dim), uint(sequenceSeed));
+uint kT = aJ.x + aJ.y * uint(round(1.0 / pixelSize.x));
+uvec4 key = uvec4(dim, aC, kT, uint(sequenceSeed));
+if (fM && all(equal(hC, key)) && hD == uint(zSobolLogSPP)) { return; }
+hC = key; hD = uint(zSobolLogSPP);
+fM = true; cZ = false;
+uint seed = ak(ak(kT, dim), uint(sequenceSeed));
 uint index = aC;
 if (samplingPattern == 1) {
 uint logSPP = uint(zSobolLogSPP);
 if (index == 0u) { logSPP = 0u; }
 else { index -= 1u; }
 
-uint jd = index >> logSPP;
+uint jH = index >> logSPP;
 uint mask = (1u << logSPP) - 1u;
-uint kY = (uX(aI) << logSPP) | (index & mask);
-index = qJ(kY, dim, logSPP);
-uvec2 tile = aI >> uvec2(8u);
+uint lS = (wL(aJ) << logSPP) | (index & mask);
+index = rX(lS, dim, logSPP);
+uvec2 tile = aJ >> uvec2(8u);
 seed = ak(ak(dim, uint(sequenceSeed)), ak(tile.x, tile.y));
 
-if (aC != 0u) { jd += 1u; }
-seed = ak(seed, jd);
+if (aC != 0u) { jH += 1u; }
+seed = ak(seed, jH);
 }
-dD = ud(index, ak(seed, 0u));
-gt = seed;
-uint x = reverseBits(iD(dD, ak(seed, 1u)));
-eJ.x = float(x >> 8u) * (1.0 / 16777216.0);
+dF = vN(index, ak(seed, 0u));
+gM = seed;
+uint x = reverseBits(jc(dF, ak(seed, 1u)));
+eT.x = float(x >> 8u) * (1.0 / 16777216.0);
 }
-vec2 le(uint dim) {
-dm(dim);
-if (!cX) {
-uint y = ud(sm(dD), ak(gt, 2u));
-eJ.y = float(y >> 8u) * (1.0 / 16777216.0);
-cX = true;
+vec2 lZ(uint dim) {
+ds(dim);
+if (!cZ) {
+uint y = vN(tP(dF), ak(gM, 2u));
+eT.y = float(y >> 8u) * (1.0 / 16777216.0);
+cZ = true;
 }
-return EPS + (1.0 - 2.0*EPS) * eJ;
+return EPS + (1.0 - 2.0*EPS) * eT;
 }
 float sample1D(uint dim) {
 if (samplingPattern == 2) { return EPS + (1.0 - 2.0*EPS)*rand(); }
-dm(dim);
-return EPS + (1.0 - 2.0*EPS) * eJ.x;
+ds(dim);
+return EPS + (1.0 - 2.0*EPS) * eT.x;
 }
 vec2 sample2D(uint dim) {
 if (samplingPattern == 2) {
 float x = sample1D(dim); float y = sample1D(dim);
 return vec2(x,y);
 }
-return le(dim);
+return lZ(dim);
 }
 
-float ek(uint slot) {
-uint dim = ak(ak(samplingBounce, slot), ca) | 0x80000000u;
-ca += 1u;
+float cm(uint slot) {
+uint dim = ak(ak(samplingBounce, slot), hashedCounter) | 0x80000000u;
+hashedCounter += 1u;
 if (samplingPattern == 2) { return EPS + (1.0 - 2.0*EPS)*rand(); }
 
-uint kl = aI.x + aI.y * uint(round(1.0 / pixelSize.x));
-uint seed = ak(ak(kl, dim), uint(sequenceSeed));
-uint i = ud(aC, ak(seed, 0u));
-uint x = reverseBits(iD(i, ak(seed, 1u)));
+uint kT = aJ.x + aJ.y * uint(round(1.0 / pixelSize.x));
+uint seed = ak(ak(kT, dim), uint(sequenceSeed));
+uint i = vN(aC, ak(seed, 0u));
+uint x = reverseBits(jc(i, ak(seed, 1u)));
 return EPS + (1.0 - 2.0*EPS) * (float(x >> 8u) * (1.0 / 16777216.0));
 }
 `;

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

@@ -0,0 +1,6 @@
+export declare const spectralPrefixGlsl = "\nstruct SpectralCompleted {\n  bool ready; vec4 result; RayTraceAuxiliary aux;\n  uvec4 rng; uint counter; uint bounce;\n};\nSpectralCompleted spCompleted[2];\nbool spActive = true;\nint spChannel;\nint spCall = 0;\nint spForkCall = -1;\nstruct SpectralPrimary {\n  SurfaceInteraction si; OpenPbrResolvedMaterial mat; RayTraceAuxiliary aux;\n  uvec4 rng; uint counter; uint bounce;\n};\nSpectralPrimary spPrimary;\nbool spDisperses(OpenPbrResolvedMaterial mat) {\n  return mat.transmissionDispersionScale > 0.0 && mat.specularIor != 1.0;\n}\nvoid spFork(inout Path path) {\n  spActive = false; pathChannel = spChannel;\n  path.li = sampling_spectral_rgb_filter(path.li, spChannel);\n}\nvec4 spReplay(int slot, inout RayTraceAuxiliary aux) {\n  SpectralCompleted saved = spCompleted[slot];\n  aux = saved.aux; s0 = saved.rng; hashedCounter = saved.counter; samplingBounce = saved.bounce;\n  return vec4(sampling_spectral_rgb_filter(saved.result.rgb, spChannel), saved.result.a);\n}\nvec4 spFinish(int slot, vec4 result, RayTraceAuxiliary aux) {\n  if (!spActive) return result;\n  if (spChannel == 1) spCompleted[slot] = SpectralCompleted(true, result, aux, s0, hashedCounter, samplingBounce);\n  return vec4(sampling_spectral_rgb_filter(result.rgb, spChannel), result.a);\n}\n";
+export type PrefixBindings = Record<string, [type: string, expression: string]>;
+export declare const prefixRandomBindings: PrefixBindings;
+export declare function prefixCheckpoint(name: string, bindings: PrefixBindings): string;
+export declare function prefixSave(name: string, bindings: PrefixBindings): string;
+export declare function prefixRestore(name: string, bindings: PrefixBindings): string;

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

@@ -0,0 +1,47 @@
+// The three wavelength continuations run inside one fragment invocation.
+export const spectralPrefixGlsl = /* glsl */ `
+struct eE {
+bool ready; vec4 result; RayTraceAuxiliary aux;
+uvec4 rng; uint counter; uint bounce;
+};
+eE eB[2];
+bool spActive = true;
+int spChannel;
+int qz = 0;
+int fC = -1;
+struct qI {
+SurfaceInteraction si; OpenPbrResolvedMaterial mat; RayTraceAuxiliary aux;
+uvec4 rng; uint counter; uint bounce;
+};
+qI lY;
+bool gf(OpenPbrResolvedMaterial mat) {
+return mat.transmissionDispersionScale > 0.0 && mat.specularIor != 1.0;
+}
+void qA(inout Path path) {
+spActive = false; pathChannel = spChannel;
+path.li = sampling_spectral_rgb_filter(path.li, spChannel);
+}
+vec4 rN(int slot, inout RayTraceAuxiliary aux) {
+eE oM = eB[slot];
+aux = oM.aux; s0 = oM.rng; hashedCounter = oM.counter; samplingBounce = oM.bounce;
+return vec4(sampling_spectral_rgb_filter(oM.result.rgb, spChannel), oM.result.a);
+}
+vec4 spFinish(int slot, vec4 result, RayTraceAuxiliary aux) {
+if (!spActive) return result;
+if (spChannel == 1) eB[slot] = eE(true, result, aux, s0, hashedCounter, samplingBounce);
+return vec4(sampling_spectral_rgb_filter(result.rgb, spChannel), result.a);
+}
+`;
+export const prefixRandomBindings = {
+    rng: ['uvec4', 's0'], counter: ['uint', 'hashedCounter'], bounce: ['uint', 'samplingBounce']
+};
+export function prefixCheckpoint(name, bindings) {
+    return `struct ${name}State {\n${Object.entries(bindings).map(([key, [type]]) => `  ${type} ${key};`).join('\n')}\n};\n${name}State ${name};\n`;
+}
+export function prefixSave(name, bindings) {
+    return Object.entries(bindings).map(([key, [, value]]) => `${name}.${key} = ${value};`).join('\n');
+}
+export function prefixRestore(name, bindings) {
+    return Object.entries(bindings).map(([key, [, value]]) => `${value} = ${name}.${key};`).join('\n');
+}
+//# sourceMappingURL=spectralPrefix.glsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"spectralPrefix.glsl.js","sourceRoot":"","sources":["../../../../src/renderer/glsl/chunks/spectralPrefix.glsl.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,MAAM,CAAC,MAAM,kBAAkB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgC5C,CAAC;AAEF,MAAM,CAAC,MAAM,oBAAoB,GAAmB;IAClD,GAAG,EAAE,CAAC,OAAO,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,CAAC,MAAM,EAAE,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC,MAAM,EAAE,gBAAgB,CAAC;CAC7F,CAAC;AACF,MAAM,UAAU,gBAAgB,CAAC,IAAY,EAAE,QAAwB;IACrE,OAAO,UAAU,IAAI,YAAY,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,IAAI,IAAI,GAAG,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,SAAS,IAAI,KAAK,CAAC;AAClJ,CAAC;AACD,MAAM,UAAU,UAAU,CAAC,IAAY,EAAE,QAAwB;IAC/D,OAAO,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,IAAI,IAAI,GAAG,MAAM,KAAK,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACrG,CAAC;AACD,MAAM,UAAU,aAAa,CAAC,IAAY,EAAE,QAAwB;IAClE,OAAO,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,KAAK,MAAM,IAAI,IAAI,GAAG,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACrG,CAAC","sourcesContent":["// The three wavelength continuations run inside one fragment invocation.\nexport const spectralPrefixGlsl = /* glsl */ `\nstruct SpectralCompleted {\n  bool ready; vec4 result; RayTraceAuxiliary aux;\n  uvec4 rng; uint counter; uint bounce;\n};\nSpectralCompleted spCompleted[2];\nbool spActive = true;\nint spChannel;\nint spCall = 0;\nint spForkCall = -1;\nstruct SpectralPrimary {\n  SurfaceInteraction si; OpenPbrResolvedMaterial mat; RayTraceAuxiliary aux;\n  uvec4 rng; uint counter; uint bounce;\n};\nSpectralPrimary spPrimary;\nbool spDisperses(OpenPbrResolvedMaterial mat) {\n  return mat.transmissionDispersionScale > 0.0 && mat.specularIor != 1.0;\n}\nvoid spFork(inout Path path) {\n  spActive = false; pathChannel = spChannel;\n  path.li = sampling_spectral_rgb_filter(path.li, spChannel);\n}\nvec4 spReplay(int slot, inout RayTraceAuxiliary aux) {\n  SpectralCompleted saved = spCompleted[slot];\n  aux = saved.aux; s0 = saved.rng; hashedCounter = saved.counter; samplingBounce = saved.bounce;\n  return vec4(sampling_spectral_rgb_filter(saved.result.rgb, spChannel), saved.result.a);\n}\nvec4 spFinish(int slot, vec4 result, RayTraceAuxiliary aux) {\n  if (!spActive) return result;\n  if (spChannel == 1) spCompleted[slot] = SpectralCompleted(true, result, aux, s0, hashedCounter, samplingBounce);\n  return vec4(sampling_spectral_rgb_filter(result.rgb, spChannel), result.a);\n}\n`;\nexport type PrefixBindings = Record<string, [type: string, expression: string]>;\nexport const prefixRandomBindings: PrefixBindings = {\n  rng: ['uvec4', 's0'], counter: ['uint', 'hashedCounter'], bounce: ['uint', 'samplingBounce']\n};\nexport function prefixCheckpoint(name: string, bindings: PrefixBindings) {\n  return `struct ${name}State {\\n${Object.entries(bindings).map(([key, [type]]) => `  ${type} ${key};`).join('\\n')}\\n};\\n${name}State ${name};\\n`;\n}\nexport function prefixSave(name: string, bindings: PrefixBindings) {\n  return Object.entries(bindings).map(([key, [, value]]) => `${name}.${key} = ${value};`).join('\\n');\n}\nexport function prefixRestore(name: string, bindings: PrefixBindings) {\n  return Object.entries(bindings).map(([key, [, value]]) => `${value} = ${name}.${key};`).join('\\n');\n}\n"]}

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

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

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

@@ -8,12 +8,12 @@ float phi = acos(n.y) / PI;
 return vec2(theta, 1.0 - phi);
 }
 
-vec2 iO(vec3 pos, vec3 normal, vec2 uvScale) {
-vec3 dg = abs(normal);
+vec2 jq(vec3 pos, vec3 normal, vec2 uvScale) {
+vec3 dj = abs(normal);
 vec2 uv = vec2(0.0);
-if (dg.x > dg.y && dg.x > dg.z) {
+if (dj.x > dj.y && dj.x > dj.z) {
 uv = pos.yz;
-} else if (dg.y > dg.x && dg.y > dg.z) {
+} else if (dj.y > dj.x && dj.y > dj.z) {
 uv = pos.xz;
 } else {
 uv = pos.xy;
@@ -53,18 +53,18 @@ return fract(uv * uvScale);
 
 
 
-vec2 hA(vec3 pos, vec3 normal) {
+vec2 hW(vec3 pos, vec3 normal) {
 float theta = atan(pos.z, pos.x) / (2.0 * PI) + 0.5;
 return vec2(theta, pos.y);
 }
 
-vec2 gE(int fg, vec3 pos, vec3 normal, vec2 uvScale) {
-if (fg == ${uvProjectionConstants.triplanar + ''}) {
-return iO(pos, normal, uvScale);
-} else if (fg == ${uvProjectionConstants.spherical + ''}) {
+vec2 gW(int fu, vec3 pos, vec3 normal, vec2 uvScale) {
+if (fu == ${uvProjectionConstants.triplanar + ''}) {
+return jq(pos, normal, uvScale);
+} else if (fu == ${uvProjectionConstants.spherical + ''}) {
 return sphericalProjection(pos) * uvScale;
-} else if (fg == ${uvProjectionConstants.cylindrical + ''}) {
-return hA(pos, normal) * uvScale;
+} else if (fu == ${uvProjectionConstants.cylindrical + ''}) {
+return hW(pos, normal) * uvScale;
 }
 return vec2(0.0);
 }

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

@@ -1,3 +1,4 @@
+import cameraProjection from './chunks/cameraProjection.glsl.js';
 import { FragmentShader, Shader } from '../shader.js';
 import { DEPTH_SAMPLE_GRID } from '../depthQuery.js';
 import common from './chunks/common.glsl.js';
@@ -14,6 +15,7 @@ export default new FragmentShader({
     uniforms: {
         depthArea: Shader.uniform('vec4'),
         viewProjectionInv: Shader.uniform('mat4'),
+        projectionInv: Shader.uniform('mat4'),
         viewInv: Shader.uniform('mat4')
     },
     main: /* glsl */ `
@@ -24,16 +26,16 @@ ${core.main}
 ${uvProjection}
 ${materials.main}
 ${intersect.main}
+${cameraProjection}
 
 void main() {
+bool picking = depthArea.z < 0.0;
+if (picking && any(greaterThan(gl_FragCoord.xy, vec2(1.0)))) {out_depth = vec4(0.0); return;}
 vec2 offset = floor(gl_FragCoord.xy) / ${DEPTH_SAMPLE_GRID - 1}.0 * 2.0 - 1.0;
-vec2 uv = depthArea.xy + depthArea.zw * offset * vec2(1.0, -1.0);
+vec2 uv = picking ? depthArea.xy : depthArea.xy + depthArea.zw * offset * vec2(1.0, -1.0);
 out_depth = vec4(0.0);
 if (any(lessThan(uv, vec2(0.0))) || any(greaterThan(uv, vec2(1.0)))) return;
-vec4 origin = viewProjectionInv * vec4(uv * 2.0 - 1.0, -1.0, 1.0);
-vec4 target = viewProjectionInv * vec4(uv * 2.0 - 1.0, 1.0, 1.0);
-Ray ray;
-initRay(ray, origin.xyz / origin.w, normalize(target.xyz * origin.w - origin.xyz * target.w));
+Ray ray = cV(uv);
 vec3 eye = viewInv[3].xyz;
 vec3 forward = -normalize(viewInv[2].xyz);
 SurfaceInteraction si;
@@ -44,7 +46,11 @@ if (!si.hit) return;
 OpenPbrResolvedMaterial material;
 getMaterial(material, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
 if (material.materialType != SHADOW_CATCHER && material.alpha > 0.0) {
-out_depth.r = max(dot(si.position - eye, forward), 0.0);
+if (picking) {
+uint instance = uint(si.instanceIndex) + 1u, materialIndex = uint(si.materialIndex) + 1u;
+out_depth = vec4(float(instance & 65535u), float(instance >> 16u),
+float(materialIndex & 65535u), float(materialIndex >> 16u));
+} else out_depth.r = max(dot(si.position - eye, forward), 0.0);
 return;
 }
 ray.o = si.position + ray.d * (EPS * 0.02);

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

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