@meimu/mutracer 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,194 @@
+import { glsl } from '../../shader.js';
+export default glsl `
+
+
+
+
+vec3 aQ(vec3 view, vec2 alpha, vec2 samplePoint) {
+vec3 qY = vec3(alpha, 1.0);
+vec3 ge = normalize(qY * view);
+float tU = min(ge.z, 1.0);
+float qD = 1.0 + tU;
+float qT = (1.0 - samplePoint.y) * qD;
+float rE = samplePoint.y * qD;
+float st = qT + (1.0 - tU);
+float fi = sqrt(max(0.0, st * rE));
+float br = TWOPI * samplePoint.x;
+vec3 lt = vec3(
+ge.x + fi * cos(br),
+ge.y + fi * sin(br),
+qT
+);
+return normalize(qY * lt);
+}
+
+float gE(vec3 oa, vec2 alpha) {
+vec3 hm = vec3(
+oa.x / alpha.x,
+oa.y / alpha.y,
+oa.z
+);
+float ap = dot(hm, hm);
+return 1.0 / (
+PI * alpha.x * alpha.y * ap * ap
+);
+}
+
+float bk(vec3 direction, vec2 alpha) {
+float eE = abs(direction.z);
+if (eE <= 1e-8) {
+return 0.0;
+}
+vec2 hZ = alpha * direction.xy;
+float lu = dot(hZ, hZ)
+/ (eE * eE);
+return 2.0 / (1.0 + sqrt(1.0 + lu));
+}
+
+float aE(float au) {
+float dg = clamp(1.0 - au, 0.0, 1.0);
+return pow(dg, 5.0);
+}
+
+float ct(float L, float cJ) {
+float iu = clamp(abs(L), 0.0, 1.0);
+float kc = cJ * cJ
+* max(0.0, 1.0 - iu * iu);
+if (kc >= 1.0) {
+return 1.0;
+}
+
+float lH = sqrt(max(0.0, 1.0 - kc));
+float ba = (iu - cJ * lH)
+/ max(iu + cJ * lH, 1e-8);
+float pr = (cJ * iu - lH)
+/ max(cJ * iu + lH, 1e-8);
+return 0.5 * (
+ba * ba + pr * pr
+);
+}
+
+vec2 gc(vec2 samplePoint) {
+vec2 offset = 2.0 * samplePoint - vec2(1.0);
+if (offset.x == 0.0 && offset.y == 0.0) {
+return vec2(0.0);
+}
+
+float radius;
+float angle;
+if (abs(offset.x) > abs(offset.y)) {
+radius = offset.x;
+angle = 0.25 * PI * (offset.y / offset.x);
+}
+else {
+radius = offset.y;
+angle = 0.5 * PI - 0.25 * PI * (offset.x / offset.y);
+}
+return radius * vec2(cos(angle), sin(angle));
+}
+
+vec3 bi(vec2 samplePoint) {
+vec2 kv = gc(samplePoint);
+return vec3(
+kv,
+sqrt(max(0.0, 1.0 - dot(kv, kv)))
+);
+}
+
+float aF(float pe, float nA) {
+float scale = max(pe, nA);
+if (scale <= 0.0) {
+return 0.0;
+}
+vec2 normalized = vec2(pe, nA) / scale;
+vec2 oD = normalized * normalized;
+return oD.x / (oD.x + oD.y);
+}
+
+void aK(in vec3 normal, out vec3 tangent, out vec3 bitangent) {
+float ig = normal.z >= 0.0 ? 1.0 : -1.0;
+float dW = -1.0 / (ig + normal.z);
+float xy = normal.x * normal.y * dW;
+tangent = vec3(
+1.0 + ig * normal.x * normal.x * dW,
+ig * xy,
+-ig * normal.x
+);
+bitangent = vec3(
+xy,
+ig + normal.y * normal.y * dW,
+-normal.y
+);
+}
+
+vec3 ai(vec3 rgb, float wavelength) {
+if (wavelength == 0.0) {
+return rgb;
+}
+vec3 tB = wavelength > 600.0
+? vec3(1.0, 0.0, 0.0)
+: wavelength > 500.0
+? vec3(0.0, 1.0, 0.0)
+: vec3(0.0, 0.0, 1.0);
+return rgb * tB;
+}
+
+float eK(
+float wavelength,
+float ha,
+float hk,
+float qg
+) {
+if (wavelength == 0.0 || hk <= 0.0) {
+return ha;
+}
+
+const float FRAUNHOFER_C = 656.3;
+const float FRAUNHOFER_D = 587.6;
+const float FRAUNHOFER_F = 486.1;
+float jI = 1.0 / (
+1.0 / (FRAUNHOFER_F * FRAUNHOFER_F)
+- 1.0 / (FRAUNHOFER_C * FRAUNHOFER_C)
+);
+float mQ = max(qg / hk, 1e-6);
+float qE = (ha - 1.0) * jI / mQ;
+float sY = ha
+- qE / (FRAUNHOFER_D * FRAUNHOFER_D);
+return sY + qE / (wavelength * wavelength);
+}
+
+vec3 fl(
+vec3 gt,
+float anisotropy,
+vec2 samplePoint
+) {
+float au;
+if (abs(anisotropy) < 0.001) {
+au = 1.0 - 2.0 * samplePoint.y;
+}
+else {
+float iU = (1.0 - anisotropy * anisotropy)
+/ (1.0 + anisotropy - 2.0 * anisotropy * samplePoint.y);
+au = (
+iU * iU - 1.0 - anisotropy * anisotropy
+) / (2.0 * anisotropy);
+}
+
+float tR = sqrt(max(0.0, 1.0 - au * au));
+float br = TWOPI * samplePoint.x;
+vec3 tangent;
+vec3 bitangent;
+aK(gt, tangent, bitangent);
+return tangent * (tR * cos(br))
++ bitangent * (tR * sin(br))
++ gt * au;
+}
+
+float bD(float au, float anisotropy) {
+float ap = 1.0 + anisotropy * anisotropy
++ 2.0 * anisotropy * au;
+return INV4PI * (1.0 - anisotropy * anisotropy)
+/ (ap * sqrt(ap));
+}
+`;
+//# sourceMappingURL=sampling.glsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sampling.glsl.js","sourceRoot":"","sources":["../../../../src/renderer/glsl/chunks/sampling.glsl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAEvC,eAAe,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+LlB,CAAC","sourcesContent":["import { glsl } from '../../shader.js';\n\nexport default glsl`\n// The GGX distribution and spherical-cap VNDF sampler are adapted from\n// adobe/openpbr-bsdf, Copyright 2026 Adobe, Apache-2.0. Other routines are\n// project implementations of their stated analytic distributions.\n\nvec3 sampling_ggx_visible_normal(vec3 view, vec2 alpha, vec2 samplePoint) {\n    vec3 stretch = vec3(alpha, 1.0);\n    vec3 sphericalView = normalize(stretch * view);\n    float viewZ = min(sphericalView.z, 1.0);\n    float capSpan = 1.0 + viewZ;\n    float normalZ = (1.0 - samplePoint.y) * capSpan;\n    float oneMinusZ = samplePoint.y * capSpan;\n    float onePlusZ = normalZ + (1.0 - viewZ);\n    float radial = sqrt(max(0.0, onePlusZ * oneMinusZ));\n    float azimuth = TWOPI * samplePoint.x;\n    vec3 sphericalNormal = vec3(\n        sphericalView.x + radial * cos(azimuth),\n        sphericalView.y + radial * sin(azimuth),\n        normalZ\n    );\n    return normalize(stretch * sphericalNormal);\n}\n\nfloat sampling_ggx_ndf(vec3 halfway, vec2 alpha) {\n    vec3 ellipsoidNormal = vec3(\n        halfway.x / alpha.x,\n        halfway.y / alpha.y,\n        halfway.z\n    );\n    float denominator = dot(ellipsoidNormal, ellipsoidNormal);\n    return 1.0 / (\n        PI * alpha.x * alpha.y * denominator * denominator\n    );\n}\n\nfloat sampling_ggx_smith_g1(vec3 direction, vec2 alpha) {\n    float normalComponent = abs(direction.z);\n    if (normalComponent <= 1e-8) {\n        return 0.0;\n    }\n    vec2 roughDirection = alpha * direction.xy;\n    float tanThetaSquared = dot(roughDirection, roughDirection)\n        / (normalComponent * normalComponent);\n    return 2.0 / (1.0 + sqrt(1.0 + tanThetaSquared));\n}\n\nfloat sampling_schlick_fifth_power(float cosine) {\n    float complement = clamp(1.0 - cosine, 0.0, 1.0);\n    return pow(complement, 5.0);\n}\n\nfloat sampling_dielectric_fresnel(float incidentCosine, float etaIOverEtaT) {\n    float cosineI = clamp(abs(incidentCosine), 0.0, 1.0);\n    float sineTSquared = etaIOverEtaT * etaIOverEtaT\n        * max(0.0, 1.0 - cosineI * cosineI);\n    if (sineTSquared >= 1.0) {\n        return 1.0;\n    }\n\n    float cosineT = sqrt(max(0.0, 1.0 - sineTSquared));\n    float perpendicular = (cosineI - etaIOverEtaT * cosineT)\n        / max(cosineI + etaIOverEtaT * cosineT, 1e-8);\n    float parallel = (etaIOverEtaT * cosineI - cosineT)\n        / max(etaIOverEtaT * cosineI + cosineT, 1e-8);\n    return 0.5 * (\n        perpendicular * perpendicular + parallel * parallel\n    );\n}\n\nvec2 sampling_concentric_disk(vec2 samplePoint) {\n    vec2 offset = 2.0 * samplePoint - vec2(1.0);\n    if (offset.x == 0.0 && offset.y == 0.0) {\n        return vec2(0.0);\n    }\n\n    float radius;\n    float angle;\n    if (abs(offset.x) > abs(offset.y)) {\n        radius = offset.x;\n        angle = 0.25 * PI * (offset.y / offset.x);\n    }\n    else {\n        radius = offset.y;\n        angle = 0.5 * PI - 0.25 * PI * (offset.x / offset.y);\n    }\n    return radius * vec2(cos(angle), sin(angle));\n}\n\nvec3 sampling_cosine_hemisphere(vec2 samplePoint) {\n    vec2 diskPoint = sampling_concentric_disk(samplePoint);\n    return vec3(\n        diskPoint,\n        sqrt(max(0.0, 1.0 - dot(diskPoint, diskPoint)))\n    );\n}\n\nfloat sampling_power_heuristic(float firstPdf, float secondPdf) {\n    float scale = max(firstPdf, secondPdf);\n    if (scale <= 0.0) {\n        return 0.0;\n    }\n    vec2 normalized = vec2(firstPdf, secondPdf) / scale;\n    vec2 squared = normalized * normalized;\n    return squared.x / (squared.x + squared.y);\n}\n\nvoid sampling_orthonormal_basis(in vec3 normal, out vec3 tangent, out vec3 bitangent) {\n    float signZ = normal.z >= 0.0 ? 1.0 : -1.0;\n    float factor = -1.0 / (signZ + normal.z);\n    float xy = normal.x * normal.y * factor;\n    tangent = vec3(\n        1.0 + signZ * normal.x * normal.x * factor,\n        signZ * xy,\n        -signZ * normal.x\n    );\n    bitangent = vec3(\n        xy,\n        signZ + normal.y * normal.y * factor,\n        -normal.y\n    );\n}\n\nvec3 sampling_spectral_rgb_filter(vec3 rgb, float wavelength) {\n    if (wavelength == 0.0) {\n        return rgb;\n    }\n    vec3 channelMask = wavelength > 600.0\n        ? vec3(1.0, 0.0, 0.0)\n        : wavelength > 500.0\n            ? vec3(0.0, 1.0, 0.0)\n            : vec3(0.0, 0.0, 1.0);\n    return rgb * channelMask;\n}\n\nfloat sampling_cauchy_ior(\n    float wavelength,\n    float referenceIor,\n    float dispersionScale,\n    float abbeNumber\n) {\n    if (wavelength == 0.0 || dispersionScale <= 0.0) {\n        return referenceIor;\n    }\n\n    const float FRAUNHOFER_C = 656.3;\n    const float FRAUNHOFER_D = 587.6;\n    const float FRAUNHOFER_F = 486.1;\n    float inverseDifference = 1.0 / (\n        1.0 / (FRAUNHOFER_F * FRAUNHOFER_F)\n        - 1.0 / (FRAUNHOFER_C * FRAUNHOFER_C)\n    );\n    float effectiveAbbe = max(abbeNumber / dispersionScale, 1e-6);\n    float cauchyB = (referenceIor - 1.0) * inverseDifference / effectiveAbbe;\n    float cauchyA = referenceIor\n        - cauchyB / (FRAUNHOFER_D * FRAUNHOFER_D);\n    return cauchyA + cauchyB / (wavelength * wavelength);\n}\n\nvec3 sampling_henyey_greenstein(\n    vec3 forwardDirection,\n    float anisotropy,\n    vec2 samplePoint\n) {\n    float cosine;\n    if (abs(anisotropy) < 0.001) {\n        cosine = 1.0 - 2.0 * samplePoint.y;\n    }\n    else {\n        float ratio = (1.0 - anisotropy * anisotropy)\n            / (1.0 + anisotropy - 2.0 * anisotropy * samplePoint.y);\n        cosine = (\n            ratio * ratio - 1.0 - anisotropy * anisotropy\n        ) / (2.0 * anisotropy);\n    }\n\n    float sine = sqrt(max(0.0, 1.0 - cosine * cosine));\n    float azimuth = TWOPI * samplePoint.x;\n    vec3 tangent;\n    vec3 bitangent;\n    sampling_orthonormal_basis(forwardDirection, tangent, bitangent);\n    return tangent * (sine * cos(azimuth))\n        + bitangent * (sine * sin(azimuth))\n        + forwardDirection * cosine;\n}\n\nfloat sampling_henyey_greenstein_phase(float cosine, float anisotropy) {\n    float denominator = 1.0 + anisotropy * anisotropy\n        + 2.0 * anisotropy * cosine;\n    return INV4PI * (1.0 - anisotropy * anisotropy)\n        / (denominator * sqrt(denominator));\n}\n`;\n"]}

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

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

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

@@ -0,0 +1,170 @@
+import { zSobolPackedPermutations, sobolD1Steps } from '../../sampling.js';
+export default /* glsl */ `
+uint reverseBits(uint x) {
+x = ((x & 0x55555555u) << 1u) | ((x >> 1u) & 0x55555555u);
+x = ((x & 0x33333333u) << 2u) | ((x >> 2u) & 0x33333333u);
+x = ((x & 0x0f0f0f0fu) << 4u) | ((x >> 4u) & 0x0f0f0f0fu);
+x = ((x & 0x00ff00ffu) << 8u) | ((x >> 8u) & 0x00ff00ffu);
+return (x << 16u) | (x >> 16u);
+}
+
+const uint CAMERA_PIXEL = 0u;
+const uint CAMERA_LENS = 1u;
+const uint CAMERA_WAVELENGTH = 2u;
+const uint CAMERA_BEVEL_BASE = 3u;
+const uint LIGHT_SELECT = 0u;
+const uint LIGHT_POSITION = 1u;
+const uint BSDF_LOBE = 2u;
+const uint BSDF_DIRECTION = 3u;
+const uint MEDIUM_CHANNEL = 4u;
+const uint MEDIUM_DISTANCE = 5u;
+const uint PHASE_DIRECTION = 6u;
+const uint RUSSIAN_ROULETTE = 7u;
+const uint BOUNCE_STRIDE = 64u;
+
+
+
+uvec2 bc;
+uint bd;
+uint cE = 0u;
+uint em = 0u;
+uint eg(uint ki) {
+uint x = ki;
+x ^= x >> 16u; x *= 0x7feb352du;
+x ^= x >> 15u; x *= 0x846ca68bu;
+return x ^ (x >> 16u);
+}
+uint aq(uint a, uint b) {
+return eg(a ^ eg(b + 0x9e3779b9u));
+}
+uint iA(uint ki, uint ie) {
+uint x = ki + ie;
+x ^= x * 0x6c50b47cu; x ^= x * 0xb82f1e52u;
+x ^= x * 0xc7afe638u; x ^= x * 0x8d22f6e6u;
+return x;
+}
+uint sv(uint x, uint ie) {
+return reverseBits(iA(reverseBits(x), ie));
+}
+
+uint qX(uint ki) {
+uint r = reverseBits(ki);
+${sobolD1Steps.map(([shift, mask]) => `r ^= (r << ${shift}u) & 0x${mask.toString(16)}u;`).join("\n  ")}
+return r;
+}
+vec2 vC(uint index, uint ie) {
+uint i = sv(index, aq(ie, 0u));
+uint x = reverseBits(iA(i, aq(ie, 1u)));
+uint y = sv(qX(i), aq(ie, 2u));
+return vec2(float(x >> 8u), float(y >> 8u)) * (1.0 / 16777216.0);
+}
+uint tj(uvec2 p) {
+uvec2 v = p & uvec2(255u);
+v = (v | (v << uvec2(4u))) & uvec2(0x0f0fu);
+v = (v | (v << uvec2(2u))) & uvec2(0x3333u);
+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 kk(uint tm) {
+uint group = tm >> 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 >> ((tm & 3u) * 8u)) & 255u;
+}
+uint pK(uint kB, uint dim, uint logSPP) {
+uint odd = logSPP & 1u;
+uint tZ = 8u + ((logSPP + 1u) >> 1u);
+uint result = 0u;
+for (int digit = int(tZ) - 1; digit >= int(odd); digit--) {
+uint shift = 2u*uint(digit) - odd;
+
+uint sd = 0u;
+if (shift < 30u) { sd = kB >> (shift + 2u); }
+uint tm = (eg(sd ^ (0x55555555u * dim)) >> 24u) % 24u;
+uint d = (kB >> shift) & 3u;
+result |= ((kk(tm) >> (2u*d)) & 3u) << shift;
+}
+if (odd != 0u) {
+result |= (kB & 1u) ^ (eg((kB >> 1u) ^ (0x55555555u * dim)) & 1u);
+}
+return result;
+}
+
+
+
+uint cv(uint slot) {
+return CAMERA_BEVEL_BASE + uint(BEVEL_SAMPLES) + cE * BOUNCE_STRIDE + slot;
+}
+
+uvec4 hh;
+uint hi;
+bool fv = false;
+bool df = false;
+uint dE;
+uint gp;
+vec2 eN;
+void dw(uint dim) {
+
+uint jU = bc.x + bc.y * uint(round(1.0 / pixelSize.x));
+uvec4 key = uvec4(dim, bd, jU, uint(sequenceSeed));
+if (fv && all(equal(hh, key)) && hi == uint(zSobolLogSPP)) { return; }
+hh = key; hi = uint(zSobolLogSPP);
+fv = true; df = false;
+uint ie = aq(aq(jU, dim), uint(sequenceSeed));
+uint index = bd;
+if (samplingPattern == 1) {
+uint logSPP = uint(zSobolLogSPP);
+if (index == 0u) { logSPP = 0u; }
+else { index -= 1u; }
+
+uint iV = index >> logSPP;
+uint mask = (1u << logSPP) - 1u;
+uint kB = (tj(bc) << logSPP) | (index & mask);
+index = pK(kB, dim, logSPP);
+uvec2 tile = bc >> uvec2(8u);
+ie = aq(aq(dim, uint(sequenceSeed)), aq(tile.x, tile.y));
+
+if (bd != 0u) { iV += 1u; }
+ie = aq(ie, iV);
+}
+dE = sv(index, aq(ie, 0u));
+gp = ie;
+uint x = reverseBits(iA(dE, aq(ie, 1u)));
+eN.x = float(x >> 8u) * (1.0 / 16777216.0);
+}
+vec2 kG(uint dim) {
+dw(dim);
+if (!df) {
+uint y = sv(qX(dE), aq(gp, 2u));
+eN.y = float(y >> 8u) * (1.0 / 16777216.0);
+df = true;
+}
+return EPS + (1.0 - 2.0*EPS) * eN;
+}
+float dz(uint dim) {
+if (samplingPattern == 2) { return EPS + (1.0 - 2.0*EPS)*rand(); }
+dw(dim);
+return EPS + (1.0 - 2.0*EPS) * eN.x;
+}
+vec2 fk(uint dim) {
+if (samplingPattern == 2) {
+float x = dz(dim); float y = dz(dim);
+return vec2(x,y);
+}
+return kG(dim);
+}
+
+float eo(uint slot) {
+uint dim = aq(aq(cE, slot), em) | 0x80000000u;
+em += 1u;
+if (samplingPattern == 2) { return EPS + (1.0 - 2.0*EPS)*rand(); }
+
+uint jU = bc.x + bc.y * uint(round(1.0 / pixelSize.x));
+uint ie = aq(aq(jU, dim), uint(sequenceSeed));
+uint i = sv(bd, aq(ie, 0u));
+uint x = reverseBits(iA(i, aq(ie, 1u)));
+return EPS + (1.0 - 2.0*EPS) * (float(x >> 8u) * (1.0 / 16777216.0));
+}
+`;
+//# sourceMappingURL=sobol.glsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sobol.glsl.js","sourceRoot":"","sources":["../../../../src/renderer/glsl/chunks/sobol.glsl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAC3E,eAAe,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkDtB,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,cAAc,KAAK,UAAU,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC;;;;;;;;;;;;;;;;EAgBtG,wBAAwB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAC,CAAC,EAAE,EAAE,CAAC,qBAAqB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;;;;EAIjF,CAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,EAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,mBAAmB,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiGnF,CAAC","sourcesContent":["import { zSobolPackedPermutations, sobolD1Steps } from '../../sampling.js';\nexport default /* glsl */ `\nuint reverseBits(uint x) {\n  x = ((x & 0x55555555u) << 1u) | ((x >> 1u) & 0x55555555u);\n  x = ((x & 0x33333333u) << 2u) | ((x >> 2u) & 0x33333333u);\n  x = ((x & 0x0f0f0f0fu) << 4u) | ((x >> 4u) & 0x0f0f0f0fu);\n  x = ((x & 0x00ff00ffu) << 8u) | ((x >> 8u) & 0x00ff00ffu);\n  return (x << 16u) | (x >> 16u);\n}\n\nconst uint CAMERA_PIXEL = 0u;\nconst uint CAMERA_LENS = 1u;\nconst uint CAMERA_WAVELENGTH = 2u;\nconst uint CAMERA_BEVEL_BASE = 3u;\nconst uint LIGHT_SELECT = 0u;\nconst uint LIGHT_POSITION = 1u;\nconst uint BSDF_LOBE = 2u;\nconst uint BSDF_DIRECTION = 3u;\nconst uint MEDIUM_CHANNEL = 4u;\nconst uint MEDIUM_DISTANCE = 5u;\nconst uint PHASE_DIRECTION = 6u;\nconst uint RUSSIAN_ROULETTE = 7u;\nconst uint BOUNCE_STRIDE = 64u;\n\n// Burley 2020, Practical Hash-based Owen Scrambling, JCGT 9(4).\n// ZSobol digit walk adapted from pbrt-v4 samplers.h (Apache-2.0).\nuvec2 samplingPixel;\nuint pixelSampleIndex;\nuint samplingBounce = 0u;\nuint hashedCounter = 0u;\nuint sampleHash(uint valueIn) {\n  uint x = valueIn;\n  x ^= x >> 16u; x *= 0x7feb352du;\n  x ^= x >> 15u; x *= 0x846ca68bu;\n  return x ^ (x >> 16u);\n}\nuint sampleSeed(uint a, uint b) {\n  return sampleHash(a ^ sampleHash(b + 0x9e3779b9u));\n}\nuint lkPermute(uint valueIn, uint seed) {\n  uint x = valueIn + seed;\n  x ^= x * 0x6c50b47cu; x ^= x * 0xb82f1e52u;\n  x ^= x * 0xc7afe638u; x ^= x * 0x8d22f6e6u;\n  return x;\n}\nuint owen(uint x, uint seed) {\n  return reverseBits(lkPermute(reverseBits(x), seed));\n}\n// Parallel XOR butterfly equals v ^= v >> 1 for all 32 direction bits.\nuint sobolD1(uint valueIn) {\n  uint r = reverseBits(valueIn);\n  ${sobolD1Steps.map(([shift, mask]) => `r ^= (r << ${shift}u) & 0x${mask.toString(16)}u;`).join(\"\\n  \")}\n  return r;\n}\nvec2 sobol2D(uint index, uint seed) {\n  uint i = owen(index, sampleSeed(seed, 0u));\n  uint x = reverseBits(lkPermute(i, sampleSeed(seed, 1u)));\n  uint y = owen(sobolD1(i), sampleSeed(seed, 2u));\n  return vec2(float(x >> 8u), float(y >> 8u)) * (1.0 / 16777216.0);\n}\nuint morton2(uvec2 p) {\n  uvec2 v = p & uvec2(255u);\n  v = (v | (v << uvec2(4u))) & uvec2(0x0f0fu);\n  v = (v | (v << uvec2(2u))) & uvec2(0x3333u);\n  v = (v | (v << uvec2(1u))) & uvec2(0x5555u);\n  return v.x | (v.y << 1u);\n}\n${zSobolPackedPermutations.map((v,i) => `const uint Z_PERM_${i} = ${v}u;`).join(\"\\n\")}\nuint zSobolPermutation(uint perm) {\n  uint group = perm >> 2u;\n  uint word = Z_PERM_5;\n  ${[0,1,2,3,4].map(i => `word = group == ${i}u ? Z_PERM_${i} : word;`).join(\"\\n  \")}\n  return (word >> ((perm & 3u) * 8u)) & 255u;\n}\nuint zSobolIndex(uint morton, uint dim, uint logSPP) {\n  uint odd = logSPP & 1u;\n  uint digits = 8u + ((logSPP + 1u) >> 1u);\n  uint result = 0u;\n  for (int digit = int(digits) - 1; digit >= int(odd); digit--) {\n    uint shift = 2u*uint(digit) - odd;\n    // A shift by 32 is undefined on GLSL and masks to zero on some GPUs.\n    uint higher = 0u;\n    if (shift < 30u) { higher = morton >> (shift + 2u); }\n    uint perm = (sampleHash(higher ^ (0x55555555u * dim)) >> 24u) % 24u;\n    uint d = (morton >> shift) & 3u;\n    result |= ((zSobolPermutation(perm) >> (2u*d)) & 3u) << shift;\n  }\n  if (odd != 0u) {\n    result |= (morton & 1u) ^ (sampleHash((morton >> 1u) ^ (0x55555555u * dim)) & 1u);\n  }\n  return result;\n}\n// IDs count 2D domains, not scalar components. Bevel IDs follow camera IDs.\n// Bounce: light selector/position, lobe/direction, medium channel/distance,\n// phase direction, RR. Further candidate IDs are addressed, never consumed.\nuint bounceDim(uint slot) {\n  return CAMERA_BEVEL_BASE + uint(BEVEL_SAMPLES) + samplingBounce * BOUNCE_STRIDE + slot;\n}\n// Last-domain cache shares the index shuffle and x between scalar/pair reads.\nuvec4 cachedSampleKey;\nuint cachedSampleLog;\nbool cachedSampleValid = false;\nbool cachedSampleYValid = false;\nuint cachedSampleIndex;\nuint cachedSampleSeed;\nvec2 cachedSample;\nvoid prepareStructuredSample(uint dim) {\n\n  uint pixelID = samplingPixel.x + samplingPixel.y * uint(round(1.0 / pixelSize.x));\n  uvec4 key = uvec4(dim, pixelSampleIndex, pixelID, uint(sequenceSeed));\n  if (cachedSampleValid && all(equal(cachedSampleKey, key)) && cachedSampleLog == uint(zSobolLogSPP)) { return; }\n  cachedSampleKey = key; cachedSampleLog = uint(zSobolLogSPP);\n  cachedSampleValid = true; cachedSampleYValid = false;\n  uint seed = sampleSeed(sampleSeed(pixelID, dim), uint(sequenceSeed));\n  uint index = pixelSampleIndex;\n  if (samplingPattern == 1) {\n    uint logSPP = uint(zSobolLogSPP);\n    if (index == 0u) { logSPP = 0u; }\n    else { index -= 1u; }\n    // Independent sample blocks after the cap avoid repeated samples indefinitely.\n    uint sequenceBlock = index >> logSPP;\n    uint mask = (1u << logSPP) - 1u;\n    uint morton = (morton2(samplingPixel) << logSPP) | (index & mask);\n    index = zSobolIndex(morton, dim, logSPP);\n    uvec2 tile = samplingPixel >> uvec2(8u);\n    seed = sampleSeed(sampleSeed(dim, uint(sequenceSeed)), sampleSeed(tile.x, tile.y));\n    // First and remaining streams must differ even at a two-sample budget.\n    if (pixelSampleIndex != 0u) { sequenceBlock += 1u; }\n    seed = sampleSeed(seed, sequenceBlock);\n  }\n  cachedSampleIndex = owen(index, sampleSeed(seed, 0u));\n  cachedSampleSeed = seed;\n  uint x = reverseBits(lkPermute(cachedSampleIndex, sampleSeed(seed, 1u)));\n  cachedSample.x = float(x >> 8u) * (1.0 / 16777216.0);\n}\nvec2 structuredSample(uint dim) {\n  prepareStructuredSample(dim);\n  if (!cachedSampleYValid) {\n    uint y = owen(sobolD1(cachedSampleIndex), sampleSeed(cachedSampleSeed, 2u));\n    cachedSample.y = float(y >> 8u) * (1.0 / 16777216.0);\n    cachedSampleYValid = true;\n  }\n  return EPS + (1.0 - 2.0*EPS) * cachedSample;\n}\nfloat sample1D(uint dim) {\n  if (samplingPattern == 2) { return EPS + (1.0 - 2.0*EPS)*rand(); }\n  prepareStructuredSample(dim);\n  return EPS + (1.0 - 2.0*EPS) * cachedSample.x;\n}\nvec2 sample2D(uint dim) {\n  if (samplingPattern == 2) {\n    float x = sample1D(dim); float y = sample1D(dim);\n    return vec2(x,y);\n  }\n  return structuredSample(dim);\n}\n// Variable traversal counts cannot move any of the structured dimensions.\nfloat hashedSample(uint slot) {\n  uint dim = sampleSeed(sampleSeed(samplingBounce, slot), hashedCounter) | 0x80000000u;\n  hashedCounter += 1u;\n  if (samplingPattern == 2) { return EPS + (1.0 - 2.0*EPS)*rand(); }\n  // Variable-count traversal has no spatial ZSobol ordering to preserve.\n  uint pixelID = samplingPixel.x + samplingPixel.y * uint(round(1.0 / pixelSize.x));\n  uint seed = sampleSeed(sampleSeed(pixelID, dim), uint(sequenceSeed));\n  uint i = owen(pixelSampleIndex, sampleSeed(seed, 0u));\n  uint x = reverseBits(lkPermute(i, sampleSeed(seed, 1u)));\n  return EPS + (1.0 - 2.0*EPS) * (float(x >> 8u) * (1.0 / 16777216.0));\n}\n`;\n"]}

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

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

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

@@ -0,0 +1,27 @@
+// 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.
+// Manually performs linear filtering if the extension OES_texture_float_linear is not supported
+import { glsl } from '../../shader.js';
+export default glsl `
+vec4 textureLinear(sampler2D map, vec2 uv) {
+#ifdef OES_texture_float_linear
+return texture(map, uv);
+#else
+vec2 size = vec2(textureSize(map, 0));
+vec2 pO = 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)) * pO);
+vec4 s2 = texture(map, (uv + vec2(1, 0)) * pO);
+vec4 s3 = texture(map, (uv + vec2(0, 1)) * pO);
+vec4 s4 = texture(map, (uv + vec2(1, 1)) * pO);
+
+return mix(mix(s1, s2, f.x), mix(s3, s4, f.x), f.y);
+#endif
+}
+`;
+//# sourceMappingURL=textureLinear.glsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"textureLinear.glsl.js","sourceRoot":"","sources":["../../../../src/renderer/glsl/chunks/textureLinear.glsl.ts"],"names":[],"mappings":"AAAA,qDAAqD;AACrD,sDAAsD;AACtD,kFAAkF;AAElF,gGAAgG;AAEhG,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAEvC,eAAe,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;CAoBlB,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// Manually performs linear filtering if the extension OES_texture_float_linear is not supported\n\nimport { glsl } from '../../shader.js';\n\nexport default glsl`\nvec4 textureLinear(sampler2D map, vec2 uv) {\n  #ifdef OES_texture_float_linear\n    return texture(map, uv);\n  #else\n    vec2 size = vec2(textureSize(map, 0));\n    vec2 texelSize = 1.0 / size;\n\n    uv = uv * size - 0.5;\n    vec2 f = fract(uv);\n    uv = floor(uv) + 0.5;\n\n    vec4 s1 = texture(map, (uv + vec2(0, 0)) * texelSize);\n    vec4 s2 = texture(map, (uv + vec2(1, 0)) * texelSize);\n    vec4 s3 = texture(map, (uv + vec2(0, 1)) * texelSize);\n    vec4 s4 = texture(map, (uv + vec2(1, 1)) * texelSize);\n\n    return mix(mix(s1, s2, f.x), mix(s3, s4, f.x), f.y);\n  #endif\n}\n`;\n"]}

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

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

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

@@ -0,0 +1,72 @@
+import { glsl } from '../../shader.js';
+import { uvProjectionConstants } from '../../MaterialTable.js';
+export default glsl `
+vec2 sphericalProjection(vec3 pos) {
+vec3 n = normalize(pos);
+float theta = atan(n.x, n.z) / (2.0 * PI) + 0.5;
+float phi = acos(n.y) / PI;
+return vec2(theta, 1.0 - phi);
+}
+
+vec2 iL(vec3 pos, vec3 normal, vec2 uvScale) {
+vec3 dm = abs(normal);
+vec2 uv = vec2(0.0);
+if (dm.x > dm.y && dm.x > dm.z) {
+uv = pos.yz;
+} else if (dm.y > dm.x && dm.y > dm.z) {
+uv = pos.xz;
+} else {
+uv = pos.xy;
+}
+return fract(uv * uvScale);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+vec2 hA(vec3 pos, vec3 normal) {
+float theta = atan(pos.z, pos.x) / (2.0 * PI) + 0.5;
+return vec2(theta, pos.y);
+}
+
+vec2 gz(int fh, vec3 pos, vec3 normal, vec2 uvScale) {
+if (fh == ${uvProjectionConstants.triplanar + ''}) {
+return iL(pos, normal, uvScale);
+} else if (fh == ${uvProjectionConstants.spherical + ''}) {
+return sphericalProjection(pos) * uvScale;
+} else if (fh == ${uvProjectionConstants.cylindrical + ''}) {
+return hA(pos, normal) * uvScale;
+}
+return vec2(0.0);
+}
+`;
+//# sourceMappingURL=uvProjection.glsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"uvProjection.glsl.js","sourceRoot":"","sources":["../../../../src/renderer/glsl/chunks/uvProjection.glsl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,eAAe,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA2DO,qBAAqB,CAAC,SAAS,GAAG,EAAE;;mBAE7B,qBAAqB,CAAC,SAAS,GAAG,EAAE;;mBAEpC,qBAAqB,CAAC,WAAW,GAAG,EAAE;;;;;CAKtE,CAAC","sourcesContent":["import { glsl } from '../../shader.js';\nimport { uvProjectionConstants } from '../../MaterialTable.js';\n\nexport default glsl`\nvec2 sphericalProjection(vec3 pos) {\n  vec3 n = normalize(pos);\n  float theta = atan(n.x, n.z) / (2.0 * PI) + 0.5;\n  float phi = acos(n.y) / PI;\n  return vec2(theta, 1.0 - phi);\n}\n\nvec2 triplanarProjection(vec3 pos, vec3 normal, vec2 uvScale) {\n  vec3 absNormal = abs(normal);\n  vec2 uv = vec2(0.0);\n  if (absNormal.x > absNormal.y && absNormal.x > absNormal.z) {\n    uv = pos.yz;\n  } else if (absNormal.y > absNormal.x && absNormal.y > absNormal.z) {\n    uv = pos.xz;\n  } else {\n    uv = pos.xy;\n  }\n  return fract(uv * uvScale);\n}\n\n// vec4 triplanarProjectionSample(\n//   sampler2DArray _map, vec2 mapSize, int index,\n//   vec3 pos, vec3 normal, vec2 uvScale, float blending\n// ) {\n//   vec3 absNormal = abs(normal);\n//   // Calculate blending power - higher expo means sharper transitions\n//   float expo = (1.0 - blending) * 125.0 + blending * 3.0;\n  \n//   // Weight each axis by its normal component raised to expo power\n//   vec3 weights = pow(absNormal, vec3(expo));\n  \n//   // Normalize weights so they sum to 1\n//   weights = weights / (weights.x + weights.y + weights.z);\n  \n//   // Project UVs on each axis plane (yz, xz, xy)\n//   vec2 yzPlane = pos.yz * uvScale;\n//   vec2 xzPlane = pos.xz * uvScale;\n//   vec2 xyPlane = pos.xy * uvScale;\n//   // Wrap\n//   yzPlane = fract(yzPlane);\n//   xzPlane = fract(xzPlane);\n//   xyPlane = fract(xyPlane);\n\n//   // Sample maps\n//   vec4 yz = texture(_map, vec3(yzPlane * mapSize, float(index)));\n//   vec4 xz = texture(_map, vec3(xzPlane * mapSize, float(index)));\n//   vec4 xy = texture(_map, vec3(xyPlane * mapSize, float(index)));\n  \n//   // Blend the projected coordinates using the weights\n//   return weights.x * yz + weights.y * xz + weights.z * xy;\n// }\n\nvec2 cylindricalProjection(vec3 pos, vec3 normal) {\n  float theta = atan(pos.z, pos.x) / (2.0 * PI) + 0.5;\n  return vec2(theta, pos.y);\n}\n\nvec2 projectUV(int projectionType, vec3 pos, vec3 normal, vec2 uvScale) {\n  if (projectionType == ${uvProjectionConstants.triplanar + ''}) {\n    return triplanarProjection(pos, normal, uvScale);\n  } else if (projectionType == ${uvProjectionConstants.spherical + ''}) {\n    return sphericalProjection(pos) * uvScale;\n  } else if (projectionType == ${uvProjectionConstants.cylindrical + ''}) {\n    return cylindricalProjection(pos, normal) * uvScale;\n  }\n  return vec2(0.0);\n}\n`;\n"]}

package/lib/renderer/glsl/depthQuery.frag.d.ts

@@ -0,0 +1,3 @@
+import { FragmentShader } from '../shader.js';
+declare const _default: FragmentShader<Record<string, import("../shader.js").ShaderDefineValue>, Record<string, import("../shader.js").ShaderUniform<unknown>>>;
+export default _default;

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

@@ -0,0 +1,55 @@
+import { FragmentShader, Shader } from '../shader.js';
+import { DEPTH_SAMPLE_GRID } from '../depthQuery.js';
+import common from './chunks/common.glsl.js';
+import core from './chunks/rayTraceCore.glsl.js';
+import materials from './chunks/materialBuffer.glsl.js';
+import intersect from './chunks/intersect.glsl.js';
+import uvProjection from './chunks/uvProjection.glsl.js';
+import random from './chunks/random.glsl.js';
+import rand from './chunks/rand.glsl.js';
+export default new FragmentShader({
+    name: 'depthQuery', outputs: ['depth'],
+    defines: { DEPTH_QUERY_MODE: true },
+    includes: [core, materials, intersect, random],
+    uniforms: {
+        depthArea: Shader.uniform('vec4'),
+        viewProjectionInv: Shader.uniform('mat4'),
+        viewInv: Shader.uniform('mat4')
+    },
+    main: /* glsl */ `
+${common}
+${rand}
+${random.main}
+${core.main}
+${uvProjection}
+${materials.main}
+${intersect.main}
+
+void main() {
+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);
+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;
+iw(ray, origin.xyz / origin.w, normalize(target.xyz * origin.w - origin.xyz * target.w));
+vec3 eye = viewInv[3].xyz;
+vec3 nV = -normalize(viewInv[2].xyz);
+ad si;
+si.triangleIndex = -1;
+for (int layer = 0; layer < 32; layer++) {
+cY(ray, si, false);
+if (!si.hit) return;
+J material;
+eT(material, si.materialIndex, si.uv, si.uv1, si.instanceIndex);
+if (material.materialType != SHADOW_CATCHER && material.alpha > 0.0) {
+out_depth.r = max(dot(si.position - eye, nV), 0.0);
+return;
+}
+ray.o = si.position + ray.d * (EPS * 0.02);
+}
+}
+`
+});
+//# sourceMappingURL=depthQuery.frag.js.map

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

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

package/lib/renderer/glsl/normalizeRayTraceOutput.frag.d.ts

@@ -0,0 +1,6 @@
+import { FragmentShader } from '../shader.js';
+/**
+ * Normalize
+ */
+declare const normalizeRayTraceOutput: FragmentShader<Record<string, import("../shader.js").ShaderDefineValue>, Record<string, import("../shader.js").ShaderUniform<unknown>>>;
+export default normalizeRayTraceOutput;

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

@@ -0,0 +1,46 @@
+import { FragmentShader, glsl, Shader } from '../shader.js';
+/**
+ * Normalize
+ */
+const normalizeRayTraceOutput = new FragmentShader({
+    name: 'normalizeRayTraceOutput',
+    outputs: ['color', 'albedo', 'normal', 'shadowCatcher'],
+    uniforms: {
+        colorTex: Shader.uniform('sampler2D'),
+        albedoTex: Shader.uniform('sampler2D'),
+        normalTex: Shader.uniform('sampler2D'),
+        shadowCatcherTex: Shader.uniform('sampler2D'),
+        sampleCount: Shader.uniform('float', 1),
+        lightScale: Shader.uniform('vec2', [1, 1])
+    },
+    main: glsl `
+void main() {
+vec2 uv = lightScale * v_Texcoord;
+vec4 rI = sample_albedoTex(uv);
+float hit = rI.a;
+vec4 rM = sample_normalTex(uv);
+
+
+
+float sc = max(rM.a, 1.0);
+vec3 albedo = rI.rgb / sc;
+vec3 normal = rM.rgb / sc;
+vec4 shadowCatcher= sample_shadowCatcherTex(uv) / sampleCount;
+vec4 sk = sample_colorTex(uv);
+
+
+
+
+vec4 light = vec4(sk.rgb / (hit > 0.0 ? hit : sampleCount), sk.a / sampleCount);
+
+
+
+out_normal = dot(normal, normal) > 0.1 ? vec4(normal * 0.5 + 0.5, 1.0) : vec4(0.0);
+out_albedo = vec4(albedo, 1.0);
+out_shadowCatcher = shadowCatcher;
+out_color = light;
+}
+`
+});
+export default normalizeRayTraceOutput;
+//# sourceMappingURL=normalizeRayTraceOutput.frag.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeRayTraceOutput.frag.js","sourceRoot":"","sources":["../../../src/renderer/glsl/normalizeRayTraceOutput.frag.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAE5D;;GAEG;AACH,MAAM,uBAAuB,GAAG,IAAI,cAAc,CAAC;IACjD,IAAI,EAAE,yBAAyB;IAC/B,OAAO,EAAE,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,eAAe,CAAC;IAEvD,QAAQ,EAAE;QACR,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;QACrC,SAAS,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;QACtC,SAAS,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;QACtC,gBAAgB,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;QAE7C,WAAW,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;QACvC,UAAU,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;KAC3C;IAED,IAAI,EAAE,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BT;CACF,CAAC,CAAC;AAEH,eAAe,uBAAuB,CAAC","sourcesContent":["import { FragmentShader, glsl, Shader } from '../shader.js';\n\n/**\n * Normalize\n */\nconst normalizeRayTraceOutput = new FragmentShader({\n  name: 'normalizeRayTraceOutput',\n  outputs: ['color', 'albedo', 'normal', 'shadowCatcher'],\n\n  uniforms: {\n    colorTex: Shader.uniform('sampler2D'),\n    albedoTex: Shader.uniform('sampler2D'),\n    normalTex: Shader.uniform('sampler2D'),\n    shadowCatcherTex: Shader.uniform('sampler2D'),\n\n    sampleCount: Shader.uniform('float', 1),\n    lightScale: Shader.uniform('vec2', [1, 1])\n  },\n\n  main: glsl`\nvoid main() {\n  vec2 uv = lightScale * v_Texcoord;\n  vec4 albedoTexel = sample_albedoTex(uv);\n  float hit = albedoTexel.a;\n  vec4 normalTexel = sample_normalTex(uv);\n  // Spectral WebGL rendering submits three additive wavelength passes per\n  // sample. Normalize auxiliary guides by their actual contribution count,\n  // not the logical sample count, or they saturate before denoising.\n  float guideCount = max(normalTexel.a, 1.0);\n  vec3 albedo = albedoTexel.rgb / guideCount;\n  vec3 normal = normalTexel.rgb / guideCount;\n  vec4 shadowCatcher= sample_shadowCatcherTex(uv) / sampleCount;\n  vec4 lightTexel = sample_colorTex(uv);\n  // vec2 hit = sample_hitTex(uv).rg;\n  // average the color by hit count.\n  // So the antialised edge color will be correct when having transparent background\n  // TODO In some platforms. the output of hit.r is always 0. In this case we use sampleCount instead.\n  vec4 light = vec4(lightTexel.rgb / (hit > 0.0 ? hit : sampleCount), lightTexel.a / sampleCount);\n\n  // Pixels whose primary rays mostly miss geometry have no normal (alpha 0),\n  // as in the WebGPU output.\n  out_normal = dot(normal, normal) > 0.1 ? vec4(normal * 0.5 + 0.5, 1.0) : vec4(0.0);\n  out_albedo = vec4(albedo, 1.0);\n  out_shadowCatcher = shadowCatcher;\n  out_color = light;\n}\n  `\n});\n\nexport default normalizeRayTraceOutput;\n"]}

package/lib/renderer/glsl/rayTrace.frag.d.ts

@@ -0,0 +1,2 @@
+import { FragmentShader } from '../shader.js';
+export default function createRayTraceFragmentShader(): FragmentShader<Record<string, import("../shader.js").ShaderDefineValue>, Record<string, import("../shader.js").ShaderUniform<unknown>>>;