@meimu/mutracer 0.2.0 → 0.3.0

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

@@ -4,71 +4,71 @@ export default glsl `
 
 
 
-vec3 aD(vec3 view, vec2 alpha, vec2 samplePoint) {
-vec3 sv = vec3(alpha, 1.0);
-vec3 cr = normalize(sv * view);
-float qP = min(cr.z, 1.0);
-float kh = 1.0 + qP;
-float kC = (1.0 - samplePoint.y) * kh;
-float sU = samplePoint.y * kh;
-float tY = kC + (1.0 - qP);
-float ex = sqrt(max(0.0, tY * sU));
+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));
 float azimuth = TWOPI * samplePoint.x;
-vec3 mr = vec3(
-cr.x + ex * cos(azimuth),
-cr.y + ex * sin(azimuth),
-kC
+vec3 lX = vec3(
+ce.x + dr * cos(azimuth),
+ce.y + dr * sin(azimuth),
+kf
 );
-return normalize(sv * mr);
+return normalize(sn * lX);
 }
 
-float cW(vec3 pf, vec2 alpha) {
-vec3 hF = vec3(
-pf.x / alpha.x,
-pf.y / alpha.y,
-pf.z
+float sampling_ggx_ndf(vec3 oU, vec2 alpha) {
+vec3 hl = vec3(
+oU.x / alpha.x,
+oU.y / alpha.y,
+oU.z
 );
-float aq = dot(hF, hF);
+float ah = dot(hl, hl);
 return 1.0 / (
-PI * alpha.x * alpha.y * aq * aq
+PI * alpha.x * alpha.y * ah * ah
 );
 }
 
-float aF(vec3 direction, vec2 alpha) {
-float eQ = abs(direction.z);
-if (eQ <= 1e-8) {
+float aD(vec3 direction, vec2 alpha) {
+float eB = abs(direction.z);
+if (eB <= 1e-8) {
 return 0.0;
 }
-vec2 iE = alpha * direction.xy;
-float mt = dot(iE, iE)
-/ (eQ * eQ);
-return 2.0 / (1.0 + sqrt(1.0 + mt));
+vec2 hZ = alpha * direction.xy;
+float lY = dot(hZ, hZ)
+/ (eB * eB);
+return 2.0 / (1.0 + sqrt(1.0 + lY));
 }
 
-float aI(float cosine) {
-float dw = clamp(1.0 - cosine, 0.0, 1.0);
-return pow(dw, 5.0);
+float aH(float cosine) {
+float cY = clamp(1.0 - cosine, 0.0, 1.0);
+return pow(cY, 5.0);
 }
 
-float cC(float J, float cR) {
-float iS = clamp(abs(J), 0.0, 1.0);
-float kQ = cR * cR
-* max(0.0, 1.0 - iS * iS);
-if (kQ >= 1.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) {
 return 1.0;
 }
 
-float mD = sqrt(max(0.0, 1.0 - kQ));
-float bk = (iS - cR * mD)
-/ max(iS + cR * mD, 1e-8);
-float qC = (cR * iS - mD)
-/ max(cR * iS + mD, 1e-8);
+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);
 return 0.5 * (
-bk * bk + qC * qC
+bd * bd + qu * qu
 );
 }
 
-vec2 gy(vec2 samplePoint) {
+vec2 gi(vec2 samplePoint) {
 vec2 offset = 2.0 * samplePoint - vec2(1.0);
 if (offset.x == 0.0 && offset.y == 0.0) {
 return vec2(0.0);
@@ -87,78 +87,75 @@ angle = 0.5 * PI - 0.25 * PI * (offset.x / offset.y);
 return radius * vec2(cos(angle), sin(angle));
 }
 
-vec3 aO(vec2 samplePoint) {
-vec2 lk = gy(samplePoint);
+vec3 aM(vec2 samplePoint) {
+vec2 kS = gi(samplePoint);
 return vec3(
-lk,
-sqrt(max(0.0, 1.0 - dot(lk, lk)))
+kS,
+sqrt(max(0.0, 1.0 - dot(kS, kS)))
 );
 }
 
-float aK(float qo, float oJ) {
-float scale = max(qo, oJ);
+float aF(float firstPdf, float secondPdf) {
+float scale = max(firstPdf, secondPdf);
 if (scale <= 0.0) {
 return 0.0;
 }
-vec2 normalized = vec2(qo, oJ) / scale;
-vec2 pL = normalized * normalized;
-return pL.x / (pL.x + pL.y);
+vec2 normalized = vec2(firstPdf, secondPdf) / scale;
+vec2 pq = normalized * normalized;
+return pq.x / (pq.x + pq.y);
 }
 
-void aP(in vec3 normal, out vec3 tangent, out vec3 bitangent) {
-float iI = normal.z >= 0.0 ? 1.0 : -1.0;
-float cL = -1.0 / (iI + normal.z);
-float xy = normal.x * normal.y * cL;
+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;
 tangent = vec3(
-1.0 + iI * normal.x * normal.x * cL,
-iI * xy,
--iI * normal.x
+1.0 + ik * normal.x * normal.x * cv,
+ik * xy,
+-ik * normal.x
 );
 bitangent = vec3(
 xy,
-iI + normal.y * normal.y * cL,
+ik + normal.y * normal.y * cv,
 -normal.y
 );
 }
 
-vec3 aj(vec3 rgb, float wavelength) {
-if (wavelength == 0.0) {
+vec3 sampling_spectral_rgb_filter(vec3 rgb, int channel) {
+if (channel == 0) {
 return rgb;
 }
-vec3 vk = 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 * vk;
+vec3 sZ = vec3(0.0);
+sZ[channel - 1] = 1.0;
+return rgb * sZ;
 }
 
-float ee(
+float sampling_cauchy_ior(
 float wavelength,
-float hu,
-float hD,
-float rt
+float ha,
+float hk,
+float rm
 ) {
-if (wavelength == 0.0 || hD <= 0.0) {
-return hu;
+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 kv = 1.0 / (
+float jX = 1.0 / (
 1.0 / (FRAUNHOFER_F * FRAUNHOFER_F)
 - 1.0 / (FRAUNHOFER_C * FRAUNHOFER_C)
 );
-float oe = max(rt / hD, 1e-6);
-float rV = (hu - 1.0) * kv / oe;
-float uK = hu
-- rV / (FRAUNHOFER_D * FRAUNHOFER_D);
-return uK + rV / (wavelength * wavelength);
+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);
 }
 
-vec3 fH(
-vec3 gO,
+vec3 fj(
+vec3 gw,
 float anisotropy,
 vec2 samplePoint
 ) {
@@ -167,28 +164,28 @@ if (abs(anisotropy) < 0.001) {
 cosine = 1.0 - 2.0 * samplePoint.y;
 }
 else {
-float ju = (1.0 - anisotropy * anisotropy)
+float iZ = (1.0 - anisotropy * anisotropy)
 / (1.0 + anisotropy - 2.0 * anisotropy * samplePoint.y);
 cosine = (
-ju * ju - 1.0 - anisotropy * anisotropy
+iZ * iZ - 1.0 - anisotropy * anisotropy
 ) / (2.0 * anisotropy);
 }
 
-float vF = sqrt(max(0.0, 1.0 - cosine * cosine));
+float uC = sqrt(max(0.0, 1.0 - cosine * cosine));
 float azimuth = TWOPI * samplePoint.x;
 vec3 tangent;
 vec3 bitangent;
-aP(gO, tangent, bitangent);
-return tangent * (vF * cos(azimuth))
-+ bitangent * (vF * sin(azimuth))
-+ gO * cosine;
+sampling_orthonormal_basis(gw, tangent, bitangent);
+return tangent * (uC * cos(azimuth))
++ bitangent * (uC * sin(azimuth))
++ gw * cosine;
 }
 
-float bL(float cosine, float anisotropy) {
-float aq = 1.0 + anisotropy * anisotropy
+float bB(float cosine, float anisotropy) {
+float ah = 1.0 + anisotropy * anisotropy
 + 2.0 * anisotropy * cosine;
 return INV4PI * (1.0 - anisotropy * anisotropy)
-/ (aq * sqrt(aq));
+/ (ah * sqrt(ah));
 }
 `;
 //# sourceMappingURL=sampling.glsl.js.map

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

@@ -1 +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"]}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4LlB,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, int channel) {\n    if (channel == 0) {\n        return rgb;\n    }\n    vec3 channelMask = vec3(0.0);\n    channelMask[channel - 1] = 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.js

@@ -24,41 +24,41 @@ const uint BOUNCE_STRIDE = 64u;
 
 
 
-uvec2 aZ;
-uint aQ;
-uint bT = 0u;
-uint cP = 0u;
-uint dG(uint kW) {
-uint x = kW;
+uvec2 aI;
+uint aC;
+uint samplingBounce = 0u;
+uint ca = 0u;
+uint cB(uint kC) {
+uint x = kC;
 x ^= x >> 16u; x *= 0x7feb352du;
 x ^= x >> 15u; x *= 0x846ca68bu;
 return x ^ (x >> 16u);
 }
-uint ar(uint a, uint b) {
-return dG(a ^ dG(b + 0x9e3779b9u));
+uint ak(uint a, uint b) {
+return cB(a ^ cB(b + 0x9e3779b9u));
 }
-uint iV(uint kW, uint seed) {
-uint x = kW + seed;
+uint iD(uint kC, uint seed) {
+uint x = kC + seed;
 x ^= x * 0x6c50b47cu; x ^= x * 0xb82f1e52u;
 x ^= x * 0xc7afe638u; x ^= x * 0x8d22f6e6u;
 return x;
 }
-uint ua(uint x, uint seed) {
-return reverseBits(iV(reverseBits(x), seed));
+uint ud(uint x, uint seed) {
+return reverseBits(iD(reverseBits(x), seed));
 }
 
-uint su(uint kW) {
-uint r = reverseBits(kW);
+uint sm(uint kC) {
+uint r = reverseBits(kC);
 ${sobolD1Steps.map(([shift, mask]) => `r ^= (r << ${shift}u) & 0x${mask.toString(16)}u;`).join("\n  ")}
 return r;
 }
-vec2 xE(uint index, uint seed) {
-uint i = ua(index, ar(seed, 0u));
-uint x = reverseBits(iV(i, ar(seed, 1u)));
-uint y = ua(su(i), ar(seed, 2u));
+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));
 return vec2(float(x >> 8u), float(y >> 8u)) * (1.0 / 16777216.0);
 }
-uint uR(uvec2 p) {
+uint uX(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 la(uint uU) {
-uint group = uU >> 2u;
+uint kG(uint va) {
+uint group = va >> 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 >> ((uU & 3u) * 8u)) & 255u;
+return (word >> ((va & 3u) * 8u)) & 255u;
 }
-uint qS(uint lu, uint dim, uint logSPP) {
+uint qJ(uint kY, uint dim, uint logSPP) {
 uint odd = logSPP & 1u;
-uint vN = 8u + ((logSPP + 1u) >> 1u);
+uint wb = 8u + ((logSPP + 1u) >> 1u);
 uint result = 0u;
-for (int digit = int(vN) - 1; digit >= int(odd); digit--) {
+for (int digit = int(wb) - 1; digit >= int(odd); digit--) {
 uint shift = 2u*uint(digit) - odd;
 
-uint tL = 0u;
-if (shift < 30u) { tL = lu >> (shift + 2u); }
-uint uU = (dG(tL ^ (0x55555555u * dim)) >> 24u) % 24u;
-uint d = (lu >> shift) & 3u;
-result |= ((la(uU) >> (2u*d)) & 3u) << shift;
+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;
 }
 if (odd != 0u) {
-result |= (lu & 1u) ^ (dG((lu >> 1u) ^ (0x55555555u * dim)) & 1u);
+result |= (kY & 1u) ^ (cB((kY >> 1u) ^ (0x55555555u * dim)) & 1u);
 }
 return result;
 }
 
 
 
-uint cE(uint slot) {
-return CAMERA_BEVEL_BASE + uint(BEVEL_SAMPLES) + bT * BOUNCE_STRIDE + slot;
+uint bE(uint slot) {
+return CAMERA_BEVEL_BASE + uint(BEVEL_SAMPLES) + samplingBounce * BOUNCE_STRIDE + slot;
 }
 
-uvec4 hA;
-uint hB;
-bool fQ = false;
-bool dv = false;
-uint dQ;
-uint gK;
-vec2 fa;
-void dN(uint dim) {
+uvec4 hg;
+uint hh;
+bool fA = false;
+bool cX = false;
+uint dD;
+uint gt;
+vec2 eJ;
+void dm(uint dim) {
 
-uint kI = aZ.x + aZ.y * uint(round(1.0 / pixelSize.x));
-uvec4 key = uvec4(dim, aQ, kI, uint(sequenceSeed));
-if (fQ && all(equal(hA, key)) && hB == uint(zSobolLogSPP)) { return; }
-hA = key; hB = uint(zSobolLogSPP);
-fQ = true; dv = false;
-uint seed = ar(ar(kI, dim), uint(sequenceSeed));
-uint index = aQ;
+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 index = aC;
 if (samplingPattern == 1) {
 uint logSPP = uint(zSobolLogSPP);
 if (index == 0u) { logSPP = 0u; }
 else { index -= 1u; }
 
-uint jw = index >> logSPP;
+uint jd = index >> logSPP;
 uint mask = (1u << logSPP) - 1u;
-uint lu = (uR(aZ) << logSPP) | (index & mask);
-index = qS(lu, dim, logSPP);
-uvec2 tile = aZ >> uvec2(8u);
-seed = ar(ar(dim, uint(sequenceSeed)), ar(tile.x, tile.y));
+uint kY = (uX(aI) << logSPP) | (index & mask);
+index = qJ(kY, dim, logSPP);
+uvec2 tile = aI >> uvec2(8u);
+seed = ak(ak(dim, uint(sequenceSeed)), ak(tile.x, tile.y));
 
-if (aQ != 0u) { jw += 1u; }
-seed = ar(seed, jw);
+if (aC != 0u) { jd += 1u; }
+seed = ak(seed, jd);
 }
-dQ = ua(index, ar(seed, 0u));
-gK = seed;
-uint x = reverseBits(iV(dQ, ar(seed, 1u)));
-fa.x = float(x >> 8u) * (1.0 / 16777216.0);
+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);
 }
-vec2 lC(uint dim) {
-dN(dim);
-if (!dv) {
-uint y = ua(su(dQ), ar(gK, 2u));
-fa.y = float(y >> 8u) * (1.0 / 16777216.0);
-dv = true;
+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;
 }
-return EPS + (1.0 - 2.0*EPS) * fa;
+return EPS + (1.0 - 2.0*EPS) * eJ;
 }
-float dp(uint dim) {
+float sample1D(uint dim) {
 if (samplingPattern == 2) { return EPS + (1.0 - 2.0*EPS)*rand(); }
-dN(dim);
-return EPS + (1.0 - 2.0*EPS) * fa.x;
+dm(dim);
+return EPS + (1.0 - 2.0*EPS) * eJ.x;
 }
-vec2 dZ(uint dim) {
+vec2 sample2D(uint dim) {
 if (samplingPattern == 2) {
-float x = dp(dim); float y = dp(dim);
+float x = sample1D(dim); float y = sample1D(dim);
 return vec2(x,y);
 }
-return lC(dim);
+return le(dim);
 }
 
-float eC(uint slot) {
-uint dim = ar(ar(bT, slot), cP) | 0x80000000u;
-cP += 1u;
+float ek(uint slot) {
+uint dim = ak(ak(samplingBounce, slot), ca) | 0x80000000u;
+ca += 1u;
 if (samplingPattern == 2) { return EPS + (1.0 - 2.0*EPS)*rand(); }
 
-uint kI = aZ.x + aZ.y * uint(round(1.0 / pixelSize.x));
-uint seed = ar(ar(kI, dim), uint(sequenceSeed));
-uint i = ua(aQ, ar(seed, 0u));
-uint x = reverseBits(iV(i, ar(seed, 1u)));
+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)));
 return EPS + (1.0 - 2.0*EPS) * (float(x >> 8u) * (1.0 / 16777216.0));
 }
 `;

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 qX = 1.0 / size;
+vec2 qQ = 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)) * qX);
-vec4 s2 = texture(map, (uv + vec2(1, 0)) * qX);
-vec4 s3 = texture(map, (uv + vec2(0, 1)) * qX);
-vec4 s4 = texture(map, (uv + vec2(1, 1)) * qX);
+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);
 
 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 jh(vec3 pos, vec3 normal, vec2 uvScale) {
-vec3 dI = abs(normal);
+vec2 iO(vec3 pos, vec3 normal, vec2 uvScale) {
+vec3 dg = abs(normal);
 vec2 uv = vec2(0.0);
-if (dI.x > dI.y && dI.x > dI.z) {
+if (dg.x > dg.y && dg.x > dg.z) {
 uv = pos.yz;
-} else if (dI.y > dI.x && dI.y > dI.z) {
+} else if (dg.y > dg.x && dg.y > dg.z) {
 uv = pos.xz;
 } else {
 uv = pos.xy;
@@ -53,18 +53,18 @@ return fract(uv * uvScale);
 
 
 
-vec2 hT(vec3 pos, vec3 normal) {
+vec2 hA(vec3 pos, vec3 normal) {
 float theta = atan(pos.z, pos.x) / (2.0 * PI) + 0.5;
 return vec2(theta, pos.y);
 }
 
-vec2 gU(int fE, vec3 pos, vec3 normal, vec2 uvScale) {
-if (fE == ${uvProjectionConstants.triplanar + ''}) {
-return jh(pos, normal, uvScale);
-} else if (fE == ${uvProjectionConstants.spherical + ''}) {
+vec2 gE(int fg, vec3 pos, vec3 normal, vec2 uvScale) {
+if (fg == ${uvProjectionConstants.triplanar + ''}) {
+return iO(pos, normal, uvScale);
+} else if (fg == ${uvProjectionConstants.spherical + ''}) {
 return sphericalProjection(pos) * uvScale;
-} else if (fE == ${uvProjectionConstants.cylindrical + ''}) {
-return hT(pos, normal) * uvScale;
+} else if (fg == ${uvProjectionConstants.cylindrical + ''}) {
+return hA(pos, normal) * uvScale;
 }
 return vec2(0.0);
 }

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

@@ -33,7 +33,7 @@ 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;
-gC(ray, origin.xyz / origin.w, normalize(target.xyz * origin.w - origin.xyz * target.w));
+initRay(ray, origin.xyz / origin.w, normalize(target.xyz * origin.w - origin.xyz * target.w));
 vec3 eye = viewInv[3].xyz;
 vec3 forward = -normalize(viewInv[2].xyz);
 SurfaceInteraction si;
@@ -42,7 +42,7 @@ for (int layer = 0; layer < 32; layer++) {
 intersectScene(ray, si, false);
 if (!si.hit) return;
 OpenPbrResolvedMaterial material;
-dg(material, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
+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);
 return;

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

@@ -17,29 +17,29 @@ const normalizeRayTraceOutput = new FragmentShader({
     main: glsl `
 void main() {
 vec2 uv = lightScale * v_Texcoord;
-vec4 tb = sample_albedoTex(uv);
-float hit = tb.a;
-vec4 tf = sample_normalTex(uv);
+vec4 sY = sample_albedoTex(uv);
+float hit = sY.a;
+vec4 td = sample_normalTex(uv);
 
 
 
-float tK = max(tf.a, 1.0);
-vec3 albedo = tb.rgb / tK;
-vec3 normal = tf.rgb / tK;
+float tL = max(td.a, 1.0);
+vec3 albedo = sY.rgb / tL;
+vec3 normal = td.rgb / tL;
 vec4 shadowCatcher = sample_shadowCatcherTex(uv);
 
 
 
-float tj = sample_catcherMomentsTex(uv).w;
-float opacity = tj > 0.0 ? shadowCatcher.a / tj : 0.0;
+float th = sample_catcherMomentsTex(uv).w;
+float opacity = th > 0.0 ? shadowCatcher.a / th : 0.0;
 shadowCatcher /= sampleCount;
 shadowCatcher.a = 1.0 - shadowCatcher.r * opacity;
-vec4 tQ = sample_colorTex(uv);
+vec4 tT = sample_colorTex(uv);
 
 
 
 
-vec4 light = vec4(tQ.rgb / (hit > 0.0 ? hit : sampleCount), tQ.a / sampleCount);
+vec4 light = vec4(tT.rgb / (hit > 0.0 ? hit : sampleCount), tT.a / sampleCount);
 
 
 

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

@@ -1,2 +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>>>;
+export default function createRayTraceFragmentShader(...options: unknown[]): FragmentShader<Record<string, import("../shader.js").ShaderDefineValue>, Record<string, import("../shader.js").ShaderUniform<unknown>>>;